mobx-roof/lib/core/MobxMiddleware.js

Simple React data management by mobx.

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = 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 _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol ? "symbol" : typeof obj; };

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 _Middleware = require('../common/Middleware');

var _Middleware2 = _interopRequireDefault(_Middleware);

var _utils = require('../common/utils');

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 KEYS = ['before', 'after', 'error', 'filter'];

function toFilter(filter) {
  if ((0, _utils.isRegExp)(filter)) {
    return function (_ref) {
      var type = _ref.type;
      return filter.test(type);
    };
  } else if (typeof filter === 'string') {
    return function (_ref2) {
      var type = _ref2.type;
      return filter === type;
    };
  } else if (typeof filter === 'function') {
    return filter;
  }
  throw new TypeError('[MobxMiddleware] Middleware filter must be RegExp, String or Function.');
}

var MobxMiddleware = function () {
  _createClass(MobxMiddleware, null, [{
    key: 'toStandardMiddleware',
    value: function toStandardMiddleware() {
      var _middleware = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];

      if (typeof _middleware === 'function') {
        return {
          after: _middleware
        };
      } else if ((typeof _middleware === 'undefined' ? 'undefined' : _typeof(_middleware)) === 'object') {
        var _ret = function () {
          var middleware = {};
          Object.keys(_middleware).forEach(function (key) {
            if (!KEYS.includes(key)) {
              throw new Error('[MobxMiddleware] Middleware key must one of "' + KEYS.join(' ,') + '"');
            }
            // filter empty middleware
            if (_middleware[key]) {
              middleware[key] = _middleware[key];
            }
          });
          if (middleware.filter) {
            var _ret2 = function () {
              var filter = toFilter(middleware.filter);
              delete middleware.filter;
              // to filter function
              return {
                v: {
                  v: (0, _utils.mapValues)(middleware, function (res) {
                    res = Array.isArray(res) ? res : [res];
                    return res.map(function (fn) {
                      return function middlewareFilterMixin(_ref3) {
                        var payload = _ref3.payload;

                        if (!filter.apply(undefined, arguments)) return payload;
                        return fn.apply(undefined, arguments);
                      };
                    });
                  }, {})
                }
              };
            }();

            if ((typeof _ret2 === 'undefined' ? 'undefined' : _typeof(_ret2)) === "object") return _ret2.v;
          }
          return {
            v: middleware
          };
        }();

        if ((typeof _ret === 'undefined' ? 'undefined' : _typeof(_ret)) === "object") return _ret.v;
      }
      throw new TypeError('[MobxMiddleware] Middleware must be a function or object but get ' + _middleware);
    }
  }]);

  function MobxMiddleware() {
    _classCallCheck(this, MobxMiddleware);

    this._before = new _Middleware2.default();
    this._after = new _Middleware2.default();
    this._error = new _Middleware2.default();
  }

  _createClass(MobxMiddleware, [{
    key: 'use',
    value: function use() {
      var _this = this;

      var removes = [];

      for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
        args[_key] = arguments[_key];
      }

      args.forEach(function (middleware) {
        middleware = MobxMiddleware.toStandardMiddleware(middleware);
        Object.keys(middleware).forEach(function (pos) {
          var cur = _this['_' + pos];
          cur.use(middleware[pos]);
          removes.push(function () {
            return cur.remove(middleware[pos]);
          });
        });
      });
      return function removeMiddlewares() {
        removes.map(function (rm) {
          return rm();
        });
      };
    }
  }, {
    key: 'execAction',
    value: function execAction(_ref4) {
      var _this2 = this;

      var actionFn = _ref4.actionFn;
      var _ref4$actionArgs = _ref4.actionArgs;
      var actionArgs = _ref4$actionArgs === undefined ? [] : _ref4$actionArgs;
      var actionName = _ref4.actionName;
      var actionContext = _ref4.actionContext;

      var args = { action: actionName, model: actionContext, type: actionContext + '.' + actionName };
      return this._before.compose(_extends({}, args, { payload: actionArgs, pos: 'before' })).then(function (args) {
        if (!Array.isArray(args)) {
          throw new Error('[MobxMiddleware] Pre middleware must return arguments');
        }
        return actionFn.apply(actionContext, args);
      }).then(function (payload) {
        return _this2._after.compose(_extends({}, args, { payload: payload, pos: 'after' }));
      }).catch(function (error) {
        return _this2._error.compose(_extends({}, args, { payload: error, pos: 'error' })).then(function (error) {
          if (error instanceof Error) {
            throw error;
          }
          return error;
        });
      });
    }
  }]);

  return MobxMiddleware;
}();

exports.default = MobxMiddleware;
module.exports = exports['default'];