fix #12

Author: mavarazy

src/utils.js

@@ -58,15 +58,20 @@ function fetchSchema(ref, schema) {
 }
 
 export function extractRefSchema(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 if (
-    schema.properties[field] &&
-    schema.properties[field].type === "object"
-  ) {
-    return schema.properties[field];
+  let { properties } = schema;
+  if (!properties || !properties[field]) {
+    toError(`${field} not defined in properties`);
+    return undefined;
+  } else if (properties[field].type === "array") {
+    if (isRefArray(field, schema)) {
+      return fetchSchema(properties[field].items["$ref"], schema);
+    } else {
+      return properties[field].items;
+    }
+  } else if (properties[field] && properties[field]["$ref"]) {
+    return fetchSchema(properties[field]["$ref"], schema);
+  } else if (properties[field] && properties[field].type === "object") {
+    return properties[field];
   } else {
     toError(`${field} has no $ref field ref schema extraction is impossible`);
     return undefined;

test/issues/12.test.js

@@ -0,0 +1,116 @@
+import Engine from "../../src/Engine";
+
+const ADDRESS_SCHEMA = {
+  type: "object",
+  properties: {
+    zip: { type: "string" },
+    city: { type: "string" },
+    street: { type: "string" },
+    flat: { type: "string" },
+  },
+};
+
+const SCHEMA = {
+  definitions: {
+    address: ADDRESS_SCHEMA,
+  },
+  type: "object",
+  properties: {
+    homeAddress: {
+      $ref: "#/definitions/address",
+    },
+    workAddress: ADDRESS_SCHEMA,
+    favFoodLocations: {
+      type: "array",
+      items: {
+        $ref: "#/definitions/address",
+      },
+    },
+    favoritePlaces: {
+      type: "array",
+      items: ADDRESS_SCHEMA,
+    },
+  },
+};
+
+let engine = new Engine([], SCHEMA);
+
+test("invalidates ref object", () => {
+  expect(() =>
+    engine.addRule({
+      conditions: {
+        "homeAddress.home": { is: "true" },
+      },
+    })
+  ).toThrow();
+});
+
+test("invalidates embedded object", () => {
+  expect(() =>
+    engine.addRule({
+      conditions: {
+        "workAddress.home": { is: "true" },
+      },
+    })
+  ).toThrow();
+});
+
+test("invalidates array object", () => {
+  expect(() =>
+    engine.addRule({
+      conditions: {
+        "favFoodLocations.home": { is: "true" },
+      },
+    })
+  ).toThrow();
+});
+
+test("invalidates array with $ref object", () => {
+  expect(() =>
+    engine.addRule({
+      conditions: {
+        "favoritePlaces.home": { is: "true" },
+      },
+    })
+  ).toThrow();
+});
+
+test("Validates ref object", () => {
+  expect(
+    engine.addRule({
+      conditions: {
+        "homeAddress.zip": { is: "true" },
+      },
+    })
+  ).toBeUndefined();
+});
+
+test("Validates embedded object", () => {
+  expect(
+    engine.addRule({
+      conditions: {
+        "workAddress.zip": { is: "true" },
+      },
+    })
+  ).toBeUndefined();
+});
+
+test("Validates array object", () => {
+  expect(
+    engine.addRule({
+      conditions: {
+        "favFoodLocations.zip": { is: "true" },
+      },
+    })
+  ).toBeUndefined();
+});
+
+test("Validates array with $ref object", () => {
+  expect(
+    engine.addRule({
+      conditions: {
+        "favoritePlaces.zip": { is: "true" },
+      },
+    })
+  ).toBeUndefined();
+});

test/validation.ref.test.js

@@ -30,6 +30,12 @@ let schema = {
     externalConfig: {
       $ref: "http://example.com/oneschema.json",
     },
+    invalidArrayRef: {
+      type: "array",
+      items: {
+        $ref: "http://example.com/oneschema.json",
+      },
+    },
   },
 };
 
@@ -44,6 +50,17 @@ test("condition with external ref", () => {
   ).toEqual([]);
 });
 
+test("array condition with external ref", () => {
+  expect(() =>
+    predicatesFromCondition({ "invalidArrayRef.name": "empty" }, schema)
+  ).toThrow();
+  expect(
+    testInProd(() =>
+      predicatesFromCondition({ "invalidArrayRef.name": "empty" }, schema)
+    )
+  ).toEqual([]);
+});
+
 test("condition with fake ref field", () => {
   expect(() =>
     predicatesFromCondition({ "fakeRef.name": "empty" }, schema)