feat(next): DEVXP-2564: implement enum validation (remoteoss#138)

Author: lukad

next/src/validation/enum.ts

@@ -0,0 +1,30 @@
+import type { ValidationError } from '../form'
+import type { NonBooleanJsfSchema, SchemaValue } from '../types'
+import { deepEqual } from './util'
+
+/**
+ * Validate that the value is one of the allowed enum values
+ * @param value - The value to validate
+ * @param schema - The schema to validate against
+ * @param path - The path to the value
+ * @returns An array of validation errors
+ *
+ * @example
+ * ```ts
+ * validateEnum('foo', { enum: ['foo', 'bar'] }) // []
+ * validateEnum('baz', { enum: ['foo', 'bar'] }) // [{ path: [], validation: 'enum', message: 'must be one of ["foo", "bar"]' }]
+ * ```
+ * @see https://json-schema.org/understanding-json-schema/reference/enum
+ * @see https://json-schema.org/draft/2020-12/json-schema-validation#name-enum
+ */
+export function validateEnum(value: SchemaValue, schema: NonBooleanJsfSchema, path: string[] = []): ValidationError[] {
+  if (schema.enum === undefined) {
+    return []
+  }
+
+  if (!schema.enum.some(enumValue => deepEqual(enumValue, value))) {
+    return [{ path, validation: 'enum', message: `must be one of ${JSON.stringify(schema.enum)}` }]
+  }
+
+  return []
+}

next/src/validation/schema.ts

@@ -4,6 +4,7 @@ import type { StringValidationErrorType } from './string'
 import { validateAllOf, validateAnyOf, validateNot, validateOneOf } from './composition'
 import { validateCondition } from './conditions'
 import { validateConst } from './const'
+import { validateEnum } from './enum'
 import { type NumberValidationErrorType, validateNumber } from './number'
 import { validateObject } from './object'
 import { validateString } from './string'
@@ -16,6 +17,7 @@ export type SchemaValidationErrorType =
   | 'required'
   | 'valid'
   | 'const'
+  | 'enum'
 
   /**
    * Schema composition keywords (allOf, anyOf, oneOf, not)
@@ -152,6 +154,9 @@ function validateType(value: SchemaValue, schema: JsfSchema, path: string[] = []
  * 3. Validate against base schema constraints:
  *    - Type validation (if type is specified)
  *    - Required properties (for objects)
+ *    - Boolean validation
+ *    - Enum validation
+ *    - Const validation
  *    - Type-specific validations (string, number, object)
  * 4. Validate against composition keywords in this order:
  *    - not (negates the validation of a subschema)
@@ -202,6 +207,7 @@ export function validateSchema(
 
   return [
     ...validateConst(value, schema, path),
+    ...validateEnum(value, schema, path),
     ...validateObject(value, schema, path),
     ...validateString(value, schema, path),
     ...validateNumber(value, schema, path),

next/src/validation/util.ts

@@ -28,6 +28,10 @@ export function deepEqual(a: SchemaValue, b: SchemaValue): boolean {
     return true
   }
 
+  // If both are null, the check above has returned true.
+  // If one is null, we return false because we know they are not equal
+  // and since `typeof null === 'object'`, we must not let the null value
+  // pass through as an object.
   if (a === null || b === null) {
     return false
   }

next/test/json-schema-test-suite/failed-json-schema-test-suite.json

@@ -35,10 +35,6 @@
     "same $anchor with different base uri": [
       "$ref does not resolve to /$defs/A/allOf/0"
     ],
-    "nul characters in strings": [
-      "do not match string lacking nul",
-      "do not match string lacking nul"
-    ],
     "contains keyword validation": [
       "array without items matching schema is invalid",
       "empty array is invalid"
@@ -143,52 +139,6 @@
     "$dynamicRef skips over intermediate resources - direct reference": [
       "string property fails"
     ],
-    "simple enum validation": [
-      "something else is invalid"
-    ],
-    "heterogeneous enum validation": [
-      "something else is invalid",
-      "objects are deep compared",
-      "extra properties in object is invalid"
-    ],
-    "heterogeneous enum-with-null validation": [
-      "something else is invalid"
-    ],
-    "enums in properties": [
-      "wrong foo value",
-      "wrong bar value"
-    ],
-    "enum with escaped characters": [
-      "another string is invalid"
-    ],
-    "enum with false does not match 0": [
-      "integer zero is invalid",
-      "float zero is invalid"
-    ],
-    "enum with [false] does not match [0]": [
-      "[0] is invalid",
-      "[0.0] is invalid"
-    ],
-    "enum with true does not match 1": [
-      "integer one is invalid",
-      "float one is invalid"
-    ],
-    "enum with [true] does not match [1]": [
-      "[1] is invalid",
-      "[1.0] is invalid"
-    ],
-    "enum with 0 does not match false": [
-      "false is invalid"
-    ],
-    "enum with [0] does not match [false]": [
-      "[false] is invalid"
-    ],
-    "enum with 1 does not match true": [
-      "true is invalid"
-    ],
-    "enum with [1] does not match [true]": [
-      "[true] is invalid"
-    ],
     "email format": [
       "invalid email string is only an annotation by default"
     ],
@@ -416,10 +366,6 @@
     "ref creates new scope when adjacent to keywords": [
       "referenced subschema doesn't see annotations from properties"
     ],
-    "naive replacement of $ref with its destination is not correct": [
-      "do not evaluate the $ref inside the enum, matching any string",
-      "do not evaluate the $ref inside the enum, definition exact match"
-    ],
     "refs with relative uris and defs": [
       "invalid on inner field",
       "invalid on outer field"

next/test/validation/enum.test.ts

@@ -0,0 +1,69 @@
+import { describe, expect, it } from '@jest/globals'
+import { validateSchema } from '../../src/validation/schema'
+
+describe('enum validation', () => {
+  it('returns no errors for values that are in the enum', () => {
+    const schema = { enum: [1, 2, 3] }
+    expect(validateSchema(1, schema)).toEqual([])
+    expect(validateSchema(2, schema)).toEqual([])
+    expect(validateSchema(3, schema)).toEqual([])
+  })
+
+  it('returns an error for values that are not in the enum', () => {
+    const schema = { enum: [1, 2, 3] }
+    expect(validateSchema(4, schema)).toEqual([{
+      path: [],
+      validation: 'enum',
+      message: 'must be one of [1,2,3]',
+    }])
+  })
+
+  it('handles null in enums', () => {
+    const schema = { enum: [1, null, 'test'] }
+    expect(validateSchema(null, schema)).toEqual([])
+    expect(validateSchema(undefined, schema)).toEqual([])
+  })
+
+  it('handles objects in enums', () => {
+    const schema = {
+      enum: [
+        { foo: 'bar' },
+        { baz: 123 },
+        1,
+      ],
+    }
+    expect(validateSchema({ foo: 'bar' }, schema)).toEqual([])
+    expect(validateSchema({ foo: 'baz' }, schema)).toEqual([{
+      path: [],
+      validation: 'enum',
+      message: 'must be one of [{"foo":"bar"},{"baz":123},1]',
+    }])
+    expect(validateSchema(1, schema)).toEqual([])
+  })
+
+  it('handles mixed type enums', () => {
+    const schema = {
+      enum: [
+        1,
+        'test',
+        null,
+        { foo: 'bar' },
+      ],
+    }
+    expect(validateSchema(1, schema)).toEqual([])
+    expect(validateSchema('test', schema)).toEqual([])
+    expect(validateSchema(null, schema)).toEqual([])
+    expect(validateSchema({ foo: 'bar' }, schema)).toEqual([])
+
+    expect(validateSchema('other', schema)).toEqual([{
+      path: [],
+      validation: 'enum',
+      message: 'must be one of [1,"test",null,{"foo":"bar"}]',
+    }])
+    expect(validateSchema({ foo: 'baz' }, schema)).toEqual([{
+      path: [],
+      validation: 'enum',
+      message: 'must be one of [1,"test",null,{"foo":"bar"}]',
+    }])
+  })
+})