@shepherdnerds/json-rules-engine 7.3.1

package/dist/json-rules-engine.js

@@ -0,0 +1,48 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.OperatorDecorator = exports.ScopedAlmanac = exports.Almanac = exports.Engine = exports.Operator = exports.Rule = exports.Fact = undefined;
+
+exports.default = function (rules, options) {
+  return new _engine2.default(rules, options);
+};
+
+var _engine = require('./engine');
+
+var _engine2 = _interopRequireDefault(_engine);
+
+var _fact = require('./fact');
+
+var _fact2 = _interopRequireDefault(_fact);
+
+var _rule = require('./rule');
+
+var _rule2 = _interopRequireDefault(_rule);
+
+var _operator = require('./operator');
+
+var _operator2 = _interopRequireDefault(_operator);
+
+var _almanac = require('./almanac');
+
+var _almanac2 = _interopRequireDefault(_almanac);
+
+var _scopedAlmanac = require('./scoped-almanac');
+
+var _scopedAlmanac2 = _interopRequireDefault(_scopedAlmanac);
+
+var _operatorDecorator = require('./operator-decorator');
+
+var _operatorDecorator2 = _interopRequireDefault(_operatorDecorator);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+exports.Fact = _fact2.default;
+exports.Rule = _rule2.default;
+exports.Operator = _operator2.default;
+exports.Engine = _engine2.default;
+exports.Almanac = _almanac2.default;
+exports.ScopedAlmanac = _scopedAlmanac2.default;
+exports.OperatorDecorator = _operatorDecorator2.default;

package/dist/operator-decorator.js

@@ -0,0 +1,60 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+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 _operator = require('./operator');
+
+var _operator2 = _interopRequireDefault(_operator);
+
+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 OperatorDecorator = function () {
+  /**
+   * Constructor
+   * @param {string}   name - decorator identifier
+   * @param {function(factValue, jsonValue, next)} callback - callback that takes the next operator as a parameter
+   * @param {function}  [factValueValidator] - optional validator for asserting the data type of the fact
+   * @returns {OperatorDecorator} - instance
+   */
+  function OperatorDecorator(name, cb, factValueValidator) {
+    _classCallCheck(this, OperatorDecorator);
+
+    this.name = String(name);
+    if (!name) throw new Error('Missing decorator name');
+    if (typeof cb !== 'function') throw new Error('Missing decorator callback');
+    this.cb = cb;
+    this.factValueValidator = factValueValidator;
+    if (!this.factValueValidator) this.factValueValidator = function () {
+      return true;
+    };
+  }
+
+  /**
+   * Takes the fact result and compares it to the condition 'value', using the callback
+   * @param   {Operator} operator - fact result
+   * @returns {Operator} - whether the values pass the operator test
+   */
+
+
+  _createClass(OperatorDecorator, [{
+    key: 'decorate',
+    value: function decorate(operator) {
+      var _this = this;
+
+      var next = operator.evaluate.bind(operator);
+      return new _operator2.default(this.name + ':' + operator.name, function (factValue, jsonValue) {
+        return _this.cb(factValue, jsonValue, next);
+      }, this.factValueValidator);
+    }
+  }]);
+
+  return OperatorDecorator;
+}();
+
+exports.default = OperatorDecorator;

package/dist/operator-map.js

@@ -0,0 +1,178 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+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 _operator = require('./operator');
+
+var _operator2 = _interopRequireDefault(_operator);
+
+var _operatorDecorator = require('./operator-decorator');
+
+var _operatorDecorator2 = _interopRequireDefault(_operatorDecorator);
+
+var _debug = require('./debug');
+
+var _debug2 = _interopRequireDefault(_debug);
+
+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 OperatorMap = function () {
+  function OperatorMap() {
+    _classCallCheck(this, OperatorMap);
+
+    this.operators = new Map();
+    this.decorators = new Map();
+  }
+
+  /**
+     * Add a custom operator definition
+     * @param {string}   operatorOrName - operator identifier within the condition; i.e. instead of 'equals', 'greaterThan', etc
+     * @param {function(factValue, jsonValue)} callback - the method to execute when the operator is encountered.
+     */
+
+
+  _createClass(OperatorMap, [{
+    key: 'addOperator',
+    value: function addOperator(operatorOrName, cb) {
+      var operator = void 0;
+      if (operatorOrName instanceof _operator2.default) {
+        operator = operatorOrName;
+      } else {
+        operator = new _operator2.default(operatorOrName, cb);
+      }
+      (0, _debug2.default)('operatorMap::addOperator', { name: operator.name });
+      this.operators.set(operator.name, operator);
+    }
+
+    /**
+       * Remove a custom operator definition
+       * @param {string}   operatorOrName - operator identifier within the condition; i.e. instead of 'equals', 'greaterThan', etc
+       * @param {function(factValue, jsonValue)} callback - the method to execute when the operator is encountered.
+       */
+
+  }, {
+    key: 'removeOperator',
+    value: function removeOperator(operatorOrName) {
+      var operatorName = void 0;
+      if (operatorOrName instanceof _operator2.default) {
+        operatorName = operatorOrName.name;
+      } else {
+        operatorName = operatorOrName;
+      }
+
+      // Delete all the operators that end in :operatorName these
+      // were decorated on-the-fly leveraging this operator
+      var suffix = ':' + operatorName;
+      var operatorNames = Array.from(this.operators.keys());
+      for (var i = 0; i < operatorNames.length; i++) {
+        if (operatorNames[i].endsWith(suffix)) {
+          this.operators.delete(operatorNames[i]);
+        }
+      }
+
+      return this.operators.delete(operatorName);
+    }
+
+    /**
+       * Add a custom operator decorator
+       * @param {string}   decoratorOrName - decorator identifier within the condition; i.e. instead of 'everyFact', 'someValue', etc
+       * @param {function(factValue, jsonValue, next)} callback - the method to execute when the decorator is encountered.
+       */
+
+  }, {
+    key: 'addOperatorDecorator',
+    value: function addOperatorDecorator(decoratorOrName, cb) {
+      var decorator = void 0;
+      if (decoratorOrName instanceof _operatorDecorator2.default) {
+        decorator = decoratorOrName;
+      } else {
+        decorator = new _operatorDecorator2.default(decoratorOrName, cb);
+      }
+      (0, _debug2.default)('operatorMap::addOperatorDecorator', { name: decorator.name });
+      this.decorators.set(decorator.name, decorator);
+    }
+
+    /**
+       * Remove a custom operator decorator
+       * @param {string}   decoratorOrName - decorator identifier within the condition; i.e. instead of 'everyFact', 'someValue', etc
+       */
+
+  }, {
+    key: 'removeOperatorDecorator',
+    value: function removeOperatorDecorator(decoratorOrName) {
+      var decoratorName = void 0;
+      if (decoratorOrName instanceof _operatorDecorator2.default) {
+        decoratorName = decoratorOrName.name;
+      } else {
+        decoratorName = decoratorOrName;
+      }
+
+      // Delete all the operators that include decoratorName: these
+      // were decorated on-the-fly leveraging this decorator
+      var prefix = decoratorName + ':';
+      var operatorNames = Array.from(this.operators.keys());
+      for (var i = 0; i < operatorNames.length; i++) {
+        if (operatorNames[i].includes(prefix)) {
+          this.operators.delete(operatorNames[i]);
+        }
+      }
+
+      return this.decorators.delete(decoratorName);
+    }
+
+    /**
+     * Get the Operator, or null applies decorators as needed
+     * @param {string} name - the name of the operator including any decorators
+     * @returns an operator or null
+     */
+
+  }, {
+    key: 'get',
+    value: function get(name) {
+      var decorators = [];
+      var opName = name;
+      // while we don't already have this operator
+      while (!this.operators.has(opName)) {
+        // try splitting on the decorator symbol (:)
+        var firstDecoratorIndex = opName.indexOf(':');
+        if (firstDecoratorIndex > 0) {
+          // if there is a decorator, and it's a valid decorator
+          var decoratorName = opName.slice(0, firstDecoratorIndex);
+          var decorator = this.decorators.get(decoratorName);
+          if (!decorator) {
+            (0, _debug2.default)('operatorMap::get invalid decorator', { name: decoratorName });
+            return null;
+          }
+          // we're going to apply this later, use unshift since we'll apply in reverse order
+          decorators.unshift(decorator);
+          // continue looking for a known operator with the rest of the name
+          opName = opName.slice(firstDecoratorIndex + 1);
+        } else {
+          (0, _debug2.default)('operatorMap::get no operator', { name: opName });
+          return null;
+        }
+      }
+
+      var op = this.operators.get(opName);
+      // apply all the decorators
+      for (var i = 0; i < decorators.length; i++) {
+        op = decorators[i].decorate(op);
+        // create an entry for the decorated operation so we don't need
+        // to do this again
+        this.operators.set(op.name, op);
+      }
+      // return the operation
+      return op;
+    }
+  }]);
+
+  return OperatorMap;
+}();
+
+exports.default = OperatorMap;

package/dist/operator.js

@@ -0,0 +1,50 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+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; }; }();
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+var Operator = function () {
+  /**
+   * Constructor
+   * @param {string}   name - operator identifier
+   * @param {function(factValue, jsonValue)} callback - operator evaluation method
+   * @param {function}  [factValueValidator] - optional validator for asserting the data type of the fact
+   * @returns {Operator} - instance
+   */
+  function Operator(name, cb, factValueValidator) {
+    _classCallCheck(this, Operator);
+
+    this.name = String(name);
+    if (!name) throw new Error('Missing operator name');
+    if (typeof cb !== 'function') throw new Error('Missing operator callback');
+    this.cb = cb;
+    this.factValueValidator = factValueValidator;
+    if (!this.factValueValidator) this.factValueValidator = function () {
+      return true;
+    };
+  }
+
+  /**
+   * Takes the fact result and compares it to the condition 'value', using the callback
+   * @param   {mixed} factValue - fact result
+   * @param   {mixed} jsonValue - "value" property of the condition
+   * @returns {Boolean} - whether the values pass the operator test
+   */
+
+
+  _createClass(Operator, [{
+    key: 'evaluate',
+    value: function evaluate(factValue, jsonValue) {
+      return this.factValueValidator(factValue) && this.cb(factValue, jsonValue);
+    }
+  }]);
+
+  return Operator;
+}();
+
+exports.default = Operator;

package/dist/rule-result.js

@@ -0,0 +1,80 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "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 _clone = require('clone');
+
+var _clone2 = _interopRequireDefault(_clone);
+
+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 RuleResult = function () {
+  function RuleResult(conditions, event, priority, name) {
+    _classCallCheck(this, RuleResult);
+
+    this.conditions = (0, _clone2.default)(conditions);
+    this.event = (0, _clone2.default)(event);
+    this.priority = (0, _clone2.default)(priority);
+    this.name = (0, _clone2.default)(name);
+    this.result = null;
+  }
+
+  _createClass(RuleResult, [{
+    key: 'setResult',
+    value: function setResult(result) {
+      this.result = result;
+    }
+  }, {
+    key: 'resolveEventParams',
+    value: function resolveEventParams(almanac) {
+      var _this = this;
+
+      if (this.event.params !== null && _typeof(this.event.params) === 'object') {
+        var updates = [];
+
+        var _loop = function _loop(key) {
+          if (Object.prototype.hasOwnProperty.call(_this.event.params, key)) {
+            updates.push(almanac.getValue(_this.event.params[key]).then(function (val) {
+              return _this.event.params[key] = val;
+            }));
+          }
+        };
+
+        for (var key in this.event.params) {
+          _loop(key);
+        }
+        return Promise.all(updates);
+      }
+      return Promise.resolve();
+    }
+  }, {
+    key: 'toJSON',
+    value: function toJSON() {
+      var stringify = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
+
+      var props = {
+        conditions: this.conditions.toJSON(false),
+        event: this.event,
+        priority: this.priority,
+        name: this.name,
+        result: this.result
+      };
+      if (stringify) {
+        return JSON.stringify(props);
+      }
+      return props;
+    }
+  }]);
+
+  return RuleResult;
+}();
+
+exports.default = RuleResult;