@famgia/omnify-typescript 0.0.64 → 0.0.66

package/dist/plugin.cjs

@@ -918,11 +918,460 @@ function generateRulesFiles(schemas, options = {}) {
   return files;
 }
 
+// src/zod-generator.ts
+function getMultiLocaleDisplayName2(value, locales, fallbackLocale, defaultValue) {
+  if (!value) {
+    const result2 = {};
+    for (const locale of locales) {
+      result2[locale] = defaultValue;
+    }
+    return result2;
+  }
+  if (typeof value === "string") {
+    const result2 = {};
+    for (const locale of locales) {
+      result2[locale] = value;
+    }
+    return result2;
+  }
+  const result = {};
+  for (const locale of locales) {
+    result[locale] = value[locale] ?? value[fallbackLocale] ?? value["en"] ?? defaultValue;
+  }
+  return result;
+}
+function getZodSchemaForType(propDef, fieldName, customTypes) {
+  const def = propDef;
+  const isNullable = def.nullable ?? false;
+  let schema = "";
+  if (customTypes) {
+    const customType = customTypes.get(propDef.type);
+    if (customType && !customType.compound) {
+      const sqlType = customType.sql?.sqlType || "VARCHAR";
+      schema = "z.string()";
+      if (customType.sql?.length) {
+        schema += `.max(${customType.sql.length})`;
+      }
+      if (isNullable) {
+        schema += ".optional().nullable()";
+      }
+      return schema;
+    }
+  }
+  switch (propDef.type) {
+    case "String":
+    case "Text":
+    case "MediumText":
+    case "LongText":
+    case "Password":
+      schema = "z.string()";
+      if (!isNullable) {
+        schema += ".min(1)";
+      }
+      if (def.maxLength || def.length) {
+        schema += `.max(${def.maxLength ?? def.length})`;
+      }
+      if (def.minLength && def.minLength > 1) {
+        schema = schema.replace(".min(1)", `.min(${def.minLength})`);
+      }
+      break;
+    case "Email":
+      schema = "z.string().email()";
+      if (def.maxLength || def.length) {
+        schema += `.max(${def.maxLength ?? def.length ?? 255})`;
+      }
+      break;
+    case "TinyInt":
+    case "Int":
+    case "BigInt":
+      schema = "z.number().int()";
+      if (def.min !== void 0) {
+        schema += `.gte(${def.min})`;
+      }
+      if (def.max !== void 0) {
+        schema += `.lte(${def.max})`;
+      }
+      break;
+    case "Float":
+      schema = "z.number()";
+      if (def.min !== void 0) {
+        schema += `.gte(${def.min})`;
+      }
+      if (def.max !== void 0) {
+        schema += `.lte(${def.max})`;
+      }
+      break;
+    case "Boolean":
+      schema = "z.boolean()";
+      break;
+    case "Date":
+      schema = "z.string().date()";
+      break;
+    case "DateTime":
+    case "Timestamp":
+      schema = "z.string().datetime({ offset: true })";
+      break;
+    case "Time":
+      schema = "z.string().time()";
+      break;
+    case "Json":
+      schema = "z.unknown()";
+      break;
+    case "Enum":
+      if (typeof def.enum === "string") {
+        schema = `${def.enum}Schema`;
+      } else if (Array.isArray(def.enum)) {
+        const values = def.enum.map((v) => `'${v}'`).join(", ");
+        schema = `z.enum([${values}])`;
+      } else {
+        schema = "z.string()";
+      }
+      break;
+    case "Select":
+      if (def.options && def.options.length > 0) {
+        const values = def.options.map((v) => `'${v}'`).join(", ");
+        schema = `z.enum([${values}])`;
+      } else {
+        schema = "z.string()";
+      }
+      break;
+    case "Lookup":
+      schema = "z.number().int().positive()";
+      break;
+    case "Association":
+      return "";
+    case "File":
+      return "";
+    default:
+      schema = "z.string()";
+  }
+  if (isNullable && schema) {
+    schema += ".optional().nullable()";
+  }
+  if (def.pattern && schema) {
+    schema += `.regex(/${def.pattern}/)`;
+  }
+  return schema;
+}
+function generateCompoundTypeSchemas(propName, propDef, customType, options) {
+  const schemas = [];
+  const propFields = propDef.fields;
+  const locales = options.localeConfig?.locales ?? ["en"];
+  const fallbackLocale = options.localeConfig?.fallbackLocale ?? "en";
+  if (!customType.expand) return schemas;
+  for (const field of customType.expand) {
+    const fieldName = `${toSnakeCase(propName)}_${toSnakeCase(field.suffix)}`;
+    const fieldOverride = propFields?.[field.suffix];
+    const isNullable = fieldOverride?.nullable ?? propDef.nullable ?? false;
+    const length = fieldOverride?.length ?? field.sql?.length;
+    let schema = "z.string()";
+    if (!isNullable) {
+      schema += ".min(1)";
+    }
+    if (length) {
+      schema += `.max(${length})`;
+    }
+    if (isNullable) {
+      schema += ".optional().nullable()";
+    }
+    const propDisplayName = getMultiLocaleDisplayName2(
+      propDef.displayName,
+      locales,
+      fallbackLocale,
+      propName
+    );
+    schemas.push({
+      fieldName,
+      schema,
+      inCreate: true,
+      inUpdate: true,
+      comment: `${propDisplayName["en"] ?? propName} (${field.suffix})`
+    });
+  }
+  return schemas;
+}
+function generateZodSchemas(schema, options) {
+  const schemas = [];
+  const customTypes = options.customTypes;
+  if (!schema.properties) return schemas;
+  for (const [propName, propDef] of Object.entries(schema.properties)) {
+    if (customTypes) {
+      const customType = customTypes.get(propDef.type);
+      if (customType?.compound) {
+        schemas.push(...generateCompoundTypeSchemas(propName, propDef, customType, options));
+        continue;
+      }
+    }
+    const zodSchema = getZodSchemaForType(propDef, propName, customTypes);
+    if (!zodSchema) continue;
+    const fieldName = toSnakeCase(propName);
+    schemas.push({
+      fieldName,
+      schema: zodSchema,
+      inCreate: true,
+      inUpdate: true,
+      comment: void 0
+    });
+  }
+  return schemas;
+}
+function generateDisplayNames(schema, options) {
+  const locales = options.localeConfig?.locales ?? ["en"];
+  const fallbackLocale = options.localeConfig?.fallbackLocale ?? "en";
+  const customTypes = options.customTypes;
+  const displayName = getMultiLocaleDisplayName2(
+    schema.displayName,
+    locales,
+    fallbackLocale,
+    schema.name
+  );
+  const propertyDisplayNames = {};
+  if (schema.properties) {
+    for (const [propName, propDef] of Object.entries(schema.properties)) {
+      const prop = propDef;
+      const fieldName = toSnakeCase(propName);
+      if (customTypes) {
+        const customType = customTypes.get(propDef.type);
+        if (customType?.compound && customType.expand) {
+          for (const field of customType.expand) {
+            const expandedFieldName = `${fieldName}_${toSnakeCase(field.suffix)}`;
+            propertyDisplayNames[expandedFieldName] = getMultiLocaleDisplayName2(
+              prop.displayName,
+              locales,
+              fallbackLocale,
+              propName
+            );
+            for (const locale of locales) {
+              propertyDisplayNames[expandedFieldName] = {
+                ...propertyDisplayNames[expandedFieldName],
+                [locale]: `${propertyDisplayNames[expandedFieldName][locale]} (${field.suffix})`
+              };
+            }
+          }
+          continue;
+        }
+      }
+      propertyDisplayNames[fieldName] = getMultiLocaleDisplayName2(
+        prop.displayName,
+        locales,
+        fallbackLocale,
+        propName
+      );
+    }
+  }
+  return { displayName, propertyDisplayNames };
+}
+function getExcludedFields(schema, customTypes) {
+  const createExclude = /* @__PURE__ */ new Set();
+  const updateExclude = /* @__PURE__ */ new Set();
+  if (schema.options?.id !== false) {
+    createExclude.add("id");
+    updateExclude.add("id");
+  }
+  if (schema.options?.timestamps !== false) {
+    createExclude.add("created_at");
+    createExclude.add("updated_at");
+    updateExclude.add("created_at");
+    updateExclude.add("updated_at");
+  }
+  if (schema.options?.softDelete) {
+    createExclude.add("deleted_at");
+    updateExclude.add("deleted_at");
+  }
+  if (schema.properties) {
+    if (schema.properties["emailVerifiedAt"] || schema.properties["email_verified_at"]) {
+      createExclude.add("email_verified_at");
+      updateExclude.add("email_verified_at");
+    }
+  }
+  if (schema.properties && customTypes) {
+    for (const [propName, propDef] of Object.entries(schema.properties)) {
+      const customType = customTypes.get(propDef.type);
+      if (customType?.accessors) {
+        for (const accessor of customType.accessors) {
+          const fieldName = `${toSnakeCase(propName)}_${toSnakeCase(accessor.name)}`;
+          createExclude.add(fieldName);
+          updateExclude.add(fieldName);
+        }
+      }
+    }
+  }
+  return { create: createExclude, update: updateExclude };
+}
+function formatZodSchemasSection(schemaName, zodSchemas, displayNames, excludedFields) {
+  const parts = [];
+  const lowerName = schemaName.charAt(0).toLowerCase() + schemaName.slice(1);
+  parts.push(`// ============================================================================
+`);
+  parts.push(`// Display Names
+`);
+  parts.push(`// ============================================================================
+
+`);
+  parts.push(`/** Display name for ${schemaName} */
+`);
+  parts.push(`export const ${schemaName}DisplayName = ${JSON.stringify(displayNames.displayName, null, 2)} as const;
+
+`);
+  parts.push(`/** Property display names for ${schemaName} */
+`);
+  parts.push(`export const ${schemaName}PropertyDisplayNames = {
+`);
+  for (const [propName, localeMap] of Object.entries(displayNames.propertyDisplayNames)) {
+    parts.push(`  ${propName}: ${JSON.stringify(localeMap)},
+`);
+  }
+  parts.push(`} as const;
+
+`);
+  parts.push(`// ============================================================================
+`);
+  parts.push(`// Zod Schemas
+`);
+  parts.push(`// ============================================================================
+
+`);
+  parts.push(`/** Field schemas for ${schemaName} */
+`);
+  parts.push(`export const base${schemaName}Schemas = {
+`);
+  for (const prop of zodSchemas) {
+    if (prop.comment) {
+      parts.push(`  /** ${prop.comment} */
+`);
+    }
+    parts.push(`  ${prop.fieldName}: ${prop.schema},
+`);
+  }
+  parts.push(`} as const;
+
+`);
+  const createFields = zodSchemas.filter((p) => p.inCreate && !excludedFields.create.has(p.fieldName));
+  parts.push(`/** Create schema for ${schemaName} (POST requests) */
+`);
+  parts.push(`export const base${schemaName}CreateSchema = z.object({
+`);
+  for (const prop of createFields) {
+    parts.push(`  ${prop.fieldName}: base${schemaName}Schemas.${prop.fieldName},
+`);
+  }
+  parts.push(`});
+
+`);
+  parts.push(`/** Update schema for ${schemaName} (PUT/PATCH requests) */
+`);
+  parts.push(`export const base${schemaName}UpdateSchema = base${schemaName}CreateSchema.partial();
+
+`);
+  parts.push(`// ============================================================================
+`);
+  parts.push(`// Inferred Types
+`);
+  parts.push(`// ============================================================================
+
+`);
+  parts.push(`export type Base${schemaName}Create = z.infer<typeof base${schemaName}CreateSchema>;
+`);
+  parts.push(`export type Base${schemaName}Update = z.infer<typeof base${schemaName}UpdateSchema>;
+
+`);
+  parts.push(`// ============================================================================
+`);
+  parts.push(`// Helper Functions
+`);
+  parts.push(`// ============================================================================
+
+`);
+  parts.push(`/** Get display name for a specific locale */
+`);
+  parts.push(`export function get${schemaName}DisplayName(locale: string): string {
+`);
+  parts.push(`  return ${schemaName}DisplayName[locale as keyof typeof ${schemaName}DisplayName] ?? ${schemaName}DisplayName['en'] ?? '${schemaName}';
+`);
+  parts.push(`}
+
+`);
+  parts.push(`/** Get property display name for a specific locale */
+`);
+  parts.push(`export function get${schemaName}PropertyDisplayName(property: string, locale: string): string {
+`);
+  parts.push(`  const names = ${schemaName}PropertyDisplayNames[property as keyof typeof ${schemaName}PropertyDisplayNames];
+`);
+  parts.push(`  if (!names) return property;
+`);
+  parts.push(`  return names[locale as keyof typeof names] ?? names['en'] ?? property;
+`);
+  parts.push(`}
+`);
+  return parts.join("");
+}
+function formatZodModelFile(schemaName) {
+  const lowerName = schemaName.charAt(0).toLowerCase() + schemaName.slice(1);
+  return `/**
+ * ${schemaName} Model
+ *
+ * This file extends the auto-generated base interface.
+ * You can add custom methods, computed properties, or override types/schemas here.
+ * This file will NOT be overwritten by the generator.
+ */
+
+import { z } from 'zod';
+import type { ${schemaName} as ${schemaName}Base } from './base/${schemaName}.js';
+import {
+  base${schemaName}Schemas,
+  base${schemaName}CreateSchema,
+  base${schemaName}UpdateSchema,
+  ${schemaName}DisplayName,
+  ${schemaName}PropertyDisplayNames,
+  get${schemaName}DisplayName,
+  get${schemaName}PropertyDisplayName,
+} from './base/${schemaName}.js';
+
+// ============================================================================
+// Types (extend or re-export)
+// ============================================================================
+
+export interface ${schemaName} extends ${schemaName}Base {
+  // Add custom properties here
+}
+
+// ============================================================================
+// Schemas (extend or re-export)
+// ============================================================================
+
+export const ${lowerName}Schemas = { ...base${schemaName}Schemas };
+export const ${lowerName}CreateSchema = base${schemaName}CreateSchema;
+export const ${lowerName}UpdateSchema = base${schemaName}UpdateSchema;
+
+// ============================================================================
+// Types
+// ============================================================================
+
+export type ${schemaName}Create = z.infer<typeof ${lowerName}CreateSchema>;
+export type ${schemaName}Update = z.infer<typeof ${lowerName}UpdateSchema>;
+
+// Re-export display names and helpers
+export {
+  ${schemaName}DisplayName,
+  ${schemaName}PropertyDisplayNames,
+  get${schemaName}DisplayName,
+  get${schemaName}PropertyDisplayName,
+};
+
+// Re-export base type for internal use
+export type { ${schemaName}Base };
+`;
+}
+
 // src/generator.ts
 var DEFAULT_OPTIONS = {
   readonly: false,
   // Changed: interfaces should be mutable for forms/mutations
-  strictNullChecks: true
+  strictNullChecks: true,
+  generateZodSchemas: true,
+  // Generate Zod schemas by default
+  generateRules: false
+  // Legacy Ant Design rules (deprecated, ignored when generateZodSchemas=true)
 };
 function generateBaseHeader() {
   return `/**
@@ -943,7 +1392,21 @@ function generateModelHeader(schemaName) {
 
 `;
 }
-function generateUtilityTypes(schemaName, schema) {
+function getComputedFields(schema, customTypes) {
+  const computedFields = [];
+  if (!schema.properties) return computedFields;
+  for (const [propName, propDef] of Object.entries(schema.properties)) {
+    const snakeName = toSnakeCase(propName);
+    const customType = customTypes?.get(propDef.type);
+    if (customType?.accessors) {
+      for (const accessor of customType.accessors) {
+        computedFields.push(`${snakeName}_${toSnakeCase(accessor.name)}`);
+      }
+    }
+  }
+  return computedFields;
+}
+function generateUtilityTypes(schemaName, schema, customTypes) {
   const parts = [];
   const excludeFields = [];
   if (schema.options?.id !== false) {
@@ -955,6 +1418,13 @@ function generateUtilityTypes(schemaName, schema) {
   if (schema.options?.softDelete) {
     excludeFields.push("'deleted_at'");
   }
+  if (schema.properties?.["emailVerifiedAt"] || schema.properties?.["email_verified_at"]) {
+    excludeFields.push("'email_verified_at'");
+  }
+  const computedFields = getComputedFields(schema, customTypes);
+  for (const field of computedFields) {
+    excludeFields.push(`'${field}'`);
+  }
   const omitType = excludeFields.length > 0 ? `Omit<${schemaName}, ${excludeFields.join(" | ")}>` : schemaName;
   parts.push(`
 /** For creating new ${schemaName} (POST requests) */`);
@@ -989,6 +1459,10 @@ function generateBaseInterfaceFile(schemaName, schemas, options) {
     throw new Error(`Interface not found for schema: ${schemaName}`);
   }
   const parts = [generateBaseHeader()];
+  if (options.generateZodSchemas) {
+    parts.push(`import { z } from 'zod';
+`);
+  }
   const dateImports = needsDateTimeImports(iface);
   const commonImports = [];
   if (dateImports.dateTime) commonImports.push("DateTimeString");
@@ -1003,12 +1477,20 @@ function generateBaseInterfaceFile(schemaName, schemas, options) {
 `);
     }
     parts.push("\n");
-  } else if (commonImports.length > 0) {
+  } else if (commonImports.length > 0 || options.generateZodSchemas) {
     parts.push("\n");
   }
   parts.push(formatInterface(iface));
   parts.push("\n");
-  parts.push(generateUtilityTypes(schemaName, schema));
+  if (options.generateZodSchemas) {
+    const zodSchemas = generateZodSchemas(schema, options);
+    const displayNames = generateDisplayNames(schema, options);
+    const excludedFields = getExcludedFields(schema, options.customTypes);
+    parts.push("\n");
+    parts.push(formatZodSchemasSection(schemaName, zodSchemas, displayNames, excludedFields));
+  } else {
+    parts.push(generateUtilityTypes(schemaName, schema, options.customTypes));
+  }
   return {
     filePath: `base/${schemaName}.ts`,
     content: parts.join(""),
@@ -1038,7 +1520,16 @@ function generateTypeAliasFile(alias) {
     overwrite: true
   };
 }
-function generateModelFile(schemaName) {
+function generateModelFile(schemaName, options) {
+  if (options.generateZodSchemas) {
+    return {
+      filePath: `${schemaName}.ts`,
+      content: formatZodModelFile(schemaName),
+      types: [schemaName],
+      overwrite: false
+      // Never overwrite user models
+    };
+  }
   const parts = [generateModelHeader(schemaName)];
   parts.push(`import type { ${schemaName} as ${schemaName}Base } from './base/${schemaName}.js';
 
@@ -1158,34 +1649,64 @@ function generateIndexFile(schemas, enums, typeAliases, options) {
     }
     parts.push("\n");
   }
-  parts.push(`// Models (with Create/Update utility types)
-`);
-  for (const schema of Object.values(schemas)) {
-    if (schema.kind === "enum") continue;
-    if (schema.options?.hidden === true) continue;
-    parts.push(`export type { ${schema.name} } from './${schema.name}.js';
-`);
-    parts.push(`export type { ${schema.name}Create, ${schema.name}Update } from './base/${schema.name}.js';
-`);
-  }
-  if (options.generateRules) {
-    parts.push(`
-// Validation Rules
+  if (options.generateZodSchemas) {
+    parts.push(`// Models (with Zod schemas and Create/Update types)
 `);
     for (const schema of Object.values(schemas)) {
       if (schema.kind === "enum") continue;
       if (schema.options?.hidden === true) continue;
+      const lowerName = schema.name.charAt(0).toLowerCase() + schema.name.slice(1);
+      parts.push(`export type { ${schema.name}, ${schema.name}Create, ${schema.name}Update } from './${schema.name}.js';
+`);
       parts.push(`export {
 `);
-      parts.push(`  get${schema.name}Rules,
+      parts.push(`  ${lowerName}Schemas,
+`);
+      parts.push(`  ${lowerName}CreateSchema,
+`);
+      parts.push(`  ${lowerName}UpdateSchema,
+`);
+      parts.push(`  ${schema.name}DisplayName,
+`);
+      parts.push(`  ${schema.name}PropertyDisplayNames,
 `);
       parts.push(`  get${schema.name}DisplayName,
 `);
       parts.push(`  get${schema.name}PropertyDisplayName,
 `);
-      parts.push(`} from './rules/${schema.name}.rules.js';
+      parts.push(`} from './${schema.name}.js';
 `);
     }
+  } else {
+    parts.push(`// Models (with Create/Update utility types)
+`);
+    for (const schema of Object.values(schemas)) {
+      if (schema.kind === "enum") continue;
+      if (schema.options?.hidden === true) continue;
+      parts.push(`export type { ${schema.name} } from './${schema.name}.js';
+`);
+      parts.push(`export type { ${schema.name}Create, ${schema.name}Update } from './base/${schema.name}.js';
+`);
+    }
+    if (options.generateRules) {
+      parts.push(`
+// Validation Rules
+`);
+      for (const schema of Object.values(schemas)) {
+        if (schema.kind === "enum") continue;
+        if (schema.options?.hidden === true) continue;
+        parts.push(`export {
+`);
+        parts.push(`  get${schema.name}Rules,
+`);
+        parts.push(`  get${schema.name}DisplayName,
+`);
+        parts.push(`  get${schema.name}PropertyDisplayName,
+`);
+        parts.push(`} from './rules/${schema.name}.rules.js';
+`);
+      }
+    }
   }
   return {
     filePath: "index.ts",
@@ -1213,9 +1734,9 @@ function generateTypeScript(schemas, options = {}) {
   for (const schema of Object.values(schemas)) {
     if (schema.kind === "enum") continue;
     if (schema.options?.hidden === true) continue;
-    files.push(generateModelFile(schema.name));
+    files.push(generateModelFile(schema.name, opts));
   }
-  if (opts.generateRules) {
+  if (!opts.generateZodSchemas && opts.generateRules) {
     const rulesFiles = generateRulesFiles(schemas, opts);
     files.push(...rulesFiles);
   }
@@ -1230,16 +1751,25 @@ var TYPESCRIPT_CONFIG_SCHEMA = {
     {
       key: "modelsPath",
       type: "path",
-      label: "Models Output Path",
-      description: "Directory for generated TypeScript model files",
-      default: "types/models",
+      label: "Schemas Output Path",
+      description: "Directory for generated TypeScript types and Zod schemas",
+      default: "types/schemas",
+      group: "output"
+    },
+    {
+      key: "generateZodSchemas",
+      type: "boolean",
+      label: "Generate Zod Schemas",
+      description: "Generate Zod schemas alongside TypeScript types for form validation",
+      default: true,
       group: "output"
     }
   ]
 };
 function resolveOptions(options) {
   return {
-    modelsPath: options?.modelsPath ?? "types/models"
+    modelsPath: options?.modelsPath ?? "types/schemas",
+    generateZodSchemas: options?.generateZodSchemas ?? true
   };
 }
 function typescriptPlugin(options) {
@@ -1253,7 +1783,11 @@ function typescriptPlugin(options) {
         name: "typescript-models",
         description: "Generate TypeScript model definitions",
         generate: async (ctx) => {
-          const files = generateTypeScript(ctx.schemas);
+          const files = generateTypeScript(ctx.schemas, {
+            generateZodSchemas: resolved.generateZodSchemas,
+            localeConfig: ctx.localeConfig,
+            customTypes: ctx.customTypes
+          });
           return files.map((file) => ({
             path: `${resolved.modelsPath}/${file.filePath}`,
             content: file.content,