fix #10

Author: mavarazy

src/utils.js

@@ -51,6 +51,11 @@ export function extractRefSchema(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];
   } else {
     toError(`${field} has no $ref field ref schema extraction is impossible`);
     return undefined;

test/issues/10.test.js

@@ -0,0 +1,90 @@
+import {
+  listInvalidPredicates,
+  validateConditionFields,
+  validatePredicates,
+} from "../../src/validation";
+
+let rules = [
+  {
+    title: "Rule #2",
+    description:
+      "This hides Address, Email, Gender and the Password fields until First Name and Last Name have a value",
+    conditions: {
+      and: [
+        {
+          or: [
+            { "registration.firstName": "empty" },
+            { "registration.lastName": "empty" },
+          ],
+        },
+      ],
+    },
+    event: {
+      type: "remove",
+      params: {
+        field: [
+          "address",
+          "registration.gender",
+          "registration.email",
+          "registration.password",
+          "registration.confirmPassword",
+        ],
+      },
+    },
+  },
+];
+
+let schema = {
+  type: "object",
+  properties: {
+    registration: {
+      type: "object",
+      properties: {
+        firstName: { type: "string" },
+        lastName: { type: "string" },
+        gender: {
+          type: "string",
+          enum: ["Male", "Female"],
+        },
+        dob: { type: "string" },
+        email: { type: "string" },
+        password: { type: "string" },
+        confirmPassword: { type: "string" },
+      },
+      required: [
+        "firstName",
+        "lastName",
+        "email",
+        "password",
+        "confirmPassword",
+      ],
+    },
+    address: {
+      type: "object",
+      properties: {
+        streetNo: { type: "string" },
+        street: { type: "string" },
+        suburb: { type: "string" },
+        postCode: { type: "string" },
+        state: {
+          type: "string",
+          enum: ["SA", "WA", "NSW", "VIC", "TAS", "ACT", "QLD", "NT"],
+        },
+        country: {
+          type: "string",
+          enum: [],
+        },
+        propertyDescription: {
+          type: "string",
+        },
+      },
+    },
+  },
+};
+
+test("#10 validation of predicates", () => {
+  let conditions = rules.map(({ conditions }) => conditions);
+  expect(listInvalidPredicates(conditions, schema)).toEqual([]);
+  expect(validatePredicates(conditions, schema)).toBeUndefined();
+  expect(validateConditionFields(conditions, schema)).toBeUndefined();
+});

test/utils.test.js

@@ -61,26 +61,32 @@ test("extract referenced schema", () => {
       externalConfig: {
         $ref: "http://example.com/oneschema.json",
       },
+      registration: {
+        type: "object",
+        properties: {
+          firstName: { type: "string" },
+          lastName: { type: "string" },
+        },
+      },
     },
   };
 
+  let { definitions: { medication }, properties: { registration } } = schema;
+
   expect(isRefArray("medications", schema)).toBeTruthy();
-  expect(extractRefSchema("medications", schema)).toEqual(
-    schema.definitions.medication
-  );
-  expect(extractRefSchema("primaryMedication", schema)).toEqual(
-    schema.definitions.medication
-  );
+  expect(extractRefSchema("medications", schema)).toEqual(medication);
+  expect(extractRefSchema("primaryMedication", schema)).toEqual(medication);
+  expect(extractRefSchema("registration", schema)).toEqual(registration);
 
   expect(() => extractRefSchema("externalConfig", schema)).toThrow();
-  expect(testInProd(() => extractRefSchema("externalConfig", schema))).toEqual(
-    undefined
-  );
+  expect(
+    testInProd(() => extractRefSchema("externalConfig", schema))
+  ).toBeUndefined();
 
   expect(() => extractRefSchema("lastName", schema)).toThrow();
-  expect(testInProd(() => extractRefSchema("lastName", schema))).toEqual(
-    undefined
-  );
+  expect(
+    testInProd(() => extractRefSchema("lastName", schema))
+  ).toBeUndefined();
 });
 
 test("array transformation", () => {

test/validation.nestedFields.test.js

@@ -41,6 +41,13 @@ let schema = {
     primaryMedication: {
       $ref: "#/definitions/medications",
     },
+    registration: {
+      type: "object",
+      properties: {
+        firstName: { type: "string" },
+        lastName: { type: "string" },
+      },
+    },
   },
 };