Support Passing in a condition constructor

Support passing a condition constructor into the engine
and the rules in order to allow for custom conditions.

Author: Christopher Pardy

docs/engine.md

@@ -54,6 +54,8 @@ as failed conditions. (default: false)
 
 `pathResolver` - Allows a custom object path resolution library to be used. (default: `json-path` syntax). See [custom path resolver](./rules.md#condition-helpers-custom-path-resolver) docs.
 
+`conditionConstructor` - The condition constructor class to use when given condition options. Allows for custom conditions to be created by specifying a new condition constructor. (default: new ConditionConstructor)
+
 ### engine.addFact(String id, Function [definitionFunc], Object [options])
 
 ```js

docs/rules.md

@@ -73,6 +73,8 @@ let rule = new Rule(options)
 
 **options.name** : `[Any]` A way of naming your rules, allowing them to be easily identifiable in [Rule Results](#rule-results).  This is usually of type `String`, but could also be `Object`, `Array`, or `Number`. Note that the name need not be unique, and that it has no impact on execution of the rule.
 
+**options.conditionConstructor**: [ConditionConstructor] - The condition constructor class to use when given condition options. Allows for custom conditions to be created by specifying a new condition constructor. (default: new ConditionConstructor)
+
 ### setConditions(Array conditions)
 
 Helper for setting rule conditions. Alternative to passing the `conditions` option to the rule constructor.

src/engine.js

@@ -25,7 +25,7 @@ class Engine extends EventEmitter {
     this.allowUndefinedConditions = options.allowUndefinedConditions || false
     this.replaceFactsInEventParams = options.replaceFactsInEventParams || false
     this.pathResolver = options.pathResolver
-    this.conditionConstructor = new ConditionConstructor();
+    this.conditionConstructor = options.conditionConstructor || new ConditionConstructor();
     this.operators = new Map()
     this.facts = new Map()
     this.conditions = new Map()
@@ -52,6 +52,9 @@ class Engine extends EventEmitter {
     } else {
       if (!Object.prototype.hasOwnProperty.call(properties, 'event')) throw new Error('Engine: addRule() argument requires "event" property')
       if (!Object.prototype.hasOwnProperty.call(properties, 'conditions')) throw new Error('Engine: addRule() argument requires "conditions" property')
+      if (!Object.prototype.hasOwnProperty.call(properties, 'conditionConstructor')) {
+        properties.conditionConstructor = this.conditionConstructor
+      }
       rule = new Rule(properties)
     }
     rule.setEngine(this)

src/json-rules-engine.js

@@ -2,8 +2,9 @@ import Engine from './engine'
 import Fact from './fact'
 import Rule from './rule'
 import Operator from './operator'
+import ConditionConstructor, { Condition } from './condition'
 
-export { Fact, Rule, Operator, Engine }
+export { Fact, Rule, Operator, Engine, ConditionConstructor, Condition }
 export default function (rules, options) {
   return new Engine(rules, options)
 }

src/rule.js

@@ -21,7 +21,11 @@ class Rule extends EventEmitter {
     if (typeof options === "string") {
       options = JSON.parse(options);
     }
-    this.conditionConstructor = new ConditionConstructor();
+    if (options && options.conditionConstructor) {
+      this.conditionConstructor = options.conditionConstructor
+    } else {
+      this.conditionConstructor = new ConditionConstructor()
+    }
     if (options && options.conditions) {
       this.setConditions(options.conditions);
     }

test/engine-condition-constructor.test.js

@@ -0,0 +1,37 @@
+'use strict'
+
+import sinon from 'sinon'
+import engineFactory, { ConditionConstructor, Condition } from '../src/index'
+
+describe('Engine: conditionConstructor', () => {
+  let engine
+  let conditionConstructor
+  let sandbox
+  before(() => {
+    sandbox = sinon.createSandbox()
+  })
+  afterEach(() => {
+    sandbox.restore()
+  })
+
+  beforeEach(() => {
+    conditionConstructor = { construct: sandbox.spy() } 
+    engine = engineFactory([], { conditionConstructor })
+  })
+
+  it('invokes the condition constructor when adding a condition', () => {
+    const conditionOpts = { all: []}
+    engine.setCondition('test', conditionOpts)
+    expect(conditionConstructor.construct).to.have.been.calledWith(conditionOpts)
+  })
+
+  it('invokes the condition constructor when adding a rule', () => {
+    const ruleOpts = {
+      conditions: { all: [] },
+      event: { type: 'unknown' }
+    }
+    engine.addRule(ruleOpts);
+    expect(conditionConstructor.construct).to.have.been.calledWith(ruleOpts.conditions)
+  })
+
+})

types/index.d.ts

@@ -3,6 +3,7 @@ export interface EngineOptions {
   allowUndefinedConditions?: boolean;
   replaceFactsInEventParams?: boolean;
   pathResolver?: PathResolver;
+  conditionConstructor?: ConditionConstructor;
 }
 
 export interface EngineResult {
@@ -118,6 +119,7 @@ export interface RuleProperties {
   priority?: number;
   onSuccess?: EventHandler;
   onFailure?: EventHandler;
+  conditionConstructor?: ConditionConstructor;
 }
 export type RuleSerializable = Pick<
   Required<RuleProperties>,
@@ -147,6 +149,22 @@ export class Rule implements RuleProperties {
   ): T extends true ? string : RuleSerializable;
 }
 
+export class Condition {
+  constructor(properties: object);
+  toJSON(stringify: true): {name?: string, priority?: number}
+  getPriority(almanac: Almanac): number | undefined;
+  evaluate(
+    almanac: Almanac,
+    operatorMap: { get(operatorName: string): Operator },
+    conditionMap: { get(conditionName): Condition}
+  ): Promise<{ result: boolean, priority: number | undefined, name?: string }>
+  skip(): {name?: string, priority?: number}
+}
+
+export class ConditionConstructor {
+  construct(options: object): Condition
+}
+
 interface ConditionProperties {
   fact: string;
   operator: string;