feat(next): custom validations with json logic

* chore: first commit (WIP)

* feat: add json-logic validation

* chore: include logic for form and types

* chore: add tests and comments

* chore: remove unnecssary options argument

* chore: fix lint

* chore: revert format on package.json

Author: antoniocapelo

next/package.json

@@ -41,13 +41,17 @@
     "release:dev": "cd .. && npm run release:v1:dev",
     "release:beta": "cd .. && npm run release:v1:beta"
   },
+  "dependencies": {
+    "json-logic-js": "^2.0.5"
+  },
   "devDependencies": {
     "@antfu/eslint-config": "^3.14.0",
     "@babel/core": "^7.23.7",
     "@babel/preset-env": "^7.23.7",
     "@babel/preset-typescript": "^7.26.0",
     "@jest/globals": "^29.7.0",
     "@jest/reporters": "^29.7.0",
+    "@types/json-logic-js": "^2.0.8",
     "@types/lodash": "^4.17.16",
     "@types/validator": "^13.12.2",
     "babel-jest": "^29.7.0",

next/pnpm-lock.yaml

@@ -29,6 +29,10 @@ export type SchemaValidationErrorType =
    * Array validation keywords
    */
   | 'minItems' | 'maxItems' | 'uniqueItems' | 'contains' | 'maxContains' | 'minContains'
+  /**
+   * Custom validation keywords
+   */
+  | 'json-logic'
 
 export type ValidationErrorPath = Array<string | number>
 
@@ -55,4 +59,10 @@ export interface ValidationError {
    * 'required'
    */
   validation: SchemaValidationErrorType
+  /**
+   * The custom error message to display
+   * @example
+   * 'The value is not valid'
+   */
+  customErrorMessage?: string
 }

next/src/errors/index.ts

@@ -7,6 +7,7 @@ export function getErrorMessage(
   schema: NonBooleanJsfSchema,
   value: SchemaValue,
   validation: SchemaValidationErrorType,
+  customErrorMessage?: string,
 ): string {
   switch (validation) {
     // Core validation
@@ -76,6 +77,8 @@ export function getErrorMessage(
       throw new Error('Array support is not implemented yet')
     case 'maxContains':
       throw new Error('Array support is not implemented yet')
+    case 'json-logic':
+      return customErrorMessage || 'The value is not valid'
   }
 }
 

next/src/errors/messages.ts

@@ -186,7 +186,7 @@ function addErrorMessages(rootValue: SchemaValue, rootSchema: JsfSchema, errors:
 
     return {
       ...error,
-      message: getErrorMessage(errorSchema, errorValue, error.validation),
+      message: getErrorMessage(errorSchema, errorValue, error.validation, error.customErrorMessage),
     }
   })
 }

next/src/form.ts

@@ -1,6 +1,6 @@
+import type { RulesLogic } from 'json-logic-js'
 import type { JSONSchema } from 'json-schema-typed/draft-2020-12'
 import type { FieldType } from './field/type'
-
 /**
  * Defines the type of a `Field` in the form.
  */
@@ -29,6 +29,21 @@ export type JsfPresentation = {
   [key: string]: unknown
 }
 
+export interface JsonLogicBag {
+  schema: JsonLogicSchema
+  value: SchemaValue
+}
+
+export interface JsonLogicSchema {
+  validations?: Record<string, {
+    errorMessage?: string
+    rule: RulesLogic
+  }>
+  computedValues?: Record<string, {
+    rule: RulesLogic
+  }>
+}
+
 /**
  * JSON Schema Form extending JSON Schema with additional JSON Schema Form properties.
  */
@@ -42,17 +57,21 @@ export type JsfSchema = JSONSchema & {
   'if'?: JsfSchema
   'then'?: JsfSchema
   'else'?: JsfSchema
-  'x-jsf-logic'?: {
-    validations: Record<string, object>
-    computedValues: Record<string, object>
-  }
   // Note: if we don't have this property here, when inspecting any recursive
   // schema (like an if inside another schema), the required property won't be
   // present in the type
   'required'?: string[]
+  // Defines the order of the fields in the form.
   'x-jsf-order'?: string[]
+  // Defines the presentation of the field in the form.
   'x-jsf-presentation'?: JsfPresentation
+  // Defines the error message of the field in the form.
   'x-jsf-errorMessage'?: Record<string, string>
+  'x-jsf-logic'?: JsonLogicSchema
+  // Extra validations to run. References validations in the `x-jsf-logic` root property.
+  'x-jsf-logic-validations'?: string[]
+  // Extra attributes to add to the schema. References computedValues in the `x-jsf-logic` root property.
+  'x-jsf-logic-computedAttrs'?: Record<keyof JsfSchema, string>
 }
 
 /**

next/src/types.ts

@@ -1,5 +1,5 @@
 import type { ValidationError, ValidationErrorPath } from '../errors'
-import type { JsfSchema, NonBooleanJsfSchema, SchemaValue } from '../types'
+import type { JsfSchema, JsonLogicBag, NonBooleanJsfSchema, SchemaValue } from '../types'
 import { validateSchema, type ValidationOptions } from './schema'
 import { deepEqual } from './util'
 
@@ -8,6 +8,7 @@ import { deepEqual } from './util'
  * @param value - The value to validate
  * @param schema - The schema to validate against
  * @param options - The validation options
+ * @param jsonLogicBag - The JSON logic bag
  * @param path - The path to the current field being validated
  * @returns An array of validation errors
  * @description
@@ -18,6 +19,7 @@ export function validateArray(
   value: SchemaValue,
   schema: JsfSchema,
   options: ValidationOptions,
+  jsonLogicBag: JsonLogicBag | undefined,
   path: ValidationErrorPath,
 ): ValidationError[] {
   if (!Array.isArray(value)) {
@@ -27,9 +29,9 @@ export function validateArray(
   return [
     ...validateLength(schema, value, path),
     ...validateUniqueItems(schema, value, path),
-    ...validateContains(value, schema, options, path),
-    ...validatePrefixItems(schema, value, options, path),
-    ...validateItems(schema, value, options, path),
+    ...validateContains(value, schema, options, jsonLogicBag, path),
+    ...validatePrefixItems(schema, value, options, jsonLogicBag, path),
+    ...validateItems(schema, value, options, jsonLogicBag, path),
   ]
 }
 
@@ -44,7 +46,11 @@ export function validateArray(
  * If the `maxItems` keyword is defined, the array must contain at most `maxItems` items.
  * If the `minItems` keyword is defined, the array must contain at least `minItems` items.
  */
-function validateLength(schema: NonBooleanJsfSchema, value: SchemaValue[], path: ValidationErrorPath): ValidationError[] {
+function validateLength(
+  schema: NonBooleanJsfSchema,
+  value: SchemaValue[],
+  path: ValidationErrorPath,
+): ValidationError[] {
   const errors: ValidationError[] = []
 
   const itemsLength = value.length
@@ -65,14 +71,21 @@ function validateLength(schema: NonBooleanJsfSchema, value: SchemaValue[], path:
  * @param schema - The schema to validate against
  * @param values - The array value to validate
  * @param options - The validation options
+ * @param jsonLogicBag - The JSON logic bag
  * @param path - The path to the current field being validated
  * @returns An array of validation errors
  * @description
  * Validates the items constraint of an array.
  * If the `items` keyword is defined, each item in the array must match the schema of the `items` keyword.
  * When the `prefixItems` keyword is defined, the items constraint is validated only for the items after the prefix items.
  */
-function validateItems(schema: NonBooleanJsfSchema, values: SchemaValue[], options: ValidationOptions, path: ValidationErrorPath): ValidationError[] {
+function validateItems(
+  schema: NonBooleanJsfSchema,
+  values: SchemaValue[],
+  options: ValidationOptions,
+  jsonLogicBag: JsonLogicBag | undefined,
+  path: ValidationErrorPath,
+): ValidationError[] {
   if (schema.items === undefined) {
     return []
   }
@@ -81,7 +94,15 @@ function validateItems(schema: NonBooleanJsfSchema, values: SchemaValue[], optio
   const startIndex = Array.isArray(schema.prefixItems) ? schema.prefixItems.length : 0
 
   for (const [i, item] of values.slice(startIndex).entries()) {
-    errors.push(...validateSchema(item, schema.items, options, [...path, 'items', i + startIndex]))
+    errors.push(
+      ...validateSchema(
+        item,
+        schema.items,
+        options,
+        [...path, 'items', i + startIndex],
+        jsonLogicBag,
+      ),
+    )
   }
 
   return errors
@@ -92,21 +113,36 @@ function validateItems(schema: NonBooleanJsfSchema, values: SchemaValue[], optio
  * @param schema - The schema to validate against
  * @param values - The array value to validate
  * @param options - The validation options
+ * @param jsonLogicBag - The JSON logic bag
  * @param path - The path to the current field being validated
  * @returns An array of validation errors
  * @description
  * Validates the prefixItems constraint of an array.
  * If the `prefixItems` keyword is defined, each item in the array must match the schema of the corresponding prefix item.
  */
-function validatePrefixItems(schema: NonBooleanJsfSchema, values: SchemaValue[], options: ValidationOptions, path: ValidationErrorPath): ValidationError[] {
+function validatePrefixItems(
+  schema: NonBooleanJsfSchema,
+  values: SchemaValue[],
+  options: ValidationOptions,
+  jsonLogicBag: JsonLogicBag | undefined,
+  path: ValidationErrorPath,
+): ValidationError[] {
   if (!Array.isArray(schema.prefixItems)) {
     return []
   }
 
   const errors: ValidationError[] = []
   for (const [i, item] of values.entries()) {
     if (i < schema.prefixItems.length) {
-      errors.push(...validateSchema(item, schema.prefixItems[i] as JsfSchema, options, [...path, 'prefixItems', i]))
+      errors.push(
+        ...validateSchema(
+          item,
+          schema.prefixItems[i] as JsfSchema,
+          options,
+          [...path, 'prefixItems', i],
+          jsonLogicBag,
+        ),
+      )
     }
   }
 
@@ -118,6 +154,7 @@ function validatePrefixItems(schema: NonBooleanJsfSchema, values: SchemaValue[],
  * @param value - The array value to validate
  * @param schema - The schema to validate against
  * @param options - The validation options
+ * @param jsonLogicBag - The JSON logic bag
  * @param path - The path to the current field being validated
  * @returns An array of validation errors
  * @description
@@ -128,6 +165,7 @@ function validateContains(
   value: SchemaValue[],
   schema: NonBooleanJsfSchema,
   options: ValidationOptions,
+  jsonLogicBag: JsonLogicBag | undefined,
   path: ValidationErrorPath,
 ): ValidationError[] {
   if (!('contains' in schema)) {
@@ -137,8 +175,15 @@ function validateContains(
   const errors: ValidationError[] = []
 
   // How many items in the array are valid against the contains schema?
-  const contains = value.filter(item =>
-    validateSchema(item, schema.contains as JsfSchema, options, [...path, 'contains']).length === 0,
+  const contains = value.filter(
+    item =>
+      validateSchema(
+        item,
+        schema.contains as JsfSchema,
+        options,
+        [...path, 'contains'],
+        jsonLogicBag,
+      ).length === 0,
   ).length
 
   if (schema.minContains === undefined && schema.maxContains === undefined) {
@@ -168,7 +213,11 @@ function validateContains(
  * @description
  * Validates the uniqueItems constraint of an array when the `uniqueItems` keyword is defined as `true`.
  */
-function validateUniqueItems(schema: NonBooleanJsfSchema, values: SchemaValue[], path: ValidationErrorPath): ValidationError[] {
+function validateUniqueItems(
+  schema: NonBooleanJsfSchema,
+  values: SchemaValue[],
+  path: ValidationErrorPath,
+): ValidationError[] {
   if (schema.uniqueItems !== true) {
     return []
   }