fact-fact comparison conditions

Author: Cache Hamm

docs/engine.md

@@ -34,12 +34,12 @@ undefined facts as falsey conditions.  (default: false)
 engine.addFact('speed-of-light', 299792458)
 
 // facts computed via function
-engine.addFact('account-type', function getAccountType() {
+engine.addFact('account-type', function getAccountType(params, almanac) {
   // ...
 })
 
 // facts with options:
-engine.addFact('account-type', function getAccountType() {
+engine.addFact('account-type', function getAccountType(params, almanac) {
   // ...
 }, { cache: false, priority: 500 })
 ```

package.json

@@ -55,7 +55,7 @@
     "chai": "3.4.1",
     "chai-as-promised": "^5.2.0",
     "colors": "~1.1.2",
-    "mocha": "2.3.4",
+    "mocha": "3.2.0",
     "regenerator": "~0.8.46",
     "sinon": "^1.17.2",
     "sinon-chai": "^2.8.0",
@@ -64,6 +64,7 @@
   },
   "dependencies": {
     "debug": "2.2.0",
+    "lodash.isplainobject": "4.0.6",
     "object-hash": "1.1.5",
     "params": "0.1.1",
     "selectn": "1.1.1"

src/almanac.js

@@ -2,6 +2,9 @@
 
 let debug = require('debug')('json-rules-engine')
 let verbose = require('debug')('json-rules-engine-verbose')
+let selectn = require('selectn')
+let isPlainObject = require('lodash.isplainobject')
+let warn = require('debug')('json-rules-engine:warn')
 
 import Fact from './fact'
 import { UndefinedFactError } from './errors'
@@ -82,9 +85,10 @@ export default class Almanac {
    * 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.
    */
-  async factValue (factId, params = {}) {
+  async factValue (factId, params = {}, path = '') {
     let fact = this._getFact(factId)
     let cacheKey = fact.getCacheKey(params)
     let cacheVal = cacheKey && this.factResultsCache.get(cacheKey)
@@ -93,6 +97,15 @@ export default class Almanac {
       return cacheVal
     }
     verbose(`almanac::factValue cache miss for fact:${factId}; calculating`)
-    return this._setFactValue(fact, params, fact.calculate(params, this))
+    let factValue = await this._setFactValue(fact, params, fact.calculate(params, this))
+    if (path) {
+      if (isPlainObject(factValue) || Array.isArray(factValue)) {
+        factValue = selectn(path)(factValue)
+        debug(`condition::evaluate extracting object property ${path}, received: ${factValue}`)
+      } else {
+        warn(`condition::evaluate could not compute object path(${path}) of non-object: ${factValue} <${typeof factValue}>; continuing with ${factValue}`)
+      }
+    }
+    return factValue
   }
 }

src/condition.js

@@ -1,10 +1,8 @@
 'use strict'
 
-import params from 'params'
-import selectn from 'selectn'
-
+let params = require('params')
 let debug = require('debug')('json-rules-engine')
-let warn = require('debug')('json-rules-engine:warn')
+let isPlainObject = require('lodash.isplainobject')
 
 export default class Condition {
   constructor (properties) {
@@ -61,33 +59,39 @@ export default class Condition {
     return props
   }
 
+  /**
+   * Interprets .value as either a primitive, or if a fact, retrieves the fact value
+   */
+  async _getValue(almanac) {
+    let value = this.value
+    if (isPlainObject(value) && value.hasOwnProperty('fact')) { // value: { fact: 'xyz' }
+      value = await almanac.factValue(value.fact, value.params, value.path)
+    }
+    return value
+  }
+
   /**
    * Takes the fact result and compares it to the condition 'value', using the operator
-   * @param   {mixed} comparisonValue - fact result
+   *   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
    */
-  evaluate (comparisonValue, operatorMap) {
-    // for any/all, simply comparisonValue that the sub-condition array evaluated truthy
-    if (this.isBooleanOperator()) return comparisonValue === true
-
-    // if the fact has provided an object, and a path is specified, retrieve the object property
-    if (this.path) {
-      if (typeof comparisonValue === 'object') {
-        comparisonValue = selectn(this.path)(comparisonValue)
-        debug(`condition::evaluate extracting object property ${this.path}, received: ${comparisonValue}`)
-      } else {
-        warn(`condition::evaluate could not compute object path(${this.path}) of non-object: ${comparisonValue} <${typeof comparisonValue}>; continuing with ${comparisonValue}`)
-      }
-    }
+  async evaluate (almanac, operatorMap) {
+    if (!almanac) throw new Error('almanac required')
+    if (!operatorMap) throw new Error('operatorMap required')
+    if (this.isBooleanOperator()) throw new Error('Cannot evaluate() a boolean condition')
 
     let op = operatorMap.get(this.operator)
     if (!op) throw new Error(`Unknown operator: ${this.operator}`)
 
-    let evaluationResult = op.evaluate(comparisonValue, this.value)
-    if (!this.isBooleanOperator()) {
-      debug(`condition::evaluate <${comparisonValue} ${this.operator} ${this.value}?> (${evaluationResult})`)
-    }
+    let rightHandSideValue = await this._getValue(almanac)
+    let leftHandSideValue = await almanac.factValue(this.fact, this.params, this.path)
+
+    let evaluationResult = op.evaluate(leftHandSideValue, rightHandSideValue)
+    debug(`condition::evaluate <${leftHandSideValue} ${this.operator} ${rightHandSideValue}?> (${evaluationResult})`)
     return evaluationResult
   }
 

src/rule.js

@@ -142,17 +142,18 @@ class Rule extends EventEmitter {
         } else {
           comparisonValue = await any(subConditions)
         }
+        // for booleans, rule passing is determined by the all/any result
+        passes = comparisonValue === true
       } else {
         try {
-          comparisonValue = await almanac.factValue(condition.fact, condition.params)
+          passes = await condition.evaluate(almanac, this.engine.operators, comparisonValue)
         } catch (err) {
+          // any condition raising an undefined fact error is considered falsey when allowUndefinedFacts is enabled
           if (this.engine.allowUndefinedFacts && err.code === 'UNDEFINED_FACT') passes = false
           else throw err
         }
       }
-      if (passes === undefined) {
-        passes = await condition.evaluate(comparisonValue, this.engine.operators)
-      }
+
       if (passes) {
         this.emit('success', this.event, almanac)
       } else {