@famgia/omnify-typescript 0.0.1 → 0.0.2

package/dist/plugin.cjs

@@ -26,6 +26,7 @@ __export(plugin_exports, {
 module.exports = __toCommonJS(plugin_exports);
 
 // src/interface-generator.ts
+var import_omnify_types = require("@famgia/omnify-types");
 var TYPE_MAP = {
   String: "string",
   Int: "number",
@@ -51,6 +52,15 @@ var PK_TYPE_MAP = {
   Uuid: "string",
   String: "string"
 };
+function resolveDisplayName(value, options = {}) {
+  if (value === void 0) {
+    return void 0;
+  }
+  return (0, import_omnify_types.resolveLocalizedString)(value, {
+    locale: options.locale,
+    config: options.localeConfig
+  });
+}
 function toPropertyName(name) {
   return name;
 }
@@ -112,6 +122,7 @@ function getPropertyType(property, _allSchemas) {
 function propertyToTSProperties(propertyName, property, allSchemas, options = {}) {
   const baseProp = property;
   const isReadonly = options.readonly ?? true;
+  const displayName = resolveDisplayName(baseProp.displayName, options);
   if (property.type === "Association") {
     const assocProp = property;
     if (assocProp.relation === "MorphTo" && assocProp.targets && assocProp.targets.length > 0) {
@@ -139,7 +150,7 @@ function propertyToTSProperties(propertyName, property, allSchemas, options = {}
           type: `${relationUnion} | null`,
           optional: true,
           readonly: isReadonly,
-          comment: baseProp.displayName ?? `Polymorphic relation to ${assocProp.targets.join(", ")}`
+          comment: displayName ?? `Polymorphic relation to ${assocProp.targets.join(", ")}`
         }
       ];
     }
@@ -150,7 +161,7 @@ function propertyToTSProperties(propertyName, property, allSchemas, options = {}
     type,
     optional: baseProp.nullable ?? false,
     readonly: isReadonly,
-    comment: baseProp.displayName
+    comment: displayName
   }];
 }
 function schemaToInterface(schema, allSchemas, options = {}) {
@@ -197,10 +208,11 @@ function schemaToInterface(schema, allSchemas, options = {}) {
       comment: "Soft delete timestamp"
     });
   }
+  const schemaDisplayName = resolveDisplayName(schema.displayName, options);
   return {
     name: toInterfaceName(schema.name),
     properties,
-    comment: schema.displayName ?? schema.name
+    comment: schemaDisplayName ?? schema.name
   };
 }
 function formatProperty(property) {
@@ -233,31 +245,54 @@ function generateInterfaces(schemas, options = {}) {
 }
 
 // src/enum-generator.ts
+var import_omnify_types2 = require("@famgia/omnify-types");
+function resolveDisplayName2(value, options = {}) {
+  if (value === void 0) {
+    return void 0;
+  }
+  return (0, import_omnify_types2.resolveLocalizedString)(value, {
+    locale: options.locale,
+    config: options.localeConfig
+  });
+}
 function toEnumMemberName(value) {
   return value.split(/[-_\s]+/).map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join("").replace(/[^a-zA-Z0-9]/g, "");
 }
 function toEnumName(schemaName) {
   return schemaName;
 }
-function schemaToEnum(schema) {
+function parseEnumValue(value) {
+  if (typeof value === "string") {
+    return {
+      name: toEnumMemberName(value),
+      value
+      // No label or extra - will fallback to value
+    };
+  }
+  return {
+    name: toEnumMemberName(value.value),
+    value: value.value,
+    label: value.label,
+    extra: value.extra
+  };
+}
+function schemaToEnum(schema, options = {}) {
   if (schema.kind !== "enum" || !schema.values) {
     return null;
   }
-  const values = schema.values.map((value) => ({
-    name: toEnumMemberName(value),
-    value
-  }));
+  const values = schema.values.map((value) => parseEnumValue(value));
+  const displayName = resolveDisplayName2(schema.displayName, options);
   return {
     name: toEnumName(schema.name),
     values,
-    comment: schema.displayName ?? schema.name
+    comment: displayName ?? schema.name
   };
 }
-function generateEnums(schemas) {
+function generateEnums(schemas, options = {}) {
   const enums = [];
   for (const schema of Object.values(schemas)) {
     if (schema.kind === "enum") {
-      const enumDef = schemaToEnum(schema);
+      const enumDef = schemaToEnum(schema, options);
       if (enumDef) {
         enums.push(enumDef);
       }
@@ -266,23 +301,132 @@ function generateEnums(schemas) {
   return enums;
 }
 function formatEnum(enumDef) {
-  const comment = enumDef.comment ? `/**
- * ${enumDef.comment}
+  const { name, values, comment } = enumDef;
+  const parts = [];
+  if (comment) {
+    parts.push(`/**
+ * ${comment}
  */
-` : "";
-  const values = enumDef.values.map((v) => `  ${v.name} = '${v.value}',`).join("\n");
-  return `${comment}export enum ${enumDef.name} {
-${values}
-}`;
+`);
+  }
+  const enumValues = values.map((v) => `  ${v.name} = '${v.value}',`).join("\n");
+  parts.push(`export enum ${name} {
+${enumValues}
+}
+
+`);
+  parts.push(`/** All ${name} values */
+`);
+  parts.push(`export const ${name}Values = Object.values(${name});
+
+`);
+  parts.push(`/** Type guard for ${name} */
+`);
+  parts.push(`export function is${name}(value: unknown): value is ${name} {
+`);
+  parts.push(`  return ${name}Values.includes(value as ${name});
+`);
+  parts.push(`}
+
+`);
+  const hasLabels = values.some((v) => v.label !== void 0);
+  if (hasLabels) {
+    const labelEntries = values.filter((v) => v.label !== void 0).map((v) => `  [${name}.${v.name}]: '${v.label}',`).join("\n");
+    parts.push(`const ${lowerFirst(name)}Labels: Partial<Record<${name}, string>> = {
+${labelEntries}
+};
+
+`);
+  }
+  parts.push(`/** Get label for ${name} value (fallback to value if no label) */
+`);
+  parts.push(`export function get${name}Label(value: ${name}): string {
+`);
+  if (hasLabels) {
+    parts.push(`  return ${lowerFirst(name)}Labels[value] ?? value;
+`);
+  } else {
+    parts.push(`  return value;
+`);
+  }
+  parts.push(`}
+
+`);
+  const hasExtra = values.some((v) => v.extra !== void 0);
+  if (hasExtra) {
+    const extraEntries = values.filter((v) => v.extra !== void 0).map((v) => `  [${name}.${v.name}]: ${JSON.stringify(v.extra)},`).join("\n");
+    parts.push(`const ${lowerFirst(name)}Extra: Partial<Record<${name}, Record<string, unknown>>> = {
+${extraEntries}
+};
+
+`);
+    parts.push(`/** Get extra metadata for ${name} value (undefined if not defined) */
+`);
+    parts.push(`export function get${name}Extra(value: ${name}): Record<string, unknown> | undefined {
+`);
+    parts.push(`  return ${lowerFirst(name)}Extra[value];
+`);
+    parts.push(`}`);
+  } else {
+    parts.push(`/** Get extra metadata for ${name} value (undefined if not defined) */
+`);
+    parts.push(`export function get${name}Extra(_value: ${name}): Record<string, unknown> | undefined {
+`);
+    parts.push(`  return undefined;
+`);
+    parts.push(`}`);
+  }
+  return parts.join("");
+}
+function lowerFirst(str) {
+  return str.charAt(0).toLowerCase() + str.slice(1);
 }
 function formatTypeAlias(alias) {
-  const comment = alias.comment ? `/**
- * ${alias.comment}
+  const { name, type, comment } = alias;
+  const parts = [];
+  if (comment) {
+    parts.push(`/**
+ * ${comment}
  */
-` : "";
-  return `${comment}export type ${alias.name} = ${alias.type};`;
+`);
+  }
+  parts.push(`export type ${name} = ${type};
+
+`);
+  const values = type.split(" | ").map((v) => v.trim());
+  parts.push(`/** All ${name} values */
+`);
+  parts.push(`export const ${name}Values: ${name}[] = [${values.join(", ")}];
+
+`);
+  parts.push(`/** Type guard for ${name} */
+`);
+  parts.push(`export function is${name}(value: unknown): value is ${name} {
+`);
+  parts.push(`  return ${name}Values.includes(value as ${name});
+`);
+  parts.push(`}
+
+`);
+  parts.push(`/** Get label for ${name} value (returns value as-is) */
+`);
+  parts.push(`export function get${name}Label(value: ${name}): string {
+`);
+  parts.push(`  return value;
+`);
+  parts.push(`}
+
+`);
+  parts.push(`/** Get extra metadata for ${name} value (always undefined for type aliases) */
+`);
+  parts.push(`export function get${name}Extra(_value: ${name}): Record<string, unknown> | undefined {
+`);
+  parts.push(`  return undefined;
+`);
+  parts.push(`}`);
+  return parts.join("");
 }
-function extractInlineEnums(schemas) {
+function extractInlineEnums(schemas, options = {}) {
   const typeAliases = [];
   for (const schema of Object.values(schemas)) {
     if (schema.kind === "enum" || !schema.properties) {
@@ -293,10 +437,14 @@ function extractInlineEnums(schemas) {
         const enumProp = property;
         if (Array.isArray(enumProp.enum) && enumProp.enum.length > 0) {
           const typeName = `${schema.name}${propName.charAt(0).toUpperCase() + propName.slice(1)}`;
+          const values = enumProp.enum.map(
+            (v) => typeof v === "string" ? v : v.value
+          );
+          const displayName = resolveDisplayName2(enumProp.displayName, options);
           typeAliases.push({
             name: typeName,
-            type: enumProp.enum.map((v) => `'${v}'`).join(" | "),
-            comment: enumProp.displayName ?? `${schema.name} ${propName} enum`
+            type: values.map((v) => `'${v}'`).join(" | "),
+            comment: displayName ?? `${schema.name} ${propName} enum`
           });
         }
       }
@@ -304,10 +452,11 @@ function extractInlineEnums(schemas) {
         const selectProp = property;
         if (selectProp.options && selectProp.options.length > 0) {
           const typeName = `${schema.name}${propName.charAt(0).toUpperCase() + propName.slice(1)}`;
+          const displayName = resolveDisplayName2(selectProp.displayName, options);
           typeAliases.push({
             name: typeName,
             type: selectProp.options.map((v) => `'${v}'`).join(" | "),
-            comment: selectProp.displayName ?? `${schema.name} ${propName} options`
+            comment: displayName ?? `${schema.name} ${propName} options`
           });
         }
       }
@@ -318,196 +467,187 @@ function extractInlineEnums(schemas) {
 
 // src/generator.ts
 var DEFAULT_OPTIONS = {
-  singleFile: true,
-  fileName: "types.ts",
   readonly: true,
   strictNullChecks: true
 };
-function generateHeader() {
+function generateBaseHeader() {
   return `/**
  * Auto-generated TypeScript types from Omnify schemas.
- * DO NOT EDIT - This file is automatically generated.
+ * DO NOT EDIT - This file is automatically generated and will be overwritten.
  */
 
 `;
 }
-function generateTypeScriptFile(schemas, options = {}) {
-  const opts = { ...DEFAULT_OPTIONS, ...options };
-  const parts = [generateHeader()];
-  const types = [];
-  const enums = generateEnums(schemas);
-  if (enums.length > 0) {
-    parts.push("// Enums\n");
+function generateModelHeader(schemaName) {
+  return `/**
+ * ${schemaName} Model
+ *
+ * This file extends the auto-generated base interface.
+ * You can add custom methods, computed properties, or override types here.
+ * This file will NOT be overwritten by the generator.
+ */
+
+`;
+}
+function generateBaseInterfaceFile(schemaName, schemas, options) {
+  const interfaces = generateInterfaces(schemas, options);
+  const iface = interfaces.find((i) => i.name === schemaName);
+  if (!iface) {
+    throw new Error(`Interface not found for schema: ${schemaName}`);
+  }
+  const parts = [generateBaseHeader()];
+  parts.push(formatInterface(iface));
+  parts.push("\n");
+  return {
+    filePath: `base/${schemaName}.ts`,
+    content: parts.join(""),
+    types: [schemaName],
+    overwrite: true
+  };
+}
+function generateEnumFile(enumDef) {
+  const parts = [generateBaseHeader()];
+  parts.push(formatEnum(enumDef));
+  parts.push("\n");
+  return {
+    filePath: `enum/${enumDef.name}.ts`,
+    content: parts.join(""),
+    types: [enumDef.name],
+    overwrite: true
+  };
+}
+function generateTypeAliasFile(alias) {
+  const parts = [generateBaseHeader()];
+  parts.push(formatTypeAlias(alias));
+  parts.push("\n");
+  return {
+    filePath: `enum/${alias.name}.ts`,
+    content: parts.join(""),
+    types: [alias.name],
+    overwrite: true
+  };
+}
+function generateModelFile(schemaName) {
+  const parts = [generateModelHeader(schemaName)];
+  parts.push(`import type { ${schemaName} as ${schemaName}Base } from './base/${schemaName}.js';
+
+`);
+  parts.push(`/**
+ * ${schemaName} model interface.
+ * Add custom properties or methods here.
+ */
+`);
+  parts.push(`export interface ${schemaName} extends ${schemaName}Base {
+`);
+  parts.push(`  // Add custom properties here
+`);
+  parts.push(`}
+
+`);
+  parts.push(`// Re-export base type for internal use
+`);
+  parts.push(`export type { ${schemaName}Base };
+`);
+  return {
+    filePath: `${schemaName}.ts`,
+    content: parts.join(""),
+    types: [schemaName],
+    overwrite: false
+    // Never overwrite user models
+  };
+}
+function generateIndexFile(schemas, enums, typeAliases) {
+  const parts = [generateBaseHeader()];
+  if (enums.length > 0 || typeAliases.length > 0) {
+    parts.push(`// Enums
+`);
     for (const enumDef of enums) {
-      parts.push(formatEnum(enumDef));
-      parts.push("\n\n");
-      types.push(enumDef.name);
+      parts.push(`export {
+`);
+      parts.push(`  ${enumDef.name},
+`);
+      parts.push(`  ${enumDef.name}Values,
+`);
+      parts.push(`  is${enumDef.name},
+`);
+      parts.push(`  get${enumDef.name}Label,
+`);
+      parts.push(`  get${enumDef.name}Extra,
+`);
+      parts.push(`} from './enum/${enumDef.name}.js';
+`);
     }
-  }
-  const inlineEnums = extractInlineEnums(schemas);
-  if (inlineEnums.length > 0) {
-    parts.push("// Type Aliases\n");
-    for (const alias of inlineEnums) {
-      parts.push(formatTypeAlias(alias));
-      parts.push("\n\n");
-      types.push(alias.name);
+    for (const alias of typeAliases) {
+      parts.push(`export {
+`);
+      parts.push(`  type ${alias.name},
+`);
+      parts.push(`  ${alias.name}Values,
+`);
+      parts.push(`  is${alias.name},
+`);
+      parts.push(`  get${alias.name}Label,
+`);
+      parts.push(`  get${alias.name}Extra,
+`);
+      parts.push(`} from './enum/${alias.name}.js';
+`);
     }
+    parts.push("\n");
   }
-  const interfaces = generateInterfaces(schemas, opts);
-  if (interfaces.length > 0) {
-    parts.push("// Interfaces\n");
-    for (const iface of interfaces) {
-      parts.push(formatInterface(iface));
-      parts.push("\n\n");
-      types.push(iface.name);
-    }
+  parts.push(`// Models
+`);
+  for (const schema of Object.values(schemas)) {
+    if (schema.kind === "enum") continue;
+    parts.push(`export type { ${schema.name} } from './${schema.name}.js';
+`);
   }
   return {
-    fileName: opts.fileName ?? "types.ts",
-    content: parts.join("").trim() + "\n",
-    types
+    filePath: "index.ts",
+    content: parts.join(""),
+    types: [],
+    overwrite: true
   };
 }
-function generateTypeScriptFiles(schemas, options = {}) {
+function generateTypeScript(schemas, options = {}) {
   const opts = { ...DEFAULT_OPTIONS, ...options };
   const files = [];
   const enums = generateEnums(schemas);
-  if (enums.length > 0) {
-    const content = generateHeader() + enums.map(formatEnum).join("\n\n") + "\n";
-    files.push({
-      fileName: "enums.ts",
-      content,
-      types: enums.map((e) => e.name)
-    });
+  for (const enumDef of enums) {
+    files.push(generateEnumFile(enumDef));
   }
-  const inlineEnums = extractInlineEnums(schemas);
-  if (inlineEnums.length > 0) {
-    const content = generateHeader() + inlineEnums.map(formatTypeAlias).join("\n\n") + "\n";
-    files.push({
-      fileName: "type-aliases.ts",
-      content,
-      types: inlineEnums.map((a) => a.name)
-    });
+  const typeAliases = extractInlineEnums(schemas);
+  for (const alias of typeAliases) {
+    files.push(generateTypeAliasFile(alias));
   }
-  const interfaces = generateInterfaces(schemas, opts);
-  for (const iface of interfaces) {
-    const imports = collectImports(iface, enums, inlineEnums, interfaces);
-    const importStatement = formatImports(imports);
-    const content = generateHeader() + (importStatement ? importStatement + "\n\n" : "") + formatInterface(iface) + "\n";
-    files.push({
-      fileName: `${toKebabCase(iface.name)}.ts`,
-      content,
-      types: [iface.name]
-    });
-  }
-  const indexContent = generateIndexFile(files);
-  files.push({
-    fileName: "index.ts",
-    content: indexContent,
-    types: []
-  });
-  return files;
-}
-function toKebabCase(name) {
-  return name.replace(/([A-Z])/g, "-$1").toLowerCase().replace(/^-/, "");
-}
-function collectImports(iface, enums, typeAliases, allInterfaces) {
-  const imports = /* @__PURE__ */ new Map();
-  const enumNames = new Set(enums.map((e) => e.name));
-  const aliasNames = new Set(typeAliases.map((a) => a.name));
-  const interfaceNames = new Set(allInterfaces.map((i) => i.name));
-  for (const prop of iface.properties) {
-    if (enumNames.has(prop.type)) {
-      const existing = imports.get("./enums.js") ?? [];
-      if (!existing.includes(prop.type)) {
-        imports.set("./enums.js", [...existing, prop.type]);
-      }
-    }
-    if (aliasNames.has(prop.type)) {
-      const existing = imports.get("./type-aliases.js") ?? [];
-      if (!existing.includes(prop.type)) {
-        imports.set("./type-aliases.js", [...existing, prop.type]);
-      }
-    }
-    const baseType = prop.type.replace("[]", "");
-    if (interfaceNames.has(baseType) && baseType !== iface.name) {
-      const fileName = `./${toKebabCase(baseType)}.js`;
-      const existing = imports.get(fileName) ?? [];
-      if (!existing.includes(baseType)) {
-        imports.set(fileName, [...existing, baseType]);
-      }
-    }
-  }
-  return imports;
-}
-function formatImports(imports) {
-  if (imports.size === 0) return "";
-  const lines = [];
-  for (const [path, names] of imports) {
-    lines.push(`import type { ${names.join(", ")} } from '${path}';`);
-  }
-  return lines.join("\n");
-}
-function generateIndexFile(files) {
-  const exports2 = [generateHeader().trim(), ""];
-  for (const file of files) {
-    if (file.fileName === "index.ts") continue;
-    const moduleName = file.fileName.replace(".ts", ".js");
-    exports2.push(`export * from './${moduleName}';`);
+  for (const schema of Object.values(schemas)) {
+    if (schema.kind === "enum") continue;
+    files.push(generateBaseInterfaceFile(schema.name, schemas, opts));
   }
-  return exports2.join("\n") + "\n";
-}
-function generateTypeScript(schemas, options = {}) {
-  const opts = { ...DEFAULT_OPTIONS, ...options };
-  if (opts.singleFile) {
-    return [generateTypeScriptFile(schemas, opts)];
+  for (const schema of Object.values(schemas)) {
+    if (schema.kind === "enum") continue;
+    files.push(generateModelFile(schema.name));
   }
-  return generateTypeScriptFiles(schemas, opts);
+  files.push(generateIndexFile(schemas, enums, typeAliases));
+  return files;
 }
 
 // src/plugin.ts
 var TYPESCRIPT_CONFIG_SCHEMA = {
   fields: [
     {
-      key: "typesPath",
+      key: "modelsPath",
       type: "path",
-      label: "Types Output Path",
-      description: "Directory for generated TypeScript type files",
-      default: "types",
-      group: "output"
-    },
-    {
-      key: "singleFile",
-      type: "boolean",
-      label: "Single File Output",
-      description: "Generate all types in a single file (types.ts) instead of separate files",
-      default: true,
+      label: "Models Output Path",
+      description: "Directory for generated TypeScript model files",
+      default: "types/models",
       group: "output"
-    },
-    {
-      key: "generateEnums",
-      type: "boolean",
-      label: "Generate Enums",
-      description: "Generate TypeScript enums from schema enums",
-      default: true,
-      group: "options"
-    },
-    {
-      key: "generateRelationships",
-      type: "boolean",
-      label: "Generate Relationships",
-      description: "Include relationship types in interfaces",
-      default: true,
-      group: "options"
     }
   ]
 };
 function resolveOptions(options) {
   return {
-    typesPath: options?.typesPath ?? "types",
-    singleFile: options?.singleFile ?? true,
-    generateEnums: options?.generateEnums ?? true,
-    generateRelationships: options?.generateRelationships ?? true
+    modelsPath: options?.modelsPath ?? "types/models"
   };
 }
 function typescriptPlugin(options) {
@@ -518,17 +658,15 @@ function typescriptPlugin(options) {
     configSchema: TYPESCRIPT_CONFIG_SCHEMA,
     generators: [
       {
-        name: "typescript-types",
-        description: "Generate TypeScript type definitions",
+        name: "typescript-models",
+        description: "Generate TypeScript model definitions",
         generate: async (ctx) => {
-          const tsOptions = {
-            singleFile: resolved.singleFile
-          };
-          const files = generateTypeScript(ctx.schemas, tsOptions);
+          const files = generateTypeScript(ctx.schemas);
           return files.map((file) => ({
-            path: `${resolved.typesPath}/${file.fileName}`,
+            path: `${resolved.modelsPath}/${file.filePath}`,
             content: file.content,
             type: "type",
+            overwrite: file.overwrite,
             metadata: {
               types: file.types
             }