Add Condition / ConditionReference Support

Add Support for Conditions which are added to the engine and then
referenced in various rules.
Condition references can be used as top-level conditions in a rule
and can be used recursively.

Author: Christopher Pardy

src/condition.js

@@ -21,7 +21,7 @@ export default class Condition {
       } else {
         this[booleanOperator] = new Condition(subConditions)
       }
-    } else {
+    } else if (!Object.prototype.hasOwnProperty.call(properties, 'condition')) {
       if (!Object.prototype.hasOwnProperty.call(properties, 'fact')) throw new Error('Condition: constructor "fact" property required')
       if (!Object.prototype.hasOwnProperty.call(properties, 'operator')) throw new Error('Condition: constructor "operator" property required')
       if (!Object.prototype.hasOwnProperty.call(properties, 'value')) throw new Error('Condition: constructor "value" property required')
@@ -54,6 +54,8 @@ export default class Condition {
       } else {
         props[oper] = this[oper].toJSON(false)
       }
+    } else if (this.isConditionReference()) {
+      props.condition = this.condition
     } else {
       props.operator = this.operator
       props.value = this.value
@@ -147,4 +149,12 @@ export default class Condition {
   isBooleanOperator () {
     return Condition.booleanOperator(this) !== undefined
   }
+
+  /**
+   * Whether the condition represents a reference to a condition
+   * @returns {Boolean}
+   */
+  isConditionReference () {
+    return Object.prototype.hasOwnProperty.call(this, 'condition')
+  }
 }

src/engine.js

@@ -7,6 +7,7 @@ import Almanac from './almanac'
 import EventEmitter from 'eventemitter2'
 import defaultOperators from './engine-default-operators'
 import debug from './debug'
+import Condition from './condition'
 
 export const READY = 'READY'
 export const RUNNING = 'RUNNING'
@@ -21,9 +22,11 @@ class Engine extends EventEmitter {
     super()
     this.rules = []
     this.allowUndefinedFacts = options.allowUndefinedFacts || false
+    this.allowUndefinedConditions = options.allowUndefinedConditions || false
     this.pathResolver = options.pathResolver
     this.operators = new Map()
     this.facts = new Map()
+    this.conditions = new Map()
     this.status = READY
     rules.map(r => this.addRule(r))
     defaultOperators.map(o => this.addOperator(o))
@@ -92,6 +95,31 @@ class Engine extends EventEmitter {
     return ruleRemoved
   }
 
+  /**
+   * sets a condition that can be referenced by the given name.
+   * If a condition with the given name has already been set this will replace it.
+   * @param {string} name - the name of the condition to be referenced by rules.
+   * @param {object} conditions - the conditions to use when the condition is referenced.
+   */
+  setCondition (name, conditions) {
+    if (!name) throw new Error('Engine: setCondition() requires name')
+    if (!conditions) throw new Error('Engine: setCondition() requires conditions')
+    if (!Object.prototype.hasOwnProperty.call(conditions, 'all') && !Object.prototype.hasOwnProperty.call(conditions, 'any') && !Object.prototype.hasOwnProperty.call(conditions, 'not') && !Object.prototype.hasOwnProperty.call(conditions, 'condition')) {
+      throw new Error('"conditions" root must contain a single instance of "all", "any", "not", or "condition"')
+    }
+    this.conditions.set(name, new Condition(conditions))
+    return this
+  }
+
+  /**
+   * Removes a condition that has previously been added to this engine
+   * @param {string} name - the name of the condition to remove.
+   * @returns true if the condition existed, otherwise false
+   */
+  removeCondition (name) {
+    return this.conditions.delete(name)
+  }
+
   /**
    * Add a custom operator definition
    * @param {string}   operatorOrName - operator identifier within the condition; i.e. instead of 'equals', 'greaterThan', etc

src/rule.js

@@ -3,6 +3,7 @@
 import Condition from './condition'
 import RuleResult from './rule-result'
 import debug from './debug'
+import deepClone from 'clone'
 import EventEmitter from 'eventemitter2'
 
 class Rule extends EventEmitter {
@@ -70,8 +71,8 @@ class Rule extends EventEmitter {
    * @param {object} conditions - conditions, root element must be a boolean operator
    */
   setConditions (conditions) {
-    if (!Object.prototype.hasOwnProperty.call(conditions, 'all') && !Object.prototype.hasOwnProperty.call(conditions, 'any') && !Object.prototype.hasOwnProperty.call(conditions, 'not')) {
-      throw new Error('"conditions" root must contain a single instance of "all", "any", or "not"')
+    if (!Object.prototype.hasOwnProperty.call(conditions, 'all') && !Object.prototype.hasOwnProperty.call(conditions, 'any') && !Object.prototype.hasOwnProperty.call(conditions, 'not') && !Object.prototype.hasOwnProperty.call(conditions, 'condition')) {
+      throw new Error('"conditions" root must contain a single instance of "all", "any", "not", or "condition"')
     }
     this.conditions = new Condition(conditions)
     return this
@@ -188,7 +189,9 @@ class Rule extends EventEmitter {
      * @return {Promise(true|false)} - resolves with the result of the condition evaluation
      */
     const evaluateCondition = (condition) => {
-      if (condition.isBooleanOperator()) {
+      if (condition.isConditionReference()) {
+        return realize(this.engine.conditions.get(condition.condition), condition)
+      } else if (condition.isBooleanOperator()) {
         const subConditions = condition[condition.operator]
         let comparisonPromise
         if (condition.operator === 'all') {
@@ -309,6 +312,23 @@ class Rule extends EventEmitter {
       return prioritizeAndRun([condition], 'not').then(result => !result)
     }
 
+    const realize = (condition, conditionReference) => {
+      if (!condition) {
+        if (this.engine.allowUndefinedConditions) {
+          // undefined conditions always fail
+          conditionReference.result = false
+          return Promise.resolve(false)
+        } else {
+          throw new Error(`No condition ${conditionReference.condition} exists`)
+        }
+      } else {
+        // project the referenced condition onto reference object and evaluate it.
+        delete conditionReference.condition
+        Object.assign(conditionReference, deepClone(condition))
+        return evaluateCondition(conditionReference)
+      }
+    }
+
     /**
      * Emits based on rule evaluation result, and decorates ruleResult with 'result' property
      * @param {RuleResult} ruleResult