Disable validation of nested structures

Author: mavarazy

README.md

@@ -65,8 +65,10 @@ engine
 
 ```
 
-## Validation
+## Schema and rules validation on construction
 
+In order to prevent most common errors, `Engine` does initial validation on the schema, during construction.
+If no `schema` is provided to the constructor 
 
 
 ## Conditional logic

src/Engine.js

@@ -9,7 +9,7 @@ class Engine {
       let conditions = rules.map(rule => rule.conditions);
       if (schema !== undefined && schema !== null) {
         if (isObject(schema)) {
-          validatePredicates(conditions);
+          validatePredicates(conditions, schema);
           validateConditionFields(conditions, schema)
         } else {
           toError(`Expected valid schema object, but got - ${schema}`)

src/validation.js

@@ -2,58 +2,70 @@ import predicate from "predicate";
 import { flatMap, isObject, toError } from "./utils";
 import { OR, AND, NOT } from './constants';
 
-export function predicatesFromRule(rule) {
+export function predicatesFromRule(rule, schema) {
   if (isObject(rule)) {
     return flatMap(Object.keys(rule), p => {
       let comparable = rule[p];
       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, schema));
           } else {
             toError(`"${p}" must be an array`);
             return [];
           }
         } else {
-          let predicates = predicatesFromRule(comparable);
+          let predicates = predicatesFromRule(comparable, schema);
           predicates.push(p);
           return predicates;
         }
       } else {
-        return predicatesFromRule(p);
+        return predicatesFromRule(p, schema);
       }
     });
   } else {
     return [rule];
   }
 }
 
-export function predicatesFromCondition(condition) {
+export function predicatesFromCondition(condition, schema) {
   return flatMap(Object.keys(condition), ref => {
     if (ref === OR || ref === AND) {
-      return flatMap(condition[ref], w => predicatesFromRule(w));
+      if (Array.isArray(condition[ref])) {
+        return flatMap(condition[ref], w => predicatesFromRule(w, schema));
+      } else {
+        toError(`${p} in ${JSON.stringify(condition)} must be an Array`);
+        return [];
+      }
     } else if (ref === NOT) {
-      return predicatesFromCondition(condition[ref]);
+      return predicatesFromCondition(condition[ref], schema);
     } else {
-      return predicatesFromRule(condition[ref]);
+      // TODO disable validation of nested structures
+      let isField = schema.properties[ref] !== undefined;
+      let isArray = isField && schema.properties[ref].type === "array";
+      if (isField && !isArray) {
+        return predicatesFromRule(condition[ref], schema);
+      } else {
+        return [];
+      }
     }
   });
 }
 
-export function listAllPredicates(conditions) {
+export function listAllPredicates(conditions, schema) {
   let allPredicates = flatMap(conditions, condition =>
-    predicatesFromCondition(condition)
+    predicatesFromCondition(condition, schema)
   );
   return allPredicates.filter((v, i, a) => allPredicates.indexOf(v) === i);
 }
 
-export function listInvalidPredicates(conditions) {
-  let refPredicates = listAllPredicates(conditions);
+export function listInvalidPredicates(conditions, schema) {
+  let refPredicates = listAllPredicates(conditions, schema);
   return refPredicates.filter((p) => predicate[p] === undefined);
 }
 
-export function validatePredicates(conditions) {
-  let invalidPredicates = listInvalidPredicates(conditions);
+export function validatePredicates(conditions, schema) {
+  let invalidPredicates = listInvalidPredicates(conditions, schema);
   if (invalidPredicates.length !== 0) {
     toError(`Rule contains invalid predicates ${invalidPredicates}`);
   }
@@ -65,8 +77,12 @@ export function fieldsFromCondition(condition) {
   return flatMap(Object.keys(condition), ref => {
     if (ref === OR || ref === AND) {
       return flatMap(condition[ref], w => fieldsFromCondition(w));
-    } else {
+    } else if (ref === NOT) {
+      return fieldsFromCondition(condition[ref]);
+    } else if(ref.indexOf(".") === -1) {
       return [ref];
+    } else {
+      return [];
     }
   });
 }

test/validation.nestedFields.test.js

@@ -0,0 +1,58 @@
+import Engine from '../src/Engine';
+
+let rules = [{
+  conditions: {
+    medications: {
+      type: { equal: "D" },
+    },
+    "primaryMedication.type": { equal: "C" }
+  },
+  event: {
+    type: 'remove'
+  }
+}];
+
+let schema = {
+  definitions: {
+    medications: {
+      type: "object",
+      properties: {
+        type: { type: "string" },
+        isLiquid: { type: "boolean" },
+      },
+    }
+  },
+  type: "object",
+  required: [
+    "medications",
+    "firstName",
+    "lastName",
+  ],
+  properties: {
+    firstName: {
+      type: "string",
+    },
+    lastName: {
+      type: "string",
+    },
+    medications: {
+      type: "array",
+      items: { "$ref": "#/definitions/hobby" }
+    },
+    primaryMedication: {
+      "$ref": "#/definitions/hobby"
+    }
+  }
+};
+
+
+test("valid rules", () => {
+  expect(new Engine(rules, schema)).not.toBeUndefined();
+
+  let engine = new Engine(rules, schema);
+  return engine.
+    run({ primaryMedication: { type: "C" }, medications: [ { type: "D" } ]}).
+    then(event => expect(event.length).toEqual(1));
+
+});
+

test/validation.test.js

@@ -14,15 +14,21 @@ function conditionsFrom(rules) {
   return rules.map(({ conditions }) => conditions);
 }
 
+let defSchema = { properties: {
+  firstName: { type: "string" },
+  password: { type: "string" },
+  age: { type: "integer" }
+}};
+
 test("Check predicates", () => {
   const conditions = conditionsFrom([
     { conditions: { firstName: "epty" } },
     { conditions: { age: { greater: 10 } } },
     { conditions: { age: { less: 20 } } },
   ]);
 
-  let predicates = listInvalidPredicates(conditions);
-  expect(predicates).toEqual(["epty"]);
+  expect(listAllPredicates(conditions, defSchema)).toEqual(["epty", "greater", "less"]);
+  expect(listInvalidPredicates(conditions, defSchema)).toEqual(["epty"]);
 });
 
 test("Two field rule ", () => {
@@ -41,7 +47,7 @@ test("Two field rule ", () => {
     },
   ]);
 
-  let predicates = listAllPredicates(conditions);
+  let predicates = listAllPredicates(conditions, defSchema);
   expect(predicates).toEqual(["empty", "greater", "less"]);
 
   let fields = listAllFields(conditions);
@@ -65,7 +71,7 @@ test("3 field rule ", () => {
     },
   ]);
 
-  let predicates = listAllPredicates(conditions);
+  let predicates = listAllPredicates(conditions, defSchema);
   expect(predicates).toEqual(["empty", "greater", "less"]);
 
   let fields = listAllFields(conditions);
@@ -87,19 +93,12 @@ test("invalidate predicates", () => {
     },
   ]);
 
-  expect(listAllPredicates(invalidConditions)).toEqual(["greater", "less", "wtf"]);
-  expect(listInvalidPredicates(invalidConditions)).toEqual(["wtf"]);
-  expect(() => validatePredicates(invalidConditions)).toThrow();
-  expect(() => testInProd(validatePredicates(invalidConditions))).not.toBeUndefined();
+  expect(listAllPredicates(invalidConditions, defSchema)).toEqual(["greater", "less", "wtf"]);
+  expect(listInvalidPredicates(invalidConditions, defSchema)).toEqual(["wtf"]);
+  expect(() => validatePredicates(invalidConditions, defSchema)).toThrow();
+  expect(() => testInProd(validatePredicates(invalidConditions, defSchema))).not.toBeUndefined();
 });
 
-let schema = {
-  properties: {
-    firstName: { type: "string" },
-    password: { type: "string" },
-  },
-};
-
 test("invalid field", () => {
   let invalidFieldConditions = conditionsFrom([
     {
@@ -116,8 +115,8 @@ test("invalid field", () => {
   ]);
 
   expect(listAllFields(invalidFieldConditions)).toEqual(["lastName", "firstName"]);
-  expect(listInvalidFields(invalidFieldConditions, schema)).toEqual([ "lastName",]);
-  expect(() => validateConditionFields(invalidFieldConditions, schema)).toThrow();
+  expect(listInvalidFields(invalidFieldConditions, defSchema)).toEqual([ "lastName",]);
+  expect(() => validateConditionFields(invalidFieldConditions, defSchema)).toThrow();
 });
 
 test("invalid OR", () => {
@@ -130,7 +129,7 @@ test("invalid OR", () => {
     },
   ]);
 
-  expect(() => validate(invalidOrConditions, schema)).toThrow();
+  expect(() => validatePredicates(invalidOrConditions, defSchema)).toThrow();
 });
 
 test("invalid field or", () => {
@@ -150,7 +149,7 @@ test("invalid field or", () => {
 
   expect(() => predicatesFromRule(invalidFieldOr[0].firstName)).toThrow();
   expect(testInProd(() => predicatesFromRule(invalidFieldOr[0].firstName))).toEqual([]);
-  expect(() => validatePredicates(invalidFieldOr, schema)).toThrow();
+  expect(() => validatePredicates(invalidFieldOr, defSchema)).toThrow();
 });
 
 test("invalid field NOT or", () => {
@@ -165,7 +164,7 @@ test("invalid field NOT or", () => {
     },
   ]);
 
-  expect(() => validatePredicates(invalidFieldNotWithOr, schema)).toThrow();
+  expect(() => validatePredicates(invalidFieldNotWithOr, defSchema)).toThrow();
 });
 
 test("valid field or", () => {
@@ -182,8 +181,8 @@ test("valid field or", () => {
     },
   ]);
 
-  expect(predicatesFromCondition(validFieldOr[0])).toEqual(["is", "is"]);
-  expect(validateConditionFields(validFieldOr, schema)).toBeUndefined();
+  expect(predicatesFromCondition(validFieldOr[0], defSchema)).toEqual(["is", "is"]);
+  expect(validateConditionFields(validFieldOr, defSchema)).toBeUndefined();
 });
 
 test("extract predicates from when with or & and", () => {