@famgia/omnify-typescript 0.0.1 → 0.0.2

package/dist/chunk-J46F3EBS.js

@@ -0,0 +1,638 @@
+// src/interface-generator.ts
+import { resolveLocalizedString } from "@famgia/omnify-types";
+var TYPE_MAP = {
+  String: "string",
+  Int: "number",
+  BigInt: "number",
+  Float: "number",
+  Boolean: "boolean",
+  Text: "string",
+  LongText: "string",
+  Date: "string",
+  Time: "string",
+  Timestamp: "string",
+  Json: "unknown",
+  Email: "string",
+  Password: "string",
+  Enum: "string",
+  Select: "string",
+  Lookup: "number"
+};
+var FILE_INTERFACE_NAME = "File";
+var PK_TYPE_MAP = {
+  Int: "number",
+  BigInt: "number",
+  Uuid: "string",
+  String: "string"
+};
+function resolveDisplayName(value, options = {}) {
+  if (value === void 0) {
+    return void 0;
+  }
+  return resolveLocalizedString(value, {
+    locale: options.locale,
+    config: options.localeConfig
+  });
+}
+function toPropertyName(name) {
+  return name;
+}
+function toInterfaceName(schemaName) {
+  return schemaName;
+}
+function getPropertyType(property, _allSchemas) {
+  if (property.type === "File") {
+    const fileProp = property;
+    if (fileProp.multiple) {
+      return `${FILE_INTERFACE_NAME}[]`;
+    }
+    return `${FILE_INTERFACE_NAME} | null`;
+  }
+  if (property.type === "Association") {
+    const assocProp = property;
+    const targetName = assocProp.target ?? "unknown";
+    switch (assocProp.relation) {
+      // Standard relations
+      case "OneToOne":
+      case "ManyToOne":
+        return targetName;
+      case "OneToMany":
+      case "ManyToMany":
+        return `${targetName}[]`;
+      // Polymorphic relations
+      case "MorphTo":
+        if (assocProp.targets && assocProp.targets.length > 0) {
+          return assocProp.targets.join(" | ");
+        }
+        return "unknown";
+      case "MorphOne":
+        return targetName;
+      case "MorphMany":
+      case "MorphToMany":
+      case "MorphedByMany":
+        return `${targetName}[]`;
+      default:
+        return "unknown";
+    }
+  }
+  if (property.type === "Enum") {
+    const enumProp = property;
+    if (typeof enumProp.enum === "string") {
+      return enumProp.enum;
+    }
+    if (Array.isArray(enumProp.enum)) {
+      return enumProp.enum.map((v) => `'${v}'`).join(" | ");
+    }
+  }
+  if (property.type === "Select") {
+    const selectProp = property;
+    if (selectProp.options && selectProp.options.length > 0) {
+      return selectProp.options.map((v) => `'${v}'`).join(" | ");
+    }
+  }
+  return TYPE_MAP[property.type] ?? "unknown";
+}
+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) {
+      const propBaseName = toPropertyName(propertyName);
+      const targetUnion = assocProp.targets.map((t) => `'${t}'`).join(" | ");
+      const relationUnion = assocProp.targets.join(" | ");
+      return [
+        {
+          name: `${propBaseName}Type`,
+          type: targetUnion,
+          optional: true,
+          // Polymorphic columns are nullable
+          readonly: isReadonly,
+          comment: `Polymorphic type for ${propertyName}`
+        },
+        {
+          name: `${propBaseName}Id`,
+          type: "number",
+          optional: true,
+          readonly: isReadonly,
+          comment: `Polymorphic ID for ${propertyName}`
+        },
+        {
+          name: propBaseName,
+          type: `${relationUnion} | null`,
+          optional: true,
+          readonly: isReadonly,
+          comment: displayName ?? `Polymorphic relation to ${assocProp.targets.join(", ")}`
+        }
+      ];
+    }
+  }
+  const type = getPropertyType(property, allSchemas);
+  return [{
+    name: toPropertyName(propertyName),
+    type,
+    optional: baseProp.nullable ?? false,
+    readonly: isReadonly,
+    comment: displayName
+  }];
+}
+function propertyToTSProperty(propertyName, property, allSchemas, options = {}) {
+  return propertyToTSProperties(propertyName, property, allSchemas, options)[0];
+}
+function schemaToInterface(schema, allSchemas, options = {}) {
+  const properties = [];
+  if (schema.options?.id !== false) {
+    const pkType = schema.options?.idType ?? "BigInt";
+    properties.push({
+      name: "id",
+      type: PK_TYPE_MAP[pkType] ?? "number",
+      optional: false,
+      readonly: options.readonly ?? true,
+      comment: "Primary key"
+    });
+  }
+  if (schema.properties) {
+    for (const [propName, property] of Object.entries(schema.properties)) {
+      properties.push(...propertyToTSProperties(propName, property, allSchemas, options));
+    }
+  }
+  if (schema.options?.timestamps !== false) {
+    properties.push(
+      {
+        name: "createdAt",
+        type: "string",
+        optional: true,
+        readonly: options.readonly ?? true,
+        comment: "Creation timestamp"
+      },
+      {
+        name: "updatedAt",
+        type: "string",
+        optional: true,
+        readonly: options.readonly ?? true,
+        comment: "Last update timestamp"
+      }
+    );
+  }
+  if (schema.options?.softDelete) {
+    properties.push({
+      name: "deletedAt",
+      type: "string",
+      optional: true,
+      readonly: options.readonly ?? true,
+      comment: "Soft delete timestamp"
+    });
+  }
+  const schemaDisplayName = resolveDisplayName(schema.displayName, options);
+  return {
+    name: toInterfaceName(schema.name),
+    properties,
+    comment: schemaDisplayName ?? schema.name
+  };
+}
+function formatProperty(property) {
+  const readonly = property.readonly ? "readonly " : "";
+  const optional = property.optional ? "?" : "";
+  const comment = property.comment ? `  /** ${property.comment} */
+` : "";
+  return `${comment}  ${readonly}${property.name}${optional}: ${property.type};`;
+}
+function formatInterface(iface) {
+  const comment = iface.comment ? `/**
+ * ${iface.comment}
+ */
+` : "";
+  const extendsClause = iface.extends && iface.extends.length > 0 ? ` extends ${iface.extends.join(", ")}` : "";
+  const properties = iface.properties.map(formatProperty).join("\n");
+  return `${comment}export interface ${iface.name}${extendsClause} {
+${properties}
+}`;
+}
+function generateInterfaces(schemas, options = {}) {
+  const interfaces = [];
+  for (const schema of Object.values(schemas)) {
+    if (schema.kind === "enum") {
+      continue;
+    }
+    interfaces.push(schemaToInterface(schema, schemas, options));
+  }
+  return interfaces;
+}
+
+// src/enum-generator.ts
+import { resolveLocalizedString as resolveLocalizedString2 } from "@famgia/omnify-types";
+function resolveDisplayName2(value, options = {}) {
+  if (value === void 0) {
+    return void 0;
+  }
+  return resolveLocalizedString2(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 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) => parseEnumValue(value));
+  const displayName = resolveDisplayName2(schema.displayName, options);
+  return {
+    name: toEnumName(schema.name),
+    values,
+    comment: displayName ?? schema.name
+  };
+}
+function generateEnums(schemas, options = {}) {
+  const enums = [];
+  for (const schema of Object.values(schemas)) {
+    if (schema.kind === "enum") {
+      const enumDef = schemaToEnum(schema, options);
+      if (enumDef) {
+        enums.push(enumDef);
+      }
+    }
+  }
+  return enums;
+}
+function formatEnum(enumDef) {
+  const { name, values, comment } = enumDef;
+  const parts = [];
+  if (comment) {
+    parts.push(`/**
+ * ${comment}
+ */
+`);
+  }
+  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 enumToUnionType(enumDef) {
+  const type = enumDef.values.map((v) => `'${v.value}'`).join(" | ");
+  return {
+    name: enumDef.name,
+    type,
+    comment: enumDef.comment
+  };
+}
+function formatTypeAlias(alias) {
+  const { name, type, comment } = alias;
+  const parts = [];
+  if (comment) {
+    parts.push(`/**
+ * ${comment}
+ */
+`);
+  }
+  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, options = {}) {
+  const typeAliases = [];
+  for (const schema of Object.values(schemas)) {
+    if (schema.kind === "enum" || !schema.properties) {
+      continue;
+    }
+    for (const [propName, property] of Object.entries(schema.properties)) {
+      if (property.type === "Enum") {
+        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: values.map((v) => `'${v}'`).join(" | "),
+            comment: displayName ?? `${schema.name} ${propName} enum`
+          });
+        }
+      }
+      if (property.type === "Select") {
+        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: displayName ?? `${schema.name} ${propName} options`
+          });
+        }
+      }
+    }
+  }
+  return typeAliases;
+}
+
+// src/generator.ts
+var DEFAULT_OPTIONS = {
+  readonly: true,
+  strictNullChecks: true
+};
+function generateBaseHeader() {
+  return `/**
+ * Auto-generated TypeScript types from Omnify schemas.
+ * DO NOT EDIT - This file is automatically generated and will be overwritten.
+ */
+
+`;
+}
+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(`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';
+`);
+    }
+    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");
+  }
+  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 {
+    filePath: "index.ts",
+    content: parts.join(""),
+    types: [],
+    overwrite: true
+  };
+}
+function generateTypeScript(schemas, options = {}) {
+  const opts = { ...DEFAULT_OPTIONS, ...options };
+  const files = [];
+  const enums = generateEnums(schemas);
+  for (const enumDef of enums) {
+    files.push(generateEnumFile(enumDef));
+  }
+  const typeAliases = extractInlineEnums(schemas);
+  for (const alias of typeAliases) {
+    files.push(generateTypeAliasFile(alias));
+  }
+  for (const schema of Object.values(schemas)) {
+    if (schema.kind === "enum") continue;
+    files.push(generateBaseInterfaceFile(schema.name, schemas, opts));
+  }
+  for (const schema of Object.values(schemas)) {
+    if (schema.kind === "enum") continue;
+    files.push(generateModelFile(schema.name));
+  }
+  files.push(generateIndexFile(schemas, enums, typeAliases));
+  return files;
+}
+
+export {
+  toPropertyName,
+  toInterfaceName,
+  getPropertyType,
+  propertyToTSProperty,
+  schemaToInterface,
+  formatProperty,
+  formatInterface,
+  generateInterfaces,
+  toEnumMemberName,
+  toEnumName,
+  schemaToEnum,
+  generateEnums,
+  formatEnum,
+  enumToUnionType,
+  formatTypeAlias,
+  extractInlineEnums,
+  generateTypeScript
+};
+//# sourceMappingURL=chunk-J46F3EBS.js.map