@setzkasten-cms/core 0.4.2

package/src/validation/schema-to-zod.ts

@@ -0,0 +1,126 @@
+import { z } from 'zod'
+import type {
+  AnyFieldDef,
+  ArrayFieldDef,
+  FieldDefinition,
+  FieldRecord,
+  ObjectFieldDef,
+  OverrideFieldDef,
+} from '../fields/field-definition'
+
+/**
+ * Generates a Zod schema from a FieldDefinition.
+ * This is the single source of truth for validation – Zod schemas are derived
+ * from field definitions, never written by hand.
+ */
+export function fieldToZod(field: FieldDefinition): z.ZodType {
+  switch (field.type) {
+    case 'text':
+      return textToZod(field as AnyFieldDef & { type: 'text' })
+    case 'number':
+      return numberToZod(field as AnyFieldDef & { type: 'number' })
+    case 'boolean':
+      return z.boolean()
+    case 'select':
+      return selectToZod(field as AnyFieldDef & { type: 'select' })
+    case 'icon':
+      return field.required ? z.string().min(1, `${field.label} ist erforderlich`) : z.string()
+    case 'image':
+      return imageToZod(field as AnyFieldDef & { type: 'image' })
+    case 'array':
+      return arrayToZod(field as ArrayFieldDef)
+    case 'object':
+      return objectToZod(field as ObjectFieldDef)
+    case 'color':
+      return z.string().regex(/^#[0-9a-fA-F]{6}$/, 'Invalid hex color')
+    case 'override':
+      return overrideToZod(field as OverrideFieldDef)
+    default:
+      return z.unknown()
+  }
+}
+
+function textToZod(field: AnyFieldDef & { type: 'text' }): z.ZodType {
+  let schema = z.string()
+
+  if (field.required) {
+    schema = schema.min(1, `${field.label} ist erforderlich`)
+  }
+  if (field.maxLength) {
+    schema = schema.max(field.maxLength, `${field.label} darf max. ${field.maxLength} Zeichen haben`)
+  }
+  if (field.pattern) {
+    schema = schema.regex(field.pattern, `${field.label} hat ein ungültiges Format`)
+  }
+
+  return schema
+}
+
+function numberToZod(field: AnyFieldDef & { type: 'number' }): z.ZodType {
+  let schema = z.number()
+
+  if (field.min !== undefined) {
+    schema = schema.min(field.min)
+  }
+  if (field.max !== undefined) {
+    schema = schema.max(field.max)
+  }
+
+  return schema
+}
+
+function selectToZod(field: AnyFieldDef & { type: 'select' }): z.ZodType {
+  const values = field.options.map((o) => o.value)
+  if (values.length === 0) return z.string()
+
+  const [first, ...rest] = values
+  return z.enum([first!, ...rest])
+}
+
+function imageToZod(field: AnyFieldDef & { type: 'image' }): z.ZodType {
+  const schema = z.object({
+    path: z.string(),
+    alt: z.string().optional(),
+  })
+
+  return field.required ? schema.refine((v) => v.path.length > 0, `${field.label} ist erforderlich`) : schema
+}
+
+function arrayToZod(field: ArrayFieldDef): z.ZodType {
+  const itemSchema = fieldToZod(field.itemField)
+  let schema = z.array(itemSchema)
+
+  if (field.minItems !== undefined) {
+    schema = schema.min(field.minItems)
+  }
+  if (field.maxItems !== undefined) {
+    schema = schema.max(field.maxItems)
+  }
+
+  return schema
+}
+
+function objectToZod(field: ObjectFieldDef): z.ZodType {
+  return schemaToZod(field.fields)
+}
+
+function overrideToZod(field: OverrideFieldDef): z.ZodType {
+  const innerSchema = schemaToZod(field.fields)
+  return z.object({
+    active: z.boolean(),
+  }).and(innerSchema.partial())
+}
+
+/**
+ * Convert an entire field record (schema) to a Zod object schema.
+ */
+export function schemaToZod(fields: FieldRecord): z.ZodObject<Record<string, z.ZodType>> {
+  const shape: Record<string, z.ZodType> = {}
+
+  for (const [key, field] of Object.entries(fields)) {
+    const zodField = fieldToZod(field)
+    shape[key] = field.required ? zodField : zodField.optional()
+  }
+
+  return z.object(shape)
+}