includio-cms 0.5.2 → 0.5.5

package/dist/components/ui/switch/index.js

@@ -0,0 +1,4 @@
+import Root from "./switch.svelte";
+export { Root, 
+//
+Root as Switch, };

package/dist/components/ui/switch/switch.svelte

@@ -0,0 +1,26 @@
+<script lang="ts">
+	import { Switch as SwitchPrimitive } from "bits-ui";
+	import { cn, type WithoutChildrenOrChild } from "../../../utils.js";
+
+	let {
+		ref = $bindable(null),
+		checked = $bindable(false),
+		class: className,
+		...restProps
+	}: WithoutChildrenOrChild<SwitchPrimitive.RootProps> = $props();
+</script>
+
+<SwitchPrimitive.Root
+	bind:ref
+	bind:checked
+	data-slot="switch"
+	class={cn(
+		"peer inline-flex h-[22px] w-[38px] shrink-0 cursor-pointer items-center rounded-full border-2 border-transparent transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 focus-visible:ring-offset-background disabled:cursor-not-allowed disabled:opacity-50 data-[state=checked]:bg-primary data-[state=unchecked]:bg-border",
+		className
+	)}
+	{...restProps}
+>
+	<SwitchPrimitive.Thumb
+		class="pointer-events-none block size-[18px] rounded-full bg-white shadow-sm ring-0 transition-transform data-[state=checked]:translate-x-4 data-[state=unchecked]:translate-x-0"
+	/>
+</SwitchPrimitive.Root>

package/dist/components/ui/switch/switch.svelte.d.ts

@@ -0,0 +1,4 @@
+import { Switch as SwitchPrimitive } from "bits-ui";
+declare const Switch: import("svelte").Component<Omit<Omit<SwitchPrimitive.RootProps, "child">, "children">, {}, "ref" | "checked">;
+type Switch = ReturnType<typeof Switch>;
+export default Switch;

package/dist/core/cms.d.ts

@@ -1,6 +1,6 @@
 import type { DatabaseAdapter } from '../types/adapters/db.js';
 import type { FilesAdapter } from '../types/adapters/files.js';
-import type { CMSConfig, ICMS, MediaConfig } from '../types/cms.js';
+import type { ApiKeyConfig, CMSConfig, ICMS, MediaConfig } from '../types/cms.js';
 import type { CollectionConfigWithType } from '../types/collections.js';
 import type { Language } from '../types/languages.js';
 import type { SingleConfigWithType } from '../types/singles.js';
@@ -22,6 +22,7 @@ export declare class CMS implements ICMS {
     languages: Language[];
     mediaConfig: MediaConfig;
     plugins: PluginConfig[];
+    apiKeys: ApiKeyConfig[];
     constructor(config: CMSConfig);
     getBySlug(slug: string): CollectionConfigWithType | SingleConfigWithType;
     getFormBySlug(slug: string): FormConfig;

package/dist/core/cms.js

@@ -11,6 +11,7 @@ export class CMS {
     languages;
     mediaConfig;
     plugins = [];
+    apiKeys = [];
     constructor(config) {
         this.config = config;
         this.databaseAdapter = config.db;
@@ -40,6 +41,7 @@ export class CMS {
             };
         });
         this.languages = config.languages || [];
+        this.apiKeys = config.apiKeys || [];
         if (config.plugins) {
             this.plugins = config.plugins;
         }

package/dist/core/fields/fieldSchemaToTs.js

@@ -139,7 +139,8 @@ export function generateZodSchemaFromField(field, languages, options = {
         }
         case 'object': {
             const data = generateZodSchemaFromFields(field.fields, languages, {
-                parentRequired: field.required
+                parentRequired: field.required,
+                localized: options.localized
             });
             const finalData = !field.required ? data.partial().optional() : data;
             return z.object({
@@ -148,7 +149,10 @@ export function generateZodSchemaFromField(field, languages, options = {
             });
         }
         case 'blocks': {
-            const schemas = field.of.map((f) => generateZodSchemaFromField(f, languages, { parentRequired: field.required }));
+            const schemas = field.of.map((f) => generateZodSchemaFromField(f, languages, {
+                parentRequired: field.required,
+                localized: options.localized
+            }));
             const itemSchema = schemas.length > 1
                 ? z.discriminatedUnion('slug', schemas)
                 : schemas[0];
@@ -283,6 +287,14 @@ export function generateZodSchemaFromField(field, languages, options = {
 }
 export function generateZodSchemaFromFields(fields, languages, options = {}) {
     return z.object({
-        ...Object.fromEntries(fields.map((f) => [f.slug, generateZodSchemaFromField(f, languages, options)]))
+        ...Object.fromEntries(fields.map((f) => {
+            let schema = generateZodSchemaFromField(f, languages, options);
+            // Fields with showWhen are conditionally visible — make them optional
+            // so hidden fields don't block validation
+            if (f.showWhen) {
+                schema = schema.optional();
+            }
+            return [f.slug, schema];
+        }))
     });
 }

package/dist/core/fields/formFieldSchemaToTs.js

@@ -1,27 +1,43 @@
 import { z } from 'zod';
 export function generateZodSchemaFromFormField(field) {
+    const errorMsg = field.errorMessage ? Object.values(field.errorMessage)[0] : undefined;
     switch (field.type) {
         case 'text': {
             let schema = z.string();
-            if (field.required)
-                schema = schema.min(1);
+            const minLen = field.minLength ?? (field.required ? 1 : undefined);
+            if (minLen) {
+                schema = schema.min(minLen, errorMsg || undefined);
+            }
+            if (field.maxLength) {
+                schema = schema.max(field.maxLength);
+            }
             return schema;
         }
         case 'email': {
             let schema = z.string();
-            if (field.required)
-                schema = schema.min(1).email();
+            if (field.required) {
+                schema = schema.min(1).email(errorMsg || undefined);
+            }
             return schema;
         }
         case 'textarea': {
             let schema = z.string();
-            if (field.required)
-                schema = schema.min(1);
+            const minLen = field.minLength ?? (field.required ? 1 : undefined);
+            if (minLen) {
+                schema = schema.min(minLen, errorMsg || undefined);
+            }
+            if (field.maxLength) {
+                schema = schema.max(field.maxLength);
+            }
             return schema;
         }
         case 'checkbox': {
             return field.required ? z.literal(true) : z.boolean();
         }
+        case 'select': {
+            const values = field.options.map((o) => o.value);
+            return z.enum(values);
+        }
         default:
             return z.any();
     }

package/dist/core/fields/urlUtils.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Check if URL is external (starts with http:// or https://).
+ */
+export declare function isExternalUrl(url: string): boolean;
+/**
+ * Build rel attribute string from individual tokens.
+ * Deduplicates and returns space-separated string or empty string.
+ */
+export declare function buildRel(tokens: string[]): string;
+/**
+ * Merge user-provided rel tokens with auto-generated ones.
+ * Returns space-separated string.
+ */
+export declare function mergeRel(userRel: string | undefined, autoTokens: string[]): string;

package/dist/core/fields/urlUtils.js

@@ -0,0 +1,21 @@
+/**
+ * Check if URL is external (starts with http:// or https://).
+ */
+export function isExternalUrl(url) {
+    return /^https?:\/\//i.test(url);
+}
+/**
+ * Build rel attribute string from individual tokens.
+ * Deduplicates and returns space-separated string or empty string.
+ */
+export function buildRel(tokens) {
+    return [...new Set(tokens.filter(Boolean))].join(' ');
+}
+/**
+ * Merge user-provided rel tokens with auto-generated ones.
+ * Returns space-separated string.
+ */
+export function mergeRel(userRel, autoTokens) {
+    const userTokens = userRel ? userRel.split(/\s+/).filter(Boolean) : [];
+    return buildRel([...autoTokens, ...userTokens]);
+}

package/dist/core/server/entries/operations/get.js

@@ -161,7 +161,8 @@ export const getEntries = async (options = {}) => {
     // Get entries that match the slug/ids filter
     const dbEntries = await getCMS().databaseAdapter.getEntries({
         ids,
-        slug
+        slug,
+        orderBy: options.orderBy
     });
     if (dbEntries.length === 0) {
         return [];

package/dist/core/server/entries/operations/update.d.ts

@@ -6,6 +6,7 @@ export declare const updateEntrySchema: z.ZodObject<{
     publishedAt: z.ZodOptional<z.ZodNullable<z.ZodDate>>;
     publishedVersionId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     publishedBy: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    sortOrder: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
 }, z.z.core.$strip>;
 export declare const updateEntry: (id: string, data: Partial<DbEntry>) => Promise<DbEntry>;
 export declare const updateEntryVersionSchema: z.ZodObject<{

package/dist/core/server/entries/operations/update.js

@@ -9,7 +9,8 @@ export const updateEntrySchema = z.object({
     archivedAt: z.date().nullable().optional(),
     publishedAt: z.date().nullable().optional(),
     publishedVersionId: z.string().uuid().nullable().optional(),
-    publishedBy: z.string().nullable().optional()
+    publishedBy: z.string().nullable().optional(),
+    sortOrder: z.number().int().nullable().optional()
 });
 export const updateEntry = async (id, data) => {
     const filteredDataParse = updateEntrySchema.safeParse(data);
@@ -33,6 +34,9 @@ export const updateEntry = async (id, data) => {
     if (filteredData.publishedBy !== undefined) {
         dataToUpdate.publishedBy = filteredData.publishedBy;
     }
+    if (filteredData.sortOrder !== undefined) {
+        dataToUpdate.sortOrder = filteredData.sortOrder;
+    }
     const updatedEntry = await getCMS().databaseAdapter.updateEntry({
         id,
         data: {

package/dist/core/server/fields/populateEntry.js

@@ -1,13 +1,56 @@
+import { walkInlineBlockNodes } from '../../../admin/components/tiptap/structured-content-utils.js';
 import { translateObject } from '../entries/utils/getEntryTranslation.js';
 import { resolveMediaFields } from './resolveImageFields.js';
 import { resolveRelationFields } from './resolveRelationFields.js';
 import { resolveRichtextLinks } from './resolveRichtextLinks.js';
 import { resolveUrlFields } from './resolveUrlFields.js';
+function translateInlineBlockData(data, fields, language) {
+    for (const field of fields) {
+        const val = data[field.slug];
+        if (val == null)
+            continue;
+        switch (field.type) {
+            case 'content': {
+                const cf = field;
+                if (cf.inlineBlocks?.length &&
+                    val &&
+                    typeof val === 'object' &&
+                    'type' in val &&
+                    val.type === 'doc') {
+                    walkInlineBlockNodes(val, (node) => {
+                        if (node.attrs?.blockData && typeof node.attrs.blockData === 'object') {
+                            node.attrs.blockData = translateObject(node.attrs.blockData, language);
+                            const def = cf.inlineBlocks.find((b) => b.slug === node.attrs?.blockType);
+                            if (def) {
+                                translateInlineBlockData(node.attrs.blockData, def.fields, language);
+                            }
+                        }
+                    });
+                }
+                break;
+            }
+            case 'object':
+                if (val && typeof val === 'object' && 'data' in val)
+                    translateInlineBlockData(val.data, field.fields, language);
+                break;
+            case 'blocks':
+                if (Array.isArray(val)) {
+                    for (const item of val) {
+                        const def = field.of.find((d) => d.slug === item.slug);
+                        if (def)
+                            translateInlineBlockData(item.data, def.fields, language);
+                    }
+                }
+                break;
+        }
+    }
+}
 export async function populateEntryData(data, fields, language) {
     let populatedData = await resolveRelationFields(data, fields, language);
     populatedData = await resolveUrlFields(populatedData, fields, language);
     populatedData = await resolveMediaFields(populatedData, fields);
     populatedData = await resolveRichtextLinks(populatedData, fields, language);
     populatedData = translateObject(populatedData, language);
+    translateInlineBlockData(populatedData, fields, language);
     return populatedData;
 }

package/dist/core/server/fields/resolveImageFields.js

@@ -3,7 +3,7 @@ const PUBLIC_URL = env.PUBLIC_URL ?? '';
 import { getCMS } from '../../cms.js';
 import z from 'zod';
 import { getImageStyles } from './utils/imageStyles.js';
-import { extractMediaIds as extractMediaIdsFromDoc, walkMediaNodes, cloneDoc } from '../../../admin/components/tiptap/structured-content-utils.js';
+import { extractMediaIds as extractMediaIdsFromDoc, walkMediaNodes, walkInlineBlockNodes, cloneDoc } from '../../../admin/components/tiptap/structured-content-utils.js';
 export async function resolveMediaFields(data, fields) {
     const mediaIds = [];
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -52,11 +52,24 @@ export async function resolveMediaFields(data, fields) {
                     }
                     break;
                 case 'content': {
+                    const contentField = field;
                     // Content field is localized: { lang: StructuredContentDoc }
                     if (typeof val === 'object' && val !== null) {
                         for (const doc of Object.values(val)) {
                             if (doc && typeof doc === 'object' && doc.type === 'doc') {
+                                // Regular media nodes (figure/video/image)
                                 mediaIds.push(...extractMediaIdsFromDoc(doc));
+                                // Inline block fields (image/file/media inside blocks/objects)
+                                if (contentField.inlineBlocks?.length) {
+                                    walkInlineBlockNodes(doc, (node) => {
+                                        const bd = node.attrs?.blockData;
+                                        if (!bd || typeof bd !== 'object')
+                                            return;
+                                        const def = contentField.inlineBlocks.find((b) => b.slug === node.attrs?.blockType);
+                                        if (def)
+                                            collectIds(bd, def.fields);
+                                    });
+                                }
                             }
                         }
                     }
@@ -208,6 +221,7 @@ export async function resolveMediaFields(data, fields) {
                     break;
                 case 'content': {
                     // Content field is localized: { lang: StructuredContentDoc }
+                    const contentField = field;
                     if (typeof val === 'object' && val !== null) {
                         // eslint-disable-next-line @typescript-eslint/no-explicit-any
                         const resolved = {};
@@ -233,6 +247,24 @@ export async function resolveMediaFields(data, fields) {
                                         ...(mediaFile.type === 'image' ? { blurDataUrl: mediaFile.blurDataUrl } : {})
                                     };
                                 });
+                                // Resolve inline block fields
+                                if (contentField.inlineBlocks?.length) {
+                                    const promises = [];
+                                    walkInlineBlockNodes(cloned, (node) => {
+                                        const bd = node.attrs?.blockData;
+                                        if (!bd || typeof bd !== 'object')
+                                            return;
+                                        const def = contentField.inlineBlocks.find((b) => b.slug === node.attrs?.blockType);
+                                        if (!def)
+                                            return;
+                                        promises.push(resolveValues(bd, def.fields).then((resolvedBd) => {
+                                            node.attrs.blockData = resolvedBd;
+                                        }));
+                                    });
+                                    if (promises.length > 0) {
+                                        await Promise.all(promises);
+                                    }
+                                }
                                 resolved[lang] = cloned;
                             }
                             else {

package/dist/core/server/fields/resolveRelationFields.js

@@ -1,3 +1,4 @@
+import { walkInlineBlockNodes, cloneDoc } from '../../../admin/components/tiptap/structured-content-utils.js';
 import z from 'zod';
 export async function resolveRelationFields(data, fields, language) {
     const entriesIds = [];
@@ -37,6 +38,24 @@ export async function resolveRelationFields(data, fields, language) {
                         });
                     }
                     break;
+                case 'content': {
+                    const cf = field;
+                    if (typeof val === 'object' && val !== null && cf.inlineBlocks?.length) {
+                        for (const doc of Object.values(val)) {
+                            if (doc && typeof doc === 'object' && doc.type === 'doc') {
+                                walkInlineBlockNodes(doc, (node) => {
+                                    const bd = node.attrs?.blockData;
+                                    if (!bd || typeof bd !== 'object')
+                                        return;
+                                    const def = cf.inlineBlocks.find((b) => b.slug === node.attrs?.blockType);
+                                    if (def)
+                                        collectIds(bd, def.fields);
+                                });
+                            }
+                        }
+                    }
+                    break;
+                }
             }
         }
     };
@@ -93,6 +112,33 @@ export async function resolveRelationFields(data, fields, language) {
                         return item;
                     });
                     break;
+                case 'content': {
+                    const cf = field;
+                    if (typeof val === 'object' && val !== null && cf.inlineBlocks?.length) {
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                        const resolved = {};
+                        for (const [lang, doc] of Object.entries(val)) {
+                            if (doc && typeof doc === 'object' && doc.type === 'doc') {
+                                const cloned = cloneDoc(doc);
+                                walkInlineBlockNodes(cloned, (node) => {
+                                    const bd = node.attrs?.blockData;
+                                    if (!bd || typeof bd !== 'object')
+                                        return;
+                                    const def = cf.inlineBlocks.find((b) => b.slug === node.attrs?.blockType);
+                                    if (!def)
+                                        return;
+                                    node.attrs.blockData = resolveValues(bd, def.fields);
+                                });
+                                resolved[lang] = cloned;
+                            }
+                            else {
+                                resolved[lang] = doc;
+                            }
+                        }
+                        result[field.slug] = resolved;
+                    }
+                    break;
+                }
                 default:
                     result[field.slug] = val;
             }

package/dist/core/server/fields/resolveRichtextLinks.js

@@ -160,12 +160,26 @@ export async function resolveRichtextLinks(data, fields, language) {
                     break;
                 }
                 case 'content': {
+                    const contentField = field;
                     if (typeof val === 'object' && val !== null) {
                         // eslint-disable-next-line @typescript-eslint/no-explicit-any
                         const resolved = {};
                         for (const [lang, doc] of Object.entries(val)) {
                             if (doc && typeof doc === 'object' && doc.type === 'doc') {
-                                resolved[lang] = resolveContentDoc(doc, slugMap);
+                                const cloned = resolveContentDoc(doc, slugMap);
+                                // Resolve inline block fields
+                                if (contentField.inlineBlocks?.length) {
+                                    walkInlineBlockNodes(cloned, (node) => {
+                                        const bd = node.attrs?.blockData;
+                                        if (!bd || typeof bd !== 'object')
+                                            return;
+                                        const def = contentField.inlineBlocks.find((b) => b.slug === node.attrs?.blockType);
+                                        if (!def)
+                                            return;
+                                        node.attrs.blockData = resolveValues(bd, def.fields);
+                                    });
+                                }
+                                resolved[lang] = cloned;
                             }
                             else {
                                 resolved[lang] = doc;

package/dist/core/server/fields/resolveUrlFields.js

@@ -1,6 +1,18 @@
 import { urlFieldDataSchema, urlFieldDataWithRelationSchema } from '../../../schemas/field/url.js';
+import { walkInlineBlockNodes, cloneDoc } from '../../../admin/components/tiptap/structured-content-utils.js';
 import { getEntries } from '../entries/operations/get.js';
 import { getEntrySlugPath, getSlugFromEntryData } from './slugResolver.js';
+import { isExternalUrl, mergeRel } from '../../fields/urlUtils.js';
+function applyExternalAutoDetect(resolvedUrl, extras) {
+    const url = typeof resolvedUrl === 'string' ? resolvedUrl : '';
+    if (url && isExternalUrl(url)) {
+        extras.isExternal = true;
+        extras.rel = mergeRel(extras.rel, ['noopener', 'noreferrer']);
+        if (extras.newTab === undefined) {
+            extras.newTab = true;
+        }
+    }
+}
 export async function resolveUrlFields(data, fields, language) {
     const entriesIds = [];
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -38,6 +50,24 @@ export async function resolveUrlFields(data, fields, language) {
                         });
                     }
                     break;
+                case 'content': {
+                    const cf = field;
+                    if (typeof val === 'object' && val !== null && cf.inlineBlocks?.length) {
+                        for (const doc of Object.values(val)) {
+                            if (doc && typeof doc === 'object' && doc.type === 'doc') {
+                                walkInlineBlockNodes(doc, (node) => {
+                                    const bd = node.attrs?.blockData;
+                                    if (!bd || typeof bd !== 'object')
+                                        return;
+                                    const def = cf.inlineBlocks.find((b) => b.slug === node.attrs?.blockType);
+                                    if (def)
+                                        collectIds(bd, def.fields);
+                                });
+                            }
+                        }
+                    }
+                    break;
+                }
                 case 'array':
                     if (field.of === 'url' && Array.isArray(val)) {
                         for (const item of val) {
@@ -98,6 +128,9 @@ export async function resolveUrlFields(data, fields, language) {
                     if (parsed.newTab !== undefined) {
                         extras.newTab = parsed.newTab;
                     }
+                    if (parsed.rel) {
+                        extras.rel = parsed.rel;
+                    }
                     if (parsedValWithRelation.success) {
                         const slug = slugMap[parsedValWithRelation.data.id];
                         if (slug) {
@@ -108,6 +141,7 @@ export async function resolveUrlFields(data, fields, language) {
                     const resolvedUrl = language
                         ? parsed.url[language]
                         : parsed.url;
+                    applyExternalAutoDetect(resolvedUrl, extras);
                     result[field.slug] = { url: resolvedUrl, ...extras };
                     break;
                 }
@@ -132,6 +166,33 @@ export async function resolveUrlFields(data, fields, language) {
                         return item;
                     });
                     break;
+                case 'content': {
+                    const cf = field;
+                    if (typeof val === 'object' && val !== null && cf.inlineBlocks?.length) {
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                        const resolved = {};
+                        for (const [lang, doc] of Object.entries(val)) {
+                            if (doc && typeof doc === 'object' && doc.type === 'doc') {
+                                const cloned = cloneDoc(doc);
+                                walkInlineBlockNodes(cloned, (node) => {
+                                    const bd = node.attrs?.blockData;
+                                    if (!bd || typeof bd !== 'object')
+                                        return;
+                                    const def = cf.inlineBlocks.find((b) => b.slug === node.attrs?.blockType);
+                                    if (!def)
+                                        return;
+                                    node.attrs.blockData = resolveValues(bd, def.fields);
+                                });
+                                resolved[lang] = cloned;
+                            }
+                            else {
+                                resolved[lang] = doc;
+                            }
+                        }
+                        result[field.slug] = resolved;
+                    }
+                    break;
+                }
                 case 'array':
                     if (field.of === 'url' && Array.isArray(val)) {
                         // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -152,6 +213,9 @@ export async function resolveUrlFields(data, fields, language) {
                             if (parsed.newTab !== undefined) {
                                 extras.newTab = parsed.newTab;
                             }
+                            if (parsed.rel) {
+                                extras.rel = parsed.rel;
+                            }
                             if (parsedValWithRelation.success) {
                                 const slug = slugMap[parsedValWithRelation.data.id];
                                 if (slug) {
@@ -161,6 +225,7 @@ export async function resolveUrlFields(data, fields, language) {
                             const resolvedUrl = language
                                 ? parsed.url[language]
                                 : parsed.url;
+                            applyExternalAutoDetect(resolvedUrl, extras);
                             return { url: resolvedUrl, ...extras };
                         });
                     }

package/dist/core/server/generator/formFieldSchemaToString.js

@@ -1,24 +1,55 @@
+function getErrorMsg(field) {
+    if (field.errorMessage) {
+        const msg = Object.values(field.errorMessage)[0];
+        if (msg)
+            return JSON.stringify(msg);
+    }
+    return undefined;
+}
 export function generateZodSchemaFromFormFieldAsString(field) {
     let code = '';
     switch (field.type) {
-        case 'text':
+        case 'text': {
             code = 'z.string()';
-            if (field.required)
-                code += '.min(1)'; // Ensure non-empty string if required
+            const msg = getErrorMsg(field);
+            const minLen = field.minLength ?? (field.required ? 1 : undefined);
+            if (minLen) {
+                code += msg ? `.min(${minLen}, ${msg})` : `.min(${minLen})`;
+            }
+            if (field.maxLength) {
+                code += `.max(${field.maxLength})`;
+            }
             break;
-        case 'email':
+        }
+        case 'email': {
             code = 'z.string()';
-            if (field.required)
-                code += '.min(1).email()'; // Ensure non-empty and valid email if required
+            const msg = getErrorMsg(field);
+            if (field.required) {
+                code += '.min(1)';
+                code += msg ? `.email(${msg})` : '.email()';
+            }
             break;
-        case 'textarea':
+        }
+        case 'textarea': {
             code = 'z.string()';
-            if (field.required)
-                code += '.min(1)'; // Ensure non-empty string if required
+            const msg = getErrorMsg(field);
+            const minLen = field.minLength ?? (field.required ? 1 : undefined);
+            if (minLen) {
+                code += msg ? `.min(${minLen}, ${msg})` : `.min(${minLen})`;
+            }
+            if (field.maxLength) {
+                code += `.max(${field.maxLength})`;
+            }
             break;
+        }
         case 'checkbox':
             code = field.required ? 'z.literal(true)' : 'z.boolean()';
             break;
+        case 'select': {
+            const values = field.options.map((o) => JSON.stringify(o.value));
+            code = `z.enum([${values.join(', ')}])`;
+            break;
+        }
         default:
             code = 'z.any()';
     }

package/dist/core/server/generator/formFields.js

@@ -6,6 +6,8 @@ function getFormFieldTypeAsString(field) {
             return 'string';
         case 'checkbox':
             return 'boolean';
+        case 'select':
+            return field.options.map((o) => JSON.stringify(o.value)).join(' | ');
         default:
             return 'any';
     }