@shepherdnerds/json-rules-engine 7.3.1

package/dist/almanac.js

@@ -0,0 +1,269 @@
+'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 _fact = require('./fact');
+
+var _fact2 = _interopRequireDefault(_fact);
+
+var _errors = require('./errors');
+
+var _debug = require('./debug');
+
+var _debug2 = _interopRequireDefault(_debug);
+
+var _jsonpathPlus = require('jsonpath-plus');
+
+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"); } }
+
+function defaultPathResolver(value, path) {
+  return (0, _jsonpathPlus.JSONPath)({ path: path, json: value, wrap: false });
+}
+
+/**
+ * Fact results lookup
+ * Triggers fact computations and saves the results
+ * A new almanac is used for every engine run()
+ */
+
+var Almanac = function () {
+  function Almanac() {
+    var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+
+    _classCallCheck(this, Almanac);
+
+    this.factMap = new Map();
+    this.factResultsCache = new Map(); // { cacheKey:  Promise<factValu> }
+    this.allowUndefinedFacts = Boolean(options.allowUndefinedFacts);
+    this.pathResolver = options.pathResolver || defaultPathResolver;
+    this.events = { success: [], failure: [] };
+    this.ruleResults = [];
+  }
+
+  /**
+   * Adds a success event
+   * @param {Object} event
+   */
+
+
+  _createClass(Almanac, [{
+    key: 'addEvent',
+    value: function addEvent(event, outcome) {
+      if (!outcome) throw new Error('outcome required: "success" | "failure"]');
+      this.events[outcome].push(event);
+    }
+
+    /**
+     * retrieve successful events
+     */
+
+  }, {
+    key: 'getEvents',
+    value: function getEvents() {
+      var outcome = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+
+      if (outcome) return this.events[outcome];
+      return this.events.success.concat(this.events.failure);
+    }
+
+    /**
+     * Adds a rule result
+     * @param {Object} event
+     */
+
+  }, {
+    key: 'addResult',
+    value: function addResult(ruleResult) {
+      this.ruleResults.push(ruleResult);
+    }
+
+    /**
+     * retrieve successful events
+     */
+
+  }, {
+    key: 'getResults',
+    value: function getResults() {
+      return this.ruleResults;
+    }
+
+    /**
+     * Retrieve fact by id, raising an exception if it DNE
+     * @param  {String} factId
+     * @return {Fact}
+     */
+
+  }, {
+    key: '_getFact',
+    value: function _getFact(factId) {
+      return this.factMap.get(factId);
+    }
+
+    /**
+     * Registers fact with the almanac
+     * @param {[type]} fact [description]
+     */
+
+  }, {
+    key: '_addConstantFact',
+    value: function _addConstantFact(fact) {
+      this.factMap.set(fact.id, fact);
+      this._setFactValue(fact, {}, fact.value);
+    }
+
+    /**
+     * Sets the computed value of a fact
+     * @param {Fact} fact
+     * @param {Object} params - values for differentiating this fact value from others, used for cache key
+     * @param {Mixed} value - computed value
+     */
+
+  }, {
+    key: '_setFactValue',
+    value: function _setFactValue(fact, params, value) {
+      var cacheKey = fact.getCacheKey(params);
+      var factValue = Promise.resolve(value);
+      if (cacheKey) {
+        this.factResultsCache.set(cacheKey, factValue);
+      }
+      return factValue;
+    }
+
+    /**
+     * Add a fact definition to the engine.  Facts are called by rules as they are evaluated.
+     * @param {object|Fact} id - fact identifier or instance of Fact
+     * @param {function} definitionFunc - function to be called when computing the fact value for a given rule
+     * @param {Object} options - options to initialize the fact with. used when "id" is not a Fact instance
+     */
+
+  }, {
+    key: 'addFact',
+    value: function addFact(id, valueOrMethod, options) {
+      var factId = id;
+      var fact = void 0;
+      if (id instanceof _fact2.default) {
+        factId = id.id;
+        fact = id;
+      } else {
+        fact = new _fact2.default(id, valueOrMethod, options);
+      }
+      (0, _debug2.default)('almanac::addFact', { id: factId });
+      this.factMap.set(factId, fact);
+      if (fact.isConstant()) {
+        this._setFactValue(fact, {}, fact.value);
+      }
+      return this;
+    }
+
+    /**
+     * Adds a constant fact during runtime.  Can be used mid-run() to add additional information
+     * @deprecated use addFact
+     * @param {String} fact - fact identifier
+     * @param {Mixed} value - constant value of the fact
+     */
+
+  }, {
+    key: 'addRuntimeFact',
+    value: function addRuntimeFact(factId, value) {
+      (0, _debug2.default)('almanac::addRuntimeFact', { id: factId });
+      var fact = new _fact2.default(factId, value);
+      return this._addConstantFact(fact);
+    }
+
+    /**
+     * Returns the value of a fact, based on the given parameters.  Utilizes the 'almanac' maintained
+     * by the engine, which cache's fact computations based on parameters provided
+     * @param  {string} factId - fact identifier
+     * @param  {Object} params - parameters to feed into the fact.  By default, these will also be used to compute the cache key
+     * @param  {String} path - object
+     * @return {Promise} a promise which will resolve with the fact computation.
+     */
+
+  }, {
+    key: 'factValue',
+    value: function factValue(factId) {
+      var _this = this;
+
+      var params = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      var path = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '';
+
+      var factValuePromise = void 0;
+      var fact = this._getFact(factId);
+      if (fact === undefined) {
+        if (this.allowUndefinedFacts) {
+          return Promise.resolve(undefined);
+        } else {
+          return Promise.reject(new _errors.UndefinedFactError('Undefined fact: ' + factId));
+        }
+      }
+      if (fact.isConstant()) {
+        factValuePromise = Promise.resolve(fact.calculate(params, this));
+      } else {
+        var cacheKey = fact.getCacheKey(params);
+        var cacheVal = cacheKey && this.factResultsCache.get(cacheKey);
+        if (cacheVal) {
+          factValuePromise = Promise.resolve(cacheVal);
+          (0, _debug2.default)('almanac::factValue cache hit for fact', { id: factId });
+        } else {
+          (0, _debug2.default)('almanac::factValue cache miss, calculating', { id: factId });
+          factValuePromise = this._setFactValue(fact, params, fact.calculate(params, this));
+        }
+      }
+      if (path) {
+        (0, _debug2.default)('condition::evaluate extracting object', { property: path });
+        return factValuePromise.then(function (factValue) {
+          if (factValue != null && (typeof factValue === 'undefined' ? 'undefined' : _typeof(factValue)) === 'object') {
+            var pathValue = _this.pathResolver(factValue, path);
+            (0, _debug2.default)('condition::evaluate extracting object', { property: path, received: pathValue });
+            return pathValue;
+          } else {
+            (0, _debug2.default)('condition::evaluate could not compute object path of non-object', { path: path, factValue: factValue, type: typeof factValue === 'undefined' ? 'undefined' : _typeof(factValue) });
+            return factValue;
+          }
+        });
+      }
+
+      return factValuePromise;
+    }
+
+    /**
+     * Interprets value as either a primitive, or if a fact, retrieves the fact value
+     */
+
+  }, {
+    key: 'getValue',
+    value: function getValue(value) {
+      if (value != null && (typeof value === 'undefined' ? 'undefined' : _typeof(value)) === 'object' && Object.prototype.hasOwnProperty.call(value, 'fact')) {
+        // value = { fact: 'xyz' }
+        return this.factValue(value.fact, value.params, value.path);
+      }
+      return Promise.resolve(value);
+    }
+
+    /**
+     * Resolves a path - only valid in scoped context (ScopedAlmanac)
+     * This method exists to provide a clear error when path-only conditions
+     * are used outside of a nested condition context
+     * @param {string} path - the path to resolve
+     * @return {Promise} rejects with an error
+     */
+
+  }, {
+    key: 'resolvePath',
+    value: function resolvePath(path) {
+      return Promise.reject(new Error('Almanac::resolvePath - path-only conditions (path: "' + path + '") can only be used inside nested conditions. ' + 'Ensure this condition is within a "some" or "every" operator block.'));
+    }
+  }]);
+
+  return Almanac;
+}();
+
+exports.default = Almanac;

package/dist/condition.js

@@ -0,0 +1,331 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }();
+
+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 _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 Condition = function () {
+  function Condition(properties) {
+    _classCallCheck(this, Condition);
+
+    if (!properties) throw new Error('Condition: constructor options required');
+    var booleanOperator = Condition.booleanOperator(properties);
+    Object.assign(this, properties);
+    if (booleanOperator) {
+      var subConditions = properties[booleanOperator];
+      var subConditionsIsArray = Array.isArray(subConditions);
+      if (booleanOperator !== 'not' && !subConditionsIsArray) {
+        throw new Error('"' + booleanOperator + '" must be an array');
+      }
+      if (booleanOperator === 'not' && subConditionsIsArray) {
+        throw new Error('"' + booleanOperator + '" cannot be an array');
+      }
+      this.operator = booleanOperator;
+      // boolean conditions always have a priority; default 1
+      this.priority = parseInt(properties.priority, 10) || 1;
+      if (subConditionsIsArray) {
+        this[booleanOperator] = subConditions.map(function (c) {
+          return new Condition(c);
+        });
+      } else {
+        this[booleanOperator] = new Condition(subConditions);
+      }
+    } else if (!Object.prototype.hasOwnProperty.call(properties, 'condition')) {
+      var hasFact = Object.prototype.hasOwnProperty.call(properties, 'fact');
+      var hasOperator = Object.prototype.hasOwnProperty.call(properties, 'operator');
+      var hasValue = Object.prototype.hasOwnProperty.call(properties, 'value');
+
+      // Check if this is a nested condition (operator: 'some' with conditions property)
+      if (this.isNestedCondition()) {
+        // Nested array conditions require fact (to get the array)
+        if (!hasFact) {
+          throw new Error('Condition: constructor "fact" property required for nested conditions');
+        }
+        // Parse the nested conditions tree
+        this.conditions = new Condition(properties.conditions);
+      } else if (this.isScopedCondition()) {
+        // Scoped conditions (path only, no fact) - used inside nested conditions
+        // where the "fact" is implicitly the current array item
+        if (!hasOperator) {
+          throw new Error('Condition: constructor "operator" property required');
+        }
+        if (!hasValue) {
+          throw new Error('Condition: constructor "value" property required');
+        }
+        // path is already validated by isScopedCondition()
+      } else {
+        // Regular fact-based condition
+        if (!hasFact) {
+          throw new Error('Condition: constructor "fact" property required');
+        }
+        if (!hasOperator) {
+          throw new Error('Condition: constructor "operator" property required');
+        }
+        if (!hasValue) {
+          throw new Error('Condition: constructor "value" property required');
+        }
+      }
+
+      // a non-boolean condition does not have a priority by default. this allows
+      // priority to be dictated by the fact definition
+      if (Object.prototype.hasOwnProperty.call(properties, 'priority')) {
+        properties.priority = parseInt(properties.priority, 10);
+      }
+    }
+  }
+
+  /**
+   * Converts the condition into a json-friendly structure
+   * @param   {Boolean} stringify - whether to return as a json string
+   * @returns {string,object} json string or json-friendly object
+   */
+
+
+  _createClass(Condition, [{
+    key: 'toJSON',
+    value: function toJSON() {
+      var stringify = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
+
+      var props = {};
+      if (this.priority) {
+        props.priority = this.priority;
+      }
+      if (this.name) {
+        props.name = this.name;
+      }
+      var oper = Condition.booleanOperator(this);
+      if (oper) {
+        if (Array.isArray(this[oper])) {
+          props[oper] = this[oper].map(function (c) {
+            return c.toJSON(false);
+          });
+        } else {
+          props[oper] = this[oper].toJSON(false);
+        }
+      } else if (this.isConditionReference()) {
+        props.condition = this.condition;
+      } else if (this.isNestedCondition()) {
+        props.operator = this.operator;
+        props.fact = this.fact;
+        props.conditions = this.conditions.toJSON(false);
+        if (this.factResult !== undefined) {
+          props.factResult = this.factResult;
+        }
+        if (this.result !== undefined) {
+          props.result = this.result;
+        }
+        if (this.params) {
+          props.params = this.params;
+        }
+        if (this.path) {
+          props.path = this.path;
+        }
+      } else if (this.isScopedCondition()) {
+        // Scoped condition (path only, no fact)
+        props.operator = this.operator;
+        props.value = this.value;
+        props.path = this.path;
+        if (this.factResult !== undefined) {
+          props.factResult = this.factResult;
+        }
+        if (this.valueResult !== undefined) {
+          props.valueResult = this.valueResult;
+        }
+        if (this.result !== undefined) {
+          props.result = this.result;
+        }
+        if (this.params) {
+          props.params = this.params;
+        }
+      } else {
+        props.operator = this.operator;
+        props.value = this.value;
+        props.fact = this.fact;
+        if (this.factResult !== undefined) {
+          props.factResult = this.factResult;
+        }
+        if (this.valueResult !== undefined) {
+          props.valueResult = this.valueResult;
+        }
+        if (this.result !== undefined) {
+          props.result = this.result;
+        }
+        if (this.params) {
+          props.params = this.params;
+        }
+        if (this.path) {
+          props.path = this.path;
+        }
+      }
+      if (stringify) {
+        return JSON.stringify(props);
+      }
+      return props;
+    }
+
+    /**
+     * Takes the fact result and compares it to the condition 'value', using the operator
+     *   LHS                      OPER       RHS
+     * <fact + params + path>  <operator>  <value>
+     *
+     * @param   {Almanac} almanac
+     * @param   {Map} operatorMap - map of available operators, keyed by operator name
+     * @returns {Boolean} - evaluation result
+     */
+
+  }, {
+    key: 'evaluate',
+    value: function evaluate(almanac, operatorMap) {
+      var _this = this;
+
+      if (!almanac) return Promise.reject(new Error('almanac required'));
+      if (!operatorMap) return Promise.reject(new Error('operatorMap required'));
+      if (this.isBooleanOperator()) {
+        return Promise.reject(new Error('Cannot evaluate() a boolean condition'));
+      }
+
+      var op = operatorMap.get(this.operator);
+      if (!op) {
+        return Promise.reject(new Error('Unknown operator: ' + this.operator));
+      }
+
+      // Handle scoped conditions (path only, no fact)
+      // These are used inside nested conditions where the almanac is a ScopedAlmanac
+      if (this.isScopedCondition()) {
+        return Promise.all([almanac.getValue(this.value), almanac.resolvePath(this.path)]).then(function (_ref) {
+          var _ref2 = _slicedToArray(_ref, 2),
+              rightHandSideValue = _ref2[0],
+              leftHandSideValue = _ref2[1];
+
+          var result = op.evaluate(leftHandSideValue, rightHandSideValue);
+          (0, _debug2.default)('condition::evaluate (scoped)', {
+            path: _this.path,
+            leftHandSideValue: leftHandSideValue,
+            operator: _this.operator,
+            rightHandSideValue: rightHandSideValue,
+            result: result
+          });
+          return {
+            result: result,
+            leftHandSideValue: leftHandSideValue,
+            rightHandSideValue: rightHandSideValue,
+            operator: _this.operator
+          };
+        });
+      }
+
+      // Regular fact-based condition
+      return Promise.all([almanac.getValue(this.value), almanac.factValue(this.fact, this.params, this.path)]).then(function (_ref3) {
+        var _ref4 = _slicedToArray(_ref3, 2),
+            rightHandSideValue = _ref4[0],
+            leftHandSideValue = _ref4[1];
+
+        var result = op.evaluate(leftHandSideValue, rightHandSideValue);
+        (0, _debug2.default)('condition::evaluate', {
+          leftHandSideValue: leftHandSideValue,
+          operator: _this.operator,
+          rightHandSideValue: rightHandSideValue,
+          result: result
+        });
+        return {
+          result: result,
+          leftHandSideValue: leftHandSideValue,
+          rightHandSideValue: rightHandSideValue,
+          operator: _this.operator
+        };
+      });
+    }
+
+    /**
+     * Returns the boolean operator for the condition
+     * If the condition is not a boolean condition, the result will be 'undefined'
+     * @return {string 'all', 'any', or 'not'}
+     */
+
+  }, {
+    key: 'booleanOperator',
+
+
+    /**
+     * Returns the condition's boolean operator
+     * Instance version of Condition.isBooleanOperator
+     * @returns {string,undefined} - 'any', 'all', 'not' or undefined (if not a boolean condition)
+     */
+    value: function booleanOperator() {
+      return Condition.booleanOperator(this);
+    }
+
+    /**
+     * Whether the operator is boolean ('all', 'any', 'not')
+     * @returns {Boolean}
+     */
+
+  }, {
+    key: 'isBooleanOperator',
+    value: function isBooleanOperator() {
+      return Condition.booleanOperator(this) !== undefined;
+    }
+
+    /**
+     * Whether the condition represents a reference to a condition
+     * @returns {Boolean}
+     */
+
+  }, {
+    key: 'isConditionReference',
+    value: function isConditionReference() {
+      return Object.prototype.hasOwnProperty.call(this, 'condition');
+    }
+
+    /**
+     * Whether the condition is a nested condition (operator: 'some' with 'conditions' property)
+     * @returns {Boolean}
+     */
+
+  }, {
+    key: 'isNestedCondition',
+    value: function isNestedCondition() {
+      return this.operator === 'some' && Object.prototype.hasOwnProperty.call(this, 'conditions');
+    }
+
+    /**
+     * Whether this is a scoped condition (path only, no fact)
+     * Used inside nested conditions where the "fact" is the current array item
+     * The path is resolved directly against the scoped item
+     * @returns {Boolean}
+     */
+
+  }, {
+    key: 'isScopedCondition',
+    value: function isScopedCondition() {
+      return !Object.prototype.hasOwnProperty.call(this, 'fact') && Object.prototype.hasOwnProperty.call(this, 'path') && Object.prototype.hasOwnProperty.call(this, 'operator') && !this.isBooleanOperator();
+    }
+  }], [{
+    key: 'booleanOperator',
+    value: function booleanOperator(condition) {
+      if (Object.prototype.hasOwnProperty.call(condition, 'any')) {
+        return 'any';
+      } else if (Object.prototype.hasOwnProperty.call(condition, 'all')) {
+        return 'all';
+      } else if (Object.prototype.hasOwnProperty.call(condition, 'not')) {
+        return 'not';
+      }
+    }
+  }]);
+
+  return Condition;
+}();
+
+exports.default = Condition;

package/dist/debug.js

@@ -0,0 +1,18 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+function createDebug() {
+  try {
+    if (typeof process !== 'undefined' && process.env && process.env.DEBUG && process.env.DEBUG.match(/json-rules-engine/) || typeof window !== 'undefined' && window.localStorage && window.localStorage.debug && window.localStorage.debug.match(/json-rules-engine/)) {
+      return console.debug.bind(console);
+    }
+  } catch (ex) {
+    // Do nothing
+  }
+  return function () {};
+}
+
+exports.default = createDebug();

package/dist/engine-default-operator-decorators.js

@@ -0,0 +1,42 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _operatorDecorator = require('./operator-decorator');
+
+var _operatorDecorator2 = _interopRequireDefault(_operatorDecorator);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var OperatorDecorators = [];
+
+OperatorDecorators.push(new _operatorDecorator2.default('someFact', function (factValue, jsonValue, next) {
+  return factValue.some(function (fv) {
+    return next(fv, jsonValue);
+  });
+}, Array.isArray));
+OperatorDecorators.push(new _operatorDecorator2.default('someValue', function (factValue, jsonValue, next) {
+  return jsonValue.some(function (jv) {
+    return next(factValue, jv);
+  });
+}));
+OperatorDecorators.push(new _operatorDecorator2.default('everyFact', function (factValue, jsonValue, next) {
+  return factValue.every(function (fv) {
+    return next(fv, jsonValue);
+  });
+}, Array.isArray));
+OperatorDecorators.push(new _operatorDecorator2.default('everyValue', function (factValue, jsonValue, next) {
+  return jsonValue.every(function (jv) {
+    return next(factValue, jv);
+  });
+}));
+OperatorDecorators.push(new _operatorDecorator2.default('swap', function (factValue, jsonValue, next) {
+  return next(jsonValue, factValue);
+}));
+OperatorDecorators.push(new _operatorDecorator2.default('not', function (factValue, jsonValue, next) {
+  return !next(factValue, jsonValue);
+}));
+
+exports.default = OperatorDecorators;