@svadmin/lite 0.3.27 → 0.6.0

package/dist/schema-generator.js

@@ -1,19 +1,19 @@
 /**
  * @svadmin/lite — Schema Generator
  *
- * Auto-generates Zod schemas from @svadmin/core FieldDefinitions.
- * Used by the Lite server actions and compatible with other Zod consumers.
+ * Auto-generates TypeBox schemas from @svadmin/core FieldDefinitions.
+ * Used by Lite server actions and high-speed JIT form validation.
  */
-import { z } from 'zod';
-import { parseExplicitBoolean } from './value-normalization';
+import { Type } from "@sinclair/typebox";
+import { parseExplicitBoolean } from "./value-normalization";
 function isNativeFile(value) {
-    return typeof File !== 'undefined' && value instanceof File;
+    return typeof File !== "undefined" && value instanceof File;
 }
 function isNonEmptyNativeFile(value) {
-    return isNativeFile(value) && value.size > 0 && value.name !== '';
+    return isNativeFile(value) && value.size > 0 && value.name !== "";
 }
 function normalizeSingleUpload(submittedUpload) {
-    if (submittedUpload === undefined || submittedUpload === null || submittedUpload === '')
+    if (submittedUpload === undefined || submittedUpload === null || submittedUpload === "")
         return undefined;
     if (isNativeFile(submittedUpload) && !isNonEmptyNativeFile(submittedUpload))
         return undefined;
@@ -22,7 +22,7 @@ function normalizeSingleUpload(submittedUpload) {
 function hasRequiredValue(value) {
     if (value === undefined || value === null)
         return false;
-    if (typeof value === 'string')
+    if (typeof value === "string")
         return value.trim().length > 0;
     if (Array.isArray(value))
         return value.length > 0;
@@ -30,246 +30,428 @@ function hasRequiredValue(value) {
         return isNonEmptyNativeFile(value);
     return true;
 }
-function applyCustomValidation(schema, field) {
-    if (!field.validate)
-        return schema;
-    return schema.superRefine((parsedFieldValue, context) => {
-        if (parsedFieldValue === undefined || parsedFieldValue === null || parsedFieldValue === '')
-            return;
-        const message = field.validate?.(parsedFieldValue);
-        if (message)
-            context.addIssue({ code: 'custom', message });
-    });
-}
-function numberFieldToZod(field) {
-    const numberSchema = z.coerce.number({ message: `${field.label} must be a number` });
-    const targetSchema = field.required ? numberSchema : numberSchema.optional();
-    return z.preprocess((value) => {
-        if (value === undefined || value === null)
-            return undefined;
-        if (typeof value === 'string' && value.trim() === '')
-            return undefined;
-        return value;
-    }, targetSchema);
-}
-function booleanFieldToZod(field) {
-    const booleanSchema = z.boolean();
-    const targetSchema = field.required ? booleanSchema : booleanSchema.optional();
-    return z.preprocess((rawBoolean) => {
-        if (rawBoolean === undefined || rawBoolean === null || rawBoolean === '')
-            return undefined;
-        return parseExplicitBoolean(rawBoolean) ?? rawBoolean;
-    }, targetSchema);
-}
 function restoreOptionValue(field, submittedOption) {
     const option = field.options?.find((candidate) => String(candidate.value) === String(submittedOption));
     return option?.value ?? submittedOption;
 }
-function optionValueSchema(field) {
-    const options = field.options ?? [];
-    return z.union([z.string(), z.number()]).refine((parsedOption) => options.length === 0
-        || options.some((option) => Object.is(option.value, parsedOption)), { message: `${field.label} must be one of the options` });
-}
-function singleOptionFieldToZod(field) {
-    return z.preprocess((submittedOption) => restoreOptionValue(field, submittedOption), optionValueSchema(field));
-}
-function multipleOptionFieldToZod(field) {
-    return z.preprocess((submittedOptions) => Array.isArray(submittedOptions)
-        ? submittedOptions.map((submittedOption) => restoreOptionValue(field, submittedOption))
-        : submittedOptions, z.array(optionValueSchema(field)).default([]));
-}
-function singleFileFieldToZod(field, options) {
-    const fileSchema = z.custom(isNonEmptyNativeFile, {
-        message: `${field.label} must be a non-empty file`,
-    });
-    const referenceSchema = z.string().trim().min(1, `${field.label} must reference an existing file`);
-    const uploadSchema = options.allowReference ? z.union([fileSchema, referenceSchema]) : fileSchema;
-    const targetSchema = options.required ? uploadSchema : uploadSchema.optional();
-    return z.preprocess(normalizeSingleUpload, targetSchema);
-}
-function imageFieldSchemas(field) {
-    const imageSchema = z.union([
-        z.string().trim().min(1, `${field.label} must reference an image`),
-        z.custom(isNonEmptyNativeFile, {
-            message: `${field.label} must reference an image or contain a non-empty file`,
-        }),
-    ]);
-    return {
-        required: z.preprocess(normalizeSingleUpload, imageSchema),
-        optional: z.preprocess(normalizeSingleUpload, imageSchema.optional()),
-    };
-}
 function normalizeImageEntries(submittedImages) {
-    if (submittedImages === undefined || submittedImages === null || submittedImages === '')
+    if (submittedImages === undefined || submittedImages === null || submittedImages === "")
         return undefined;
     const entries = Array.isArray(submittedImages) ? submittedImages : [submittedImages];
     const normalized = entries.flatMap((entry) => {
-        if (typeof entry !== 'string')
+        if (typeof entry !== "string")
             return [entry];
         return entry.split(/[\r\n]+/u).map((reference) => reference.trim()).filter(Boolean);
     }).filter((entry) => !isNativeFile(entry) || isNonEmptyNativeFile(entry));
     return normalized.length > 0 ? normalized : undefined;
 }
-function imagesFieldSchemas(field) {
-    const imageEntrySchema = z.union([
-        z.string().trim().min(1, `${field.label} contains an empty image reference`),
-        z.custom(isNonEmptyNativeFile, {
-            message: `${field.label} contains an empty or invalid file`,
-        }),
-    ]);
-    const requiredImages = z.array(imageEntrySchema)
-        .min(1, `${field.label} must contain at least one image`);
-    return {
-        required: z.preprocess(normalizeImageEntries, requiredImages),
-        optional: z.preprocess(normalizeImageEntries, z.array(imageEntrySchema).optional()),
-    };
-}
-/**
- * Convert a single FieldDefinition to its corresponding Zod type.
- */
-function fieldToZod(field, mode, withinArray = false) {
-    let schema;
+function coerceAndValidateField(field, value, mode, withinArray = false, path = [field.key]) {
+    const issues = [];
+    let coerced = value;
     switch (field.type) {
-        case 'number':
-            return numberFieldToZod(field);
-        case 'boolean':
-            return booleanFieldToZod(field);
-        case 'email':
-            schema = z.string().email(`${field.label} must be a valid email`);
+        case "number": {
+            if (coerced === undefined || coerced === null || coerced === "") {
+                coerced = undefined;
+                if (field.required) {
+                    issues.push({ path, message: `${field.label} is required` });
+                }
+            }
+            else if (typeof coerced === "string") {
+                const trimmed = coerced.trim();
+                if (trimmed === "") {
+                    coerced = undefined;
+                    if (field.required) {
+                        issues.push({ path, message: `${field.label} is required` });
+                    }
+                }
+                else {
+                    const num = Number(trimmed);
+                    if (Number.isNaN(num)) {
+                        issues.push({ path, message: `${field.label} must be a number` });
+                    }
+                    else {
+                        coerced = num;
+                    }
+                }
+            }
+            else if (typeof coerced === "number") {
+                if (Number.isNaN(coerced)) {
+                    issues.push({ path, message: `${field.label} must be a number` });
+                }
+            }
+            else {
+                issues.push({ path, message: `${field.label} must be a number` });
+            }
             break;
-        case 'url':
-            schema = z.string().url(`${field.label} must be a valid URL`);
+        }
+        case "boolean": {
+            if (coerced === undefined || coerced === null || coerced === "") {
+                coerced = field.required ? false : undefined;
+                if (field.required && coerced === undefined) {
+                    issues.push({ path, message: `${field.label} is required` });
+                }
+            }
+            else if (typeof coerced === "boolean") {
+                // ok
+            }
+            else if (typeof coerced === "string") {
+                const parsed = parseExplicitBoolean(coerced);
+                if (parsed === undefined) {
+                    issues.push({ path, message: `${field.label} must be a boolean` });
+                }
+                else {
+                    coerced = parsed;
+                }
+            }
+            else if (typeof coerced === "number") {
+                if (coerced === 1)
+                    coerced = true;
+                else if (coerced === 0)
+                    coerced = false;
+                else
+                    issues.push({ path, message: `${field.label} must be a boolean` });
+            }
+            else {
+                issues.push({ path, message: `${field.label} must be a boolean` });
+            }
             break;
-        case 'date':
-            schema = z.string().refine((v) => !v || !isNaN(Date.parse(v)), { message: `${field.label} must be a valid date` });
+        }
+        case "email": {
+            if (typeof coerced === "string" && coerced.length > 0) {
+                const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+                if (!emailRegex.test(coerced)) {
+                    issues.push({ path, message: `${field.label} must be a valid email` });
+                }
+            }
             break;
-        case 'select':
-            schema = singleOptionFieldToZod(field);
+        }
+        case "url": {
+            if (typeof coerced === "string" && coerced.length > 0) {
+                try {
+                    new URL(coerced);
+                }
+                catch {
+                    issues.push({ path, message: `${field.label} must be a valid URL` });
+                }
+            }
             break;
-        case 'multiselect':
-            schema = multipleOptionFieldToZod(field);
+        }
+        case "date": {
+            if (typeof coerced === "string" && coerced.length > 0) {
+                if (Number.isNaN(Date.parse(coerced))) {
+                    issues.push({ path, message: `${field.label} must be a valid date` });
+                }
+            }
             break;
-        case 'relation':
-            schema = field.options?.length ? singleOptionFieldToZod(field) : z.string();
+        }
+        case "select": {
+            if (coerced !== undefined && coerced !== null && coerced !== "") {
+                coerced = restoreOptionValue(field, coerced);
+                const options = field.options ?? [];
+                if (options.length > 0 && !options.some((opt) => Object.is(opt.value, coerced))) {
+                    issues.push({ path, message: `${field.label} must be one of the options` });
+                }
+            }
             break;
-        case 'array': {
-            const shape = {};
-            for (const subField of field.subFields ?? []) {
-                shape[subField.key] = applyCustomValidation(fieldToZod(subField, mode, true), subField);
+        }
+        case "multiselect": {
+            if (Array.isArray(coerced)) {
+                coerced = coerced.map((item) => restoreOptionValue(field, item));
+                const options = field.options ?? [];
+                if (options.length > 0) {
+                    for (const item of coerced) {
+                        if (!options.some((opt) => Object.is(opt.value, item))) {
+                            issues.push({ path, message: `${field.label} must be one of the options` });
+                            break;
+                        }
+                    }
+                }
+            }
+            else if (coerced === undefined || coerced === null || coerced === "") {
+                coerced = [];
             }
-            const arraySchema = z.array(z.object(shape));
-            return field.required
-                ? arraySchema.min(1, `${field.label} must contain at least one item`)
-                : arraySchema.optional().or(z.literal(''));
+            break;
         }
-        case 'tags':
-            schema = z.union([
-                z.array(z.string()),
-                z.string().transform((value) => value ? value.split(',').map((tag) => tag.trim()).filter(Boolean) : []),
-            ]);
+        case "relation": {
+            if (field.options?.length && coerced !== undefined && coerced !== null && coerced !== "") {
+                coerced = restoreOptionValue(field, coerced);
+                if (!field.options.some((opt) => Object.is(opt.value, coerced))) {
+                    issues.push({ path, message: `${field.label} must be one of the options` });
+                }
+            }
             break;
-        case 'textarea':
-        case 'richtext':
-        case 'markdown':
-            schema = z.string().max(50000, `${field.label} is too long`);
+        }
+        case "array": {
+            if (Array.isArray(coerced)) {
+                if (field.required && coerced.length === 0) {
+                    issues.push({ path, message: `${field.label} must contain at least one item` });
+                }
+                else {
+                    const processedRows = [];
+                    for (let r = 0; r < coerced.length; r++) {
+                        const row = coerced[r];
+                        if (typeof row !== "object" || row === null) {
+                            issues.push({ path: [...path, r], message: "Row must be an object" });
+                            continue;
+                        }
+                        const rowObj = row;
+                        const processedRow = {};
+                        for (const subField of field.subFields ?? []) {
+                            const subRes = coerceAndValidateField(subField, rowObj[subField.key], mode, true, [...path, r, subField.key]);
+                            issues.push(...subRes.issues);
+                            if (subRes.value !== undefined) {
+                                processedRow[subField.key] = subRes.value;
+                            }
+                        }
+                        processedRows.push(processedRow);
+                    }
+                    coerced = processedRows;
+                }
+            }
+            else if (coerced === undefined || coerced === null || coerced === "") {
+                if (field.required) {
+                    issues.push({ path, message: `${field.label} must contain at least one item` });
+                }
+                else {
+                    coerced = [];
+                }
+            }
+            else {
+                issues.push({ path, message: `${field.label} must be an array` });
+            }
+            break;
+        }
+        case "tags": {
+            if (typeof coerced === "string") {
+                coerced = coerced ? coerced.split(",").map((tag) => tag.trim()).filter(Boolean) : [];
+            }
+            else if (!Array.isArray(coerced)) {
+                coerced = [];
+            }
+            break;
+        }
+        case "textarea":
+        case "richtext":
+        case "markdown": {
+            if (typeof coerced === "string" && coerced.length > 50000) {
+                issues.push({ path, message: `${field.label} is too long` });
+            }
             break;
-        case 'json':
-            schema = z.unknown().transform((value, context) => {
-                if (typeof value !== 'string')
-                    return value;
+        }
+        case "json": {
+            if (typeof coerced === "string") {
                 try {
-                    return JSON.parse(value);
+                    coerced = JSON.parse(coerced);
                 }
                 catch {
-                    context.addIssue({ code: 'custom', message: `${field.label} must be valid JSON` });
-                    return z.NEVER;
+                    issues.push({ path, message: `${field.label} must be valid JSON` });
+                }
+            }
+            break;
+        }
+        case "phone": {
+            if (typeof coerced === "string" && coerced.length > 0) {
+                if (!/^[+\d\s()-]*$/.test(coerced)) {
+                    issues.push({ path, message: `${field.label} must be a valid phone number` });
+                }
+            }
+            break;
+        }
+        case "file": {
+            coerced = normalizeSingleUpload(coerced);
+            const isFile = isNonEmptyNativeFile(coerced);
+            const isStringRef = typeof coerced === "string" && coerced.trim().length > 0;
+            const isRequired = field.required === true && (mode === "create" || withinArray);
+            const allowRef = withinArray && mode === "edit";
+            if (isRequired) {
+                if (!isFile && (!allowRef || !isStringRef)) {
+                    issues.push({ path, message: `${field.label} must be a non-empty file` });
+                }
+            }
+            else if (coerced !== undefined) {
+                if (!isFile && (!allowRef || !isStringRef)) {
+                    issues.push({ path, message: `${field.label} must be a non-empty file` });
                 }
-            });
+            }
             break;
-        case 'phone':
-            schema = z.string().regex(/^[+\d\s()-]*$/, `${field.label} must be a valid phone number`);
+        }
+        case "image": {
+            coerced = normalizeSingleUpload(coerced);
+            const isFile = isNonEmptyNativeFile(coerced);
+            const isStringRef = typeof coerced === "string" && coerced.trim().length > 0;
+            const isRequired = field.required === true;
+            if (isRequired) {
+                if (mode === "create" || withinArray) {
+                    if (!isFile && !isStringRef) {
+                        issues.push({ path, message: `${field.label} must reference an image or contain a non-empty file` });
+                    }
+                }
+                else if (mode === "edit") {
+                    if (coerced !== undefined && !isFile && !isStringRef) {
+                        issues.push({ path, message: `${field.label} must reference an image or contain a non-empty file` });
+                    }
+                }
+            }
             break;
-        case 'file':
-            return singleFileFieldToZod(field, {
-                required: field.required === true && (mode === 'create' || withinArray),
-                allowReference: mode === 'edit' && withinArray,
-            });
-        case 'image': {
-            const imageSchemas = imageFieldSchemas(field);
-            return field.required === true && (mode === 'create' || withinArray)
-                ? imageSchemas.required
-                : imageSchemas.optional;
         }
-        case 'images': {
-            const imagesSchemas = imagesFieldSchemas(field);
-            return field.required === true && (mode === 'create' || withinArray)
-                ? imagesSchemas.required
-                : imagesSchemas.optional;
+        case "images": {
+            coerced = normalizeImageEntries(coerced);
+            const isRequired = field.required === true;
+            const entries = Array.isArray(coerced) ? coerced : (coerced ? [coerced] : []);
+            if (isRequired && (mode === "create" || withinArray)) {
+                if (entries.length === 0) {
+                    issues.push({ path, message: `${field.label} must contain at least one image` });
+                }
+            }
+            break;
         }
         default:
-            schema = z.string();
+            break;
     }
-    // Enforce meaningful values for required fields, including nested array rows.
-    if (field.required) {
-        schema = schema.refine(hasRequiredValue, { message: `${field.label} is required` });
+    // Check required
+    if (field.type !== "number" && field.type !== "boolean" && field.type !== "array" && field.type !== "file" && field.type !== "image" && field.type !== "images") {
+        if (field.required && !hasRequiredValue(coerced)) {
+            issues.push({ path, message: `${field.label} is required` });
+        }
     }
-    else {
-        schema = schema.optional().or(z.literal(''));
+    // Custom validate
+    if (field.validate && issues.length === 0 && coerced !== undefined && coerced !== null && coerced !== "") {
+        const customMessage = field.validate(coerced);
+        if (customMessage) {
+            issues.push({ path, message: customMessage });
+        }
     }
-    return schema;
+    return { value: coerced, issues };
 }
 /**
- * Generate a Zod object schema from a ResourceDefinition's fields.
- * Only includes fields that are relevant for form rendering.
- *
- * @param mode - 'create' | 'edit' to filter fields by showInCreate / showInEdit
+ * Generate a TypeBox object schema from a list of FieldDefinitions.
  */
-export function fieldsToZodSchema(fields, mode = 'create') {
+export function fieldsToTypeBoxSchema(fields, mode = "create") {
     const shape = {};
+    const activeFields = [];
     for (const field of fields) {
-        // Skip fields not shown in forms
         if (field.showInForm === false)
             continue;
-        if (mode === 'create' && field.showInCreate === false)
+        if (mode === "create" && field.showInCreate === false)
             continue;
-        if (mode === 'edit' && field.showInEdit === false)
+        if (mode === "edit" && field.showInEdit === false)
             continue;
-        shape[field.key] = applyCustomValidation(fieldToZod(field, mode), field);
+        activeFields.push(field);
+        switch (field.type) {
+            case "number":
+                shape[field.key] = field.required ? Type.Number() : Type.Optional(Type.Number());
+                break;
+            case "boolean":
+                shape[field.key] = field.required ? Type.Boolean() : Type.Optional(Type.Boolean());
+                break;
+            case "array":
+                shape[field.key] = field.required ? Type.Array(Type.Any(), { minItems: 1 }) : Type.Optional(Type.Array(Type.Any()));
+                break;
+            default:
+                shape[field.key] = field.required ? Type.Any() : Type.Optional(Type.Any());
+                break;
+        }
     }
-    return z.object(shape);
+    const baseSchema = Type.Object(shape, { additionalProperties: true });
+    const safeParse = (values) => {
+        if (typeof values !== "object" || values === null) {
+            return {
+                success: false,
+                error: { issues: [{ path: ["_root"], message: "Values must be an object" }] },
+            };
+        }
+        const input = values;
+        const resultData = {};
+        const allIssues = [];
+        for (const field of activeFields) {
+            const val = input[field.key];
+            const fieldRes = coerceAndValidateField(field, val, mode, false, [field.key]);
+            allIssues.push(...fieldRes.issues);
+            if (fieldRes.value !== undefined) {
+                resultData[field.key] = fieldRes.value;
+            }
+        }
+        if (allIssues.length > 0) {
+            return {
+                success: false,
+                error: { issues: allIssues },
+            };
+        }
+        return {
+            success: true,
+            data: resultData,
+        };
+    };
+    const parse = (values) => {
+        const res = safeParse(values);
+        if (!res.success) {
+            const err = new Error(res.error?.issues[0]?.message || "Validation failed");
+            err.issues = res.error?.issues ?? [];
+            throw err;
+        }
+        return res.data ?? {};
+    };
+    return Object.assign(baseSchema, {
+        parse,
+        safeParse,
+        Check: (val) => safeParse(val).success,
+        "~standard": {
+            version: 1,
+            vendor: "svadmin",
+            validate: (val) => {
+                const res = safeParse(val);
+                if (res.success) {
+                    return { value: res.data ?? {} };
+                }
+                return {
+                    issues: (res.error?.issues ?? []).map((iss) => ({
+                        message: iss.message,
+                        path: iss.path,
+                    })),
+                };
+            },
+        },
+    });
 }
 /**
- * Generate a Zod schema from a ResourceDefinition.
- * Convenience wrapper around fieldsToZodSchema.
+ * Generate a TypeBox schema from a ResourceDefinition.
+ * Convenience wrapper around fieldsToTypeBoxSchema.
  */
-export function resourceToZodSchema(resource, mode = 'create') {
-    const primaryKey = resource.primaryKey ?? 'id';
-    return fieldsToZodSchema(resource.fields.filter((field) => field.key !== primaryKey), mode);
+export function resourceToTypeBoxSchema(resource, mode = "create") {
+    const primaryKey = resource.primaryKey ?? "id";
+    return fieldsToTypeBoxSchema(resource.fields.filter((field) => field.key !== primaryKey), mode);
 }
+/**
+ * Backward compatibility alias for fieldsToTypeBoxSchema
+ */
+export const fieldsToZodSchema = fieldsToTypeBoxSchema;
+/**
+ * Backward compatibility alias for resourceToTypeBoxSchema
+ */
+export const resourceToZodSchema = resourceToTypeBoxSchema;
 /**
  * Determine a conservative HTML input type for server-rendered forms.
- * Text fallbacks avoid inconsistent native validation and date widgets.
  */
 export function fieldToInputType(field) {
     switch (field.type) {
-        case 'number': return 'text';
-        case 'email': return 'text';
-        case 'url': return 'text';
-        case 'phone': return 'tel';
-        case 'boolean': return 'checkbox';
-        case 'date': return 'text';
-        case 'textarea':
-        case 'richtext':
-        case 'markdown':
-        case 'images': return 'textarea';
-        case 'json': return 'textarea';
-        case 'select':
-        case 'multiselect': return 'select';
-        case 'relation': return field.options?.length ? 'select' : 'text';
-        case 'array': return 'text';
-        case 'file': return 'file';
-        case 'password': return 'password';
-        default: return 'text';
+        case "number": return "text";
+        case "email": return "text";
+        case "url": return "text";
+        case "phone": return "tel";
+        case "boolean": return "checkbox";
+        case "date": return "text";
+        case "textarea":
+        case "richtext":
+        case "markdown":
+        case "images": return "textarea";
+        case "json": return "textarea";
+        case "select":
+        case "multiselect": return "select";
+        case "relation": return field.options?.length ? "select" : "text";
+        case "array": return "text";
+        case "file": return "file";
+        case "password": return "password";
+        default: return "text";
     }
 }
 /**
@@ -277,11 +459,11 @@ export function fieldToInputType(field) {
  */
 export function fieldToPlaceholder(field) {
     switch (field.type) {
-        case 'date': return 'YYYY-MM-DD';
-        case 'email': return 'user@example.com';
-        case 'url': return 'https://example.com';
-        case 'phone': return '+1 (555) 000-0000';
-        case 'number': return '0';
-        default: return '';
+        case "date": return "YYYY-MM-DD";
+        case "email": return "user@example.com";
+        case "url": return "https://example.com";
+        case "phone": return "+1 (555) 000-0000";
+        case "number": return "0";
+        default: return "";
     }
 }