ircgrampp/lib/session.js

IRCGram++ is a complexly simple Telegram <-> IRC Gateway

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = void 0;

var _events = require("events");

var _debug = _interopRequireDefault(require("debug"));

var _bridge = _interopRequireDefault(require("./bridge"));

var _config = _interopRequireWildcard(require("./config"));

var _hooks = require("./hooks");

var _dec, _dec2, _dec3, _dec4, _class;

function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }

function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _applyDecoratedDescriptor(target, property, decorators, descriptor, context) { var desc = {}; Object.keys(descriptor).forEach(function (key) { desc[key] = descriptor[key]; }); desc.enumerable = !!desc.enumerable; desc.configurable = !!desc.configurable; if ('value' in desc || desc.initializer) { desc.writable = true; } desc = decorators.slice().reverse().reduce(function (desc, decorator) { return decorator(target, property, desc) || desc; }, desc); if (context && desc.initializer !== void 0) { desc.value = desc.initializer ? desc.initializer.call(context) : void 0; desc.initializer = undefined; } if (desc.initializer === void 0) { Object.defineProperty(target, property, desc); desc = null; } return desc; }

var Promise = require("bluebird");

const debug = (0, _debug.default)("session");
/**
 * Bridges up session
 */

let Session = (_dec = (0, _hooks.syncHookedMethod)('session:create'), _dec2 = (0, _hooks.syncHookedMethod)('session:make.bridges.tree'), _dec3 = (0, _hooks.syncHookedMethod)('session:start.bridge', 'ircChannel', 'telegramChannel', 'config'), _dec4 = (0, _hooks.asyncHookedMethod)('session:start'), (_class = class Session extends _events.EventEmitter {
  /**
   * Create session
   * @param {object} [options] Options
   */
  constructor(options = {}) {
    super();

    this._constructor(options);
  }

  _constructor(options = {}) {
    this._options = options;
    this._bridgesConfig = this._makeBridgesTree();
    this._started = false;
    this._bridges = [];
    return this;
  }

  _makeBridgesTree() {
    if (this._options.only) {
      debug(`only option for ${this._options.only}`);
    }

    return (_config.default.get("bridges") || []).map(x => x.name).filter(b => {
      if (this._options.only) {
        return b === this._options.only;
      } else {
        return true;
      }
    }).map(n => (0, _config.getBridgeConfig)(n)).filter(n => n.enable);
  }

  startBridge(ircChannel, telegramChannel, bridgeConfig) {
    let bridge = new _bridge.default(bridgeConfig.name, ircChannel, telegramChannel, bridgeConfig);
    return Promise.all([new Promise(resolve => {
      bridge.once("irc:registered", () => {
        debug(`Bridge ${bridgeConfig.name} registered with IRC`);
        return resolve();
      });
    }), new Promise(resolve => {
      bridge.once("telegram:me", () => {
        debug(`Bridge ${bridgeConfig.name} success with Telegram`);
        return resolve();
      });
    })]).then(() => {
      debug(`Bridge ${bridgeConfig.name} stablished`);
      this.emit("bridgestablished", bridgeConfig.name);
      return bridge;
    });
  }

  start() {
    if (this._started) {
      throw new Error("Already started");
    }

    if (!this._bridgesConfig.length) {
      throw new Error("Nothing to start");
    }

    debug("Starting bridges");
    this._started = true;
    let config = this._bridgesConfig;
    return Promise.map(config, bridgeConfig => {
      let ircChannel = bridgeConfig.irc.channel;
      let telegramChannel = bridgeConfig.telegram.channel;

      if (!ircChannel || !telegramChannel) {
        throw new Error(`Bridge ${bridgeConfig.name} has a ` + `error in IRC or telegram channel definition`);
      }

      debug(`Starting ${bridgeConfig.name} ${ircChannel} <-> ` + ` ${telegramChannel}`);
      return this.startBridge(ircChannel, telegramChannel, bridgeConfig);
    }).then(bridges => {
      this._bridges = bridges;
      return bridges;
    });
  }

}, (_applyDecoratedDescriptor(_class.prototype, "_constructor", [_dec], Object.getOwnPropertyDescriptor(_class.prototype, "_constructor"), _class.prototype), _applyDecoratedDescriptor(_class.prototype, "_makeBridgesTree", [_dec2], Object.getOwnPropertyDescriptor(_class.prototype, "_makeBridgesTree"), _class.prototype), _applyDecoratedDescriptor(_class.prototype, "startBridge", [_dec3], Object.getOwnPropertyDescriptor(_class.prototype, "startBridge"), _class.prototype), _applyDecoratedDescriptor(_class.prototype, "start", [_dec4], Object.getOwnPropertyDescriptor(_class.prototype, "start"), _class.prototype)), _class));
exports.default = Session;