chore: address PR comments

fix: provide empty fields for hidden fieldsets/group-arrays

chore: update test

feat: add 'value' fallback when const is not present for const validation

fix: delete conditional branches after processing them

chore: add comment

Author: antoniocapeloremote

next/src/field/schema.ts

@@ -349,15 +349,18 @@ export function buildFieldSchema({
 }: BuildFieldSchemaParams): Field | null {
   // If schema is boolean false, return a field with isVisible=false
   if (schema === false) {
-    // If the schema is false, we use the original schema to get the input type
+    // If the schema is false (hidden field), we use the original schema to get the input type
     const inputType = getInputType(type, name, originalSchema, strictInputType)
+    const inputHasInnerFields = ['fieldset', 'group-array'].includes(inputType)
+
     return {
       type: inputType,
       name,
       inputType,
       jsonType: 'boolean',
       required,
       isVisible: false,
+      ...(inputHasInnerFields && { fields: [] }),
     }
   }
 

next/src/mutations.ts

@@ -108,10 +108,14 @@ function applySchemaRules(
     // If the rule matches, process the then branch
     if (matches && rule.then) {
       processBranch(schema, values, rule.then, options, jsonLogicContext)
+      // Delete the then branch to avoid processing it again when validating the schema
+      delete rule.then
     }
     // If the rule doesn't match, process the else branch
     else if (!matches && rule.else) {
       processBranch(schema, values, rule.else, options, jsonLogicContext)
+      // Delete the else branch to avoid processing it again when validating the schema
+      delete rule.else
     }
   }
 

next/src/types.ts

@@ -62,6 +62,8 @@ export type JsfSchema = JSONSchema & {
   'if'?: JsfSchema
   'then'?: JsfSchema
   'else'?: JsfSchema
+  // while value is not part of the spec, we're keeping it for v0 backwards compatibility
+  'value'?: SchemaValue
   // 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

next/src/utils.ts

@@ -52,7 +52,7 @@ export function convertKBToMB(kb: number): number {
   return Number.parseFloat(mb.toFixed(2)) // Keep 2 decimal places
 }
 
-// Keys to skip when merging schema objects
+// When merging schemas, we should skip merging the if/then/else properties as we could be creating wrong conditions
 const KEYS_TO_SKIP = ['if', 'then', 'else']
 
 function isObject(value: any): boolean {

next/src/validation/const.ts

@@ -19,7 +19,7 @@ export function validateConst(
   schema: NonBooleanJsfSchema,
   path: ValidationErrorPath = [],
 ): ValidationError[] {
-  const constValue = schema.const
+  const constValue = typeof schema.const !== 'undefined' ? schema.const : schema.value
 
   if (constValue === undefined) {
     return []

next/test/fields.test.ts

@@ -99,6 +99,7 @@ describe('fields', () => {
         inputType: 'fieldset',
         type: 'fieldset',
         jsonType: 'boolean',
+        fields: [],
         name: 'root',
         required: true,
         isVisible: false,

next/test/validation/const.test.ts

@@ -0,0 +1,76 @@
+import type { NonBooleanJsfSchema } from '../../src/types'
+import { describe, expect, it } from '@jest/globals'
+import { validateConst } from '../../src/validation/const'
+
+describe('const schema validation', () => {
+  it('should return empty array when const value matches', () => {
+    const schema: NonBooleanJsfSchema = { const: 42 }
+    const value = 42
+    expect(validateConst(value, schema)).toEqual([])
+  })
+
+  it('should return error when const value does not match', () => {
+    const schema: NonBooleanJsfSchema = { const: 42 }
+    const value = 43
+    const result = validateConst(value, schema)
+    expect(result).toHaveLength(1)
+    expect(result[0]).toEqual({
+      path: [],
+      validation: 'const',
+      schema,
+      value: 43,
+    })
+  })
+
+  it('should handle nested objects with deep equality', () => {
+    const schema: NonBooleanJsfSchema = {
+      const: { foo: { bar: 42 } },
+    }
+    const value = { foo: { bar: 42 } }
+    expect(validateConst(value, schema)).toEqual([])
+  })
+
+  it('should handle arrays with deep equality', () => {
+    const schema: NonBooleanJsfSchema = {
+      const: [1, 2, { foo: 'bar' }],
+    }
+    const value = [1, 2, { foo: 'bar' }]
+    expect(validateConst(value, schema)).toEqual([])
+  })
+
+  it('should return empty array when const is not present', () => {
+    const schema: NonBooleanJsfSchema = {}
+    const value = 42
+    expect(validateConst(value, schema)).toEqual([])
+  })
+
+  it('should handle schema.value as fallback for const', () => {
+    const schema: NonBooleanJsfSchema = { value: 42 }
+    const input = 42
+    expect(validateConst(input, schema)).toEqual([])
+  })
+
+  it('should handle different types correctly', () => {
+    const testCases = [
+      { schema: { const: 'string' }, value: 'string', shouldPass: true },
+      { schema: { const: true }, value: false, shouldPass: false },
+      { schema: { const: null }, value: null, shouldPass: true },
+      { schema: { const: 0 }, value: '0', shouldPass: false },
+      { schema: { const: [] }, value: [], shouldPass: true },
+      { schema: { const: {} }, value: {}, shouldPass: true },
+    ]
+
+    testCases.forEach(({ schema, value, shouldPass }) => {
+      const result = validateConst(value, schema as NonBooleanJsfSchema)
+      expect(result.length).toBe(shouldPass ? 0 : 1)
+    })
+  })
+
+  it('should handle path parameter correctly', () => {
+    const schema: NonBooleanJsfSchema = { const: 42 }
+    const value = 43
+    const path = ['foo', 'bar']
+    const result = validateConst(value, schema, path)
+    expect(result[0].path).toEqual(path)
+  })
+})