feat: add more error handling

Author: brennj

src/jsonLogic.js

@@ -79,6 +79,9 @@ function createValidationsScope(schema) {
     evaluateValidation,
     evaluateValidationRuleInCondition(id, values) {
       const validation = validationMap.get(id);
+      if (validation === undefined)
+        throw Error(`"${id}" validation in if condition doesn't exist.`);
+
       return evaluateValidation(validation.rule, values);
     },
     evaluateComputedValueRuleForField(id, values, fieldName) {
@@ -90,6 +93,9 @@ function createValidationsScope(schema) {
     },
     evaluateComputedValueRuleInCondition(id, values) {
       const validation = computedValuesMap.get(id);
+      if (validation === undefined)
+        throw Error(`"${id}" computedValue in if condition doesn't exist.`);
+
       return evaluateValidation(validation.rule, values);
     },
   };
@@ -117,6 +123,10 @@ export function yupSchemaWithCustomJSONLogic({ field, validations, config, id })
   const { parentID = 'root' } = config;
   const validation = validations.getScope(parentID).validationMap.get(id);
 
+  if (validation === undefined) {
+    throw Error(`Validation "${id}" required for "${field.name}" doesn't exist.`);
+  }
+
   return (yupSchema) =>
     yupSchema.test(
       `${field.name}-validation-${id}`,

src/tests/jsonLogic.test.js

@@ -9,13 +9,18 @@ import {
   schemaWithComputedAttributeThatDoesntExistTitle,
   schemaWithComputedAttributes,
   schemaWithComputedAttributesAndErrorMessages,
+  schemaWithDeepVarThatDoesNotExist,
+  schemaWithDeepVarThatDoesNotExistOnFieldset,
   schemaWithInlinedRuleOnComputedAttributeThatReferencesUnknownVar,
   schemaWithMissingComputedValue,
   schemaWithMissingRule,
   schemaWithMissingValueInlineRule,
   schemaWithNativeAndJSONLogicChecks,
   schemaWithNonRequiredField,
+  schemaWithPropertyThatDoesNotExistInThatLevelButDoesInFieldset,
   schemaWithTwoRules,
+  schemaWithValidationThatDoesNotExistOnProperty,
+  schemaWithVarThatDoesNotExist,
 } from './jsonLogicFixtures';
 
 describe('cross-value validations', () => {
@@ -98,6 +103,50 @@ describe('cross-value validations', () => {
       console.error.mockRestore();
     });
 
+    it('Should throw when a var does not exist in a rule.', () => {
+      createHeadlessForm(schemaWithVarThatDoesNotExist, { strictInputType: false });
+      expect(console.error).toHaveBeenCalledWith(
+        'JSON Schema invalid!',
+        Error('"field_b" in rule "a_greater_than_ten" does not exist as a JSON schema property.')
+      );
+    });
+
+    it('Should throw when a var does not exist in a deeply nested rule', () => {
+      createHeadlessForm(schemaWithDeepVarThatDoesNotExist, { strictInputType: false });
+      expect(console.error).toHaveBeenCalledWith(
+        'JSON Schema invalid!',
+        Error('"field_b" in rule "a_greater_than_ten" does not exist as a JSON schema property.')
+      );
+    });
+
+    it('Should throw when a var does not exist in a fieldset.', () => {
+      createHeadlessForm(schemaWithDeepVarThatDoesNotExistOnFieldset, { strictInputType: false });
+      expect(console.error).toHaveBeenCalledWith(
+        'JSON Schema invalid!',
+        Error('"field_a" in rule "a_greater_than_ten" does not exist as a JSON schema property.')
+      );
+    });
+
+    it('On a property, it should throw an error for a requiredValidation that does not exist', () => {
+      createHeadlessForm(schemaWithValidationThatDoesNotExistOnProperty, {
+        strictInputType: false,
+      });
+      expect(console.error).toHaveBeenCalledWith(
+        'JSON Schema invalid!',
+        Error(`Validation "iDontExist" required for "field_a" doesn't exist.`)
+      );
+    });
+
+    it('A top level logic keyword will not be able to reference fieldset properties', () => {
+      createHeadlessForm(schemaWithPropertyThatDoesNotExistInThatLevelButDoesInFieldset, {
+        strictInputType: false,
+      });
+      expect(console.error).toHaveBeenCalledWith(
+        'JSON Schema invalid!',
+        Error('"child" in rule "validation_parent" does not exist as a JSON schema property.')
+      );
+    });
+
     it('Should throw when theres a missing rule', () => {
       createHeadlessForm(schemaWithMissingRule, { strictInputType: false });
       expect(console.error).toHaveBeenCalledWith(

src/tests/jsonLogicFixtures.js

@@ -108,6 +108,77 @@ export const schemaWithMissingComputedValue = {
   required: [],
 };
 
+export const schemaWithVarThatDoesNotExist = {
+  properties: {
+    field_a: {
+      type: 'number',
+    },
+  },
+  'x-jsf-logic': {
+    validations: {
+      a_greater_than_ten: {
+        errorMessage: 'Must be greater than 10',
+        rule: {
+          '>': [{ var: 'field_b' }, 10],
+        },
+      },
+    },
+  },
+  required: [],
+};
+
+export const schemaWithDeepVarThatDoesNotExist = {
+  properties: {
+    field_a: {
+      type: 'number',
+    },
+  },
+  'x-jsf-logic': {
+    validations: {
+      a_greater_than_ten: {
+        errorMessage: 'Must be greater than 10',
+        rule: {
+          '>': [{ var: 'field_a' }, { '*': [2, { '/': [2, { '*': [1, { var: 'field_b' }] }] }] }],
+        },
+      },
+    },
+  },
+  required: [],
+};
+
+export const schemaWithDeepVarThatDoesNotExistOnFieldset = {
+  properties: {
+    field_a: {
+      type: 'object',
+      properties: {
+        child: {
+          type: 'number',
+        },
+      },
+      'x-jsf-logic': {
+        validations: {
+          a_greater_than_ten: {
+            errorMessage: 'Must be greater than 10',
+            rule: {
+              '>': [{ var: 'child' }, { '*': [2, { '/': [2, { '*': [1, { var: 'field_a' }] }] }] }],
+            },
+          },
+        },
+      },
+    },
+  },
+  required: [],
+};
+
+export const schemaWithValidationThatDoesNotExistOnProperty = {
+  properties: {
+    field_a: {
+      type: 'number',
+      'x-jsf-logic-validations': ['iDontExist'],
+    },
+  },
+};
+
 export const multiRuleSchema = {
   properties: {
     field_a: {
@@ -343,3 +414,42 @@ export const schemaWithComputedAttributesAndErrorMessages = {
     },
   },
 };
+
+export const schemaWithPropertyThatDoesNotExistInThatLevelButDoesInFieldset = {
+  properties: {
+    field_a: {
+      type: 'object',
+      'x-jsf-presentation': {
+        inputType: 'fieldset',
+      },
+      properties: {
+        child: {
+          type: 'number',
+          'x-jsf-logic-validations': ['child_greater_than_10'],
+        },
+        other_child: {
+          type: 'number',
+          'x-jsf-logic-validations': ['greater_than_child'],
+        },
+      },
+      required: ['child', 'other_child'],
+    },
+  },
+  'x-jsf-logic': {
+    validations: {
+      validation_parent: {
+        errorMessage: 'Must be greater than 10!',
+        rule: {
+          '>': [{ var: 'child' }, 10],
+        },
+      },
+      greater_than_child: {
+        errorMessage: 'Must be greater than child',
+        rule: {
+          '>': [{ var: 'other_child' }, { var: 'child' }],
+        },
+      },
+    },
+  },
+  required: ['field_a'],
+};