fix #1

Author: mavarazy

src/utils.js

@@ -14,21 +14,30 @@ export function toError(message) {
   }
 }
 
-export function isArray(field, schema) {
-  return schema.properties[field] && schema.properties[field].type === "array";
+export function isRefArray(field, schema) {
+  return (
+    schema.properties[field] &&
+    schema.properties[field].type === "array" &&
+    schema.properties[field].items &&
+    schema.properties[field].items["$ref"]
+  );
+}
+
+function fetchSchema(ref, schema) {
+  let relevantSchema = ref.split("/");
+  return relevantSchema
+    .filter(ref => ref !== "#")
+    .reduce((schema, field) => schema[field], schema);
 }
 
 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);
+  if (isRefArray(field, schema)) {
+    return fetchSchema(schema.properties[field].items["$ref"], schema);
+  } else if (schema.properties[field] && schema.properties[field]["$ref"]) {
+    return fetchSchema(schema.properties[field]["$ref"], schema);
+  } else {
+    return undefined;
   }
-  return undefined;
 }
 
 const concat = (x, y) => x.concat(y);

src/validation.js

@@ -1,5 +1,11 @@
 import predicate from "predicate";
-import { flatMap, isObject, toError, isArray, extractRefSchema } from "./utils";
+import {
+  flatMap,
+  isObject,
+  toError,
+  isRefArray,
+  extractRefSchema,
+} from "./utils";
 import { OR, AND, NOT } from "./constants";
 
 export function predicatesFromRule(rule, schema) {
@@ -42,22 +48,27 @@ export function predicatesFromCondition(condition, schema) {
       }
     } else if (ref === NOT) {
       return predicatesFromCondition(refVal, schema);
-    } else {
-      // TODO disable validation of nested structures
-      let isField = schema.properties[ref] !== undefined;
-      let isFieldAnArray = isArray(ref, schema);
-      console.log(`${ref} is field ${isField} and array ${isFieldAnArray}`);
-      if (isField && !isFieldAnArray) {
-        return predicatesFromRule(refVal, schema);
+    } else if (ref.indexOf(".") !== -1) {
+      let separator = ref.indexOf(".");
+      let schemaField = ref.substr(0, separator);
+      let subSchema = extractRefSchema(schemaField, schema);
+
+      if (subSchema) {
+        let subSchemaField = ref.substr(separator + 1);
+        let newCondition = { [subSchemaField]: refVal };
+        return predicatesFromCondition(newCondition, subSchema);
       } else {
-        if (isFieldAnArray) {
-          let refSchema = extractRefSchema(ref, schema);
-          console.log(`Ref schema ${JSON.stringify(refSchema)}`);
-          return refSchema ? predicatesFromCondition(refVal, refSchema) : [];
-        } else {
-          return [];
-        }
+        toError(`Can't find schema for ${schemaField}`);
+        return [];
       }
+    } else if (isRefArray(ref, schema)) {
+      let refSchema = extractRefSchema(ref, schema);
+      return refSchema ? predicatesFromCondition(refVal, refSchema) : [];
+    } else if (schema.properties[ref]) {
+      return predicatesFromRule(refVal, schema);
+    } else {
+      toError(`Can't validate ${ref}`);
+      return [];
     }
   });
 }

test/utils.test.js

@@ -4,7 +4,7 @@ import {
   isDevelopment,
   toError,
   extractRefSchema,
-  isArray,
+  isRefArray,
 } from "../src/utils";
 import { testInProd } from "./utils";
 
@@ -55,13 +55,16 @@ test("extract referenced schema", () => {
         items: { $ref: "#/definitions/medication" },
       },
       primaryMedication: {
-        $ref: "#/definitions/medications",
+        $ref: "#/definitions/medication",
       },
     },
   };
 
-  expect(isArray("medications", schema)).toBeTruthy();
+  expect(isRefArray("medications", schema)).toBeTruthy();
   expect(extractRefSchema("medications", schema)).toEqual(
     schema.definitions.medication
   );
+  expect(extractRefSchema("primaryMedication", schema)).toEqual(
+    schema.definitions.medication
+  );
 });

test/validation.nestedFields.test.js

@@ -47,6 +47,7 @@ let schema = {
 test("list all predicates", () => {
   expect(listAllPredicates(rules.map(r => r.conditions), schema)).toEqual([
     "is",
+    "equal",
   ]);
 });