feat: throw on invalid json-logic schemas (#178)

Author: antoniocapelo

next/src/validation/json-logic.ts

@@ -33,6 +33,7 @@ function replaceUndefinedAndNullValuesWithNaN(values: ObjectValue = {}) {
  * @param {NonBooleanJsfSchema} schema - JSON Schema to validate.
  * @param {JsonLogicContext | undefined} jsonLogicContext - JSON Logic context.
  * @param {ValidationErrorPath} path - Current validation error path.
+ * @throws {Error} If a validation has missing rule.
  */
 export function validateJsonLogicRules(
   schema: NonBooleanJsfSchema,
@@ -46,12 +47,15 @@ export function validateJsonLogicRules(
     return []
   }
 
-  return validations.map((validation: string) => {
-    const validationData = jsonLogicContext?.schema?.validations?.[validation]
+  return validations.map((validationName: string) => {
+    const validationData = jsonLogicContext?.schema?.validations?.[validationName]
     const formValue = jsonLogicContext?.value
 
+    // if the validation name does not reference any valid rule, we throw an error
     if (!validationData) {
-      return []
+      throw new Error(
+        `[json-schema-form] json-logic error: "${schema.title}" required validation "${validationName}" doesn't exist.`,
+      )
     }
 
     const result: any = jsonLogic.apply(validationData.rule, replaceUndefinedAndNullValuesWithNaN(formValue as ObjectValue))
@@ -73,6 +77,7 @@ export function validateJsonLogicRules(
  * @param {ValidationOptions} options - Validation options.
  * @param {JsonLogicContext | undefined} jsonLogicContext - JSON Logic context.
  * @param {ValidationErrorPath} path - Current validation error path.
+ * @throws {Error} If a computed attribute has missing rule.
  */
 export function validateJsonLogicComputedAttributes(
   values: SchemaValue,
@@ -111,14 +116,15 @@ export function validateJsonLogicComputedAttributes(
 
       const formValue = jsonLogicContext?.value
 
-      // if the computation name does not reference any valid rule, we ignore it
+      // if the computation name does not reference any valid rule, we throw an error
       if (!computedAttributeRule) {
-        return
+        throw new Error(`[json-schema-form] json-logic error: Computed value "${validationName}" has missing rule.`)
       }
 
       const result: any = jsonLogic.apply(computedAttributeRule, replaceUndefinedAndNullValuesWithNaN(formValue as ObjectValue))
 
-      if (typeof result === 'undefined') {
+      // If running the apply function returns null, some variables are probably missing
+      if (result === null) {
         return
       }
 
@@ -147,8 +153,9 @@ function interpolate(message: string, jsonLogicContext: JsonLogicContext | undef
     const computedRule = jsonLogicContext.schema.computedValues?.[computationName]?.rule
 
     if (!computedRule) {
-      console.warn(`No computed rule found for ${computationName}`)
-      return `{{${computationName}}}`
+      throw new Error(
+        `[json-schema-form] json-logic error: Computed value "${computationName}" doesn't exist`,
+      )
     }
 
     const result = jsonLogic.apply(

next/test/validation/json-logic.test.ts

@@ -43,6 +43,7 @@ describe('validateJsonLogicRules', () => {
   it('returns empty array when validation data is not found', () => {
     const schema: NonBooleanJsfSchema = {
       'type': 'object',
+      'title': 'foo',
       'properties': {},
       'x-jsf-logic-validations': ['someValidation'],
     }
@@ -54,8 +55,9 @@ describe('validateJsonLogicRules', () => {
       value: {},
     }
 
-    const result = validateJsonLogicRules(schema, jsonLogicContext)
-    expect(result).toEqual([])
+    expect(() => validateJsonLogicRules(schema, jsonLogicContext)).toThrow(
+      `[json-schema-form] json-logic error: "foo" required validation "someValidation" doesn't exist.`,
+    )
   })
 
   it('returns validation error when rule evaluates to false', () => {
@@ -316,8 +318,9 @@ describe('validateJsonLogicRules', () => {
         },
       }
 
-      const errors = validateSchema({ num_guests: 4, amount_of_snacks_to_bring: 3 }, schema)
-      expect(errors).toHaveLength(0)
+      expect(() => validateSchema({ num_guests: 4, amount_of_snacks_to_bring: 3 }, schema)).toThrow(
+        `[json-schema-form] json-logic error: "Number of snacks to bring" required validation "invalid-rule" doesn't exist.`,
+      )
       expect(jsonLogic.apply).not.toHaveBeenCalled()
     })
 
@@ -378,9 +381,10 @@ describe('validateJsonLogicComputedAttributes', () => {
     }
 
     const jsonLogicContext: JsonLogicContext = { schema: { computedValues: {} }, value: { age: 16 } }
-    const result = validateJsonLogicComputedAttributes({ age: 16 }, schema, {}, jsonLogicContext, [])
+    expect(() => validateJsonLogicComputedAttributes({ age: 16 }, schema, {}, jsonLogicContext, [])).toThrow(
+      `[json-schema-form] json-logic error: Computed value "nonexistentRule" has missing rule.`,
+    )
 
-    expect(result).toEqual([])
     expect(jsonLogic.apply).not.toHaveBeenCalled()
   })
 
@@ -570,10 +574,9 @@ describe('validateJsonLogicComputedAttributes', () => {
 
       (jsonLogic.apply as jest.Mock).mockReturnValue(15)
 
-      const result = validateSchema({ someProperty: 10 }, schema)
-      expect(result).toHaveLength(1)
-      expect(result[0].validation).toBe('minimum')
-      expect(result[0].schema['x-jsf-errorMessage']?.minimum).toBe('Must be at least {{invalidVar}} units')
+      expect(() => validateSchema({ someProperty: 10 }, schema)).toThrow(
+        `[json-schema-form] json-logic error: Computed value "invalidVar" doesn't exist`,
+      )
     })
   })
 })