marsdb-sync-client/dist/MethodCallManager.js

Standalone Meteor DDP client based on MarsDB

'use strict';

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _bind2 = require('fast.js/function/bind');

var _bind3 = _interopRequireDefault(_bind2);

var _forEach = require('fast.js/forEach');

var _forEach2 = _interopRequireDefault(_forEach);

var _MethodCall = require('./MethodCall');

var _MethodCall2 = _interopRequireDefault(_MethodCall);

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

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

/**
 * Make an RPC calls and track results.
 * Track a DDP connection for canceling active
 * methods calls.
 */

var MethodCallManager = function () {
  function MethodCallManager(connection) {
    _classCallCheck(this, MethodCallManager);

    this.conn = connection;
    this._methods = {};

    connection.on('status:disconnected', (0, _bind3.default)(this._handleDisconnected, this));
    connection.on('status:connected', (0, _bind3.default)(this._handleConnected, this));
    connection.on('message:result', (0, _bind3.default)(this._handleMethodResult, this));
    connection.on('message:updated', (0, _bind3.default)(this._handleMethodUpdated, this));
  }

  /**
   * Call a Meteor method
   * @param  {String} method
   * @param  {...}    param1, param2, ..
   * @return {MethodCall}
   */

  _createClass(MethodCallManager, [{
    key: 'call',
    value: function call(method) {
      for (var _len = arguments.length, params = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
        params[_key - 1] = arguments[_key];
      }

      return this.apply(method, params);
    }

    /**
     * Apply a method with given parameters and
     * randomSeed
     * @param  {String} method
     * @param  {Array} params
     * @param  {String} randomSeed
     * @return {MethodCall}
     */

  }, {
    key: 'apply',
    value: function apply(method) {
      var _this = this;

      var params = arguments.length <= 1 || arguments[1] === undefined ? [] : arguments[1];
      var options = arguments.length <= 2 || arguments[2] === undefined ? {} : arguments[2];

      var call = new _MethodCall2.default(method, params, options, this.conn);
      this._methods[call.id] = call;

      var cleanupCallback = function cleanupCallback() {
        return delete _this._methods[call.id];
      };
      call.then(cleanupCallback, cleanupCallback);

      if (this.conn.isConnected) {
        call._invoke();
      }

      return call;
    }
  }, {
    key: '_handleMethodResult',
    value: function _handleMethodResult(msg) {
      if (msg.id && this._methods[msg.id]) {
        var result = msg.result;
        var error = msg.error;

        this._methods[msg.id]._handleResult(error, result);
      }
    }
  }, {
    key: '_handleMethodUpdated',
    value: function _handleMethodUpdated(msg) {
      var _this2 = this;

      (0, _forEach2.default)(msg.methods, function (mid) {
        if (_this2._methods[mid]) {
          _this2._methods[mid]._handleUpdated();
        }
      });
    }
  }, {
    key: '_handleDisconnected',
    value: function _handleDisconnected() {
      (0, _forEach2.default)(this._methods, function (methodCall) {
        if (methodCall.isSent) {
          if (!methodCall.options.retryOnDisconnect) {
            methodCall._handleResult({
              reason: 'Disconnected, method can\'t be done',
              code: 'DISCONNECTED'
            });
          } else {
            methodCall._retry();
          }
        }
      });
    }
  }, {
    key: '_handleConnected',
    value: function _handleConnected() {
      (0, _forEach2.default)(this._methods, function (methodCall) {
        if (methodCall.isPending) {
          methodCall._invoke();
        }
      });
    }
  }]);

  return MethodCallManager;
}();

exports.default = MethodCallManager;