Fix handleValidation for undefined fieldsets

Author: dragidavid

next/src/field/object.ts

@@ -31,6 +31,7 @@ export function buildFieldObject(schema: JsfObjectSchema, name: string, required
     name: schema.title || name,
     required,
     fields: orderedFields,
+    isVisible: true,
   }
 
   if (schema.title !== undefined) {

next/src/field/schema.ts

@@ -2,19 +2,6 @@ import type { JsfObjectSchema, JsfSchema, NonBooleanJsfSchema } from '../types'
 import type { Field } from './type'
 import { buildFieldObject } from './object'
 
-/**
- * Get the input type for a field
- * @param schema - The schema of the field
- * @returns The input type for the field, based schema type. Default to 'text'
- */
-function getInputType(schema: NonBooleanJsfSchema): string {
-  if (schema.type === 'string') {
-    return 'text'
-  }
-
-  return 'text'
-}
-
 /**
  * Get the JSON type for a field
  * @param schema - The non boolean schema of the field
@@ -32,12 +19,82 @@ function getJsonType(schema: NonBooleanJsfSchema): string {
   return 'text'
 }
 
+/**
+ * Convert options to the required format
+ * This is used when we have a oneOf or anyOf schema property
+ */
+function convertToOptions(nodeOptions: JsfSchema[]): Array<{
+  label: string
+  value: unknown
+  [key: string]: unknown
+}> {
+  return nodeOptions
+    .filter((option): option is NonBooleanJsfSchema =>
+      option !== null && typeof option === 'object')
+    .map((schemaOption) => {
+      const title = schemaOption.title
+      const value = schemaOption.const
+      const presentation = schemaOption['x-jsf-presentation']
+      const meta = presentation?.meta
+
+      const result: {
+        label: string
+        value: unknown
+        [key: string]: unknown
+      } = {
+        label: title || '',
+        value,
+      }
+
+      // Add meta if it exists
+      if (meta) {
+        result.meta = meta
+      }
+
+      // Add other properties, without known ones we already handled above
+      const { title: _, const: __, 'x-jsf-presentation': ___, ...rest } = schemaOption
+
+      return { ...result, ...rest }
+    })
+}
+
+/**
+ * Get field options from schema
+ */
+function getFieldOptions(schema: NonBooleanJsfSchema) {
+  // Handle oneOf or radio input type
+  if (schema.oneOf) {
+    return convertToOptions(schema.oneOf || [])
+  }
+
+  // Handle items.anyOf (for multiple select)
+  if (schema.items?.anyOf) {
+    return convertToOptions(schema.items.anyOf)
+  }
+
+  // Handle anyOf
+  if (schema.anyOf) {
+    return convertToOptions(schema.anyOf)
+  }
+
+  return null
+}
+
+/**
+ * List of schema properties that should be excluded from the final field or handled specially
+ */
+const excludedSchemaProps = [
+  'title', // Transformed to 'label'
+  'type', // Handled separately
+  'x-jsf-errorMessage', // Handled separately
+  'x-jsf-presentation', // Handled separately
+  'oneOf', // Transformed to 'options'
+  'anyOf', // Transformed to 'options'
+  'items', // Handled specially for arrays
+]
+
 /**
  * Build a field from any schema
- * @param schema - The schema of the field
- * @param name - The name of the field, used if the schema has no title
- * @param required - Whether the field is required
- * @returns The field
  */
 export function buildFieldSchema(
   schema: JsfSchema,
@@ -53,27 +110,52 @@ export function buildFieldSchema(
     return buildFieldObject(objectSchema, name, required)
   }
 
-  if (Array.isArray(schema.type)) {
+  if (schema.type === 'array') {
     throw new TypeError('Array type is not yet supported')
   }
 
-  const inputType = getInputType(schema)
+  const presentation = schema['x-jsf-presentation'] || {}
+  const errorMessage = schema['x-jsf-errorMessage']
 
-  const { title: _title, ...spreadSchema } = schema
+  // Get input type from presentation or fallback to schema type
+  const inputType = presentation.inputType || 'text'
 
+  // Build field with all schema properties by default, excluding ones that need special handling
   const field: Field = {
-    ...spreadSchema,
-    ...schema['x-jsf-presentation'],
-    inputType,
+    // Spread all schema properties except excluded ones
+    ...Object.entries(schema)
+      .filter(([key]) => !excludedSchemaProps.includes(key))
+      .reduce((acc, [key, value]) => ({ ...acc, [key]: value }), {}),
+
+    // Add required field properties
     type: inputType,
-    jsonType: getJsonType(schema),
     name,
+    inputType,
+    jsonType: getJsonType(schema),
     required,
+    isVisible: true,
+    ...(errorMessage && { errorMessage }),
   }
 
-  if (schema.title !== undefined) {
+  if (schema.title) {
     field.label = schema.title
   }
 
+  // Spread presentation properties to the root level
+  if (Object.keys(presentation).length > 0) {
+    Object.entries(presentation).forEach(([key, value]) => {
+      // inputType is already handled above
+      if (key !== 'inputType') {
+        field[key] = value
+      }
+    })
+  }
+
+  // Handle options
+  const options = getFieldOptions(schema)
+  if (options) {
+    field.options = options
+  }
+
   return field
 }

next/src/field/type.ts

@@ -1,19 +1,28 @@
 /**
  * WIP type for UI field output that allows for all `x-jsf-presentation` properties to be splatted
+ * TODO/QUESTION: what are the required fields for a field? what are the things we want to deprecate, if any?
  */
-export type Field = {
+export interface Field {
   name: string
   label?: string
+  description?: string
   fields?: Field[]
   type: string
   inputType: string
   required: boolean
   jsonType: string
+  isVisible: boolean
   accept?: string
-  description?: string
-  maxFileSize?: number
+  errorMessage?: Record<string, string>
+  computedAttributes?: Record<string, unknown>
   minDate?: string
   maxDate?: string
-} & {
+  maxLength?: number
+  maxFileSize?: number
+  format?: string
+  anyOf?: unknown[]
+  options?: unknown[]
+
+  // Allow additional properties from x-jsf-presentation (e.g. meta from oneOf/anyOf)
   [key: string]: unknown
 }