#1

Author: mavarazy

src/utils.js

@@ -14,5 +14,22 @@ export function toError(message) {
   }
 }
 
+export function isArray(field, schema) {
+  return schema.properties[field] && schema.properties[field].type === "array";
+}
+
+export function extractRefSchema(field, schema) {
+  if (isArray(field, schema)) {
+    let relevantSchema =
+      schema.properties[field].items && schema.properties[field].items["$ref"]
+        ? schema.properties[field].items["$ref"].split("/")
+        : [];
+    return relevantSchema
+      .filter(ref => ref !== "#")
+      .reduce((schema, field) => schema[field], schema);
+  }
+  return undefined;
+}
+
 const concat = (x, y) => x.concat(y);
 export const flatMap = (xs, f) => xs.map(f).reduce(concat, []);

src/validation.js

@@ -1,5 +1,5 @@
 import predicate from "predicate";
-import { flatMap, isObject, toError } from "./utils";
+import { flatMap, isObject, toError, isArray, extractRefSchema } from "./utils";
 import { OR, AND, NOT } from "./constants";
 
 export function predicatesFromRule(rule, schema) {
@@ -45,11 +45,18 @@ export function predicatesFromCondition(condition, schema) {
     } else {
       // TODO disable validation of nested structures
       let isField = schema.properties[ref] !== undefined;
-      let isArray = isField && schema.properties[ref].type === "array";
-      if (isField && !isArray) {
+      let isFieldAnArray = isArray(ref, schema);
+      console.log(`${ref} is field ${isField} and array ${isFieldAnArray}`);
+      if (isField && !isFieldAnArray) {
         return predicatesFromRule(refVal, schema);
       } else {
-        return [];
+        if (isFieldAnArray) {
+          let refSchema = extractRefSchema(ref, schema);
+          console.log(`Ref schema ${JSON.stringify(refSchema)}`);
+          return refSchema ? predicatesFromCondition(refVal, refSchema) : [];
+        } else {
+          return [];
+        }
       }
     }
   });

test/utils.test.js

@@ -1,4 +1,11 @@
-import { flatMap, isObject, isDevelopment, toError } from "../src/utils";
+import {
+  flatMap,
+  isObject,
+  isDevelopment,
+  toError,
+  extractRefSchema,
+  isArray,
+} from "../src/utils";
 import { testInProd } from "./utils";
 
 test("array flatmap", () => {
@@ -22,3 +29,39 @@ test("error throws exception", () => {
   expect(() => toError("Yes")).toThrow();
   expect(testInProd(() => toError("Yes"))).toBeUndefined();
 });
+
+test("extract referenced schema", () => {
+  let schema = {
+    definitions: {
+      medication: {
+        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/medication" },
+      },
+      primaryMedication: {
+        $ref: "#/definitions/medications",
+      },
+    },
+  };
+
+  expect(isArray("medications", schema)).toBeTruthy();
+  expect(extractRefSchema("medications", schema)).toEqual(
+    schema.definitions.medication
+  );
+});

test/validation.nestedFields.test.js

@@ -1,10 +1,11 @@
 import Engine from "../src/Engine";
+import { listAllPredicates } from "../src/validation";
 
 let rules = [
   {
     conditions: {
       medications: {
-        type: { equal: "D" },
+        type: { is: "D" },
       },
       "primaryMedication.type": { equal: "C" },
     },
@@ -35,14 +36,20 @@ let schema = {
     },
     medications: {
       type: "array",
-      items: { $ref: "#/definitions/hobby" },
+      items: { $ref: "#/definitions/medications" },
     },
     primaryMedication: {
-      $ref: "#/definitions/hobby",
+      $ref: "#/definitions/medications",
     },
   },
 };
 
+test("list all predicates", () => {
+  expect(listAllPredicates(rules.map(r => r.conditions), schema)).toEqual([
+    "is",
+  ]);
+});
+
 test("valid rules", () => {
   expect(new Engine(rules, schema)).not.toBeUndefined();