chat-service/lib/CommandBinder.js

'use strict';

var _slicedToArray2 = require('babel-runtime/helpers/slicedToArray');

var _slicedToArray3 = _interopRequireDefault(_slicedToArray2);

var _toConsumableArray2 = require('babel-runtime/helpers/toConsumableArray');

var _toConsumableArray3 = _interopRequireDefault(_toConsumableArray2);

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

var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

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

var _createClass3 = _interopRequireDefault(_createClass2);

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

var ExecInfo = require('./ExecInfo');
var Promise = require('bluebird');
var _ = require('lodash');

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

var execHook = _require.execHook;
var logError = _require.logError;
var possiblyCallback = _require.possiblyCallback;
var resultsTransform = _require.resultsTransform;

// Implements command functions binding and wrapping.

var CommandBinder = function () {
  function CommandBinder(server, transport, userName) {
    (0, _classCallCheck3.default)(this, CommandBinder);

    this.server = server;
    this.transport = transport;
    this.userName = userName;
  }

  (0, _createClass3.default)(CommandBinder, [{
    key: 'commandWatcher',
    value: function commandWatcher(id, name) {
      var _this = this;

      this.server.runningCommands++;
      return Promise.resolve().disposer(function () {
        _this.server.runningCommands--;
        if (_this.transport.closed && _this.server.runningCommands <= 0) {
          _this.server.emit('commandsFinished');
        }
      });
    }
  }, {
    key: 'makeCommand',
    value: function makeCommand(name, fn) {
      var _this2 = this;

      var validator = this.server.validator;

      var beforeHook = this.server.hooks[name + 'Before'];
      var afterHook = this.server.hooks[name + 'After'];
      return function (args, info) {
        var execInfo = new ExecInfo();
        _.assign(execInfo, { server: _this2.server, userName: _this2.userName });
        _.assign(execInfo, info);
        _.assign(execInfo, validator.splitArguments(name, args));
        return Promise.using(_this2.commandWatcher(info.id, name), function () {
          return validator.checkArguments.apply(validator, [name].concat((0, _toConsumableArray3.default)(execInfo.args))).then(function () {
            if (beforeHook && !execInfo.bypassHooks) {
              return execHook(beforeHook, execInfo);
            } else {
              return Promise.resolve();
            }
          }).then(function (results) {
            if (results && results.length) {
              return results;
            }
            return fn.apply(undefined, (0, _toConsumableArray3.default)(execInfo.args).concat([execInfo])).then(function (result) {
              execInfo.results = [result];
            }, function (error) {
              execInfo.error = error;
            }).then(function () {
              if (afterHook && !execInfo.bypassHooks) {
                return execHook(afterHook, execInfo);
              } else {
                return Promise.resolve();
              }
            }).then(function (results) {
              if (results && results.length) {
                return results;
              } else if (execInfo.error) {
                return Promise.reject(execInfo.error);
              } else {
                return execInfo.results;
              }
            });
          });
        }).catch(function (error) {
          return logError(error);
        });
      };
    }
  }, {
    key: 'bindDisconnect',
    value: function bindDisconnect(id, fn) {
      var _this3 = this;

      var server = this.server;
      var hook = this.server.hooks.onDisconnect;
      this.transport.bindHandler(id, 'disconnect', function () {
        return Promise.using(_this3.commandWatcher(id, 'disconnect'), function () {
          return fn(id).catch(function (error) {
            return logError(error);
          }).catchReturn().then(function () {
            return execHook(hook, server, id);
          }).catch(function (error) {
            return logError(error);
          }).catchReturn();
        });
      });
    }
  }, {
    key: 'bindCommand',
    value: function bindCommand(id, name, fn) {
      var cmd = this.makeCommand(name, fn);
      var useErrorObjects = this.server.useRawErrorObjects;
      var info = { id: id };
      return this.transport.bindHandler(id, name, function () {
        var _possiblyCallback = possiblyCallback(arguments);

        var _possiblyCallback2 = (0, _slicedToArray3.default)(_possiblyCallback, 2);

        var args = _possiblyCallback2[0];
        var cb = _possiblyCallback2[1];

        var ack = resultsTransform(useErrorObjects, cb);
        return cmd(args, info).asCallback(ack, { spread: true });
      });
    }
  }]);
  return CommandBinder;
}();

module.exports = CommandBinder;
//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../src/CommandBinder.js"],"names":[],"mappings":"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","file":"CommandBinder.js","sourcesContent":["'use strict'\n\nconst ExecInfo = require('./ExecInfo')\nconst Promise = require('bluebird')\nconst _ = require('lodash')\nconst { execHook, logError, possiblyCallback, resultsTransform } =\n        require('./utils')\n\n// Implements command functions binding and wrapping.\nclass CommandBinder {\n\n  constructor (server, transport, userName) {\n    this.server = server\n    this.transport = transport\n    this.userName = userName\n  }\n\n  commandWatcher (id, name) {\n    this.server.runningCommands++\n    return Promise.resolve().disposer(() => {\n      this.server.runningCommands--\n      if (this.transport.closed && this.server.runningCommands <= 0) {\n        this.server.emit('commandsFinished')\n      }\n    })\n  }\n\n  makeCommand (name, fn) {\n    let { validator } = this.server\n    let beforeHook = this.server.hooks[`${name}Before`]\n    let afterHook = this.server.hooks[`${name}After`]\n    return (args, info) => {\n      let execInfo = new ExecInfo()\n      _.assign(execInfo, { server: this.server, userName: this.userName })\n      _.assign(execInfo, info)\n      _.assign(execInfo, validator.splitArguments(name, args))\n      return Promise.using(\n        this.commandWatcher(info.id, name),\n        () => validator.checkArguments(name, ...execInfo.args)\n          .then(() => {\n            if (beforeHook && !execInfo.bypassHooks) {\n              return execHook(beforeHook, execInfo)\n            } else {\n              return Promise.resolve()\n            } })\n          .then(results => {\n            if (results && results.length) { return results }\n            return fn(...execInfo.args, execInfo)\n              .then(result => { execInfo.results = [result] },\n                    error => { execInfo.error = error })\n              .then(() => {\n                if (afterHook && !execInfo.bypassHooks) {\n                  return execHook(afterHook, execInfo)\n                } else {\n                  return Promise.resolve()\n                } })\n              .then(results => {\n                if (results && results.length) {\n                  return results\n                } else if (execInfo.error) {\n                  return Promise.reject(execInfo.error)\n                } else {\n                  return execInfo.results\n                }\n              })\n          }))\n        .catch(error => logError(error))\n    }\n  }\n\n  bindDisconnect (id, fn) {\n    let server = this.server\n    let hook = this.server.hooks.onDisconnect\n    this.transport.bindHandler(id, 'disconnect', () => {\n      return Promise.using(\n        this.commandWatcher(id, 'disconnect'),\n        () => fn(id)\n          .catch(error => logError(error))\n          .catchReturn()\n          .then(() => execHook(hook, server, id))\n          .catch(error => logError(error))\n          .catchReturn())\n    })\n  }\n\n  bindCommand (id, name, fn) {\n    let cmd = this.makeCommand(name, fn)\n    let useErrorObjects = this.server.useRawErrorObjects\n    let info = {id}\n    return this.transport.bindHandler(id, name, function () {\n      let [args, cb] = possiblyCallback(arguments)\n      let ack = resultsTransform(useErrorObjects, cb)\n      return cmd(args, info).asCallback(ack, { spread: true })\n    })\n  }\n\n}\n\nmodule.exports = CommandBinder\n"]}