abstracting engine

Author: mavarazy

README.md

@@ -1,13 +1,19 @@
 # json-rules-engine-simplified
 A simple rules engine expressed in JSON
 
+The primary goal of this project was to be used 
+as alternative to [json-rules-engine](https://github.com/CacheControl/json-rules-engine) in [react-jsonschema-form-conditionals](https://github.com/RxNT/react-jsonschema-form-conditionals),
+as such it has some functionality, that might be specific, but there is nothing preventing it from more generic use. 
+
 ## Features
 
-- Rules expressed in simple, easy to read JSON
-- Declarative conditional logic with [Predicates](https://github.com/landau/predicate)
-- Validation, based on JSON schema and available [predicates](https://github.com/landau/predicate)
-- Secure; no use of eval()
-- Support of nested structures
+- Optional schema and rules validation, to prevent runtime surprises
+- Basic boolean operations (`and` `or` and `not`) that allow to have any arbitrary complexity 
+- Rules expressed in simple, easy to read JSON 
+- Declarative conditional logic with [predicates](https://github.com/landau/predicate)
+- Support of nested structures with [selectn](https://github.com/wilmoore/selectn.js) 
+including composite arrays 
+- Secure - no use of eval()
 
 ## Installation
 
@@ -24,36 +30,45 @@ The simplest example of using `json-rules-engine-simplified`
 ```jsx
 import { Engine } from 'json-rules-engine-simplified'
 
-/**
- * Setup a new engine
- */
-let engine = new Engine()
-/**
- * Specify engine rules
- */
-engine.addRule({
+let rules = [{
     conditions: {
       firstName: "empty"
     },
     event: {
         type: "remove",
         params: { fields: [ "password" ] },
     }
-});
+}];
 
-let facts = {
+let schema = {
+    properties: {
+        firstName: { type: "string" },
+        lastName: { type: "string" }
+    }
+}
+
+/**
+ * Setup a new engine
+ */
+let engine = new Engine(rules, schema);
+
+let formData = {
   lastName: "Smit"
 }
 
 // Run the engine to evaluate
 engine
-  .run(facts)
+  .run(formData)
   .then(events => { // run() returns remove event
     events.map(event => console.log(event.type));
   })
 
 ```
 
+## Validation
+
+
+
 ## Conditional logic
 
 Conditional logic is based on public [predicate](https://github.com/landau/predicate) library 

package.json

@@ -18,7 +18,8 @@
   },
   "jest": {
     "verbose": true,
-    "collectCoverage": true
+    "collectCoverage": true,
+    "collectCoverageFrom" : ["src/**/*.{js,jsx}"]
   },
   "prettierOptions": "--jsx-bracket-same-line --trailing-comma es5 --semi",
   "lint-staged": {

src/Engine.js

@@ -0,0 +1,23 @@
+import { validatePredicates, validateConditionFields } from "./validation";
+import applicableActions from "./applicableActions";
+import { isDevelopment, isObject, toError } from "./utils";
+
+class Engine {
+  constructor(rules, schema) {
+    this.rules = rules;
+    if (isDevelopment()) {
+      let conditions = rules.map(rule => rule.conditions);
+      validatePredicates(conditions);
+      if (schema !== undefined && schema !== null) {
+        if (isObject(schema)) {
+          validateConditionFields(conditions, schema)
+        } else {
+          toError(`Expected valid schema object, but got - ${schema}`)
+        }
+      }
+    }
+  }
+  run = (formData) => Promise.resolve(applicableActions(this.rules, formData));
+}
+
+export default Engine;

src/PredicatesRuleEngine.js

@@ -1,34 +1,45 @@
 import predicate from "predicate";
 import { isObject } from "./utils";
 
+export const OR = "or";
+export const AND = "and";
+export const NOT = "not";
+
 const POSITIVE_PREDICATE = predicate;
 const NEGATIVE_PREDICATE = predicate.not;
 
 export default function checkField(
   fieldVal,
   rule,
   predicator = predicate,
-  condition = Array.prototype.every
 ) {
-  if (isObject(rule)) {
+  if (Array.isArray(fieldVal)) {
+    // Simple rule - like emptyString
+    return fieldVal.some(val => checkField(val, rule, predicator));
+  } else if (isObject(rule)) {
     // Complicated rule - like { greater then 10 }
-    return condition.call(Object.keys(rule), p => {
+    return Object.keys(rule).every(p => {
       let comparable = rule[p];
-      if (isObject(comparable) || p === "not") {
-        if (p === "or") {
-          return comparable.some(condition =>
-            checkField(fieldVal, condition, predicator, Array.prototype.every)
-          );
-        } else if (p === "not") {
+      if (isObject(comparable) || p === NOT) {
+        if (p === OR || p === AND) {
+          if (Array.isArray(comparable)) {
+            if ( p === OR ) {
+              return comparable.some(rule => checkField(fieldVal, rule, predicator));
+            } else {
+              return comparable.every(rule => checkField(fieldVal, rule, predicator));
+            }
+          } else {
+            return false;
+          }
+        } else if (p === NOT) {
           let oppositePredicator =
             predicator === NEGATIVE_PREDICATE
               ? POSITIVE_PREDICATE
               : NEGATIVE_PREDICATE;
           return checkField(
             fieldVal,
             comparable,
-            oppositePredicator,
-            Array.prototype.every
+            oppositePredicator
           );
         } else {
           return false;
@@ -37,9 +48,6 @@ export default function checkField(
         return predicator[p](fieldVal, comparable);
       }
     });
-  } else if (Array.isArray(fieldVal)) {
-    // Simple rule - like emptyString
-    return fieldVal.some(val => predicator[rule](val));
   } else {
     return predicator[rule](fieldVal);
   }

src/checkField.js

@@ -1,19 +1,21 @@
 import { isObject, toError } from "./utils";
-import checkField from "./checkField";
+import checkField, { OR, AND, NOT} from "./checkField";
 import selectn from "selectn";
 
 export default function conditionsMeet(conditions, formData) {
   if (!isObject(conditions) || !isObject(formData)) {
     toError(`Rule ${conditions} with ${formData} can't be processed`);
   }
   return Object.keys(conditions).every(conditionKey => {
-    if (conditionKey === "or") {
-      return conditions[conditionKey].some(sr => conditionsMeet(sr, formData));
-    } else if (conditionKey === "and") {
-      return conditions[conditionKey].every(sr => conditionsMeet(sr, formData));
+    let refFieldRule = conditions[conditionKey];
+    if (conditionKey === OR) {
+      return refFieldRule.some(sr => conditionsMeet(sr, formData));
+    } else if (conditionKey === AND) {
+      return refFieldRule.every(sr => conditionsMeet(sr, formData));
+    } else if (conditionKey === NOT) {
+      return !conditionsMeet(refFieldRule, formData);
     } else {
       let refVal = selectn(conditionKey, formData);
-      let refFieldRule = conditions[conditionKey];
       if (Array.isArray(refVal)) {
         return refVal.some(val => conditionsMeet(refFieldRule, val));
       } else {

src/conditionsMeet.js

@@ -1,3 +1,3 @@
-import PredicatesRuleEngine from "./PredicatesRuleEngine";
+import Engine from './Engine';
 
-export default PredicatesRuleEngine;
+export default Engine;

src/index.js

@@ -1,18 +1,18 @@
 import predicate from "predicate";
 import { flatMap, isObject, toError } from "./utils";
 
+import { NOT, AND, OR } from './checkField';
+
 export function predicatesFromRule(rule) {
   if (isObject(rule)) {
     return flatMap(Object.keys(rule), p => {
       let comparable = rule[p];
-      if (isObject(comparable) || p === "not") {
-        if (p === "or") {
+      if (isObject(comparable) || p === NOT) {
+        if (p === OR || p === AND) {
           if (Array.isArray(comparable)) {
-            return flatMap(comparable, condition =>
-              predicatesFromRule(condition)
-            );
+            return flatMap(comparable, condition => predicatesFromRule(condition));
           } else {
-            toError(`OR must be an array`);
+            toError(`"${p}" must be an array`);
             return [];
           }
         } else {
@@ -31,7 +31,7 @@ export function predicatesFromRule(rule) {
 
 export function predicatesFromCondition(condition) {
   return flatMap(Object.keys(condition), ref => {
-    if (ref === "or" || ref === "and") {
+    if (ref === OR || ref === AND) {
       return flatMap(condition[ref], w => predicatesFromRule(w));
     } else {
       return predicatesFromRule(condition[ref]);
@@ -54,7 +54,7 @@ export function listInvalidPredicates(rules) {
 
 export function fieldsFromCondition(condition) {
   return flatMap(Object.keys(condition), ref => {
-    if (ref === "or" || ref === "and") {
+    if (ref === OR || ref === AND) {
       return flatMap(condition[ref], w => fieldsFromCondition(w));
     } else {
       return [ref];
@@ -75,14 +75,16 @@ export function listInvalidFields(conditions, schema) {
   return Array.from(ruleFields);
 }
 
-export default function validateConditions(conditions, schema) {
+export function validateConditionFields(conditions, schema) {
   let invalidFields = listInvalidFields(conditions, schema);
   if (invalidFields.length !== 0) {
     toError(`Rule contains invalid fields ${invalidFields}`);
   }
+}
 
+export function validatePredicates(conditions) {
   let invalidPredicates = listInvalidPredicates(conditions);
   if (invalidPredicates.length !== 0) {
     toError(`Rule contains invalid predicates ${invalidPredicates}`);
   }
-}
+}

src/validation.js

@@ -0,0 +1,42 @@
+import Engine from "../src/Engine";
+import { testInProd } from "./utils";
+
+let invalidRules = [
+  {
+    conditions: {
+      age: {
+        and: {
+          greater: 5,
+          less: 70,
+        },
+      },
+    },
+    event: {
+      type: "remove",
+      params: {
+        fields: ["telephone"],
+      },
+    },
+  },
+];
+
+let schema = {
+  properties: {
+    age: { type: "number" },
+    telephone: { type: "string" },
+  },
+};
+
+test("ignore invalid rules if no schema provided", () => {
+  expect(() => new Engine(invalidRules)).not.toBeUndefined();
+});
+
+test("ignore invalid rules with invalid schema", () => {
+  expect(() => new Engine({}, [])).toThrow();
+  expect(() => new Engine({}, "schema")).toThrow();
+});
+
+test("initialize with invalid rules", () => {
+  expect(() => new Engine(invalidRules, schema)).toThrow();
+  expect(testInProd(() => new Engine(invalidRules, schema))).not.toBeUndefined();
+});

test/Engine.invalid.test.js

@@ -1,4 +1,4 @@
-import PredicatesRuleEngine from "../src/PredicatesRuleEngine";
+import Engine from "../src/index";
 
 let rules = [
   {
@@ -22,11 +22,11 @@ let schema = {
   },
 };
 
-let engine = PredicatesRuleEngine;
+let engine = new Engine(rules, schema);
 
 test("age greater 5", () => {
   return engine
-    .run({ age: 10 }, rules, schema)
+    .run({ age: 10 })
     .then(actions =>
       expect(actions).toEqual([
         { type: "remove", params: { fields: ["telephone"] } },
@@ -36,13 +36,13 @@ test("age greater 5", () => {
 
 test("age less 5", () => {
   return engine
-    .run({ age: 4 }, rules, schema)
+    .run({ age: 4 })
     .then(actions => expect(actions).toEqual([]));
 });
 
 test("age less 70 ", () => {
   return engine
-    .run({ age: 69 }, rules, schema)
+    .run({ age: 69 })
     .then(actions =>
       expect(actions).toEqual([
         { type: "remove", params: { fields: ["telephone"] } },
@@ -52,6 +52,6 @@ test("age less 70 ", () => {
 
 test("age greater 70 ", () => {
   return engine
-    .run({ age: 71 }, rules, schema)
+    .run({ age: 71 })
     .then(actions => expect(actions).toEqual([]));
 });