migratex 1.0.0 → 1.2.0

package/README.md

@@ -1,10 +1,10 @@
-# migratex
+# Migratex
 
-a schema diff and migration engine that sits on top of your ORM. it treats database changes like a graph — not a numbered list — enabling deterministic migrations, drift detection, and safe CI/CD workflows.
+A schema diff and migration engine that sits on top of your ORM. it treats database changes like a graph not a numbered list enabling deterministic migrations, drift detection, and safe CI/CD workflows.
 
-works with **drizzle**, **prisma**, and **typeorm**. supports **postgres** (mysql coming soon).
+works with **drizzle**, **prisma**, and **typeorm**. supports **postgres** and **mysql**.
 
-## why
+## Why
 
 every ORM handles migrations the same way: numbered files in a folder. `001_create_users.sql`, `002_add_posts.sql`, and so on. works fine solo. put a team on it and two devs on different branches will both create `004_*.sql`, someone has to manually rename theirs, and you pray the SQL doesn't conflict. at scale this is a constant source of broken deploys, merge pain, and wasted time.
 
@@ -56,16 +56,20 @@ npm install migratex
 ```bash
 $ migratex init
 
-? ORM: drizzle
-? Dialect: pg
-? Schema path: ./src/schema.ts
-? Connection: postgresql://user:pass@localhost:5432/mydb
-? Migrations dir: ./migrations
+Initializing migratex...
+
+Detected ORM: drizzle              # or prisma, typeorm — auto-detected from package.json
+Detected database: pg (from drizzle config)
+Schema path [./db/schema]:
 
 Created migratex.config.yaml
 Created migrations/
+
+migratex will read the database connection from your drizzle config at runtime.
 ```
 
+no connection setup needed — migratex auto-detects your ORM from `package.json`, reads the dialect from your ORM config (`drizzle.config.ts`, `schema.prisma`, `ormconfig.json`), and uses the same env vars your ORM already uses for the database connection.
+
 ### generate
 
 change your ORM schema, then:
@@ -178,11 +182,12 @@ each migration node has:
 # migratex.config.yaml
 orm: drizzle          # drizzle | prisma | typeorm
 dialect: pg           # pg | mysql
-connection: postgresql://user:pass@localhost:5432/mydb
-schemaPath: ./src/schema.ts
+schemaPath: ./db/schema
 migrationsDir: ./migrations
 ```
 
+no connection field needed — migratex reads it from your ORM's config at runtime. it checks `drizzle.config.ts`, `schema.prisma`, or `ormconfig.json` and uses the same env vars your ORM already uses (`DATABASE_URL`, `PGHOST`, etc.).
+
 ## license
 
 MIT

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "migratex",
-  "version": "1.0.0",
+  "version": "1.2.0",
   "description": "Schema diff and migration engine for ORMs (Drizzle, Prisma, TypeORM)",
   "license": "MIT",
   "repository": {
@@ -15,7 +15,8 @@
   },
   "files": [
     "bin/migratex.js",
-    "install.js"
+    "install.js",
+    "sidecar/dist/"
   ],
   "keywords": [
     "migrations",

package/sidecar/dist/bin/migratex-export.js

@@ -0,0 +1,514 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/drizzle.ts
+var drizzle_exports = {};
+__export(drizzle_exports, {
+  exportDrizzleSchema: () => exportDrizzleSchema
+});
+async function exportDrizzleSchema(schemaPath, dialect) {
+  const schemaModule = await import(schemaPath);
+  const tables = [];
+  const enumSet = /* @__PURE__ */ new Map();
+  for (const [, value] of Object.entries(schemaModule)) {
+    if (!isDrizzleTable(value)) continue;
+    const table = extractTable(value, dialect, enumSet);
+    if (table) tables.push(table);
+  }
+  return {
+    dialect,
+    tables,
+    enums: Array.from(enumSet.entries()).map(([name, values]) => ({
+      name,
+      values
+    }))
+  };
+}
+function isDrizzleTable(obj) {
+  return obj !== null && typeof obj === "object" && (DrizzleSymbols.IsDrizzleTable in obj || DrizzleSymbols.Columns in obj);
+}
+function extractTable(tableObj, dialect, enumSet) {
+  const tableName = tableObj[DrizzleSymbols.Name] || tableObj[DrizzleSymbols.BaseName];
+  if (!tableName) return null;
+  const drizzleColumns = tableObj[DrizzleSymbols.Columns];
+  if (!drizzleColumns) return null;
+  const columns = [];
+  const pkColumns = [];
+  const indexes = [];
+  const foreignKeys = [];
+  for (const [colName, colDef] of Object.entries(drizzleColumns)) {
+    const column = extractColumn(colName, colDef, dialect, enumSet);
+    columns.push(column);
+    if (colDef.primary || colDef.primaryKey) {
+      pkColumns.push(colName);
+    }
+  }
+  if (typeof tableObj.getSQL === "function") {
+  }
+  const table = {
+    name: tableName,
+    columns,
+    indexes,
+    foreignKeys
+  };
+  if (pkColumns.length > 0) {
+    table.primaryKey = { columns: pkColumns };
+  }
+  return table;
+}
+function extractColumn(name, colDef, dialect, enumSet) {
+  const colType = mapDrizzleType(colDef, dialect, enumSet);
+  const column = {
+    name: colDef.name || name,
+    type: colType,
+    nullable: colDef.notNull !== true
+  };
+  if (colDef.hasDefault && colDef.default !== void 0) {
+    if (typeof colDef.default === "function") {
+      column.default = { kind: "expression", value: String(colDef.default) };
+    } else {
+      column.default = { kind: "value", value: String(colDef.default) };
+    }
+  }
+  if (colDef.isUnique) {
+    column.unique = true;
+  }
+  return column;
+}
+function mapDrizzleType(colDef, dialect, enumSet) {
+  const dataType = (colDef.dataType || colDef.columnType || colDef.getSQLType?.() || "").toLowerCase();
+  const sqlName = (colDef.sqlName || "").toLowerCase();
+  if (dataType.includes("serial") || sqlName.includes("serial")) {
+    if (dataType.includes("bigserial") || sqlName.includes("bigserial")) {
+      return { kind: "serial", size: "bigserial" };
+    }
+    if (dataType.includes("smallserial") || sqlName.includes("smallserial")) {
+      return { kind: "serial", size: "smallserial" };
+    }
+    return { kind: "serial" };
+  }
+  if (dataType === "number" || dataType === "integer" || sqlName.includes("int")) {
+    if (sqlName.includes("bigint") || dataType.includes("bigint")) {
+      return { kind: "int", size: "bigint" };
+    }
+    if (sqlName.includes("smallint") || dataType.includes("smallint")) {
+      return { kind: "int", size: "smallint" };
+    }
+    return { kind: "int" };
+  }
+  if (dataType === "string" || sqlName.includes("text") || sqlName.includes("varchar")) {
+    const length = colDef.length || colDef.config?.length;
+    return { kind: "text", ...length ? { length } : {} };
+  }
+  if (dataType === "boolean" || sqlName.includes("bool")) {
+    return { kind: "boolean" };
+  }
+  if (sqlName.includes("timestamp") || dataType.includes("timestamp")) {
+    return {
+      kind: "timestamp",
+      withTimezone: sqlName.includes("tz") || colDef.withTimezone === true
+    };
+  }
+  if (sqlName === "date" || dataType === "date") {
+    return { kind: "date" };
+  }
+  if (sqlName.includes("json")) {
+    return { kind: "json", binary: sqlName === "jsonb" };
+  }
+  if (sqlName === "uuid" || dataType === "uuid") {
+    return { kind: "uuid" };
+  }
+  if (sqlName.includes("real") || sqlName.includes("float")) {
+    return { kind: "float" };
+  }
+  if (sqlName.includes("double")) {
+    return { kind: "float", size: "double" };
+  }
+  if (sqlName.includes("numeric") || sqlName.includes("decimal")) {
+    return {
+      kind: "decimal",
+      precision: colDef.precision,
+      scale: colDef.scale
+    };
+  }
+  if (colDef.enumValues && Array.isArray(colDef.enumValues)) {
+    const enumName = colDef.enumName || colDef.name || "unknown_enum";
+    enumSet.set(enumName, colDef.enumValues);
+    return { kind: "enum", enumName };
+  }
+  return { kind: "custom", raw: sqlName || dataType || "unknown" };
+}
+var DrizzleSymbols;
+var init_drizzle = __esm({
+  "src/drizzle.ts"() {
+    "use strict";
+    DrizzleSymbols = {
+      Columns: /* @__PURE__ */ Symbol.for("drizzle:Columns"),
+      Name: /* @__PURE__ */ Symbol.for("drizzle:Name"),
+      Schema: /* @__PURE__ */ Symbol.for("drizzle:Schema"),
+      IsDrizzleTable: /* @__PURE__ */ Symbol.for("drizzle:IsDrizzleTable"),
+      BaseName: /* @__PURE__ */ Symbol.for("drizzle:BaseName")
+    };
+  }
+});
+
+// src/prisma.ts
+var prisma_exports = {};
+__export(prisma_exports, {
+  exportPrismaSchema: () => exportPrismaSchema
+});
+async function exportPrismaSchema(schemaPath) {
+  let getDMMF;
+  try {
+    const internals = await import("@prisma/internals");
+    getDMMF = internals.getDMMF;
+  } catch {
+    throw new Error(
+      "Cannot find @prisma/internals. Install it: npm install @prisma/internals"
+    );
+  }
+  const { readFileSync } = await import("fs");
+  const datamodel = readFileSync(schemaPath, "utf-8");
+  const dialect = detectDialect(datamodel);
+  const dmmf = await getDMMF({ datamodel });
+  const tables = [];
+  const enums = [];
+  for (const model of dmmf.datamodel.models) {
+    tables.push(convertModel(model, dmmf.datamodel.models, dialect));
+  }
+  for (const enumDef of dmmf.datamodel.enums) {
+    enums.push({
+      name: enumDef.name,
+      values: enumDef.values.map((v) => v.name)
+    });
+  }
+  return { dialect, tables, enums };
+}
+function detectDialect(datamodel) {
+  const match = datamodel.match(/provider\s*=\s*"(\w+)"/);
+  if (match) {
+    const provider = match[1].toLowerCase();
+    if (provider === "mysql") return "mysql";
+  }
+  return "pg";
+}
+function convertModel(model, allModels, dialect) {
+  const columns = [];
+  const foreignKeys = [];
+  const indexes = [];
+  const pkColumns = [];
+  for (const field of model.fields) {
+    if (field.kind === "object") continue;
+    const column = convertField(field, dialect);
+    columns.push(column);
+    if (field.isId) {
+      pkColumns.push(field.name);
+    }
+  }
+  for (const field of model.fields) {
+    if (field.kind === "object" && field.relationFromFields?.length > 0) {
+      const fk = {
+        name: `fk_${model.name.toLowerCase()}_${field.name}`,
+        columns: field.relationFromFields,
+        referencedTable: field.type.toLowerCase(),
+        referencedColumns: field.relationToFields || ["id"],
+        onDelete: mapPrismaAction(field.relationOnDelete),
+        onUpdate: mapPrismaAction(field.relationOnUpdate)
+      };
+      foreignKeys.push(fk);
+    }
+  }
+  if (model.uniqueFields) {
+    for (const fields of model.uniqueFields) {
+      indexes.push({
+        name: `${model.name.toLowerCase()}_${fields.join("_")}_unique`,
+        columns: fields,
+        unique: true
+      });
+    }
+  }
+  const table = {
+    // Prisma uses PascalCase model names; DB uses snake_case
+    // The @@map attribute overrides this, but dbName captures it
+    name: model.dbName || model.name.toLowerCase(),
+    columns,
+    indexes,
+    foreignKeys
+  };
+  if (pkColumns.length > 0) {
+    table.primaryKey = { columns: pkColumns };
+  }
+  return table;
+}
+function convertField(field, dialect) {
+  return {
+    name: field.dbName || field.name,
+    type: mapPrismaType(field, dialect),
+    nullable: !field.isRequired,
+    ...field.hasDefaultValue && field.default !== void 0 ? { default: parsePrismaDefault(field.default) } : {},
+    ...field.isId ? { primaryKey: true } : {},
+    ...field.isUnique ? { unique: true } : {}
+  };
+}
+function mapPrismaType(field, dialect) {
+  const nativeType = field.nativeType;
+  switch (field.type) {
+    case "Int":
+      if (nativeType) {
+        if (nativeType[0] === "SmallInt") return { kind: "int", size: "smallint" };
+        if (nativeType[0] === "BigInt") return { kind: "int", size: "bigint" };
+      }
+      return { kind: "int" };
+    case "BigInt":
+      return { kind: "int", size: "bigint" };
+    case "Float":
+      return { kind: "float", size: "double" };
+    case "Decimal":
+      return {
+        kind: "decimal",
+        precision: nativeType?.[1]?.precision || 65,
+        scale: nativeType?.[1]?.scale || 30
+      };
+    case "String":
+      if (nativeType?.[0] === "VarChar") {
+        return { kind: "text", length: nativeType[1]?.length || 255 };
+      }
+      return { kind: "text" };
+    case "Boolean":
+      return { kind: "boolean" };
+    case "DateTime":
+      return { kind: "timestamp", withTimezone: dialect === "pg" };
+    case "Json":
+      return { kind: "json", binary: dialect === "pg" };
+    case "Bytes":
+      return { kind: "bytea" };
+    default:
+      if (field.kind === "enum") {
+        return { kind: "enum", enumName: field.type };
+      }
+      return { kind: "custom", raw: field.type };
+  }
+}
+function parsePrismaDefault(def) {
+  if (typeof def === "object" && def.name) {
+    return { kind: "expression", value: `${def.name}()` };
+  }
+  return { kind: "value", value: String(def) };
+}
+function mapPrismaAction(action) {
+  if (!action) return void 0;
+  const map = {
+    Cascade: "CASCADE",
+    SetNull: "SET NULL",
+    SetDefault: "SET DEFAULT",
+    Restrict: "RESTRICT",
+    NoAction: "NO ACTION"
+  };
+  return map[action];
+}
+var init_prisma = __esm({
+  "src/prisma.ts"() {
+    "use strict";
+  }
+});
+
+// src/typeorm.ts
+var typeorm_exports = {};
+__export(typeorm_exports, {
+  exportTypeORMSchema: () => exportTypeORMSchema
+});
+async function exportTypeORMSchema(schemaPath, dialect) {
+  let getMetadataArgsStorage;
+  try {
+    const typeorm = await import("typeorm");
+    getMetadataArgsStorage = typeorm.getMetadataArgsStorage;
+  } catch {
+    throw new Error("Cannot find typeorm. Install it: npm install typeorm reflect-metadata");
+  }
+  await import(schemaPath);
+  const storage = getMetadataArgsStorage();
+  const tables = [];
+  for (const tableArgs of storage.tables) {
+    const table = convertTypeORMTable(tableArgs, storage, dialect);
+    tables.push(table);
+  }
+  return { dialect, tables };
+}
+function convertTypeORMTable(tableArgs, storage, dialect) {
+  const entityTarget = tableArgs.target;
+  const tableName = tableArgs.name || entityTarget.name?.toLowerCase() || "unknown";
+  const columnArgs = storage.columns.filter(
+    (c) => c.target === entityTarget || c.target?.prototype instanceof entityTarget
+  );
+  const columns = [];
+  const foreignKeys = [];
+  for (const colArg of columnArgs) {
+    columns.push(convertTypeORMColumn(colArg, dialect));
+  }
+  const relations = storage.relations.filter(
+    (r) => r.target === entityTarget
+  );
+  for (const rel of relations) {
+    const joinColumns = storage.joinColumns.filter(
+      (jc) => jc.target === entityTarget && jc.propertyName === rel.propertyName
+    );
+    for (const jc of joinColumns) {
+      foreignKeys.push({
+        name: `fk_${tableName}_${jc.name || rel.propertyName}`,
+        columns: [jc.name || `${rel.propertyName}Id`],
+        referencedTable: typeof rel.type === "function" ? rel.type().name?.toLowerCase() : String(rel.type).toLowerCase(),
+        referencedColumns: [jc.referencedColumnName || "id"]
+      });
+    }
+  }
+  const pkColumns = columns.filter((c) => c.primaryKey).map((c) => c.name);
+  const table = {
+    name: tableName,
+    columns,
+    foreignKeys
+  };
+  if (pkColumns.length > 0) {
+    table.primaryKey = { columns: pkColumns };
+  }
+  return table;
+}
+function convertTypeORMColumn(colArg, dialect) {
+  const options = colArg.options || {};
+  const isPrimary = colArg.mode === "regular" ? options.primary : colArg.mode === "objectId";
+  return {
+    name: options.name || colArg.propertyName,
+    type: mapTypeORMType(colArg, options, dialect),
+    nullable: options.nullable === true,
+    ...isPrimary ? { primaryKey: true } : {},
+    ...options.unique ? { unique: true } : {},
+    ...options.default !== void 0 ? {
+      default: {
+        kind: typeof options.default === "string" && options.default.includes("(") ? "expression" : "value",
+        value: String(options.default)
+      }
+    } : {}
+  };
+}
+function mapTypeORMType(colArg, options, dialect) {
+  const type = options.type || colArg.mode === "createDate" || colArg.mode === "updateDate" ? "timestamp" : "unknown";
+  switch (type.toLowerCase()) {
+    case "int":
+    case "integer":
+    case "int4":
+      return { kind: "int" };
+    case "smallint":
+    case "int2":
+      return { kind: "int", size: "smallint" };
+    case "bigint":
+    case "int8":
+      return { kind: "int", size: "bigint" };
+    case "varchar":
+    case "character varying":
+      return { kind: "text", length: options.length || 255 };
+    case "text":
+      return { kind: "text" };
+    case "boolean":
+    case "bool":
+      return { kind: "boolean" };
+    case "timestamp":
+    case "timestamp with time zone":
+    case "timestamptz":
+      return { kind: "timestamp", withTimezone: dialect === "pg" };
+    case "timestamp without time zone":
+      return { kind: "timestamp" };
+    case "date":
+      return { kind: "date" };
+    case "json":
+      return { kind: "json" };
+    case "jsonb":
+      return { kind: "json", binary: true };
+    case "uuid":
+      return { kind: "uuid" };
+    case "float":
+    case "real":
+    case "float4":
+      return { kind: "float" };
+    case "double precision":
+    case "float8":
+      return { kind: "float", size: "double" };
+    case "decimal":
+    case "numeric":
+      return {
+        kind: "decimal",
+        precision: options.precision,
+        scale: options.scale
+      };
+    case "bytea":
+    case "blob":
+      return { kind: "bytea" };
+    case "enum":
+      return { kind: "enum", enumName: options.enum?.name || "unknown" };
+    default:
+      return { kind: "custom", raw: type };
+  }
+}
+var init_typeorm = __esm({
+  "src/typeorm.ts"() {
+    "use strict";
+  }
+});
+
+// bin/migratex-export.ts
+import { resolve } from "path";
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+  if (!args.orm) {
+    console.error("Usage: migratex-export --orm <drizzle|prisma|typeorm> --schema <path> [--dialect <pg|mysql>]");
+    process.exit(1);
+  }
+  if (!args.schema) {
+    console.error("Error: --schema is required");
+    process.exit(1);
+  }
+  const schemaPath = resolve(process.cwd(), args.schema);
+  const dialect = args.dialect || "pg";
+  let schema;
+  switch (args.orm) {
+    case "drizzle": {
+      const { exportDrizzleSchema: exportDrizzleSchema2 } = await Promise.resolve().then(() => (init_drizzle(), drizzle_exports));
+      schema = await exportDrizzleSchema2(schemaPath, dialect);
+      break;
+    }
+    case "prisma": {
+      const { exportPrismaSchema: exportPrismaSchema2 } = await Promise.resolve().then(() => (init_prisma(), prisma_exports));
+      schema = await exportPrismaSchema2(schemaPath);
+      break;
+    }
+    case "typeorm": {
+      const { exportTypeORMSchema: exportTypeORMSchema2 } = await Promise.resolve().then(() => (init_typeorm(), typeorm_exports));
+      schema = await exportTypeORMSchema2(schemaPath, dialect);
+      break;
+    }
+    default:
+      console.error(`Unknown ORM: ${args.orm}. Supported: drizzle, prisma, typeorm`);
+      process.exit(1);
+  }
+  console.log(JSON.stringify(schema, null, 2));
+}
+function parseArgs(argv) {
+  const args = {};
+  for (let i = 0; i < argv.length; i++) {
+    if (argv[i].startsWith("--") && i + 1 < argv.length) {
+      args[argv[i].slice(2)] = argv[i + 1];
+      i++;
+    }
+  }
+  return args;
+}
+main().catch((err) => {
+  console.error("Error:", err.message);
+  process.exit(1);
+});

package/sidecar/dist/src/index.js

@@ -0,0 +1,428 @@
+// src/drizzle.ts
+var DrizzleSymbols = {
+  Columns: /* @__PURE__ */ Symbol.for("drizzle:Columns"),
+  Name: /* @__PURE__ */ Symbol.for("drizzle:Name"),
+  Schema: /* @__PURE__ */ Symbol.for("drizzle:Schema"),
+  IsDrizzleTable: /* @__PURE__ */ Symbol.for("drizzle:IsDrizzleTable"),
+  BaseName: /* @__PURE__ */ Symbol.for("drizzle:BaseName")
+};
+async function exportDrizzleSchema(schemaPath, dialect) {
+  const schemaModule = await import(schemaPath);
+  const tables = [];
+  const enumSet = /* @__PURE__ */ new Map();
+  for (const [, value] of Object.entries(schemaModule)) {
+    if (!isDrizzleTable(value)) continue;
+    const table = extractTable(value, dialect, enumSet);
+    if (table) tables.push(table);
+  }
+  return {
+    dialect,
+    tables,
+    enums: Array.from(enumSet.entries()).map(([name, values]) => ({
+      name,
+      values
+    }))
+  };
+}
+function isDrizzleTable(obj) {
+  return obj !== null && typeof obj === "object" && (DrizzleSymbols.IsDrizzleTable in obj || DrizzleSymbols.Columns in obj);
+}
+function extractTable(tableObj, dialect, enumSet) {
+  const tableName = tableObj[DrizzleSymbols.Name] || tableObj[DrizzleSymbols.BaseName];
+  if (!tableName) return null;
+  const drizzleColumns = tableObj[DrizzleSymbols.Columns];
+  if (!drizzleColumns) return null;
+  const columns = [];
+  const pkColumns = [];
+  const indexes = [];
+  const foreignKeys = [];
+  for (const [colName, colDef] of Object.entries(drizzleColumns)) {
+    const column = extractColumn(colName, colDef, dialect, enumSet);
+    columns.push(column);
+    if (colDef.primary || colDef.primaryKey) {
+      pkColumns.push(colName);
+    }
+  }
+  if (typeof tableObj.getSQL === "function") {
+  }
+  const table = {
+    name: tableName,
+    columns,
+    indexes,
+    foreignKeys
+  };
+  if (pkColumns.length > 0) {
+    table.primaryKey = { columns: pkColumns };
+  }
+  return table;
+}
+function extractColumn(name, colDef, dialect, enumSet) {
+  const colType = mapDrizzleType(colDef, dialect, enumSet);
+  const column = {
+    name: colDef.name || name,
+    type: colType,
+    nullable: colDef.notNull !== true
+  };
+  if (colDef.hasDefault && colDef.default !== void 0) {
+    if (typeof colDef.default === "function") {
+      column.default = { kind: "expression", value: String(colDef.default) };
+    } else {
+      column.default = { kind: "value", value: String(colDef.default) };
+    }
+  }
+  if (colDef.isUnique) {
+    column.unique = true;
+  }
+  return column;
+}
+function mapDrizzleType(colDef, dialect, enumSet) {
+  const dataType = (colDef.dataType || colDef.columnType || colDef.getSQLType?.() || "").toLowerCase();
+  const sqlName = (colDef.sqlName || "").toLowerCase();
+  if (dataType.includes("serial") || sqlName.includes("serial")) {
+    if (dataType.includes("bigserial") || sqlName.includes("bigserial")) {
+      return { kind: "serial", size: "bigserial" };
+    }
+    if (dataType.includes("smallserial") || sqlName.includes("smallserial")) {
+      return { kind: "serial", size: "smallserial" };
+    }
+    return { kind: "serial" };
+  }
+  if (dataType === "number" || dataType === "integer" || sqlName.includes("int")) {
+    if (sqlName.includes("bigint") || dataType.includes("bigint")) {
+      return { kind: "int", size: "bigint" };
+    }
+    if (sqlName.includes("smallint") || dataType.includes("smallint")) {
+      return { kind: "int", size: "smallint" };
+    }
+    return { kind: "int" };
+  }
+  if (dataType === "string" || sqlName.includes("text") || sqlName.includes("varchar")) {
+    const length = colDef.length || colDef.config?.length;
+    return { kind: "text", ...length ? { length } : {} };
+  }
+  if (dataType === "boolean" || sqlName.includes("bool")) {
+    return { kind: "boolean" };
+  }
+  if (sqlName.includes("timestamp") || dataType.includes("timestamp")) {
+    return {
+      kind: "timestamp",
+      withTimezone: sqlName.includes("tz") || colDef.withTimezone === true
+    };
+  }
+  if (sqlName === "date" || dataType === "date") {
+    return { kind: "date" };
+  }
+  if (sqlName.includes("json")) {
+    return { kind: "json", binary: sqlName === "jsonb" };
+  }
+  if (sqlName === "uuid" || dataType === "uuid") {
+    return { kind: "uuid" };
+  }
+  if (sqlName.includes("real") || sqlName.includes("float")) {
+    return { kind: "float" };
+  }
+  if (sqlName.includes("double")) {
+    return { kind: "float", size: "double" };
+  }
+  if (sqlName.includes("numeric") || sqlName.includes("decimal")) {
+    return {
+      kind: "decimal",
+      precision: colDef.precision,
+      scale: colDef.scale
+    };
+  }
+  if (colDef.enumValues && Array.isArray(colDef.enumValues)) {
+    const enumName = colDef.enumName || colDef.name || "unknown_enum";
+    enumSet.set(enumName, colDef.enumValues);
+    return { kind: "enum", enumName };
+  }
+  return { kind: "custom", raw: sqlName || dataType || "unknown" };
+}
+
+// src/prisma.ts
+async function exportPrismaSchema(schemaPath) {
+  let getDMMF;
+  try {
+    const internals = await import("@prisma/internals");
+    getDMMF = internals.getDMMF;
+  } catch {
+    throw new Error(
+      "Cannot find @prisma/internals. Install it: npm install @prisma/internals"
+    );
+  }
+  const { readFileSync } = await import("fs");
+  const datamodel = readFileSync(schemaPath, "utf-8");
+  const dialect = detectDialect(datamodel);
+  const dmmf = await getDMMF({ datamodel });
+  const tables = [];
+  const enums = [];
+  for (const model of dmmf.datamodel.models) {
+    tables.push(convertModel(model, dmmf.datamodel.models, dialect));
+  }
+  for (const enumDef of dmmf.datamodel.enums) {
+    enums.push({
+      name: enumDef.name,
+      values: enumDef.values.map((v) => v.name)
+    });
+  }
+  return { dialect, tables, enums };
+}
+function detectDialect(datamodel) {
+  const match = datamodel.match(/provider\s*=\s*"(\w+)"/);
+  if (match) {
+    const provider = match[1].toLowerCase();
+    if (provider === "mysql") return "mysql";
+  }
+  return "pg";
+}
+function convertModel(model, allModels, dialect) {
+  const columns = [];
+  const foreignKeys = [];
+  const indexes = [];
+  const pkColumns = [];
+  for (const field of model.fields) {
+    if (field.kind === "object") continue;
+    const column = convertField(field, dialect);
+    columns.push(column);
+    if (field.isId) {
+      pkColumns.push(field.name);
+    }
+  }
+  for (const field of model.fields) {
+    if (field.kind === "object" && field.relationFromFields?.length > 0) {
+      const fk = {
+        name: `fk_${model.name.toLowerCase()}_${field.name}`,
+        columns: field.relationFromFields,
+        referencedTable: field.type.toLowerCase(),
+        referencedColumns: field.relationToFields || ["id"],
+        onDelete: mapPrismaAction(field.relationOnDelete),
+        onUpdate: mapPrismaAction(field.relationOnUpdate)
+      };
+      foreignKeys.push(fk);
+    }
+  }
+  if (model.uniqueFields) {
+    for (const fields of model.uniqueFields) {
+      indexes.push({
+        name: `${model.name.toLowerCase()}_${fields.join("_")}_unique`,
+        columns: fields,
+        unique: true
+      });
+    }
+  }
+  const table = {
+    // Prisma uses PascalCase model names; DB uses snake_case
+    // The @@map attribute overrides this, but dbName captures it
+    name: model.dbName || model.name.toLowerCase(),
+    columns,
+    indexes,
+    foreignKeys
+  };
+  if (pkColumns.length > 0) {
+    table.primaryKey = { columns: pkColumns };
+  }
+  return table;
+}
+function convertField(field, dialect) {
+  return {
+    name: field.dbName || field.name,
+    type: mapPrismaType(field, dialect),
+    nullable: !field.isRequired,
+    ...field.hasDefaultValue && field.default !== void 0 ? { default: parsePrismaDefault(field.default) } : {},
+    ...field.isId ? { primaryKey: true } : {},
+    ...field.isUnique ? { unique: true } : {}
+  };
+}
+function mapPrismaType(field, dialect) {
+  const nativeType = field.nativeType;
+  switch (field.type) {
+    case "Int":
+      if (nativeType) {
+        if (nativeType[0] === "SmallInt") return { kind: "int", size: "smallint" };
+        if (nativeType[0] === "BigInt") return { kind: "int", size: "bigint" };
+      }
+      return { kind: "int" };
+    case "BigInt":
+      return { kind: "int", size: "bigint" };
+    case "Float":
+      return { kind: "float", size: "double" };
+    case "Decimal":
+      return {
+        kind: "decimal",
+        precision: nativeType?.[1]?.precision || 65,
+        scale: nativeType?.[1]?.scale || 30
+      };
+    case "String":
+      if (nativeType?.[0] === "VarChar") {
+        return { kind: "text", length: nativeType[1]?.length || 255 };
+      }
+      return { kind: "text" };
+    case "Boolean":
+      return { kind: "boolean" };
+    case "DateTime":
+      return { kind: "timestamp", withTimezone: dialect === "pg" };
+    case "Json":
+      return { kind: "json", binary: dialect === "pg" };
+    case "Bytes":
+      return { kind: "bytea" };
+    default:
+      if (field.kind === "enum") {
+        return { kind: "enum", enumName: field.type };
+      }
+      return { kind: "custom", raw: field.type };
+  }
+}
+function parsePrismaDefault(def) {
+  if (typeof def === "object" && def.name) {
+    return { kind: "expression", value: `${def.name}()` };
+  }
+  return { kind: "value", value: String(def) };
+}
+function mapPrismaAction(action) {
+  if (!action) return void 0;
+  const map = {
+    Cascade: "CASCADE",
+    SetNull: "SET NULL",
+    SetDefault: "SET DEFAULT",
+    Restrict: "RESTRICT",
+    NoAction: "NO ACTION"
+  };
+  return map[action];
+}
+
+// src/typeorm.ts
+async function exportTypeORMSchema(schemaPath, dialect) {
+  let getMetadataArgsStorage;
+  try {
+    const typeorm = await import("typeorm");
+    getMetadataArgsStorage = typeorm.getMetadataArgsStorage;
+  } catch {
+    throw new Error("Cannot find typeorm. Install it: npm install typeorm reflect-metadata");
+  }
+  await import(schemaPath);
+  const storage = getMetadataArgsStorage();
+  const tables = [];
+  for (const tableArgs of storage.tables) {
+    const table = convertTypeORMTable(tableArgs, storage, dialect);
+    tables.push(table);
+  }
+  return { dialect, tables };
+}
+function convertTypeORMTable(tableArgs, storage, dialect) {
+  const entityTarget = tableArgs.target;
+  const tableName = tableArgs.name || entityTarget.name?.toLowerCase() || "unknown";
+  const columnArgs = storage.columns.filter(
+    (c) => c.target === entityTarget || c.target?.prototype instanceof entityTarget
+  );
+  const columns = [];
+  const foreignKeys = [];
+  for (const colArg of columnArgs) {
+    columns.push(convertTypeORMColumn(colArg, dialect));
+  }
+  const relations = storage.relations.filter(
+    (r) => r.target === entityTarget
+  );
+  for (const rel of relations) {
+    const joinColumns = storage.joinColumns.filter(
+      (jc) => jc.target === entityTarget && jc.propertyName === rel.propertyName
+    );
+    for (const jc of joinColumns) {
+      foreignKeys.push({
+        name: `fk_${tableName}_${jc.name || rel.propertyName}`,
+        columns: [jc.name || `${rel.propertyName}Id`],
+        referencedTable: typeof rel.type === "function" ? rel.type().name?.toLowerCase() : String(rel.type).toLowerCase(),
+        referencedColumns: [jc.referencedColumnName || "id"]
+      });
+    }
+  }
+  const pkColumns = columns.filter((c) => c.primaryKey).map((c) => c.name);
+  const table = {
+    name: tableName,
+    columns,
+    foreignKeys
+  };
+  if (pkColumns.length > 0) {
+    table.primaryKey = { columns: pkColumns };
+  }
+  return table;
+}
+function convertTypeORMColumn(colArg, dialect) {
+  const options = colArg.options || {};
+  const isPrimary = colArg.mode === "regular" ? options.primary : colArg.mode === "objectId";
+  return {
+    name: options.name || colArg.propertyName,
+    type: mapTypeORMType(colArg, options, dialect),
+    nullable: options.nullable === true,
+    ...isPrimary ? { primaryKey: true } : {},
+    ...options.unique ? { unique: true } : {},
+    ...options.default !== void 0 ? {
+      default: {
+        kind: typeof options.default === "string" && options.default.includes("(") ? "expression" : "value",
+        value: String(options.default)
+      }
+    } : {}
+  };
+}
+function mapTypeORMType(colArg, options, dialect) {
+  const type = options.type || colArg.mode === "createDate" || colArg.mode === "updateDate" ? "timestamp" : "unknown";
+  switch (type.toLowerCase()) {
+    case "int":
+    case "integer":
+    case "int4":
+      return { kind: "int" };
+    case "smallint":
+    case "int2":
+      return { kind: "int", size: "smallint" };
+    case "bigint":
+    case "int8":
+      return { kind: "int", size: "bigint" };
+    case "varchar":
+    case "character varying":
+      return { kind: "text", length: options.length || 255 };
+    case "text":
+      return { kind: "text" };
+    case "boolean":
+    case "bool":
+      return { kind: "boolean" };
+    case "timestamp":
+    case "timestamp with time zone":
+    case "timestamptz":
+      return { kind: "timestamp", withTimezone: dialect === "pg" };
+    case "timestamp without time zone":
+      return { kind: "timestamp" };
+    case "date":
+      return { kind: "date" };
+    case "json":
+      return { kind: "json" };
+    case "jsonb":
+      return { kind: "json", binary: true };
+    case "uuid":
+      return { kind: "uuid" };
+    case "float":
+    case "real":
+    case "float4":
+      return { kind: "float" };
+    case "double precision":
+    case "float8":
+      return { kind: "float", size: "double" };
+    case "decimal":
+    case "numeric":
+      return {
+        kind: "decimal",
+        precision: options.precision,
+        scale: options.scale
+      };
+    case "bytea":
+    case "blob":
+      return { kind: "bytea" };
+    case "enum":
+      return { kind: "enum", enumName: options.enum?.name || "unknown" };
+    default:
+      return { kind: "custom", raw: type };
+  }
+}
+export {
+  exportDrizzleSchema,
+  exportPrismaSchema,
+  exportTypeORMSchema
+};