nesquirk/lib/server/Server.js

Ties Nes + minimongo together for gloryful reactive apps.

'use strict';

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

var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };

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; }; }();

var _ejson = require('ejson');

var _ejson2 = _interopRequireDefault(_ejson);

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"); } }

var filterYes = function filterYes(path, message, options, next) {
  return next(true);
};

var Server = exports.Server = function () {
  function Server(server) {
    _classCallCheck(this, Server);

    this._server = server;
  }

  _createClass(Server, [{
    key: 'subscription',
    value: function subscription(path, opts, onSubscribe) {
      var _this = this;

      if (!onSubscribe) {
        onSubscribe = opts;
        opts = {};
      }

      opts = opts || {};

      var _onSubscribe = opts.onSubscribe || function (socket, path, params, next) {
        return next();
      };

      opts.onSubscribe = function (socket, path, params, next) {
        // console.log('onSubscribe', path, params)

        _onSubscribe(socket, path, params, function (err) {
          if (err) return next(err);

          var onReady = function onReady(err, data) {
            if (err && err instanceof Error) return next(err);
            data = _ejson2.default.stringify(_this._stringifyObjectIds(err || data || []));
            socket.publish(path, { msg: 'ready', data: data }, next);
          };

          if (onSubscribe) {
            onSubscribe(socket, path, params, onReady);
          } else {
            onReady();
          }
        });
      };

      opts.filter = this._createFilter(opts.filter);

      this._server.subscription(path, opts);

      return this;
    }
  }, {
    key: '_createFilter',
    value: function _createFilter(filter) {
      var _this2 = this;

      if (typeof filter === 'function') return filter;

      filter = ['ready', 'added', 'updated', 'removed'].reduce(function (f, type) {
        f[type] = filter && filter[type] || filterYes;
        return f;
      }, {});

      return function (path, message, options, next) {
        filter[message.msg](path, options.internal.__data, options, function (isMatch, override) {
          if (!isMatch) return next(false, override);
          if (override === undefined) return next(true);

          // Otherwise we have to clone the message and stringify the overridden data
          var msg = _extends({}, message);

          if (message.msg === 'removed') {
            override = Array.isArray(override) ? override.map(function (id) {
              return id.toString();
            }) : override.toString();
          } else {
            override = _this2._stringifyObjectIds(override);
          }

          msg.data = _ejson2.default.stringify(override);

          next(true, msg);
        });
      };
    }
  }, {
    key: '_stringifyObjectIds',
    value: function _stringifyObjectIds(data) {
      return Array.isArray(data) ? data.map(function (d) {
        return d && d._id ? _extends({}, d, { _id: d._id.toString() }) : d;
      }) : data && data._id ? _extends({}, data, { _id: data._id.toString() }) : data;
    }
  }, {
    key: 'add',
    value: function add(path) {
      var data = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
      var opts = arguments[2];

      opts = opts || {};
      opts.internal = opts.internal || {};
      opts.internal.__data = data;

      data = _ejson2.default.stringify(this._stringifyObjectIds(data));
      this._server.publish(path, { msg: 'added', data: data }, opts);

      return this;
    }
  }, {
    key: 'update',
    value: function update(path) {
      var data = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
      var opts = arguments[2];

      opts = opts || {};
      opts.internal = opts.internal || {};
      opts.internal.__data = data;

      data = _ejson2.default.stringify(this._stringifyObjectIds(data));
      this._server.publish(path, { msg: 'updated', data: data }, opts);

      return this;
    }
  }, {
    key: 'remove',
    value: function remove(path) {
      var ids = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
      var opts = arguments[2];

      opts = opts || {};
      opts.internal = opts.internal || {};
      opts.internal.__data = ids;

      ids = Array.isArray(ids) ? ids.map(function (id) {
        return id.toString();
      }) : ids.toString();
      var data = _ejson2.default.stringify(ids);
      this._server.publish(path, { msg: 'removed', data: data }, opts);

      return this;
    }
  }]);

  return Server;
}();