Move Top Level enforcement to ConditionConstructor

Move the enforcement of top-level conditions in the rules
and the engine to the top-level condition constructor
this also allows for passing Condition instances
to the setCondition method by default

Ultimately this adds a huge amount of support for new
types of conditions that can be plugged into the system.

Author: Christopher Pardy

docs/engine.md

@@ -54,7 +54,7 @@ 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)
+`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 TopLevelConditionConstructor())
 
 ### engine.addFact(String id, Function [definitionFunc], Object [options])
 

docs/rules.md

@@ -73,7 +73,7 @@ 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)
+**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 TopLevelConditionConstructor())
 
 ### setConditions(Array conditions)
 

src/condition/condition-constructor.js

@@ -30,3 +30,29 @@ export default class ConditionConstructor {
     return new ComparisonCondition(options);
   }
 }
+
+export class TopLevelConditionConstructor extends ConditionConstructor {
+  constructor(nestedConditionConstructor) {
+    super()
+    this.nestedConditionConstructor = nestedConditionConstructor || new ConditionConstructor()
+  }
+
+  construct(options) {
+    if (!options) {
+      throw new Error("Condition: constructor options required");
+    }
+    if (options instanceof Condition) {
+      return options;
+    }
+    if (Object.prototype.hasOwnProperty.call(options, "any")) {
+      return new AnyCondition(options, this.nestedConditionConstructor);
+    } else if (Object.prototype.hasOwnProperty.call(options, "all")) {
+      return new AllCondition(options, this.nestedConditionConstructor);
+    } else if (Object.prototype.hasOwnProperty.call(options, "not")) {
+      return new NotCondition(options, this.nestedConditionConstructor);
+    } else if (Object.prototype.hasOwnProperty.call(options, "condition")) {
+      return new ConditionReference(options);
+    }
+    throw new Error('"conditions" root must contain a single instance of "all", "any", "not", or "condition"')
+  }
+}

src/condition/index.js

@@ -1,6 +1,6 @@
 import AllCondition from "./all-condition";
 import AnyCondition from "./any-condition";
-import ConditionConstructor from "./condition-constructor";
+import ConditionConstructor, { TopLevelConditionConstructor } from "./condition-constructor";
 import neverCondition from "./never-condition";
 import ComparisonCondition from "./comparison-condition";
 import ConditionReference from "./condition-reference";
@@ -15,5 +15,6 @@ export {
   neverCondition,
   ComparisonCondition,
   ConditionReference,
-  NotCondition
+  NotCondition,
+  TopLevelConditionConstructor
 }

src/engine.js

@@ -7,7 +7,7 @@ import Almanac from './almanac'
 import EventEmitter from 'eventemitter2'
 import defaultOperators from './engine-default-operators'
 import debug from './debug'
-import ConditionConstructor from './condition'
+import { TopLevelConditionConstructor } from './condition'
 
 export const READY = 'READY'
 export const RUNNING = 'RUNNING'
@@ -25,7 +25,7 @@ class Engine extends EventEmitter {
     this.allowUndefinedConditions = options.allowUndefinedConditions || false
     this.replaceFactsInEventParams = options.replaceFactsInEventParams || false
     this.pathResolver = options.pathResolver
-    this.conditionConstructor = options.conditionConstructor || new ConditionConstructor();
+    this.conditionConstructor = options.conditionConstructor || new TopLevelConditionConstructor();
     this.operators = new Map()
     this.facts = new Map()
     this.conditions = new Map()
@@ -109,9 +109,6 @@ class Engine extends EventEmitter {
   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, this.conditionConstructor.construct(conditions))
     return this
   }

src/json-rules-engine.js

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

src/rule.js

@@ -2,7 +2,7 @@
 
 import RuleResult from "./rule-result";
 import EventEmitter from "eventemitter2";
-import ConditionConstructor, { neverCondition } from "./condition";
+import { neverCondition, TopLevelConditionConstructor } from "./condition";
 
 class Rule extends EventEmitter {
   /**
@@ -24,7 +24,7 @@ class Rule extends EventEmitter {
     if (options && options.conditionConstructor) {
       this.conditionConstructor = options.conditionConstructor
     } else {
-      this.conditionConstructor = new ConditionConstructor()
+      this.conditionConstructor = new TopLevelConditionConstructor()
     }
     if (options && options.conditions) {
       this.setConditions(options.conditions);
@@ -74,16 +74,6 @@ 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") &&
-      !Object.prototype.hasOwnProperty.call(conditions, "condition")
-    ) {
-      throw new Error(
-        '"conditions" root must contain a single instance of "all", "any", "not", or "condition"'
-      );
-    }
     this.conditions = this.conditionConstructor.construct(conditions);
     return this;
   }

test/engine-condition-constructor.test.js

@@ -34,4 +34,9 @@ describe('Engine: conditionConstructor', () => {
     expect(conditionConstructor.construct).to.have.been.calledWith(ruleOpts.conditions)
   })
 
+  it('allows non-top-level conditions if the constructor will allow them.', () => {
+    const conditionOpts = { never: true }
+    expect(engine.setCondition.bind(engine, 'test', conditionOpts)).not.to.throw()
+  })
+
 })

types/index.d.ts

@@ -26,7 +26,7 @@ export class Engine {
   removeRule(ruleOrName: Rule | string): boolean;
   updateRule(rule: Rule): void;
 
-  setCondition(name: string, conditions: TopLevelCondition): this;
+  setCondition(name: string, conditions: object | Condition): this;
   removeCondition(name: string): boolean;
 
   addOperator(operator: Operator): Map<string, Operator>;
@@ -137,10 +137,10 @@ export interface RuleResult {
 export class Rule implements RuleProperties {
   constructor(ruleProps: RuleProperties | string);
   name: string;
-  conditions: TopLevelCondition;
+  conditions: Condition;
   event: Event;
   priority: number;
-  setConditions(conditions: TopLevelCondition): this;
+  setConditions(conditions: object | Condition): this;
   setEvent(event: Event): this;
   setPriority(priority: number): this;
   toJSON(): string;
@@ -165,6 +165,10 @@ export class ConditionConstructor {
   construct(options: object): Condition
 }
 
+export class TopLevelConditionConstructor extends ConditionConstructor {
+  constructor(nestedConditionConstructor?: ConditionConstructor)
+}
+
 interface ConditionProperties {
   fact: string;
   operator: string;