chat-service/lib/ChatService.js

'use strict';

/**
 * Node style callback. All callbacks are optional, promises may be
 * used instead. But only one API must be used per invocation.
 *
 * @callback callback
 * @param {Error} error
 * @param {...*} results
 */

/**
 * Server side related documentation.
 *
 * @example <caption>npm package usage</caption>
 *   let ChatService = require('chat-service')
 *
 * @namespace chat-service
 */

var _getPrototypeOf = require('babel-runtime/core-js/object/get-prototype-of');

var _getPrototypeOf2 = _interopRequireDefault(_getPrototypeOf);

var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

var _createClass2 = require('babel-runtime/helpers/createClass');

var _createClass3 = _interopRequireDefault(_createClass2);

var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');

var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);

var _inherits2 = require('babel-runtime/helpers/inherits');

var _inherits3 = _interopRequireDefault(_inherits2);

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

var ArgumentsValidator = require('./ArgumentsValidator');
var ChatServiceError = require('./ChatServiceError');
var MemoryState = require('./MemoryState');
var Promise = require('bluebird');
var RecoveryAPI = require('./RecoveryAPI');
var RedisState = require('./RedisState');
var Room = require('./Room');
var ServiceAPI = require('./ServiceAPI');
var SocketIOClusterBus = require('./SocketIOClusterBus');
var SocketIOTransport = require('./SocketIOTransport');
var User = require('./User');
var _ = require('lodash');
var uid = require('uid-safe');

var _require = require('events');

var EventEmitter = _require.EventEmitter;

var _require2 = require('./utils');

var checkNameSymbols = _require2.checkNameSymbols;
var _convertError = _require2.convertError;
var execHook = _require2.execHook;
var logError = _require2.logError;

var _require3 = require('es6-mixin');

var mixin = _require3.mixin;


var rpcRequestsNames = ['directAddToList', 'directGetAccessList', 'directGetWhitelistMode', 'directMessage', 'directRemoveFromList', 'directSetWhitelistMode', 'listOwnSockets', 'roomAddToList', 'roomCreate', 'roomDelete', 'roomGetAccessList', 'roomGetOwner', 'roomGetWhitelistMode', 'roomHistoryGet', 'roomHistoryInfo', 'roomJoin', 'roomLeave', 'roomMessage', 'roomNotificationsInfo', 'roomRecentHistory', 'roomRemoveFromList', 'roomSetWhitelistMode', 'roomUserSeen', 'systemMessage'];

/**
 * Service class, is the package exported object.
 *
 * @extends EventEmitter
 *
 * @mixes chat-service.ServiceAPI
 * @mixes chat-service.RecoveryAPI
 *
 * @fires chat-service.ChatService.ready
 * @fires chat-service.ChatService.closed
 * @fires chat-service.ChatService.storeConsistencyFailure
 * @fires chat-service.ChatService.transportConsistencyFailure
 * @fires chat-service.ChatService.lockTimeExceeded
 *
 * @example <caption>starting a server</caption>
 *   let ChatService = require('chat-service')
 *   let service = new ChatService(options, hooks)
 *
 * @example <caption>server-side: adding a room</caption>
 *   let owner = 'admin'
 *   let whitelistOnly = true
 *   let whitelist = [ 'user' ]
 *   let state = { owner, whitelistOnly, whitelist }
 *   chatService.addRoom('someRoom', state).then(fn)
 *
 * @example <caption>server-side: sending a room message</caption>
 *   let room = 'someRoom'
 *   let msg = { textMessage: 'some message' }
 *   let context = {
 *     userName: 'system',
 *     bypassPermissions: true
 *   }
 *   chatService.execUserCommand(context, 'roomMessage', room, msg)
 *     .then(fn)
 *
 * @example <caption>server-side: joining an user socket to a room</caption>
 *   let room = 'someRoom'
 *   let context = {
 *     userName: 'user',
 *     id: id // socket id
 *   }
 *   chatService.execUserCommand(context, 'roomJoin', room)
 *     .then(fn) // real sockets will get a notification
 *
 * @memberof chat-service
 *
 */

var ChatService = function (_EventEmitter) {
  (0, _inherits3.default)(ChatService, _EventEmitter);

  /**
   * Crates an object and starts a new service instance. The {@link
   * chat-service.ChatService#close} method __MUST__ be called before
   * the node process exit.
   *
   * @param {chat-service.config.options} [options] Service
   * configuration options.
   *
   * @param {chat-service.hooks.HooksInterface} [hooks] Service
   * customisation hooks.
   */
  function ChatService() {
    var options = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];
    var hooks = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];
    (0, _classCallCheck3.default)(this, ChatService);

    var _this = (0, _possibleConstructorReturn3.default)(this, (0, _getPrototypeOf2.default)(ChatService).call(this));

    _this.options = options;
    _this.hooks = hooks;
    _this.initVariables();
    _this.setOptions();
    _this.setIntegraionOptions();
    _this.setComponents();
    _this.attachBusListeners();
    mixin(_this, ServiceAPI, _this.state, function () {
      return new User(_this);
    }, _this.clusterBus);
    mixin(_this, RecoveryAPI, _this.state, _this.transport, _this.execUserCommand.bind(_this), _this.instanceUID);
    _this.startServer();
    return _this;
  }

  /**
   * ChatService errors constructor. This errors are intended to be
   * returned to clients as a part of a normal service functioning
   * (something like 403 errors). Can be also used to create custom
   * errors subclasses.
   *
   * @name ChatServiceError
   * @type Class
   * @static
   * @readonly
   *
   * @memberof chat-service.ChatService
   *
   * @see rpc.datatypes.ChatServiceError
   */

  /**
   * Service instance UID.
   *
   * @name chat-service.ChatService#instanceUID
   * @type string
   * @readonly
   */

  /**
   * Cluster communication via an adapter. Emits messages to all
   * services nodes, including the sender node.
   *
   * @name chat-service.ChatService#clusterBus
   * @type EventEmitter
   * @readonly
   */

  /**
   * Transport object.
   *
   * @name chat-service.ChatService#transport
   * @type chat-service.TransportInterface
   * @readonly
   */

  /**
   * Service is ready, state and transport are up.
   * @event ready
   *
   * @memberof chat-service.ChatService
   */

  /**
   * Service is closed, state and transport are closed.
   * @event closed
   * @param {Error} [error] If was closed due to an error.
   *
   * @memberof chat-service.ChatService
   */

  /**
   * State store failed to be updated to reflect an user's connection
   * or presence state.
   *
   * @event storeConsistencyFailure
   * @param {Error} error Error.
   * @param {Object} operationInfo Operation details.
   * @property {string} operationInfo.userName User name.
   * @property {string} operationInfo.opType Operation type.
   * @property {string} [operationInfo.roomName] Room name.
   * @property {string} [operationInfo.id] Socket id.
   *
   * @see chat-service.RecoveryAPI
   *
   * @memberof chat-service.ChatService
   */

  /**
   * Failed to teardown a transport connection.
   *
   * @event transportConsistencyFailure
   *
   * @param {Error} error Error.
   * @param {Object} operationInfo Operation details.
   * @property {string} operationInfo.userName User name.
   * @property {string} operationInfo.opType Operation type.
   * @property {string} [operationInfo.roomName] Room name.
   * @property {string} [operationInfo.id] Socket id.
   *
   * @memberof chat-service.ChatService
   */

  /**
   * Lock was hold longer than a lock ttl.
   *
   * @event lockTimeExceeded
   *
   * @param {string} id Lock id.
   * @param {Object} lockInfo Lock resource details.
   * @property {string} [lockInfo.userName] User name.
   * @property {string} [lockInfo.roomName] Room name.
   *
   * @see chat-service.RecoveryAPI
   *
   * @memberof chat-service.ChatService
   */

  /**
   * Exposes an internal arguments validation method, it is run
   * automatically by all client request (command) handlers.
   *
   * @method chat-service.ChatService#checkArguments
   *
   * @param {string} name Command name.
   * @param {...*} args Command arguments.
   * @param {callback} [cb] Optional callback.
   *
   * @return {Promise<undefined>} Promise that resolves without any
   * data if validation is successful, otherwise a promise is
   * rejected.
   */

  (0, _createClass3.default)(ChatService, [{
    key: 'initVariables',
    value: function initVariables() {
      this.instanceUID = uid.sync(18);
      this.runningCommands = 0;
      this.rpcRequestsNames = rpcRequestsNames;
      this.closed = false;
      // constants
      this.ChatServiceError = ChatServiceError;
      this.SocketIOClusterBus = SocketIOClusterBus;
      this.User = User;
      this.Room = Room;
    }
  }, {
    key: 'setOptions',
    value: function setOptions() {
      this.closeTimeout = this.options.closeTimeout || 15000;
      this.busAckTimeout = this.options.busAckTimeout || 5000;
      this.heartbeatRate = this.options.heartbeatRate || 10000;
      this.heartbeatTimeout = this.options.heartbeatTimeout || 30000;
      this.directListSizeLimit = this.options.directListSizeLimit || 1000;
      this.roomListSizeLimit = this.options.roomListSizeLimit || 10000;
      this.enableAccessListsUpdates = this.options.enableAccessListsUpdates || false;
      this.enableDirectMessages = this.options.enableDirectMessages || false;
      this.enableRoomsManagement = this.options.enableRoomsManagement || false;
      this.enableUserlistUpdates = this.options.enableUserlistUpdates || false;
      this.historyMaxGetMessages = this.options.historyMaxGetMessages;
      if (!_.isNumber(this.historyMaxGetMessages) || this.historyMaxGetMessages < 0) {
        this.historyMaxGetMessages = 100;
      }
      this.historyMaxSize = this.options.historyMaxSize;
      if (!_.isNumber(this.historyMaxSize) || this.historyMaxSize < 0) {
        this.historyMaxSize = 10000;
      }
      this.port = this.options.port || 8000;
      this.directMessagesChecker = this.hooks.directMessagesChecker;
      this.roomMessagesChecker = this.hooks.roomMessagesChecker;
      this.useRawErrorObjects = this.options.useRawErrorObjects || false;
    }
  }, {
    key: 'setIntegraionOptions',
    value: function setIntegraionOptions() {
      this.adapterConstructor = this.options.adapter || 'memory';
      this.adapterOptions = _.castArray(this.options.adapterOptions);

      this.stateConstructor = this.options.state || 'memory';
      this.stateOptions = this.options.stateOptions || {};

      this.transportConstructor = this.options.transport || 'socket.io';
      this.transportOptions = this.options.transportOptions || {};
    }
  }, {
    key: 'setComponents',
    value: function setComponents() {
      var _this2 = this;

      var State = function () {
        switch (true) {
          case _this2.stateConstructor === 'memory':
            return MemoryState;
          case _this2.stateConstructor === 'redis':
            return RedisState;
          case _.isFunction(_this2.stateConstructor):
            return _this2.stateConstructor;
          default:
            throw new Error('Invalid state: ' + _this2.stateConstructor);
        }
      }();
      var Transport = function () {
        switch (true) {
          case _this2.transportConstructor === 'socket.io':
            return SocketIOTransport;
          case _.isFunction(_this2.transportConstructor):
            return _this2.transportConstructor;
          default:
            throw new Error('Invalid transport: ' + _this2.transportConstructor);
        }
      }();
      this.validator = new ArgumentsValidator(this);
      this.checkArguments = this.validator.checkArguments.bind(this.validator);
      this.state = new State(this, this.stateOptions);
      this.transport = new Transport(this, this.transportOptions, this.adapterConstructor, this.adapterOptions);
      this.clusterBus = this.transport.clusterBus;
    }
  }, {
    key: 'attachBusListeners',
    value: function attachBusListeners() {
      var _this3 = this;

      this.clusterBus.on('roomLeaveSocket', function (id, roomName) {
        return _this3.transport.leaveChannel(id, roomName).then(function () {
          return _this3.clusterBus.emit('socketRoomLeft', id, roomName);
        }).catchReturn();
      });
      this.clusterBus.on('disconnectUserSockets', function (userName) {
        return _this3.state.getUser(userName).then(function (user) {
          return user.disconnectInstanceSockets();
        }).catchReturn();
      });
    }

    // for transport plugins integration

  }, {
    key: 'convertError',
    value: function convertError(error) {
      return _convertError(error, this.useRawErrorObjects);
    }

    // for transport plugins integration

  }, {
    key: 'onConnect',
    value: function onConnect(id) {
      var _this4 = this;

      if (this.hooks.onConnect) {
        return Promise.try(function () {
          return execHook(_this4.hooks.onConnect, _this4, id);
        }).then(function (loginData) {
          loginData = _.castArray(loginData);
          return Promise.resolve(loginData);
        }).catch(function (error) {
          return logError(error);
        });
      } else {
        return Promise.resolve([]);
      }
    }

    // for transport plugins integration

  }, {
    key: 'registerClient',
    value: function registerClient(userName, id) {
      var _this5 = this;

      return checkNameSymbols(userName).then(function () {
        return _this5.state.getOrAddUser(userName);
      }).then(function (user) {
        return user.registerSocket(id);
      }).catch(function (error) {
        return logError(error);
      });
    }
  }, {
    key: 'waitCommands',
    value: function waitCommands() {
      var _this6 = this;

      if (this.runningCommands > 0) {
        return Promise.fromCallback(function (cb) {
          return _this6.once('commandsFinished', cb);
        });
      } else {
        return Promise.resolve();
      }
    }
  }, {
    key: 'closeTransport',
    value: function closeTransport() {
      var _this7 = this;

      return this.transport.close().then(function () {
        return _this7.waitCommands();
      }).timeout(this.closeTimeout);
    }
  }, {
    key: 'startServer',
    value: function startServer() {
      var _this8 = this;

      return Promise.try(function () {
        if (_this8.hooks.onStart) {
          return _this8.clusterBus.listen().then(function () {
            return execHook(_this8.hooks.onStart, _this8);
          }).then(function () {
            return _this8.transport.setEvents();
          });
        } else {
          // tests spec compatibility
          _this8.transport.setEvents();
          return _this8.clusterBus.listen();
        }
      }).then(function () {
        _this8.state.updateHeartbeat();
        var hbupdater = _this8.state.updateHeartbeat.bind(_this8.state);
        _this8.hbtimer = setInterval(hbupdater, _this8.heartbeatRate);
        return _this8.emit('ready');
      }).catch(function (error) {
        _this8.closed = true;
        return _this8.closeTransport().then(function () {
          return _this8.state.close();
        }).finally(function () {
          return _this8.emit('closed', error);
        });
      });
    }

    /**
     * Closes server.
     * @note __MUST__ be called before node process shutdown to correctly
     *   update the state.
     * @param {callback} [cb] Optional callback.
     * @return {Promise<undefined>} Promise that resolves without any data.
     */

  }, {
    key: 'close',
    value: function close(cb) {
      var _this9 = this;

      if (this.closed) {
        return Promise.resolve();
      }
      this.closed = true;
      clearInterval(this.hbtimer);
      var closeError = null;
      return this.closeTransport().then(function () {
        return execHook(_this9.hooks.onClose, _this9, null);
      }, function (error) {
        if (_this9.hooks.onClose) {
          return execHook(_this9.hooks.onClose, _this9, error);
        } else {
          return Promise.reject(error);
        }
      }).catch(function (error) {
        closeError = error;
        return Promise.reject(error);
      }).finally(function () {
        return _this9.state.close().finally(function () {
          return _this9.emit('closed', closeError);
        });
      }).asCallback(cb);
    }
  }]);
  return ChatService;
}(EventEmitter);

// for custom errors


ChatService.ChatServiceError = ChatServiceError;

// for transport plugin implementations
ChatService.SocketIOClusterBus = SocketIOClusterBus;

// for store plugin implementations
ChatService.User = User;
ChatService.Room = Room;

module.exports = ChatService;
//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../src/ChatService.js"],"names":[],"mappings":"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","file":"ChatService.js","sourcesContent":["'use strict'\n\n/**\n * Node style callback. All callbacks are optional, promises may be\n * used instead. But only one API must be used per invocation.\n *\n * @callback callback\n * @param {Error} error\n * @param {...*} results\n */\n\n/**\n * Server side related documentation.\n *\n * @example <caption>npm package usage</caption>\n *   let ChatService = require('chat-service')\n *\n * @namespace chat-service\n */\n\nconst ArgumentsValidator = require('./ArgumentsValidator')\nconst ChatServiceError = require('./ChatServiceError')\nconst MemoryState = require('./MemoryState')\nconst Promise = require('bluebird')\nconst RecoveryAPI = require('./RecoveryAPI')\nconst RedisState = require('./RedisState')\nconst Room = require('./Room')\nconst ServiceAPI = require('./ServiceAPI')\nconst SocketIOClusterBus = require('./SocketIOClusterBus')\nconst SocketIOTransport = require('./SocketIOTransport')\nconst User = require('./User')\nconst _ = require('lodash')\nconst uid = require('uid-safe')\nconst { EventEmitter } = require('events')\nconst { checkNameSymbols, convertError, execHook, logError } =\n        require('./utils')\nconst { mixin } = require('es6-mixin')\n\nconst rpcRequestsNames = [\n  'directAddToList',\n  'directGetAccessList',\n  'directGetWhitelistMode',\n  'directMessage',\n  'directRemoveFromList',\n  'directSetWhitelistMode',\n  'listOwnSockets',\n  'roomAddToList',\n  'roomCreate',\n  'roomDelete',\n  'roomGetAccessList',\n  'roomGetOwner',\n  'roomGetWhitelistMode',\n  'roomHistoryGet',\n  'roomHistoryInfo',\n  'roomJoin',\n  'roomLeave',\n  'roomMessage',\n  'roomNotificationsInfo',\n  'roomRecentHistory',\n  'roomRemoveFromList',\n  'roomSetWhitelistMode',\n  'roomUserSeen',\n  'systemMessage'\n]\n\n/**\n * Service class, is the package exported object.\n *\n * @extends EventEmitter\n *\n * @mixes chat-service.ServiceAPI\n * @mixes chat-service.RecoveryAPI\n *\n * @fires chat-service.ChatService.ready\n * @fires chat-service.ChatService.closed\n * @fires chat-service.ChatService.storeConsistencyFailure\n * @fires chat-service.ChatService.transportConsistencyFailure\n * @fires chat-service.ChatService.lockTimeExceeded\n *\n * @example <caption>starting a server</caption>\n *   let ChatService = require('chat-service')\n *   let service = new ChatService(options, hooks)\n *\n * @example <caption>server-side: adding a room</caption>\n *   let owner = 'admin'\n *   let whitelistOnly = true\n *   let whitelist = [ 'user' ]\n *   let state = { owner, whitelistOnly, whitelist }\n *   chatService.addRoom('someRoom', state).then(fn)\n *\n * @example <caption>server-side: sending a room message</caption>\n *   let room = 'someRoom'\n *   let msg = { textMessage: 'some message' }\n *   let context = {\n *     userName: 'system',\n *     bypassPermissions: true\n *   }\n *   chatService.execUserCommand(context, 'roomMessage', room, msg)\n *     .then(fn)\n *\n * @example <caption>server-side: joining an user socket to a room</caption>\n *   let room = 'someRoom'\n *   let context = {\n *     userName: 'user',\n *     id: id // socket id\n *   }\n *   chatService.execUserCommand(context, 'roomJoin', room)\n *     .then(fn) // real sockets will get a notification\n *\n * @memberof chat-service\n *\n */\nclass ChatService extends EventEmitter {\n\n  /**\n   * Crates an object and starts a new service instance. The {@link\n   * chat-service.ChatService#close} method __MUST__ be called before\n   * the node process exit.\n   *\n   * @param {chat-service.config.options} [options] Service\n   * configuration options.\n   *\n   * @param {chat-service.hooks.HooksInterface} [hooks] Service\n   * customisation hooks.\n   */\n  constructor (options = {}, hooks = {}) {\n    super()\n    this.options = options\n    this.hooks = hooks\n    this.initVariables()\n    this.setOptions()\n    this.setIntegraionOptions()\n    this.setComponents()\n    this.attachBusListeners()\n    mixin(this, ServiceAPI, this.state,\n          () => new User(this), this.clusterBus)\n    mixin(this, RecoveryAPI, this.state, this.transport,\n          this.execUserCommand.bind(this), this.instanceUID)\n    this.startServer()\n  }\n\n  /**\n   * ChatService errors constructor. This errors are intended to be\n   * returned to clients as a part of a normal service functioning\n   * (something like 403 errors). Can be also used to create custom\n   * errors subclasses.\n   *\n   * @name ChatServiceError\n   * @type Class\n   * @static\n   * @readonly\n   *\n   * @memberof chat-service.ChatService\n   *\n   * @see rpc.datatypes.ChatServiceError\n   */\n\n  /**\n   * Service instance UID.\n   *\n   * @name chat-service.ChatService#instanceUID\n   * @type string\n   * @readonly\n   */\n\n  /**\n   * Cluster communication via an adapter. Emits messages to all\n   * services nodes, including the sender node.\n   *\n   * @name chat-service.ChatService#clusterBus\n   * @type EventEmitter\n   * @readonly\n   */\n\n  /**\n   * Transport object.\n   *\n   * @name chat-service.ChatService#transport\n   * @type chat-service.TransportInterface\n   * @readonly\n   */\n\n  /**\n   * Service is ready, state and transport are up.\n   * @event ready\n   *\n   * @memberof chat-service.ChatService\n   */\n\n  /**\n   * Service is closed, state and transport are closed.\n   * @event closed\n   * @param {Error} [error] If was closed due to an error.\n   *\n   * @memberof chat-service.ChatService\n   */\n\n  /**\n   * State store failed to be updated to reflect an user's connection\n   * or presence state.\n   *\n   * @event storeConsistencyFailure\n   * @param {Error} error Error.\n   * @param {Object} operationInfo Operation details.\n   * @property {string} operationInfo.userName User name.\n   * @property {string} operationInfo.opType Operation type.\n   * @property {string} [operationInfo.roomName] Room name.\n   * @property {string} [operationInfo.id] Socket id.\n   *\n   * @see chat-service.RecoveryAPI\n   *\n   * @memberof chat-service.ChatService\n   */\n\n  /**\n   * Failed to teardown a transport connection.\n   *\n   * @event transportConsistencyFailure\n   *\n   * @param {Error} error Error.\n   * @param {Object} operationInfo Operation details.\n   * @property {string} operationInfo.userName User name.\n   * @property {string} operationInfo.opType Operation type.\n   * @property {string} [operationInfo.roomName] Room name.\n   * @property {string} [operationInfo.id] Socket id.\n   *\n   * @memberof chat-service.ChatService\n   */\n\n  /**\n   * Lock was hold longer than a lock ttl.\n   *\n   * @event lockTimeExceeded\n   *\n   * @param {string} id Lock id.\n   * @param {Object} lockInfo Lock resource details.\n   * @property {string} [lockInfo.userName] User name.\n   * @property {string} [lockInfo.roomName] Room name.\n   *\n   * @see chat-service.RecoveryAPI\n   *\n   * @memberof chat-service.ChatService\n   */\n\n  /**\n   * Exposes an internal arguments validation method, it is run\n   * automatically by all client request (command) handlers.\n   *\n   * @method chat-service.ChatService#checkArguments\n   *\n   * @param {string} name Command name.\n   * @param {...*} args Command arguments.\n   * @param {callback} [cb] Optional callback.\n   *\n   * @return {Promise<undefined>} Promise that resolves without any\n   * data if validation is successful, otherwise a promise is\n   * rejected.\n   */\n\n  initVariables () {\n    this.instanceUID = uid.sync(18)\n    this.runningCommands = 0\n    this.rpcRequestsNames = rpcRequestsNames\n    this.closed = false\n    // constants\n    this.ChatServiceError = ChatServiceError\n    this.SocketIOClusterBus = SocketIOClusterBus\n    this.User = User\n    this.Room = Room\n  }\n\n  setOptions () {\n    this.closeTimeout = this.options.closeTimeout || 15000\n    this.busAckTimeout = this.options.busAckTimeout || 5000\n    this.heartbeatRate = this.options.heartbeatRate || 10000\n    this.heartbeatTimeout = this.options.heartbeatTimeout || 30000\n    this.directListSizeLimit = this.options.directListSizeLimit || 1000\n    this.roomListSizeLimit = this.options.roomListSizeLimit || 10000\n    this.enableAccessListsUpdates =\n      this.options.enableAccessListsUpdates || false\n    this.enableDirectMessages = this.options.enableDirectMessages || false\n    this.enableRoomsManagement = this.options.enableRoomsManagement || false\n    this.enableUserlistUpdates = this.options.enableUserlistUpdates || false\n    this.historyMaxGetMessages = this.options.historyMaxGetMessages\n    if (!_.isNumber(this.historyMaxGetMessages) ||\n        this.historyMaxGetMessages < 0) {\n      this.historyMaxGetMessages = 100\n    }\n    this.historyMaxSize = this.options.historyMaxSize\n    if (!_.isNumber(this.historyMaxSize) ||\n        this.historyMaxSize < 0) {\n      this.historyMaxSize = 10000\n    }\n    this.port = this.options.port || 8000\n    this.directMessagesChecker = this.hooks.directMessagesChecker\n    this.roomMessagesChecker = this.hooks.roomMessagesChecker\n    this.useRawErrorObjects = this.options.useRawErrorObjects || false\n  }\n\n  setIntegraionOptions () {\n    this.adapterConstructor = this.options.adapter || 'memory'\n    this.adapterOptions = _.castArray(this.options.adapterOptions)\n\n    this.stateConstructor = this.options.state || 'memory'\n    this.stateOptions = this.options.stateOptions || {}\n\n    this.transportConstructor = this.options.transport || 'socket.io'\n    this.transportOptions = this.options.transportOptions || {}\n  }\n\n  setComponents () {\n    let State = (() => {\n      switch (true) {\n        case this.stateConstructor === 'memory':\n          return MemoryState\n        case this.stateConstructor === 'redis':\n          return RedisState\n        case _.isFunction(this.stateConstructor):\n          return this.stateConstructor\n        default:\n          throw new Error(`Invalid state: ${this.stateConstructor}`)\n      }\n    })()\n    let Transport = (() => {\n      switch (true) {\n        case this.transportConstructor === 'socket.io':\n          return SocketIOTransport\n        case _.isFunction(this.transportConstructor):\n          return this.transportConstructor\n        default:\n          throw new Error(`Invalid transport: ${this.transportConstructor}`)\n      }\n    })()\n    this.validator = new ArgumentsValidator(this)\n    this.checkArguments = this.validator.checkArguments.bind(this.validator)\n    this.state = new State(this, this.stateOptions)\n    this.transport = new Transport(\n      this, this.transportOptions,\n      this.adapterConstructor, this.adapterOptions)\n    this.clusterBus = this.transport.clusterBus\n  }\n\n  attachBusListeners () {\n    this.clusterBus.on('roomLeaveSocket', (id, roomName) => {\n      return this.transport.leaveChannel(id, roomName)\n        .then(() => this.clusterBus.emit('socketRoomLeft', id, roomName))\n        .catchReturn()\n    })\n    this.clusterBus.on('disconnectUserSockets', userName => {\n      return this.state.getUser(userName)\n        .then(user => user.disconnectInstanceSockets())\n        .catchReturn()\n    })\n  }\n\n  // for transport plugins integration\n  convertError (error) {\n    return convertError(error, this.useRawErrorObjects)\n  }\n\n  // for transport plugins integration\n  onConnect (id) {\n    if (this.hooks.onConnect) {\n      return Promise.try(() => {\n        return execHook(this.hooks.onConnect, this, id)\n      }).then(loginData => {\n        loginData = _.castArray(loginData)\n        return Promise.resolve(loginData)\n      }).catch(error => logError(error))\n    } else {\n      return Promise.resolve([])\n    }\n  }\n\n  // for transport plugins integration\n  registerClient (userName, id) {\n    return checkNameSymbols(userName)\n      .then(() => this.state.getOrAddUser(userName))\n      .then(user => user.registerSocket(id))\n      .catch(error => logError(error))\n  }\n\n  waitCommands () {\n    if (this.runningCommands > 0) {\n      return Promise.fromCallback(cb => {\n        return this.once('commandsFinished', cb)\n      })\n    } else {\n      return Promise.resolve()\n    }\n  }\n\n  closeTransport () {\n    return this.transport.close()\n      .then(() => this.waitCommands())\n      .timeout(this.closeTimeout)\n  }\n\n  startServer () {\n    return Promise.try(() => {\n      if (this.hooks.onStart) {\n        return this.clusterBus.listen()\n          .then(() => execHook(this.hooks.onStart, this))\n          .then(() => this.transport.setEvents())\n      } else {\n        // tests spec compatibility\n        this.transport.setEvents()\n        return this.clusterBus.listen()\n      }\n    }).then(() => {\n      this.state.updateHeartbeat()\n      let hbupdater = this.state.updateHeartbeat.bind(this.state)\n      this.hbtimer = setInterval(hbupdater, this.heartbeatRate)\n      return this.emit('ready')\n    }).catch(error => {\n      this.closed = true\n      return this.closeTransport()\n        .then(() => this.state.close())\n        .finally(() => this.emit('closed', error))\n    })\n  }\n\n  /**\n   * Closes server.\n   * @note __MUST__ be called before node process shutdown to correctly\n   *   update the state.\n   * @param {callback} [cb] Optional callback.\n   * @return {Promise<undefined>} Promise that resolves without any data.\n   */\n  close (cb) {\n    if (this.closed) { return Promise.resolve() }\n    this.closed = true\n    clearInterval(this.hbtimer)\n    let closeError = null\n    return this.closeTransport().then(\n      () => execHook(this.hooks.onClose, this, null),\n      error => {\n        if (this.hooks.onClose) {\n          return execHook(this.hooks.onClose, this, error)\n        } else {\n          return Promise.reject(error)\n        }\n      }).catch(error => {\n        closeError = error\n        return Promise.reject(error)\n      }).finally(() => {\n        return this.state.close()\n          .finally(() => this.emit('closed', closeError))\n      }).asCallback(cb)\n  }\n}\n\n// for custom errors\nChatService.ChatServiceError = ChatServiceError\n\n// for transport plugin implementations\nChatService.SocketIOClusterBus = SocketIOClusterBus\n\n// for store plugin implementations\nChatService.User = User\nChatService.Room = Room\n\nmodule.exports = ChatService\n"]}