@famgia/omnify-laravel 0.0.1

package/dist/index.cjs

@@ -0,0 +1,959 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  enumToUnionType: () => enumToUnionType,
+  extractInlineEnums: () => extractInlineEnums,
+  formatColumnMethod: () => formatColumnMethod,
+  formatEnum: () => formatEnum,
+  formatForeignKey: () => formatForeignKey,
+  formatIndex: () => formatIndex,
+  formatInterface: () => formatInterface,
+  formatMigrationFile: () => formatMigrationFile,
+  formatProperty: () => formatProperty,
+  formatTypeAlias: () => formatTypeAlias,
+  generateDropMigrationForTable: () => generateDropMigrationForTable,
+  generateEnums: () => generateEnums,
+  generateForeignKey: () => generateForeignKey,
+  generateInterfaces: () => generateInterfaces,
+  generateMigrationFromSchema: () => generateMigrationFromSchema,
+  generateMigrations: () => generateMigrations,
+  generatePrimaryKeyColumn: () => generatePrimaryKeyColumn,
+  generateSoftDeleteColumn: () => generateSoftDeleteColumn,
+  generateTimestampColumns: () => generateTimestampColumns,
+  generateTypeScript: () => generateTypeScript,
+  generateTypeScriptFile: () => generateTypeScriptFile,
+  generateTypeScriptFiles: () => generateTypeScriptFiles,
+  getMigrationPath: () => getMigrationPath,
+  getPropertyType: () => getPropertyType,
+  getTypeScriptPath: () => getTypeScriptPath,
+  propertyToColumnMethod: () => propertyToColumnMethod,
+  propertyToTSProperty: () => propertyToTSProperty,
+  schemaToBlueprint: () => schemaToBlueprint,
+  schemaToEnum: () => schemaToEnum,
+  schemaToInterface: () => schemaToInterface,
+  toColumnName: () => toColumnName,
+  toEnumMemberName: () => toEnumMemberName,
+  toEnumName: () => toEnumName,
+  toInterfaceName: () => toInterfaceName,
+  toPropertyName: () => toPropertyName,
+  toTableName: () => toTableName
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/migration/schema-builder.ts
+var TYPE_METHOD_MAP = {
+  String: "string",
+  Int: "integer",
+  BigInt: "bigInteger",
+  Float: "double",
+  Boolean: "boolean",
+  Text: "text",
+  LongText: "longText",
+  Date: "date",
+  Time: "time",
+  Timestamp: "timestamp",
+  Json: "json",
+  Email: "string",
+  Password: "string",
+  File: "string",
+  MultiFile: "json",
+  Enum: "enum",
+  Select: "string",
+  Lookup: "unsignedBigInteger"
+};
+var PK_METHOD_MAP = {
+  Int: "increments",
+  BigInt: "bigIncrements",
+  Uuid: "uuid",
+  String: "string"
+};
+function toColumnName(propertyName) {
+  return propertyName.replace(/([A-Z])/g, "_$1").toLowerCase().replace(/^_/, "");
+}
+function toTableName(schemaName) {
+  const snakeCase = schemaName.replace(/([A-Z])/g, "_$1").toLowerCase().replace(/^_/, "");
+  if (snakeCase.endsWith("y")) {
+    return snakeCase.slice(0, -1) + "ies";
+  } else if (snakeCase.endsWith("s") || snakeCase.endsWith("x") || snakeCase.endsWith("ch") || snakeCase.endsWith("sh")) {
+    return snakeCase + "es";
+  } else {
+    return snakeCase + "s";
+  }
+}
+function propertyToColumnMethod(propertyName, property) {
+  if (property.type === "Association") {
+    return null;
+  }
+  const columnName = toColumnName(propertyName);
+  const method = TYPE_METHOD_MAP[property.type] ?? "string";
+  const args = [columnName];
+  const modifiers = [];
+  const propWithLength = property;
+  if (method === "string" && propWithLength.length) {
+    args.push(propWithLength.length);
+  }
+  if (property.type === "Enum") {
+    const enumProp = property;
+    if (enumProp.enum && enumProp.enum.length > 0) {
+      args.push(enumProp.enum);
+    }
+  }
+  const baseProp = property;
+  if (baseProp.nullable) {
+    modifiers.push({ method: "nullable" });
+  }
+  if (baseProp.unique) {
+    modifiers.push({ method: "unique" });
+  }
+  if (baseProp.default !== void 0) {
+    const defaultValue = typeof baseProp.default === "string" ? baseProp.default : JSON.stringify(baseProp.default);
+    modifiers.push({ method: "default", args: [defaultValue] });
+  }
+  if (baseProp.unsigned && (method === "integer" || method === "bigInteger")) {
+    modifiers.push({ method: "unsigned" });
+  }
+  return {
+    name: columnName,
+    method,
+    args,
+    modifiers
+  };
+}
+function generatePrimaryKeyColumn(pkType = "BigInt") {
+  const method = PK_METHOD_MAP[pkType] ?? "bigIncrements";
+  if (pkType === "Uuid") {
+    return {
+      name: "id",
+      method: "uuid",
+      args: ["id"],
+      modifiers: [{ method: "primary" }]
+    };
+  }
+  if (pkType === "String") {
+    return {
+      name: "id",
+      method: "string",
+      args: ["id", 255],
+      modifiers: [{ method: "primary" }]
+    };
+  }
+  return {
+    name: "id",
+    method,
+    args: ["id"],
+    modifiers: []
+  };
+}
+function generateTimestampColumns() {
+  return [
+    {
+      name: "created_at",
+      method: "timestamp",
+      args: ["created_at"],
+      modifiers: [{ method: "nullable" }]
+    },
+    {
+      name: "updated_at",
+      method: "timestamp",
+      args: ["updated_at"],
+      modifiers: [{ method: "nullable" }]
+    }
+  ];
+}
+function generateSoftDeleteColumn() {
+  return {
+    name: "deleted_at",
+    method: "timestamp",
+    args: ["deleted_at"],
+    modifiers: [{ method: "nullable" }]
+  };
+}
+function generateForeignKey(propertyName, property, allSchemas) {
+  if (property.type !== "Association") {
+    return null;
+  }
+  const assocProp = property;
+  if (assocProp.relation !== "ManyToOne" && assocProp.relation !== "OneToOne") {
+    return null;
+  }
+  const columnName = toColumnName(propertyName) + "_id";
+  const targetSchema = assocProp.target ? allSchemas[assocProp.target] : void 0;
+  const targetTable = assocProp.target ? toTableName(assocProp.target) : "unknown";
+  const targetPkType = targetSchema?.options?.primaryKeyType ?? "BigInt";
+  let method = "unsignedBigInteger";
+  if (targetPkType === "Int") {
+    method = "unsignedInteger";
+  } else if (targetPkType === "Uuid") {
+    method = "uuid";
+  } else if (targetPkType === "String") {
+    method = "string";
+  }
+  const column = {
+    name: columnName,
+    method,
+    args: [columnName],
+    modifiers: assocProp.relation === "ManyToOne" ? [{ method: "nullable" }] : []
+  };
+  const foreignKey = {
+    columns: [columnName],
+    references: "id",
+    on: [targetTable],
+    onDelete: assocProp.onDelete ?? "restrict",
+    onUpdate: assocProp.onUpdate ?? "cascade"
+  };
+  const index = {
+    name: `idx_${columnName}`,
+    columns: [columnName],
+    unique: false
+  };
+  return { column, foreignKey, index };
+}
+function schemaToBlueprint(schema, allSchemas) {
+  const tableName = toTableName(schema.name);
+  const columns = [];
+  const foreignKeys = [];
+  const indexes = [];
+  const pkType = schema.options?.primaryKeyType ?? "BigInt";
+  columns.push(generatePrimaryKeyColumn(pkType));
+  if (schema.properties) {
+    for (const [propName, property] of Object.entries(schema.properties)) {
+      const columnMethod = propertyToColumnMethod(propName, property);
+      if (columnMethod) {
+        columns.push(columnMethod);
+      }
+      const fkResult = generateForeignKey(propName, property, allSchemas);
+      if (fkResult) {
+        columns.push(fkResult.column);
+        foreignKeys.push(fkResult.foreignKey);
+        indexes.push(fkResult.index);
+      }
+    }
+  }
+  if (schema.options?.timestamps !== false) {
+    columns.push(...generateTimestampColumns());
+  }
+  if (schema.options?.softDelete) {
+    columns.push(generateSoftDeleteColumn());
+  }
+  if (schema.options?.indexes) {
+    for (const index of schema.options.indexes) {
+      indexes.push({
+        name: index.name,
+        columns: index.columns.map(toColumnName),
+        unique: index.unique ?? false
+      });
+    }
+  }
+  if (schema.options?.unique) {
+    const uniqueConstraints = Array.isArray(schema.options.unique[0]) ? schema.options.unique : [schema.options.unique];
+    for (const constraint of uniqueConstraints) {
+      indexes.push({
+        columns: constraint.map(toColumnName),
+        unique: true
+      });
+    }
+  }
+  return {
+    tableName,
+    columns,
+    primaryKey: ["id"],
+    foreignKeys,
+    indexes
+  };
+}
+function formatColumnMethod(column) {
+  const args = column.args.map((arg) => {
+    if (typeof arg === "string") {
+      return `'${arg}'`;
+    }
+    if (Array.isArray(arg)) {
+      return `[${arg.map((v) => `'${v}'`).join(", ")}]`;
+    }
+    return String(arg);
+  }).join(", ");
+  let code = `$table->${column.method}(${args})`;
+  for (const modifier of column.modifiers) {
+    if (modifier.args && modifier.args.length > 0) {
+      const modArgs = modifier.args.map((arg) => {
+        if (typeof arg === "string") {
+          return `'${arg}'`;
+        }
+        return String(arg);
+      }).join(", ");
+      code += `->${modifier.method}(${modArgs})`;
+    } else {
+      code += `->${modifier.method}()`;
+    }
+  }
+  return code + ";";
+}
+function formatForeignKey(fk) {
+  const column = fk.columns[0];
+  const table = fk.on[0];
+  let code = `$table->foreign('${column}')->references('${fk.references}')->on('${table}')`;
+  if (fk.onDelete) {
+    code += `->onDelete('${fk.onDelete}')`;
+  }
+  if (fk.onUpdate) {
+    code += `->onUpdate('${fk.onUpdate}')`;
+  }
+  return code + ";";
+}
+function formatIndex(index) {
+  const columns = index.columns.length === 1 ? `'${index.columns[0]}'` : `[${index.columns.map((c) => `'${c}'`).join(", ")}]`;
+  const method = index.unique ? "unique" : "index";
+  const name = index.name ? `, '${index.name}'` : "";
+  return `$table->${method}(${columns}${name});`;
+}
+
+// src/migration/generator.ts
+function generateTimestamp() {
+  const now = /* @__PURE__ */ new Date();
+  const year = now.getFullYear();
+  const month = String(now.getMonth() + 1).padStart(2, "0");
+  const day = String(now.getDate()).padStart(2, "0");
+  const hours = String(now.getHours()).padStart(2, "0");
+  const minutes = String(now.getMinutes()).padStart(2, "0");
+  const seconds = String(now.getSeconds()).padStart(2, "0");
+  return `${year}_${month}_${day}_${hours}${minutes}${seconds}`;
+}
+function toClassName(tableName, type) {
+  const pascalCase = tableName.split("_").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join("");
+  switch (type) {
+    case "create":
+      return `Create${pascalCase}Table`;
+    case "alter":
+      return `Alter${pascalCase}Table`;
+    case "drop":
+      return `Drop${pascalCase}Table`;
+  }
+}
+function generateFileName(tableName, type, timestamp) {
+  const ts = timestamp ?? generateTimestamp();
+  const action = type === "create" ? "create" : type === "drop" ? "drop" : "update";
+  return `${ts}_${action}_${tableName}_table.php`;
+}
+function renderCreateTableUp(blueprint) {
+  const lines = [];
+  for (const column of blueprint.columns) {
+    lines.push(`            ${formatColumnMethod(column)}`);
+  }
+  return lines.join("\n");
+}
+function renderForeignKeys(blueprint) {
+  if (blueprint.foreignKeys.length === 0) {
+    return "";
+  }
+  const lines = blueprint.foreignKeys.map((fk) => `            ${formatForeignKey(fk)}`);
+  return "\n" + lines.join("\n");
+}
+function renderIndexes(blueprint) {
+  const customIndexes = blueprint.indexes.filter((idx) => {
+    if (idx.unique && idx.columns.length === 1) {
+      return false;
+    }
+    return true;
+  });
+  if (customIndexes.length === 0) {
+    return "";
+  }
+  const lines = customIndexes.map((idx) => `            ${formatIndex(idx)}`);
+  return "\n" + lines.join("\n");
+}
+function generateCreateMigration(blueprint, options = {}) {
+  const className = toClassName(blueprint.tableName, "create");
+  const fileName = generateFileName(blueprint.tableName, "create", options.timestamp);
+  const connection = options.connection ? `
+    protected $connection = '${options.connection}';
+` : "";
+  const upContent = renderCreateTableUp(blueprint);
+  const foreignKeyContent = renderForeignKeys(blueprint);
+  const indexContent = renderIndexes(blueprint);
+  const content = `<?php
+
+use Illuminate\\Database\\Migrations\\Migration;
+use Illuminate\\Database\\Schema\\Blueprint;
+use Illuminate\\Support\\Facades\\Schema;
+
+return new class extends Migration
+{${connection}
+    /**
+     * Run the migrations.
+     */
+    public function up(): void
+    {
+        Schema::create('${blueprint.tableName}', function (Blueprint $table) {
+${upContent}${foreignKeyContent}${indexContent}
+        });
+    }
+
+    /**
+     * Reverse the migrations.
+     */
+    public function down(): void
+    {
+        Schema::dropIfExists('${blueprint.tableName}');
+    }
+};
+`;
+  return {
+    fileName,
+    className,
+    content,
+    tables: [blueprint.tableName],
+    type: "create"
+  };
+}
+function generateDropMigration(tableName, options = {}) {
+  const className = toClassName(tableName, "drop");
+  const fileName = generateFileName(tableName, "drop", options.timestamp);
+  const connection = options.connection ? `
+    protected $connection = '${options.connection}';
+` : "";
+  const content = `<?php
+
+use Illuminate\\Database\\Migrations\\Migration;
+use Illuminate\\Database\\Schema\\Blueprint;
+use Illuminate\\Support\\Facades\\Schema;
+
+return new class extends Migration
+{${connection}
+    /**
+     * Run the migrations.
+     */
+    public function up(): void
+    {
+        Schema::dropIfExists('${tableName}');
+    }
+
+    /**
+     * Reverse the migrations.
+     */
+    public function down(): void
+    {
+        // Cannot recreate table without schema information
+        // This is a one-way migration
+    }
+};
+`;
+  return {
+    fileName,
+    className,
+    content,
+    tables: [tableName],
+    type: "drop"
+  };
+}
+function generateMigrations(schemas, options = {}) {
+  const migrations = [];
+  let timestampOffset = 0;
+  for (const schema of Object.values(schemas)) {
+    if (schema.kind === "enum") {
+      continue;
+    }
+    const timestamp = options.timestamp ?? generateTimestamp();
+    const offsetTimestamp = incrementTimestamp(timestamp, timestampOffset);
+    timestampOffset++;
+    const blueprint = schemaToBlueprint(schema, schemas);
+    const migration = generateCreateMigration(blueprint, {
+      ...options,
+      timestamp: offsetTimestamp
+    });
+    migrations.push(migration);
+  }
+  return migrations;
+}
+function incrementTimestamp(timestamp, seconds) {
+  if (seconds === 0) return timestamp;
+  const parts = timestamp.split("_");
+  if (parts.length < 4) {
+    return timestamp;
+  }
+  const yearPart = parts[0] ?? "2024";
+  const monthPart = parts[1] ?? "01";
+  const dayPart = parts[2] ?? "01";
+  const timePart = parts[3] ?? "000000";
+  const year = parseInt(yearPart, 10);
+  const month = parseInt(monthPart, 10) - 1;
+  const day = parseInt(dayPart, 10);
+  const hours = parseInt(timePart.substring(0, 2), 10);
+  const minutes = parseInt(timePart.substring(2, 4), 10);
+  const secs = parseInt(timePart.substring(4, 6), 10);
+  const date = new Date(year, month, day, hours, minutes, secs + seconds);
+  const newYear = date.getFullYear();
+  const newMonth = String(date.getMonth() + 1).padStart(2, "0");
+  const newDay = String(date.getDate()).padStart(2, "0");
+  const newHours = String(date.getHours()).padStart(2, "0");
+  const newMinutes = String(date.getMinutes()).padStart(2, "0");
+  const newSecs = String(date.getSeconds()).padStart(2, "0");
+  return `${newYear}_${newMonth}_${newDay}_${newHours}${newMinutes}${newSecs}`;
+}
+function generateMigrationFromSchema(schema, allSchemas, options = {}) {
+  const blueprint = schemaToBlueprint(schema, allSchemas);
+  return generateCreateMigration(blueprint, options);
+}
+function generateDropMigrationForTable(tableName, options = {}) {
+  return generateDropMigration(tableName, options);
+}
+function formatMigrationFile(migration) {
+  return migration.content;
+}
+function getMigrationPath(migration, outputDir = "database/migrations") {
+  return `${outputDir}/${migration.fileName}`;
+}
+
+// src/typescript/interface-generator.ts
+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",
+  File: "string",
+  MultiFile: "string[]",
+  Enum: "string",
+  Select: "string",
+  Lookup: "number"
+};
+var PK_TYPE_MAP = {
+  Int: "number",
+  BigInt: "number",
+  Uuid: "string",
+  String: "string"
+};
+function toPropertyName(name) {
+  return name;
+}
+function toInterfaceName(schemaName) {
+  return schemaName;
+}
+function getPropertyType(property, _allSchemas) {
+  if (property.type === "Association") {
+    const assocProp = property;
+    const targetName = assocProp.target ?? "unknown";
+    switch (assocProp.relation) {
+      case "OneToOne":
+      case "ManyToOne":
+        return targetName;
+      case "OneToMany":
+      case "ManyToMany":
+        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 propertyToTSProperty(propertyName, property, allSchemas, options = {}) {
+  const type = getPropertyType(property, allSchemas);
+  const baseProp = property;
+  return {
+    name: toPropertyName(propertyName),
+    type,
+    optional: baseProp.nullable ?? false,
+    readonly: options.readonly ?? true,
+    comment: baseProp.displayName
+  };
+}
+function schemaToInterface(schema, allSchemas, options = {}) {
+  const properties = [];
+  const pkType = schema.options?.primaryKeyType ?? "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(propertyToTSProperty(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"
+    });
+  }
+  return {
+    name: toInterfaceName(schema.name),
+    properties,
+    comment: schema.displayName ?? 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/typescript/enum-generator.ts
+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) {
+  if (schema.kind !== "enum" || !schema.values) {
+    return null;
+  }
+  const values = schema.values.map((value) => ({
+    name: toEnumMemberName(value),
+    value
+  }));
+  return {
+    name: toEnumName(schema.name),
+    values,
+    comment: schema.displayName ?? schema.name
+  };
+}
+function generateEnums(schemas) {
+  const enums = [];
+  for (const schema of Object.values(schemas)) {
+    if (schema.kind === "enum") {
+      const enumDef = schemaToEnum(schema);
+      if (enumDef) {
+        enums.push(enumDef);
+      }
+    }
+  }
+  return enums;
+}
+function formatEnum(enumDef) {
+  const comment = enumDef.comment ? `/**
+ * ${enumDef.comment}
+ */
+` : "";
+  const values = enumDef.values.map((v) => `  ${v.name} = '${v.value}',`).join("\n");
+  return `${comment}export enum ${enumDef.name} {
+${values}
+}`;
+}
+function enumToUnionType(enumDef) {
+  const type = enumDef.values.map((v) => `'${v.value}'`).join(" | ");
+  return {
+    name: enumDef.name,
+    type,
+    comment: enumDef.comment
+  };
+}
+function formatTypeAlias(alias) {
+  const comment = alias.comment ? `/**
+ * ${alias.comment}
+ */
+` : "";
+  return `${comment}export type ${alias.name} = ${alias.type};`;
+}
+function extractInlineEnums(schemas) {
+  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)}`;
+          typeAliases.push({
+            name: typeName,
+            type: enumProp.enum.map((v) => `'${v}'`).join(" | "),
+            comment: enumProp.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)}`;
+          typeAliases.push({
+            name: typeName,
+            type: selectProp.options.map((v) => `'${v}'`).join(" | "),
+            comment: selectProp.displayName ?? `${schema.name} ${propName} options`
+          });
+        }
+      }
+    }
+  }
+  return typeAliases;
+}
+
+// src/typescript/generator.ts
+var DEFAULT_OPTIONS = {
+  singleFile: true,
+  fileName: "types.ts",
+  readonly: true,
+  strictNullChecks: true
+};
+function generateHeader() {
+  return `/**
+ * Auto-generated TypeScript types from Omnify schemas.
+ * DO NOT EDIT - This file is automatically generated.
+ */
+
+`;
+}
+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");
+    for (const enumDef of enums) {
+      parts.push(formatEnum(enumDef));
+      parts.push("\n\n");
+      types.push(enumDef.name);
+    }
+  }
+  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);
+    }
+  }
+  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);
+    }
+  }
+  return {
+    fileName: opts.fileName ?? "types.ts",
+    content: parts.join("").trim() + "\n",
+    types
+  };
+}
+function generateTypeScriptFiles(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)
+    });
+  }
+  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 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}';`);
+  }
+  return exports2.join("\n") + "\n";
+}
+function generateTypeScript(schemas, options = {}) {
+  const opts = { ...DEFAULT_OPTIONS, ...options };
+  if (opts.singleFile) {
+    return [generateTypeScriptFile(schemas, opts)];
+  }
+  return generateTypeScriptFiles(schemas, opts);
+}
+function getTypeScriptPath(file, outputDir = "src/types") {
+  return `${outputDir}/${file.fileName}`;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  enumToUnionType,
+  extractInlineEnums,
+  formatColumnMethod,
+  formatEnum,
+  formatForeignKey,
+  formatIndex,
+  formatInterface,
+  formatMigrationFile,
+  formatProperty,
+  formatTypeAlias,
+  generateDropMigrationForTable,
+  generateEnums,
+  generateForeignKey,
+  generateInterfaces,
+  generateMigrationFromSchema,
+  generateMigrations,
+  generatePrimaryKeyColumn,
+  generateSoftDeleteColumn,
+  generateTimestampColumns,
+  generateTypeScript,
+  generateTypeScriptFile,
+  generateTypeScriptFiles,
+  getMigrationPath,
+  getPropertyType,
+  getTypeScriptPath,
+  propertyToColumnMethod,
+  propertyToTSProperty,
+  schemaToBlueprint,
+  schemaToEnum,
+  schemaToInterface,
+  toColumnName,
+  toEnumMemberName,
+  toEnumName,
+  toInterfaceName,
+  toPropertyName,
+  toTableName
+});
+//# sourceMappingURL=index.cjs.map