bun-query-builder 0.1.63 → 0.2.0

package/dist/bin/cli.js

@@ -11641,9 +11641,18 @@ var init_dist = __esm(() => {
 });
 
 // src/config.ts
+import process19 from "process";
 function isMysqlLike(dialect = config5.dialect) {
   return dialect === "mysql" || dialect === "singlestore";
 }
+function resolveDialect(explicit) {
+  if (explicit)
+    return explicit;
+  const fromEnv = process19.env.DB_DIALECT || process19.env.DB_CONNECTION;
+  if (fromEnv)
+    return fromEnv;
+  return config5.dialect || "postgres";
+}
 function getPlaceholder(index) {
   if (config5.dialect === "postgres") {
     return `$${index}`;
@@ -11802,7 +11811,7 @@ var {SQL } = globalThis.Bun;
 import { Database } from "bun:sqlite";
 import { mkdirSync as mkdirSync5 } from "fs";
 import { dirname as dirname5 } from "path";
-import process19 from "process";
+import process21 from "process";
 
 class SQLiteWrapper {
   db;
@@ -12080,9 +12089,13 @@ function sqliteFileFromUrl(url) {
   const path = stripped.startsWith("///") ? stripped.slice(2) : stripped.startsWith("//") ? stripped.slice(2) : stripped;
   return path || ":memory:";
 }
+function resolveDatabaseName(dbConfig = config5.database) {
+  const raw = process21.env.DB_DATABASE || dbConfig?.database || "";
+  return String(raw).replace(/^['"]|['"]$/g, "");
+}
 function createConnectionString(dialect, dbConfig) {
-  if ((dialect === "postgres" || dialect === "mysql" || dialect === "singlestore") && process19.env.DB_CONNECTION === dialect) {
-    const e = process19.env;
+  if ((dialect === "postgres" || dialect === "mysql" || dialect === "singlestore") && process21.env.DB_CONNECTION === dialect) {
+    const e = process21.env;
     const envDb = (e.DB_DATABASE || dbConfig.database || "").replace(/^['"]|['"]$/g, "");
     const envUser = e.DB_USERNAME || dbConfig.username;
     const envPass = e.DB_PASSWORD ?? dbConfig.password ?? "";
@@ -12096,7 +12109,7 @@ function createConnectionString(dialect, dbConfig) {
     return dialect === "sqlite" ? sqliteFileFromUrl(dbConfig.url) : dbConfig.url;
   }
   const { database, username, password, host = "localhost", port, ssl } = dbConfig;
-  const sslQ = ssl || process19.env.DB_SSL === "true" || process19.env.DB_SSL === "1" ? "?ssl=true" : "";
+  const sslQ = ssl || process21.env.DB_SSL === "true" || process21.env.DB_SSL === "1" ? "?ssl=true" : "";
   switch (dialect) {
     case "postgres":
       return `postgres://${username}:${password}@${host}${port ? `:${port}` : ""}/${database}${sslQ}`;
@@ -12370,6 +12383,17 @@ var init_benchmark = __esm(() => {
 });
 
 // src/inflect.ts
+function toTableName(modelName) {
+  const snake = String(modelName).replace(/([A-Z])/g, "_$1").toLowerCase().replace(/^_/, "");
+  if (snake.endsWith("y") && !/[aeou]y$/.test(snake))
+    return `${snake.slice(0, -1)}ies`;
+  if (snake.endsWith("s") || snake.endsWith("x") || snake.endsWith("ch") || snake.endsWith("sh"))
+    return `${snake}es`;
+  return `${snake}s`;
+}
+function tableNameFor(model) {
+  return typeof model?.table === "string" && model.table.length > 0 ? model.table : toTableName(String(model?.name ?? ""));
+}
 function stripTrailingS(name) {
   return name.endsWith("s") ? name.slice(0, -1) : name;
 }
@@ -16590,7 +16614,7 @@ var init_cache = __esm(() => {
 });
 
 // src/actions/console.ts
-import process21 from "process";
+import process22 from "process";
 import { createInterface } from "readline";
 async function startConsole() {
   console.log("-- Query Builder Interactive Console");
@@ -16599,8 +16623,8 @@ async function startConsole() {
   console.log();
   const qb = createQueryBuilder();
   const rl = createInterface({
-    input: process21.stdin,
-    output: process21.stdout,
+    input: process22.stdin,
+    output: process22.stdout,
     prompt: "qb> "
   });
   let multilineBuffer = "";
@@ -16651,7 +16675,7 @@ Tips:
       if (cmd === ".exit" || cmd === ".quit") {
         console.log("Goodbye!");
         rl.close();
-        process21.exit(0);
+        process22.exit(0);
       } else if (cmd === ".help") {
         console.log(helpText);
       } else if (cmd === ".clear") {
@@ -16722,7 +16746,7 @@ Tips:
   rl.on("close", () => {
     console.log(`
 Goodbye!`);
-    process21.exit(0);
+    process22.exit(0);
   });
   rl.prompt();
 }
@@ -17100,9 +17124,8 @@ var init_db_info = __esm(() => {
 });
 
 // src/actions/db-optimize.ts
-import process22 from "process";
 async function dbOptimize(options = {}) {
-  const dialect = options.dialect || process22.env.DB_DIALECT || config5.dialect || "postgres";
+  const dialect = resolveDialect(options.dialect);
   const aggressive = options.aggressive || false;
   if (options.verbose) {
     console.log(`Optimizing ${dialect} database${aggressive ? " (aggressive mode)" : ""}...`);
@@ -17142,7 +17165,7 @@ async function dbOptimize(options = {}) {
           await bunSql`ANALYZE TABLE ${bunSql(table)}`;
         }
       } else {
-        const dbName = process22.env.DB_NAME || "test";
+        const dbName = resolveDatabaseName();
         const tables = await bunSql`
           SELECT table_name
           FROM information_schema.tables
@@ -17195,9 +17218,8 @@ var init_db_optimize = __esm(() => {
 });
 
 // src/actions/db-wipe.ts
-import process23 from "process";
 async function dbWipe(options = {}) {
-  const dialect = options.dialect || process23.env.DB_DIALECT || config5.dialect || "postgres";
+  const dialect = resolveDialect(options.dialect);
   if (options.verbose) {
     console.log(`Wiping all tables from ${dialect} database...`);
   }
@@ -17211,7 +17233,7 @@ async function dbWipe(options = {}) {
       `;
       tables = result.map((row) => row.tablename);
     } else if (isMysqlLike(dialect)) {
-      const dbName = process23.env.DB_NAME || "test";
+      const dbName = resolveDatabaseName();
       const result = await bunSql`
         SELECT table_name
         FROM information_schema.tables
@@ -17648,6 +17670,8 @@ function sqlTypeToNormalized(rawType, dialect, ctx) {
     return "decimal";
   if (base === "date")
     return "date";
+  if (base === "timestamptz" || /\bwith time zone\b/.test(t))
+    return "timestamptz";
   if (/^(?:timestamp|datetime)/.test(base))
     return "datetime";
   if (/^time/.test(base))
@@ -17903,7 +17927,7 @@ var init_introspect_db = __esm(() => {
 // src/actions/make-model.ts
 import { existsSync as existsSync14, mkdirSync as mkdirSync7, writeFileSync as writeFileSync10 } from "fs";
 import { dirname as dirname7, join as join7 } from "path";
-import process24 from "process";
+import process23 from "process";
 function findWorkspaceRoot(startPath) {
   let currentPath = startPath;
   while (currentPath !== dirname7(currentPath)) {
@@ -17912,10 +17936,10 @@ function findWorkspaceRoot(startPath) {
     }
     currentPath = dirname7(currentPath);
   }
-  return process24.cwd();
+  return process23.cwd();
 }
 async function makeModel(name, options = {}) {
-  const workspaceRoot = findWorkspaceRoot(process24.cwd());
+  const workspaceRoot = findWorkspaceRoot(process23.cwd());
   const modelsDir = options.dir || join7(workspaceRoot, "app/Models");
   if (!existsSync14(modelsDir)) {
     mkdirSync7(modelsDir, { recursive: true });
@@ -18111,7 +18135,7 @@ class MySQLDriver {
     )`;
   }
   getExecutedMigrationsQuery() {
-    return "SELECT migration FROM migrations ORDER BY executed_at";
+    return "SELECT migration, executed_at FROM migrations ORDER BY executed_at";
   }
   recordMigrationQuery() {
     return "INSERT INTO migrations (migration) VALUES (?)";
@@ -18292,7 +18316,7 @@ class PostgresDriver {
     )`;
   }
   getExecutedMigrationsQuery() {
-    return "SELECT migration FROM migrations ORDER BY executed_at";
+    return "SELECT migration, executed_at FROM migrations ORDER BY executed_at";
   }
   recordMigrationQuery() {
     return "INSERT INTO migrations (migration) VALUES ($1)";
@@ -18537,7 +18561,7 @@ class SQLiteDriver {
     )`;
   }
   getExecutedMigrationsQuery() {
-    return "SELECT migration FROM migrations ORDER BY executed_at";
+    return "SELECT migration, executed_at FROM migrations ORDER BY executed_at";
   }
   recordMigrationQuery() {
     return "INSERT INTO migrations (migration) VALUES (?)";
@@ -18590,6 +18614,24 @@ var init_drivers = __esm(() => {
   init_singlestore();
 });
 
+// src/workspace.ts
+import { existsSync as existsSync16 } from "fs";
+import { dirname as dirname8, join as join9 } from "path";
+import process24 from "process";
+function findWorkspaceRoot2(startPath = process24.cwd()) {
+  let currentPath = startPath;
+  while (currentPath !== dirname8(currentPath)) {
+    if (existsSync16(join9(currentPath, "package.json")))
+      return currentPath;
+    currentPath = dirname8(currentPath);
+  }
+  return process24.cwd();
+}
+function getSqlDirectory(workspaceRoot) {
+  return join9(workspaceRoot ?? findWorkspaceRoot2(), "database", "migrations");
+}
+var init_workspace = () => {};
+
 // src/actions/migrate.ts
 var exports_migrate = {};
 __export(exports_migrate, {
@@ -18601,23 +18643,48 @@ __export(exports_migrate, {
   copyModelsToGenerated: () => copyModelsToGenerated,
   clearGeneratedDirectory: () => clearGeneratedDirectory
 });
-import { existsSync as existsSync16, mkdirSync as mkdirSync8, mkdtempSync, readdirSync as readdirSync6, readFileSync as readFileSync3, rmSync, unlinkSync, writeFileSync as writeFileSync11 } from "fs";
+import { existsSync as existsSync17, mkdirSync as mkdirSync8, mkdtempSync, readdirSync as readdirSync6, readFileSync as readFileSync3, rmSync, unlinkSync, writeFileSync as writeFileSync11 } from "fs";
 import { tmpdir } from "os";
-import { join as join9 } from "path";
+import { join as join10 } from "path";
 import process25 from "process";
+async function settleAppliedFiles(qb, dialect, files) {
+  if (files.length === 0)
+    return;
+  const sqlDir = ensureSqlDirectory(getWorkspaceRoot());
+  try {
+    await createMigrationsTable(qb, dialect);
+    for (const file2 of files) {
+      await recordMigration(qb, file2, dialect);
+      info(`-- \u2713 Recorded applied migration: ${file2}`);
+    }
+  } catch (err) {
+    info(`-- Could not record applied migrations (the schema change itself succeeded): ${err instanceof Error ? err.message : String(err)}`);
+  }
+}
+function isGeneratedMigration(sqlDir, file2) {
+  try {
+    return isGeneratedMigrationSql(readFileSync3(join10(sqlDir, file2), "utf8"));
+  } catch {
+    return false;
+  }
+}
+function isAlreadyAppliedError(err) {
+  const message = err instanceof Error ? err.message : String(err);
+  return /duplicate column name/i.test(message) || /duplicate key name/i.test(message) || /\balready exists\b/i.test(message);
+}
 function info(message) {
   if (config5.verbose)
     console.log(message);
 }
 function getSnapshotDir(workspaceRoot) {
-  return join9(workspaceRoot, config5.snapshotDir || ".qb");
+  return join10(workspaceRoot, config5.snapshotDir || ".qb");
 }
 function getSnapshotPath(workspaceRoot, dialect) {
-  return join9(getSnapshotDir(workspaceRoot), `model-snapshot.${dialect}.json`);
+  return join10(getSnapshotDir(workspaceRoot), `model-snapshot.${dialect}.json`);
 }
 function loadPlanSnapshot(workspaceRoot, dialect) {
   const snapshotPath = getSnapshotPath(workspaceRoot, dialect);
-  if (!existsSync16(snapshotPath)) {
+  if (!existsSync17(snapshotPath)) {
     return;
   }
   try {
@@ -18640,7 +18707,7 @@ function savePlanSnapshot(workspaceRoot, dialect, plan) {
   const snapshotPath = getSnapshotPath(workspaceRoot, dialect);
   const snapshotDir = getSnapshotDir(workspaceRoot);
   const hash = hashMigrationPlan(plan);
-  if (existsSync16(snapshotPath)) {
+  if (existsSync17(snapshotPath)) {
     try {
       const current = JSON.parse(readFileSync3(snapshotPath, "utf8"));
       if (current?.hash === hash && current?.dialect === dialect && current?.plan) {
@@ -18649,7 +18716,7 @@ function savePlanSnapshot(workspaceRoot, dialect, plan) {
       }
     } catch {}
   }
-  if (!existsSync16(snapshotDir)) {
+  if (!existsSync17(snapshotDir)) {
     mkdirSync8(snapshotDir, { recursive: true });
     info(`-- Created snapshot directory: ${snapshotDir}`);
   }
@@ -18667,11 +18734,11 @@ function saveMigrationSnapshot(plan, options = {}) {
   savePlanSnapshot(options.workspaceRoot ?? getWorkspaceRoot(), dialect, plan);
 }
 function getWorkspaceRoot() {
-  return process25.cwd();
+  return findWorkspaceRoot2();
 }
 function ensureSqlDirectory(workspaceRoot) {
   const sqlDir = getSqlDirectory(workspaceRoot);
-  if (!existsSync16(sqlDir)) {
+  if (!existsSync17(sqlDir)) {
     mkdirSync8(sqlDir, { recursive: true });
     info(`-- Created SQL directory: ${sqlDir}`);
   }
@@ -18680,21 +18747,22 @@ function ensureSqlDirectory(workspaceRoot) {
 async function generateMigration(dir, opts = {}) {
   await getConfig();
   if (!dir) {
-    dir = join9(process25.cwd(), "app/Models");
+    dir = join10(process25.cwd(), "app/Models");
   }
   const dialect = opts.dialect || config5.dialect || "postgres";
   const workspaceRoot = getWorkspaceRoot();
   const models = await loadModels({ modelsDir: dir });
   const plan = buildMigrationPlan2(models, { dialect });
   let previous;
+  let reconciledFromDatabase = false;
   if (!opts.full) {
     previous = loadPlanSnapshot(workspaceRoot, dialect);
     if (previous) {
       info("-- Comparing with stored model snapshot");
     } else {
-      const defaultStatePath = join9(dir, `.qb-migrations.${dialect}.json`);
+      const defaultStatePath = join10(dir, `.qb-migrations.${dialect}.json`);
       const statePath = String(opts.state || defaultStatePath);
-      if (existsSync16(statePath)) {
+      if (existsSync17(statePath)) {
         try {
           const raw2 = readFileSync3(statePath, "utf8");
           const parsed = JSON.parse(raw2);
@@ -18711,6 +18779,7 @@ async function generateMigration(dir, opts = {}) {
           const scoped = livePlan.tables.filter((t) => modelTables.has(t.table));
           if (scoped.length > 0) {
             previous = { dialect: livePlan.dialect, tables: scoped };
+            reconciledFromDatabase = true;
             info(`-- No snapshot; reconciling against live database (${scoped.length} matching table${scoped.length === 1 ? "" : "s"})`);
           }
         } catch (err) {
@@ -18724,25 +18793,34 @@ async function generateMigration(dir, opts = {}) {
   } else {
     info("-- Full migration requested, ignoring any previous state");
   }
-  const diff = opts.full ? { statements: generateSql(plan, { dryRun: opts.dryRun }), operations: plan.tables.map((t) => ({ kind: "create_table", table: t.table, destructive: false, sql: "" })) } : generateDiffOperations(previous, plan, { applyRenames: opts.applyRenames, dryRun: opts.dryRun });
+  const diff = opts.full ? { statements: generateSql(plan, { dryRun: opts.dryRun }), operations: plan.tables.map((t) => ({ kind: "create_table", table: t.table, destructive: false, sql: "" })) } : generateDiffOperations(previous, plan, {
+    applyRenames: opts.applyRenames,
+    dryRun: opts.dryRun,
+    preserveUnknownColumns: reconciledFromDatabase
+  });
   const sqlStatements = diff.statements;
   const operations = diff.operations;
   const sql = sqlStatements.join(`
 `);
   const hasChanges = sqlStatements.some((stmt) => /\b(?:CREATE|ALTER|DROP)\b/i.test(stmt));
   if (opts.apply) {
-    const dirPath = mkdtempSync(join9(tmpdir(), "qb-migrate-"));
-    const filePath = join9(dirPath, "migration.sql");
+    const dirPath = mkdtempSync(join10(tmpdir(), "qb-migrate-"));
+    const filePath = join10(dirPath, "migration.sql");
     try {
       if (hasChanges) {
         writeFileSync11(filePath, sql);
+        const qb = createQueryBuilder();
+        await qb.file(filePath);
         info("-- Migration applied");
+        await settleAppliedFiles(qb, dialect, lastCreatedMigrationFiles());
       } else {
         info("-- No changes; nothing to apply");
       }
     } catch (err) {
       console.error("-- Migration failed:", err);
       throw err;
+    } finally {
+      rmSync(dirPath, { recursive: true, force: true });
     }
   }
   if (!opts.dryRun)
@@ -18751,9 +18829,6 @@ async function generateMigration(dir, opts = {}) {
 }
 async function executeMigration(dir) {
   await getConfig();
-  if (!dir) {
-    dir = join9(process25.cwd(), "app/Models");
-  }
   const workspaceRoot = getWorkspaceRoot();
   const sqlDir = ensureSqlDirectory(workspaceRoot);
   const dialect = config5.dialect || "postgres";
@@ -18768,42 +18843,25 @@ async function executeMigration(dir) {
     const qb = createQueryBuilder();
     await createMigrationsTable(qb, dialect);
     const executedMigrations = await getExecutedMigrations(qb, dialect);
-    const permanentMigrations = [];
-    const transientMigrations = [];
-    for (const file2 of scriptFiles) {
-      if (file2.includes("alter-") && file2.includes("-table")) {
-        transientMigrations.push(file2);
-      } else if (!executedMigrations.includes(file2)) {
-        permanentMigrations.push(file2);
-      }
-    }
-    const totalPending = permanentMigrations.length + transientMigrations.length;
-    if (totalPending === 0) {
+    const pending = scriptFiles.filter((file2) => !executedMigrations.includes(file2));
+    if (pending.length === 0) {
       info("-- No pending migrations to execute");
       return true;
     }
-    info(`-- Executing ${totalPending} migrations (${permanentMigrations.length} permanent, ${transientMigrations.length} transient)`);
-    for (const file2 of permanentMigrations) {
-      const filePath = join9(sqlDir, file2);
+    info(`-- Executing ${pending.length} migration${pending.length === 1 ? "" : "s"}`);
+    for (const file2 of pending) {
+      const filePath = join10(sqlDir, file2);
       info(`-- Executing: ${file2}`);
       try {
         await qb.file(filePath);
         await recordMigration(qb, file2, dialect);
         info(`-- \u2713 Migration ${file2} executed and recorded`);
       } catch (err) {
-        console.error(`-- \u2717 Migration ${file2} failed:`, err);
-        throw err;
-      }
-    }
-    for (const file2 of transientMigrations) {
-      const filePath = join9(sqlDir, file2);
-      info(`-- Executing: ${file2} (transient)`);
-      try {
-        await qb.file(filePath);
-        info(`-- \u2713 Migration ${file2} executed (not recorded)`);
-        unlinkSync(filePath);
-        info(`-- \uD83D\uDDD1\uFE0F  Deleted transient migration: ${file2}`);
-      } catch (err) {
+        if (isGeneratedMigration(sqlDir, file2) && isAlreadyAppliedError(err)) {
+          await recordMigration(qb, file2, dialect);
+          info(`-- \u2713 Migration ${file2} was already applied; recorded it (${err instanceof Error ? err.message : String(err)})`);
+          continue;
+        }
         console.error(`-- \u2717 Migration ${file2} failed:`, err);
         throw err;
       }
@@ -18818,7 +18876,7 @@ async function executeMigration(dir) {
 async function resetDatabase(dir, opts = {}) {
   await getConfig();
   if (!dir) {
-    dir = join9(process25.cwd(), "app/Models");
+    dir = join10(process25.cwd(), "app/Models");
   }
   const dialect = opts.dialect || config5.dialect || "postgres";
   const driver = getDialectDriver(dialect);
@@ -18915,42 +18973,50 @@ async function resetDatabase(dir, opts = {}) {
 }
 async function deleteMigrationFiles(dir, workspaceRoot, opts = {}) {
   if (!dir) {
-    dir = join9(process25.cwd(), "app/Models");
+    dir = join10(process25.cwd(), "app/Models");
   }
   if (!workspaceRoot) {
     workspaceRoot = getWorkspaceRoot();
   }
   const dialect = String(opts.dialect || config5.dialect || "postgres");
   const snapshotPath = getSnapshotPath(workspaceRoot, dialect);
-  if (existsSync16(snapshotPath)) {
+  if (existsSync17(snapshotPath)) {
     unlinkSync(snapshotPath);
     info(`-- Removed model snapshot file: ${snapshotPath}`);
   }
-  const defaultStatePath = join9(dir, `.qb-migrations.${dialect}.json`);
+  const defaultStatePath = join10(dir, `.qb-migrations.${dialect}.json`);
   const statePath = String(opts.state || defaultStatePath);
-  if (existsSync16(statePath)) {
+  if (existsSync17(statePath)) {
     unlinkSync(statePath);
     info(`-- Removed legacy migration state file: ${statePath}`);
   }
-  const sqlDir = getSqlDirectory(workspaceRoot);
-  if (existsSync16(sqlDir)) {
-    const sqlFiles = readdirSync6(sqlDir);
-    const migrationFiles = sqlFiles.filter((file2) => file2.endsWith(".sql"));
-    for (const file2 of migrationFiles) {
-      const filePath = join9(sqlDir, file2);
-      unlinkSync(filePath);
-      info(`-- Removed migration file: ${file2}`);
+  removeGeneratedMigrationFiles(getSqlDirectory(workspaceRoot));
+}
+function removeGeneratedMigrationFiles(sqlDir) {
+  if (!existsSync17(sqlDir))
+    return;
+  let removed = 0;
+  const kept = [];
+  for (const file2 of readdirSync6(sqlDir).filter((f) => f.endsWith(".sql"))) {
+    if (!isGeneratedMigration(sqlDir, file2)) {
+      kept.push(file2);
+      continue;
     }
-    info(`-- Cleaned up ${migrationFiles.length} migration files from migrations directory`);
+    unlinkSync(join10(sqlDir, file2));
+    info(`-- Removed generated migration file: ${file2}`);
+    removed += 1;
   }
+  info(`-- Cleaned up ${removed} generated migration file${removed === 1 ? "" : "s"} from migrations directory`);
+  if (kept.length > 0)
+    info(`-- Kept ${kept.length} hand-written migration${kept.length === 1 ? "" : "s"}: ${kept.slice(0, 5).join(", ")}${kept.length > 5 ? `, +${kept.length - 5} more` : ""}`);
 }
 async function copyModelsToGenerated(_dir, _workspaceRoot) {}
 async function clearGeneratedDirectory(workspaceRoot) {
   if (!workspaceRoot) {
     workspaceRoot = getWorkspaceRoot();
   }
-  const generatedDir = join9(workspaceRoot, "generated");
-  if (existsSync16(generatedDir)) {
+  const generatedDir = join10(workspaceRoot, "generated");
+  if (existsSync17(generatedDir)) {
     try {
       rmSync(generatedDir, { recursive: true, force: true });
       info("-- Cleared generated directory");
@@ -18959,12 +19025,6 @@ async function clearGeneratedDirectory(workspaceRoot) {
     }
   }
 }
-function getSqlDirectory(workspaceRoot) {
-  if (!workspaceRoot) {
-    workspaceRoot = getWorkspaceRoot();
-  }
-  return join9(workspaceRoot, "database", "migrations");
-}
 async function createMigrationsTable(qb, dialect) {
   const driver = getDialectDriver(dialect);
   const createTableSql = driver.createMigrationsTable();
@@ -19003,6 +19063,7 @@ var init_migrate = __esm(() => {
   init_drivers();
   init_src2();
   init_introspect_db();
+  init_workspace();
 });
 
 // src/actions/migrate-generate.ts
@@ -19014,28 +19075,49 @@ var init_migrate_generate = __esm(() => {
 });
 
 // src/actions/migrate-rollback.ts
-import { existsSync as existsSync17, readFileSync as readFileSync4, unlinkSync as unlinkSync2 } from "fs";
-import { dirname as dirname8, join as join10 } from "path";
-import process26 from "process";
+import { existsSync as existsSync18, readFileSync as readFileSync4, unlinkSync as unlinkSync2 } from "fs";
+import { join as join11 } from "path";
 function splitSqlStatements2(sql) {
   const out = [];
   let buf = "";
-  let inString = false;
-  const lines = sql.split(`
-`).filter((l) => !/^\s*--/.test(l));
-  const text = lines.join(`
-`);
-  for (let i = 0;i < text.length; i++) {
-    const ch = text[i];
-    if (ch === "'")
-      inString = !inString;
-    if (ch === ";" && !inString) {
+  let quote = null;
+  for (let i = 0;i < sql.length; i++) {
+    const ch = sql[i];
+    if (quote) {
+      buf += ch;
+      if (ch === quote) {
+        if (sql[i + 1] === quote) {
+          buf += sql[i + 1];
+          i++;
+        } else {
+          quote = null;
+        }
+      }
+      continue;
+    }
+    if (ch === "'" || ch === '"' || ch === "`") {
+      quote = ch;
+      buf += ch;
+      continue;
+    }
+    if (ch === "-" && sql[i + 1] === "-") {
+      const newline = sql.indexOf(`
+`, i);
+      i = newline === -1 ? sql.length : newline;
+      continue;
+    }
+    if (ch === "/" && sql[i + 1] === "*") {
+      const close = sql.indexOf("*/", i + 2);
+      i = close === -1 ? sql.length : close + 1;
+      continue;
+    }
+    if (ch === ";") {
       if (buf.trim())
         out.push(buf.trim());
       buf = "";
-    } else {
-      buf += ch;
+      continue;
     }
+    buf += ch;
   }
   if (buf.trim())
     out.push(buf.trim());
@@ -19049,8 +19131,20 @@ function deriveDownStatements(forwardSql, dialect = config5.dialect) {
     let m;
     if (m = /^CREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?["`']?(\w+)["`']?/i.exec(stmt)) {
       down.push(`DROP TABLE IF EXISTS ${q(m[1])}`);
-    } else if (m = /^ALTER\s+TABLE\s+["`']?(\w+)["`']?\s+ADD\s+(?:COLUMN\s+)?["`']?(\w+)["`']?/i.exec(stmt)) {
-      down.push(`ALTER TABLE ${q(m[1])} DROP COLUMN ${q(m[2])}`);
+    } else if (m = /^ALTER\s+TABLE\s+["`']?(\w+)["`']?\s+ADD\s+CONSTRAINT\s+["`']?(\w+)["`']?([\s\S]*)$/i.exec(stmt)) {
+      if (dialect === "sqlite") {
+        skipped.push(stmt);
+      } else if (isMysqlLike(dialect) && /\bFOREIGN\s+KEY\b/i.test(m[3] ?? "")) {
+        down.push(`ALTER TABLE ${q(m[1])} DROP FOREIGN KEY ${q(m[2])}`);
+      } else {
+        down.push(`ALTER TABLE ${q(m[1])} DROP CONSTRAINT ${q(m[2])}`);
+      }
+    } else if (m = /^ALTER\s+TABLE\s+["`']?(\w+)["`']?\s+ADD\s+(?:COLUMN\s+["`']?(\w+)["`']?|["`'](\w+)["`']|(\w+))/i.exec(stmt)) {
+      const column = m[2] ?? m[3] ?? m[4];
+      if (m[4] && /^(?:PRIMARY|UNIQUE|INDEX|KEY|FOREIGN|CHECK|FULLTEXT|SPATIAL)$/i.test(m[4]))
+        skipped.push(stmt);
+      else
+        down.push(`ALTER TABLE ${q(m[1])} DROP COLUMN ${q(column)}`);
     } else if (m = /^CREATE\s+(?:UNIQUE\s+)?INDEX\s+(?:IF\s+NOT\s+EXISTS\s+)?["`']?(\w+)["`']?(?:\s+ON\s+["`']?(\w+)["`']?)?/i.exec(stmt)) {
       down.push(isMysqlLike(dialect) && m[2] ? `DROP INDEX ${q(m[1])} ON ${q(m[2])}` : `DROP INDEX IF EXISTS ${q(m[1])}`);
     } else {
@@ -19059,22 +19153,6 @@ function deriveDownStatements(forwardSql, dialect = config5.dialect) {
   }
   return { down: down.reverse(), skipped };
 }
-function findWorkspaceRoot2(startPath) {
-  let currentPath = startPath;
-  while (currentPath !== dirname8(currentPath)) {
-    if (existsSync17(join10(currentPath, "package.json"))) {
-      return currentPath;
-    }
-    currentPath = dirname8(currentPath);
-  }
-  return process26.cwd();
-}
-function getSqlDirectory2(workspaceRoot) {
-  if (!workspaceRoot) {
-    workspaceRoot = findWorkspaceRoot2(process26.cwd());
-  }
-  return join10(workspaceRoot, "database", "migrations");
-}
 async function migrateRollback(options = {}) {
   const steps = options.steps || 1;
   const reverseSchema = options.reverseSchema !== false;
@@ -19107,12 +19185,12 @@ async function migrateRollback(options = {}) {
       console.log(`  - ${migration.migration}`);
     }
     console.log();
-    const sqlDir = getSqlDirectory2();
+    const sqlDir = getSqlDirectory();
     let reversedAny = false;
     for (const migration of migrationsToRollback) {
       try {
-        const filePath = join10(sqlDir, migration.migration);
-        if (reverseSchema && existsSync17(filePath)) {
+        const filePath = join11(sqlDir, migration.migration);
+        if (reverseSchema && existsSync18(filePath)) {
           const forwardSql = readFileSync4(filePath, "utf8");
           const { down, skipped } = deriveDownStatements(forwardSql);
           for (const stmt of down) {
@@ -19123,10 +19201,10 @@ async function migrateRollback(options = {}) {
           if (skipped.length > 0)
             console.log(`-- \u26A0\uFE0F  ${skipped.length} statement(s) in ${migration.migration} could not be auto-reversed (data/complex DDL) \u2014 reverse manually.`);
         }
-        const deleteSql = `DELETE FROM migrations WHERE migration = $1`;
+        const deleteSql = `DELETE FROM migrations WHERE migration = ${getPlaceholder(1)}`;
         await qb.unsafe(deleteSql, [migration.migration]);
         console.log(`-- \u2713 Removed migration record: ${migration.migration}`);
-        if (existsSync17(filePath)) {
+        if (options.deleteFiles && existsSync18(filePath)) {
           unlinkSync2(filePath);
           console.log(`-- \uD83D\uDDD1\uFE0F  Deleted migration file: ${migration.migration}`);
         }
@@ -19149,37 +19227,20 @@ async function migrateRollback(options = {}) {
 var init_migrate_rollback = __esm(() => {
   init_config();
   init_src2();
+  init_workspace();
 });
 
 // src/actions/migrate-status.ts
-import { existsSync as existsSync18, readdirSync as readdirSync8 } from "fs";
-import { dirname as dirname9, join as join11 } from "path";
-import process27 from "process";
-function findWorkspaceRoot3(startPath) {
-  let currentPath = startPath;
-  while (currentPath !== dirname9(currentPath)) {
-    if (existsSync18(join11(currentPath, "package.json"))) {
-      return currentPath;
-    }
-    currentPath = dirname9(currentPath);
-  }
-  return process27.cwd();
-}
-function getSqlDirectory3(workspaceRoot) {
-  if (!workspaceRoot) {
-    workspaceRoot = findWorkspaceRoot3(process27.cwd());
-  }
-  return join11(workspaceRoot, "database", "migrations");
-}
+import { existsSync as existsSync19, readdirSync as readdirSync8 } from "fs";
 async function migrateStatus() {
   const dialect = config5.dialect || "postgres";
   const driver = getDialectDriver(dialect);
-  const sqlDir = getSqlDirectory3();
+  const sqlDir = getSqlDirectory();
   console.log("-- Migration Status");
   console.log(`-- Dialect: ${dialect}`);
   console.log(`-- SQL directory: ${sqlDir}`);
   console.log();
-  if (!existsSync18(sqlDir)) {
+  if (!existsSync19(sqlDir)) {
     console.log("-- No SQL directory found. No migrations have been created yet.");
     return [];
   }
@@ -19200,27 +19261,16 @@ async function migrateStatus() {
       console.log();
     }
     const executedMap = new Map(executedMigrations.map((m) => [m.migration, m.executed_at]));
-    const statuses = migrationFiles.map((file2) => {
-      if (file2.includes("alter-") && file2.includes("-table")) {
-        return {
-          file: file2,
-          status: "transient"
-        };
-      }
-      const executedAt = executedMap.get(file2);
-      return {
-        file: file2,
-        status: executedAt ? "executed" : "pending",
-        executedAt
-      };
-    });
+    const statuses = migrationFiles.map((file2) => ({
+      file: file2,
+      status: executedMap.has(file2) ? "executed" : "pending",
+      executedAt: executedMap.get(file2)
+    }));
     const executed = statuses.filter((s) => s.status === "executed");
     const pending = statuses.filter((s) => s.status === "pending");
-    const transient = statuses.filter((s) => s.status === "transient");
     console.log(`-- Total migrations: ${migrationFiles.length}`);
     console.log(`-- Executed: ${executed.length}`);
     console.log(`-- Pending: ${pending.length}`);
-    console.log(`-- Transient: ${transient.length}`);
     console.log();
     if (executed.length > 0) {
       console.log("\u2713 Executed Migrations:");
@@ -19236,13 +19286,6 @@ async function migrateStatus() {
       }
       console.log();
     }
-    if (transient.length > 0) {
-      console.log("\u26A1 Transient Migrations (ALTER TABLE - not tracked):");
-      for (const migration of transient) {
-        console.log(`  - ${migration.file}`);
-      }
-      console.log();
-    }
     return statuses;
   } catch (err) {
     console.error("-- Failed to get migration status:", err);
@@ -19256,14 +19299,15 @@ var init_migrate_status = __esm(() => {
   init_config();
   init_drivers();
   init_src2();
+  init_workspace();
 });
 
 // src/actions/model-show.ts
 import { readdirSync as readdirSync9 } from "fs";
 import { extname as extname2, join as join12 } from "path";
-import process28 from "process";
+import process26 from "process";
 async function modelShow(modelName, options = {}) {
-  const dir = options.dir || join12(process28.cwd(), "app/Models");
+  const dir = options.dir || join12(process26.cwd(), "app/Models");
   try {
     const files = readdirSync9(dir);
     const modelFile = files.find((f) => {
@@ -19477,9 +19521,9 @@ var init_query_explain_all = __esm(() => {
 // src/actions/relation-diagram.ts
 import { writeFileSync as writeFileSync12 } from "fs";
 import { join as join14 } from "path";
-import process29 from "process";
+import process27 from "process";
 async function relationDiagram(options = {}) {
-  const dir = options.dir || join14(process29.cwd(), "app/Models");
+  const dir = options.dir || join14(process27.cwd(), "app/Models");
   const format = options.format || "mermaid";
   try {
     const models = await loadModels({ modelsDir: dir });
@@ -19599,25 +19643,25 @@ var init_relation_diagram = __esm(() => {
 });
 
 // src/actions/seed.ts
-import { existsSync as existsSync19, mkdirSync as mkdirSync9, readdirSync as readdirSync11, writeFileSync as writeFileSync13 } from "fs";
+import { existsSync as existsSync20, mkdirSync as mkdirSync9, readdirSync as readdirSync11, writeFileSync as writeFileSync13 } from "fs";
 import { dirname as dirname10, join as join15 } from "path";
-import process30 from "process";
-function findWorkspaceRoot4(startPath) {
+import process28 from "process";
+function findWorkspaceRoot3(startPath) {
   let currentPath = startPath;
   while (currentPath !== dirname10(currentPath)) {
-    if (existsSync19(join15(currentPath, "package.json"))) {
+    if (existsSync20(join15(currentPath, "package.json"))) {
       return currentPath;
     }
     currentPath = dirname10(currentPath);
   }
-  return process30.cwd();
+  return process28.cwd();
 }
 async function loadSeeders(seedersDir) {
-  if (!existsSync19(seedersDir)) {
+  if (!existsSync20(seedersDir)) {
     console.log(`-- Seeders directory not found: ${seedersDir}`);
     return [];
   }
-  const files = readdirSync11(seedersDir);
+  const files = readdirSync11(seedersDir).sort((a, b) => a.localeCompare(b));
   const seederFiles = files.filter((file2) => (file2.endsWith(".ts") || file2.endsWith(".js")) && file2 !== "index.ts" && file2 !== "index.js");
   const seeders = [];
   for (const file2 of seederFiles) {
@@ -19630,6 +19674,7 @@ async function loadSeeders(seedersDir) {
         if (instance && typeof instance.run === "function") {
           seeders.push({
             name: file2.replace(/\.(ts|js)$/, ""),
+            className: String(SeederClass.name || ""),
             instance
           });
         }
@@ -19642,7 +19687,7 @@ async function loadSeeders(seedersDir) {
   return seeders;
 }
 async function runSeeders(config6 = {}) {
-  const workspaceRoot = findWorkspaceRoot4(process30.cwd());
+  const workspaceRoot = findWorkspaceRoot3(process28.cwd());
   const seedersDir = config6.seedersDir || join15(workspaceRoot, "database/seeders");
   const verbose = config6.verbose ?? true;
   if (verbose) {
@@ -19677,17 +19722,18 @@ async function runSeeders(config6 = {}) {
   }
 }
 async function runSeeder(className, options = {}) {
-  const workspaceRoot = findWorkspaceRoot4(process30.cwd());
+  const workspaceRoot = findWorkspaceRoot3(process28.cwd());
   const seedersDir = join15(workspaceRoot, "database/seeders");
   const verbose = options.verbose ?? true;
   if (verbose) {
     console.log(`-- Running seeder: ${className}`);
   }
   const seeders = await loadSeeders(seedersDir);
-  const seeder = seeders.find((s) => s.name === className);
+  const seeder = seeders.find((s) => s.className === className) ?? seeders.find((s) => s.name === className);
   if (!seeder) {
-    console.error(`-- Seeder not found: ${className}`);
-    throw new Error(`Seeder not found: ${className}`);
+    const known = seeders.map((s) => s.className || s.name).join(", ") || "none";
+    console.error(`-- Seeder not found: ${className}. Available: ${known}`);
+    throw new Error(`Seeder not found: ${className}. Available: ${known}`);
   }
   const qb = createQueryBuilder();
   try {
@@ -19701,9 +19747,9 @@ async function runSeeder(className, options = {}) {
   }
 }
 async function makeSeeder(name) {
-  const workspaceRoot = findWorkspaceRoot4(process30.cwd());
+  const workspaceRoot = findWorkspaceRoot3(process28.cwd());
   const seedersDir = join15(workspaceRoot, "database/seeders");
-  if (!existsSync19(seedersDir)) {
+  if (!existsSync20(seedersDir)) {
     mkdirSync9(seedersDir, { recursive: true });
     console.log(`-- Created seeders directory: ${seedersDir}`);
   }
@@ -19711,7 +19757,7 @@ async function makeSeeder(name) {
   const className = `${baseName}Seeder`;
   const fileName = `${className}.ts`;
   const filePath = join15(seedersDir, fileName);
-  if (existsSync19(filePath)) {
+  if (existsSync20(filePath)) {
     console.error(`-- Seeder already exists: ${filePath}`);
     throw new Error(`Seeder already exists: ${filePath}`);
   }
@@ -19765,7 +19811,7 @@ export default class ${className} extends Seeder {
   console.log(`-- \u2713 Created seeder: ${filePath}`);
 }
 async function freshDatabase(options = {}) {
-  const workspaceRoot = findWorkspaceRoot4(process30.cwd());
+  const workspaceRoot = findWorkspaceRoot3(process28.cwd());
   const modelsDir = options.modelsDir || join15(workspaceRoot, "app/Models");
   const seedersDir = options.seedersDir || join15(workspaceRoot, "database/seeders");
   const verbose = options.verbose ?? true;
@@ -19825,22 +19871,22 @@ var init_unsafe = __esm(() => {
 });
 
 // src/actions/validate.ts
-import { existsSync as existsSync20 } from "fs";
+import { existsSync as existsSync21 } from "fs";
 import { dirname as dirname11, join as join16 } from "path";
-import process31 from "process";
-function findWorkspaceRoot5(startPath) {
+import process29 from "process";
+function findWorkspaceRoot4(startPath) {
   let currentPath = startPath;
   while (currentPath !== dirname11(currentPath)) {
-    if (existsSync20(join16(currentPath, "package.json"))) {
+    if (existsSync21(join16(currentPath, "package.json"))) {
       return currentPath;
     }
     currentPath = dirname11(currentPath);
   }
-  return process31.cwd();
+  return process29.cwd();
 }
 async function validateSchema(dir) {
   if (!dir) {
-    dir = join16(findWorkspaceRoot5(process31.cwd()), "app/Models");
+    dir = join16(findWorkspaceRoot4(process29.cwd()), "app/Models");
   }
   const dialect = config5.dialect || "postgres";
   console.log("-- Validating Schema");
@@ -25091,18 +25137,11 @@ function toSnakeCase(str) {
   snakeCaseCache.set(str, cached);
   return cached;
 }
-function toTableName(modelName) {
+function toTableName2(modelName) {
   let cached = tableNameCache.get(modelName);
   if (cached !== undefined)
     return cached;
-  const snake = toSnakeCase(modelName);
-  if (snake.endsWith("y") && !snake.endsWith("ay") && !snake.endsWith("ey") && !snake.endsWith("oy") && !snake.endsWith("uy")) {
-    cached = snake.slice(0, -1) + "ies";
-  } else if (snake.endsWith("s") || snake.endsWith("x") || snake.endsWith("ch") || snake.endsWith("sh")) {
-    cached = `${snake}es`;
-  } else {
-    cached = `${snake}s`;
-  }
+  cached = toTableName(modelName);
   tableNameCache.set(modelName, cached);
   return cached;
 }
@@ -25187,14 +25226,14 @@ function resolveRelation(definition, relationName) {
   const hasManyModel = findModelName(definition.hasMany);
   if (hasManyModel) {
     const relatedModel = getModelFromRegistry(hasManyModel);
-    const relatedTable = relatedModel?.getTable?.() || toTableName(hasManyModel);
+    const relatedTable = relatedModel?.getTable?.() || toTableName2(hasManyModel);
     const foreignKey = toSnakeCase(parentName) + "_id";
     return { type: "hasMany", relatedModelName: hasManyModel, relatedTable, foreignKey, localKey: parentPk };
   }
   const hasOneModel = findModelName(definition.hasOne);
   if (hasOneModel) {
     const relatedModel = getModelFromRegistry(hasOneModel);
-    const relatedTable = relatedModel?.getTable?.() || toTableName(hasOneModel);
+    const relatedTable = relatedModel?.getTable?.() || toTableName2(hasOneModel);
     const foreignKey = toSnakeCase(parentName) + "_id";
     return { type: "hasOne", relatedModelName: hasOneModel, relatedTable, foreignKey, localKey: parentPk };
   }
@@ -25202,7 +25241,7 @@ function resolveRelation(definition, relationName) {
   if (belongsToEntry) {
     const belongsToModel = belongsToEntry.model;
     const relatedModel = getModelFromRegistry(belongsToModel);
-    const relatedTable = relatedModel?.getTable?.() || toTableName(belongsToModel);
+    const relatedTable = relatedModel?.getTable?.() || toTableName2(belongsToModel);
     const relatedPk = relatedModel?.getDefinition?.()?.primaryKey || "id";
     const foreignKey = belongsToEntry.foreignKey || `${toSnakeCase(belongsToModel)}_id`;
     return { type: "belongsTo", relatedModelName: belongsToModel, relatedTable, foreignKey, localKey: relatedPk };
@@ -25212,7 +25251,7 @@ function resolveRelation(definition, relationName) {
     const isConfig = typeof found.entry === "object";
     const relatedModelName = isConfig ? found.entry.model : found.entry;
     const relatedModel = getModelFromRegistry(relatedModelName);
-    const relatedTable = relatedModel?.getTable?.() || toTableName(relatedModelName);
+    const relatedTable = relatedModel?.getTable?.() || toTableName2(relatedModelName);
     const config6 = isConfig ? found.entry : null;
     let pivotTable;
     let pivotModelName;
@@ -25224,7 +25263,7 @@ function resolveRelation(definition, relationName) {
       if (!throughModel) {
         throw new Error(`[orm] belongsToMany relation '${relationName}' on '${parentName}' references unknown through model '${config6.through}'. Make sure '${config6.through}' is registered.`);
       }
-      pivotTable = throughModel.getTable?.() || throughModel.getDefinition?.()?.table || toTableName(config6.through);
+      pivotTable = throughModel.getTable?.() || throughModel.getDefinition?.()?.table || toTableName2(config6.through);
     } else {
       const a2 = singularizeWord(parentTable);
       const b2 = singularizeWord(relatedTable);
@@ -25275,10 +25314,10 @@ function resolveRelation(definition, relationName) {
       return null;
     const throughModel = getModelFromRegistry(throughModelName);
     const throughDef = throughModel?.getDefinition?.() || throughModel?.definition;
-    const throughTable = throughModel?.getTable?.() || throughDef?.table || toTableName(throughModelName);
+    const throughTable = throughModel?.getTable?.() || throughDef?.table || toTableName2(throughModelName);
     const throughPk = throughDef?.primaryKey || "id";
     const targetModel = getModelFromRegistry(targetModelName);
-    const targetTable = targetModel?.getTable?.() || toTableName(targetModelName);
+    const targetTable = targetModel?.getTable?.() || toTableName2(targetModelName);
     return {
       type,
       relatedModelName: targetModelName,
@@ -27875,7 +27914,7 @@ function buildDatabaseSchema(models) {
   for (const modelName of Object.keys(models)) {
     const rawModel = models[modelName];
     const m2 = rawModel.definition ?? rawModel.getDefinition?.() ?? rawModel;
-    const table = m2.table || `${String(m2.name).toLowerCase()}s`;
+    const table = tableNameFor(m2);
     const attrs = m2.attributes ?? {};
     const columns = {};
     for (const key of Object.keys(attrs))
@@ -27887,30 +27926,53 @@ function buildDatabaseSchema(models) {
   }
   return schema;
 }
+var init_factory = () => {};
 
 // src/loader.ts
-import { readdirSync as readdirSync12, statSync as statSync5 } from "fs";
-import { basename, extname as extname4 } from "path";
-import process33 from "process";
-async function loadModels(options) {
-  const cwd = options.cwd ?? process33.cwd();
-  const dir = options.modelsDir.startsWith("/") ? options.modelsDir : `${cwd}/${options.modelsDir}`;
-  const result = {};
-  const entries = readdirSync12(dir);
+import { readdirSync as readdirSync12 } from "fs";
+import { basename, extname as extname4, isAbsolute as isAbsolute3, join as join17 } from "path";
+import process30 from "process";
+function isModelFile(name) {
+  const ext = extname4(name);
+  if (!MODEL_EXTENSIONS.has(ext))
+    return false;
+  const base = basename(name, ext);
+  if (base.startsWith("_") || base === "index")
+    return false;
+  return !base.endsWith(".d");
+}
+function isModelDefinition(def) {
+  if (!def || typeof def !== "object")
+    return false;
+  const d2 = def;
+  return typeof d2.name === "string" || typeof d2.table === "string";
+}
+function collectModelFiles(dir) {
+  const files = [];
+  const entries = readdirSync12(dir, { withFileTypes: true }).sort((a2, b2) => a2.name.localeCompare(b2.name));
   for (const entry of entries) {
-    const full = `${dir}/${entry}`;
-    const st = statSync5(full);
-    if (st.isDirectory())
-      continue;
-    const ext = extname4(full);
-    if (![".ts", ".mts", ".cts", ".js", ".mjs", ".cjs"].includes(ext))
+    const full = join17(dir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...collectModelFiles(full));
       continue;
+    }
+    if (isModelFile(entry.name))
+      files.push(full);
+  }
+  return files;
+}
+async function loadModels(options) {
+  const cwd = options.cwd ?? process30.cwd();
+  const dir = isAbsolute3(options.modelsDir) ? options.modelsDir : join17(cwd, options.modelsDir);
+  const result = {};
+  for (const full of collectModelFiles(dir)) {
     const cacheBuster = `?t=${Date.now()}-${Math.random().toString(36).slice(2)}`;
     const mod = await import(`${full}${cacheBuster}`);
     const rawDef = mod.default ?? mod;
     const def = rawDef.definition ?? rawDef.getDefinition?.() ?? rawDef;
-    const fileName = basename(entry, ext);
-    const name = def.name ?? fileName;
+    if (!isModelDefinition(def))
+      continue;
+    const name = def.name ?? basename(full, extname4(full));
     result[name] = {
       ...def,
       name
@@ -27918,7 +27980,10 @@ async function loadModels(options) {
   }
   return result;
 }
-var init_loader = () => {};
+var MODEL_EXTENSIONS;
+var init_loader = __esm(() => {
+  MODEL_EXTENSIONS = new Set([".ts", ".mts", ".cts", ".js", ".mjs", ".cjs"]);
+});
 
 // src/meta.ts
 function buildSchemaMeta(models) {
@@ -27930,7 +27995,7 @@ function buildSchemaMeta(models) {
   for (const name of Object.keys(models)) {
     const rawModel = models[name];
     const m2 = rawModel.definition ?? rawModel.getDefinition?.() ?? rawModel;
-    const table = m2.table || `${String(m2.name).toLowerCase()}s`;
+    const table = tableNameFor(m2);
     modelToTable[name] = table;
     tableToModel[table] = name;
     primaryKeys[table] = m2.primaryKey ?? "id";
@@ -28004,9 +28069,9 @@ function buildSchemaMeta(models) {
 var init_meta = () => {};
 
 // src/migrations.ts
-import { existsSync as existsSync21, mkdirSync as mkdirSync10, writeFileSync as writeFileSync14 } from "fs";
-import { dirname as dirname12, join as join17 } from "path";
-import process35 from "process";
+import { existsSync as existsSync23, mkdirSync as mkdirSync10, readdirSync as readdirSync13, readFileSync as readFileSync6, writeFileSync as writeFileSync14 } from "fs";
+import { dirname as dirname12, join as join18 } from "path";
+import process31 from "process";
 function info2(message) {
   if (config5.verbose)
     console.log(message);
@@ -28017,36 +28082,80 @@ function snakeCase(str) {
 function singularizeTable(table) {
   return singularizerFor(config5.relations?.singularizeStrategy)(table);
 }
-function findWorkspaceRoot6(startPath) {
+function lastCreatedMigrationFiles() {
+  return [...createdMigrationFiles];
+}
+function findWorkspaceRoot5(startPath) {
   let currentPath = startPath;
   while (currentPath !== dirname12(currentPath)) {
-    if (existsSync21(join17(currentPath, "package.json"))) {
+    if (existsSync23(join18(currentPath, "package.json"))) {
       return currentPath;
     }
     currentPath = dirname12(currentPath);
   }
-  return process35.cwd();
+  return process31.cwd();
 }
 function ensureSqlDirectory2() {
-  const workspaceRoot = findWorkspaceRoot6(process35.cwd());
-  const sqlDir = join17(workspaceRoot, "database", "migrations");
-  if (!existsSync21(sqlDir)) {
+  const workspaceRoot = findWorkspaceRoot5(process31.cwd());
+  const sqlDir = join18(workspaceRoot, "database", "migrations");
+  if (!existsSync23(sqlDir)) {
     mkdirSync10(sqlDir, { recursive: true });
     info2(`-- Created SQL directory: ${sqlDir}`);
   }
   return sqlDir;
 }
+function isGeneratedMigrationSql(sql2) {
+  return sql2.trimStart().startsWith(GENERATED_MARKER);
+}
+function migrationBody(sql2) {
+  return sql2.split(`
+`).filter((line) => !line.trimStart().startsWith("--")).join(`
+`).replace(/\s+/g, " ").trim().replace(/;+$/, "");
+}
+function existingMigrationBodies(sqlDir) {
+  const bodies = new Set;
+  let files;
+  try {
+    files = readdirSync13(sqlDir).filter((f2) => f2.endsWith(".sql"));
+  } catch {
+    return bodies;
+  }
+  for (const file2 of files) {
+    try {
+      bodies.add(migrationBody(readFileSync6(join18(sqlDir, file2), "utf8")));
+    } catch {}
+  }
+  return bodies;
+}
 function createMigrationFile(statement, fileName) {
   if (!statement)
     return false;
   const sqlDir = ensureSqlDirectory2();
+  if (existingCorpusBodies === null)
+    existingCorpusBodies = existingMigrationBodies(sqlDir);
+  const body = migrationBody(statement);
+  if (body.length > 0 && existingCorpusBodies.has(body)) {
+    info2(`-- Migration already in the corpus, not writing it again: ${fileName}`);
+    return false;
+  }
   migrationCounter++;
-  const sequence = useDeterministicNames ? String(migrationCounter).padStart(10, "0") : String(Math.floor(Date.now() / 1000) + migrationCounter);
-  const fullFileName = `${sequence}-${fileName}.sql`;
-  const filePath = join17(sqlDir, fullFileName);
-  writeFileSync14(filePath, statement);
+  let sequence = useDeterministicNames ? String(migrationCounter).padStart(10, "0") : String(Math.floor(Date.now() / 1000) + migrationCounter);
+  let fullFileName = `${sequence}-${fileName}.sql`;
+  if (!useDeterministicNames) {
+    let next = Number(sequence);
+    while (existsSync23(join18(sqlDir, fullFileName))) {
+      next += 1;
+      sequence = String(next);
+      fullFileName = `${sequence}-${fileName}.sql`;
+    }
+  }
+  const filePath = join18(sqlDir, fullFileName);
+  writeFileSync14(filePath, `${GENERATED_MARKER}
+${statement}`);
   info2(`-- Migration file created: ${fullFileName}`);
   migrationsCreatedCount++;
+  createdMigrationFiles.push(fullFileName);
+  existingCorpusBodies?.add(body);
   return true;
 }
 function guessTypeFromName(columnName) {
@@ -28221,7 +28330,7 @@ function buildMigrationPlan2(models, options) {
   const tables = [];
   for (const modelName of Object.keys(models)) {
     const model = models[modelName];
-    const table = model.table || `${String(model.name).toLowerCase()}s`;
+    const table = tableNameFor(model);
     const primaryKey = model.primaryKey ?? "id";
     const _autoIncrement = model.autoIncrement !== false;
     const attrs = model.attributes ?? {};
@@ -28313,9 +28422,7 @@ function buildMigrationPlan2(models, options) {
       if (columns.some((c2) => c2.name === fkColumnName))
         continue;
       const refTable = meta.modelToTable[rel.model];
-      if (!refTable)
-        continue;
-      const refPk = meta.primaryKeys[refTable] ?? "id";
+      const refPk = refTable ? meta.primaryKeys[refTable] ?? "id" : undefined;
       columns.push({
         name: fkColumnName,
         type: "bigint",
@@ -28323,7 +28430,7 @@ function buildMigrationPlan2(models, options) {
         isUnique: false,
         isNullable: true,
         hasDefault: false,
-        references: { table: refTable, column: refPk, onDelete: rel.onDelete }
+        references: refTable && refPk ? { table: refTable, column: refPk, onDelete: rel.onDelete } : undefined
       });
     }
     const traits = model.traits;
@@ -28404,7 +28511,7 @@ function buildMigrationPlan2(models, options) {
   for (const modelName of Object.keys(models)) {
     const model = models[modelName];
     const traits = model?.traits ?? {};
-    const modelTable = model.table || `${String(model.name).toLowerCase()}s`;
+    const modelTable = tableNameFor(model);
     const singular = singularizeTable(modelTable);
     if (traits.likeable) {
       const opts = typeof traits.likeable === "object" ? traits.likeable : {};
@@ -28471,7 +28578,7 @@ function buildMigrationPlan2(models, options) {
     const btm = model?.belongsToMany;
     if (!btm || typeof btm !== "object" || Array.isArray(btm))
       continue;
-    const parentTable = model.table || `${String(model.name).toLowerCase()}s`;
+    const parentTable = tableNameFor(model);
     const parentSingular = singularizeTable(parentTable);
     for (const [relKey, value] of Object.entries(btm)) {
       const cfg = value;
@@ -28532,6 +28639,8 @@ function generateSql(plan, opts = {}) {
   migrationCounter = 0;
   migrationsCreatedCount = 0;
   migrationsUpdatedCount = 0;
+  createdMigrationFiles = [];
+  existingCorpusBodies = null;
   useDeterministicNames = true;
   const emit = opts.dryRun ? () => false : createMigrationFile;
   const statements = [];
@@ -28793,12 +28902,13 @@ function referencesAreDifferent(r1, r2) {
   const act = (a2) => (a2 ?? "no action").toLowerCase();
   return r1.table !== r2.table || r1.column !== r2.column || act(r1.onDelete) !== act(r2.onDelete) || act(r1.onUpdate) !== act(r2.onUpdate);
 }
+function indexKey(index) {
+  return `${index.type}:${index.name}:${index.columns.join(",")}`;
+}
 function mapIndexesByKey(indexes) {
   const map = {};
-  for (const i2 of indexes) {
-    const key = `${i2.type}:${i2.name}:${i2.columns.join(",")}`;
-    map[key] = i2;
-  }
+  for (const i2 of indexes)
+    map[indexKey(i2)] = i2;
   return map;
 }
 function generateDiffOperations(previous, next, opts = {}) {
@@ -28813,10 +28923,13 @@ function generateDiffOperations(previous, next, opts = {}) {
     return { statements: statements2, operations: operations2 };
   }
   const applyRenames = opts.applyRenames !== false;
+  const preserveUnknownColumns = opts.preserveUnknownColumns === true;
   const emit = opts.dryRun ? () => false : createMigrationFile;
   migrationCounter = 0;
   migrationsCreatedCount = 0;
   migrationsUpdatedCount = 0;
+  createdMigrationFiles = [];
+  existingCorpusBodies = null;
   useDeterministicNames = false;
   const chunks = [];
   const operations = [];
@@ -28915,22 +29028,32 @@ function generateDiffOperations(previous, next, opts = {}) {
   }
   for (const tableName of Object.keys(nextTables)) {
     const prev = prevTables[tableName];
-    const curr = nextTables[tableName];
+    let curr = nextTables[tableName];
     if (!prev)
       continue;
     const prevCols = mapColumnsByName(prev.columns);
-    const currCols = mapColumnsByName(curr.columns);
     const prevIdx = mapIndexesByKey(prev.indexes);
-    const currIdx = mapIndexesByKey(curr.indexes);
+    let currCols = mapColumnsByName(curr.columns);
+    let currIdx = mapIndexesByKey(curr.indexes);
     let renames = [];
     let removedCols = Object.keys(prevCols).filter((n2) => !currCols[n2]);
     let addedCols = Object.keys(currCols).filter((n2) => !prevCols[n2]);
-    if (applyRenames) {
+    if (applyRenames && !preserveUnknownColumns) {
       const detected = detectColumnRenames(prevCols, currCols, dialect);
       renames = detected.renames;
       removedCols = detected.removed;
       addedCols = detected.added;
     }
+    if (preserveUnknownColumns && removedCols.length > 0) {
+      const preserved = removedCols.map((name) => prevCols[name]);
+      const preservedNames = new Set(removedCols);
+      const keptIndexes = prev.indexes.filter((idx) => idx.columns.some((c2) => preservedNames.has(c2)) && !currIdx[indexKey(idx)]);
+      info2(`-- Keeping ${preserved.length} column(s) on "${curr.table}" no model declares: ${removedCols.join(", ")} \u2014 reconciled from the database, where an undeclared column is out of scope rather than removed`);
+      curr = { ...curr, columns: [...curr.columns, ...preserved], indexes: [...curr.indexes, ...keptIndexes] };
+      currCols = mapColumnsByName(curr.columns);
+      currIdx = mapIndexesByKey(curr.indexes);
+      removedCols = [];
+    }
     const modifiedCols = Object.keys(currCols).filter((n2) => prevCols[n2] && columnsAreDifferent(prevCols[n2], currCols[n2], dialect));
     const fkChangedCols = Object.keys(currCols).filter((n2) => prevCols[n2] && referencesAreDifferent(prevCols[n2].references, currCols[n2].references));
     if (dialect === "sqlite") {
@@ -29078,11 +29201,12 @@ function generateDiffOperations(previous, next, opts = {}) {
 function generateDiffSql(previous, next, opts = {}) {
   return generateDiffOperations(previous, next, opts).statements;
 }
-var migrationCounter = 0, migrationsCreatedCount = 0, migrationsUpdatedCount = 0, useDeterministicNames = true;
+var migrationCounter = 0, migrationsCreatedCount = 0, migrationsUpdatedCount = 0, useDeterministicNames = true, createdMigrationFiles, existingCorpusBodies = null, GENERATED_MARKER = "-- qb:generated";
 var init_migrations = __esm(() => {
   init_config();
   init_drivers();
   init_meta();
+  createdMigrationFiles = [];
 });
 
 // src/schema.ts
@@ -29116,6 +29240,7 @@ var init_src2 = __esm(() => {
   init_dynamodb_single_table();
   init_dynamodb_tooling_adapter();
   init_dynamodb();
+  init_factory();
   init_loader();
   init_meta();
   init_migrations();
@@ -29125,11 +29250,11 @@ var init_src2 = __esm(() => {
 });
 
 // ../../node_modules/@stacksjs/clapp/dist/index.js
-import { existsSync as existsSync23 } from "fs";
+import { existsSync as existsSync25 } from "fs";
 import fs from "fs/promises";
 import os from "os";
 import path from "path";
-import process36 from "process";
+import process33 from "process";
 import { EventEmitter } from "events";
 import process52 from "process";
 import process210 from "process";
@@ -29153,10 +29278,10 @@ class Telemetry {
     this.configPath = path.join(configDir, "telemetry.json");
   }
   async isEnabled() {
-    if (process36.env.DO_NOT_TRACK === "1" || process36.env.DO_NOT_TRACK === "true") {
+    if (process33.env.DO_NOT_TRACK === "1" || process33.env.DO_NOT_TRACK === "true") {
       return false;
     }
-    if (process36.env.NO_TELEMETRY === "1" || process36.env.NO_TELEMETRY === "true") {
+    if (process33.env.NO_TELEMETRY === "1" || process33.env.NO_TELEMETRY === "true") {
       return false;
     }
     const config6 = await this.loadConfig();
@@ -29185,7 +29310,7 @@ class Telemetry {
       ...data,
       timestamp: Date.now(),
       platform: os.platform(),
-      nodeVersion: process36.version
+      nodeVersion: process33.version
     };
     this.events.push(telemetryEvent);
     if (this.events.length >= 10) {
@@ -29241,7 +29366,7 @@ class Telemetry {
     const config6 = await this.loadConfig();
     return {
       enabled: config6.enabled,
-      doNotTrack: process36.env.DO_NOT_TRACK === "1" || process36.env.DO_NOT_TRACK === "true",
+      doNotTrack: process33.env.DO_NOT_TRACK === "1" || process33.env.DO_NOT_TRACK === "true",
       eventsQueued: this.events.length,
       lastSent: config6.lastSent
     };
@@ -29251,7 +29376,7 @@ class Telemetry {
       return this.config;
     }
     try {
-      if (existsSync23(this.configPath)) {
+      if (existsSync25(this.configPath)) {
         const data = await fs.readFile(this.configPath, "utf-8");
         this.config = JSON.parse(data);
         return this.config;
@@ -31163,7 +31288,7 @@ function getPrefix() {
 }
 var prefix = getPrefix();
 // package.json
-var version2 = "0.1.63";
+var version2 = "0.2.0";
 
 // bin/cli.ts
 init_actions();
@@ -31218,7 +31343,7 @@ cli.command("unsafe <sql>", "Execute an unsafe SQL string (one statement with pa
 cli.command("file <path>", "Execute a SQL file (supports $1, $2 params)").option("--params <json>", "JSON array of parameters").example("query-builder file ./migrations/seed.sql").example('query-builder file ./reports/top.sql --params "[30]"').action(async (path2, opts) => {
   await file(path2, opts);
 });
-cli.command("migrate <dir>", "Generate SQL migrations from models").option("--dialect <d>", "Dialect (postgres|mysql|sqlite)", { default: "postgres" }).option("--state <path>", "Path to migration state file (defaults to <dir>/.qb-migrations.<dialect>.json)").option("--apply", "Execute the generated SQL against the database").option("--full", "Force full migration SQL instead of incremental diff").example("query-builder migrate ./app/Models --dialect postgres").action(async (dir, opts) => {
+cli.command("migrate <dir>", "Generate SQL migrations from models").option("--dialect <d>", "Dialect (postgres|mysql|sqlite) \u2014 defaults to the configured dialect").option("--state <path>", "Path to migration state file (defaults to <dir>/.qb-migrations.<dialect>.json)").option("--apply", "Execute the generated SQL against the database").option("--full", "Force full migration SQL instead of incremental diff").example("query-builder migrate ./app/Models --dialect postgres").action(async (dir, opts) => {
   try {
     await generateMigration(dir, {
       dialect: opts.dialect,
@@ -31262,7 +31387,7 @@ cli.command("relation:diagram", "Generate relationship diagram from models").opt
     proc.default.exitCode = 1;
   }
 });
-cli.command("migrate:fresh <dir>", "Reset database and run all migrations").option("--dialect <d>", "Dialect (postgres|mysql|sqlite)", { default: "postgres" }).option("--state <path>", "Path to migration state file (defaults to <dir>/.qb-migrations.<dialect>.json)").option("--full", "Force full migration SQL instead of incremental diff").example("query-builder migrate:fresh ./app/Models --dialect postgres").action(async (dir, opts) => {
+cli.command("migrate:fresh <dir>", "Reset database and run all migrations").option("--dialect <d>", "Dialect (postgres|mysql|sqlite) \u2014 defaults to the configured dialect").option("--state <path>", "Path to migration state file (defaults to <dir>/.qb-migrations.<dialect>.json)").option("--full", "Force full migration SQL instead of incremental diff").example("query-builder migrate:fresh ./app/Models --dialect postgres").action(async (dir, opts) => {
   try {
     console.log("-- Resetting database...");
     await resetDatabase(dir, {
@@ -31283,7 +31408,7 @@ cli.command("migrate:fresh <dir>", "Reset database and run all migrations").opti
     proc.default.exitCode = 1;
   }
 });
-cli.command("reset <dir>", "Drop all tables and reset database").option("--dialect <d>", "Dialect (postgres|mysql|sqlite)", { default: "postgres" }).option("--state <path>", "Path to migration state file (defaults to <dir>/.qb-migrations.<dialect>.json)").example("query-builder reset ./app/Models --dialect postgres").action(async (dir, opts) => {
+cli.command("reset <dir>", "Drop all tables and reset database").option("--dialect <d>", "Dialect (postgres|mysql|sqlite) \u2014 defaults to the configured dialect").option("--state <path>", "Path to migration state file (defaults to <dir>/.qb-migrations.<dialect>.json)").example("query-builder reset ./app/Models --dialect postgres").action(async (dir, opts) => {
   try {
     await resetDatabase(dir, {
       dialect: opts.dialect,
@@ -31387,16 +31512,20 @@ cli.command("migrate:list", "List all migrations (alias for migrate:status)").ex
     proc.default.exitCode = 1;
   }
 });
-cli.command("migrate:rollback", "Rollback migrations").option("--steps <n>", "Number of migrations to rollback", { default: 1 }).example("query-builder migrate:rollback").example("query-builder migrate:rollback --steps 2").action(async (opts) => {
+cli.command("migrate:rollback", "Rollback migrations").option("--steps <n>", "Number of migrations to rollback", { default: 1 }).option("--no-reverse-schema", "Only remove the migration records; leave the schema alone").option("--delete-files", "Also delete the rolled-back migration files from disk").example("query-builder migrate:rollback").example("query-builder migrate:rollback --steps 2").example("query-builder migrate:rollback --no-reverse-schema").action(async (opts) => {
   try {
-    await migrateRollback({ steps: Number(opts.steps) });
+    await migrateRollback({
+      steps: Number(opts.steps),
+      reverseSchema: opts.reverseSchema,
+      deleteFiles: Boolean(opts.deleteFiles)
+    });
   } catch (err) {
     console.error("-- Rollback failed:", err);
     const proc = await import("process");
     proc.default.exitCode = 1;
   }
 });
-cli.command("migrate:generate [dir]", "Generate migration from model changes").option("--dialect <d>", "Dialect (postgres|mysql|sqlite)", { default: "postgres" }).option("--state <path>", "Path to migration state file").option("--apply", "Execute the generated SQL").option("--full", "Force full migration SQL").example("query-builder migrate:generate").example("query-builder migrate:generate ./app/Models --dialect postgres").action(async (dir, opts) => {
+cli.command("migrate:generate [dir]", "Generate migration from model changes").option("--dialect <d>", "Dialect (postgres|mysql|sqlite) \u2014 defaults to the configured dialect").option("--state <path>", "Path to migration state file").option("--apply", "Execute the generated SQL").option("--full", "Force full migration SQL").example("query-builder migrate:generate").example("query-builder migrate:generate ./app/Models --dialect postgres").action(async (dir, opts) => {
   try {
     await migrateGenerate(dir, {
       dialect: opts?.dialect,
@@ -31428,7 +31557,7 @@ cli.command("db:stats", "Show database statistics (alias for db:info)").example(
     proc.default.exitCode = 1;
   }
 });
-cli.command("db:wipe", "Drop all tables from the database").option("--dialect <d>", "Dialect (postgres|mysql|sqlite)", { default: "postgres" }).option("--force", "Skip confirmation prompt").option("--verbose", "Enable verbose output").example("query-builder db:wipe").example("query-builder db:wipe --force").action(async (opts) => {
+cli.command("db:wipe", "Drop all tables from the database").option("--dialect <d>", "Dialect (postgres|mysql|sqlite) \u2014 defaults to the configured dialect").option("--force", "Skip confirmation prompt").option("--verbose", "Enable verbose output").example("query-builder db:wipe").example("query-builder db:wipe --force").action(async (opts) => {
   try {
     await dbWipe({
       dialect: opts.dialect,
@@ -31441,7 +31570,7 @@ cli.command("db:wipe", "Drop all tables from the database").option("--dialect <d
     proc.default.exitCode = 1;
   }
 });
-cli.command("db:optimize", "Optimize database tables (VACUUM, ANALYZE, OPTIMIZE)").option("--dialect <d>", "Dialect (postgres|mysql|sqlite)", { default: "postgres" }).option("--aggressive", "Use aggressive optimization (VACUUM FULL for postgres)").option("--tables <tables>", "Comma-separated list of tables to optimize").option("--verbose", "Enable verbose output").example("query-builder db:optimize").example("query-builder db:optimize --aggressive").example("query-builder db:optimize --tables users,posts").action(async (opts) => {
+cli.command("db:optimize", "Optimize database tables (VACUUM, ANALYZE, OPTIMIZE)").option("--dialect <d>", "Dialect (postgres|mysql|sqlite) \u2014 defaults to the configured dialect").option("--aggressive", "Use aggressive optimization (VACUUM FULL for postgres)").option("--tables <tables>", "Comma-separated list of tables to optimize").option("--verbose", "Enable verbose output").example("query-builder db:optimize").example("query-builder db:optimize --aggressive").example("query-builder db:optimize --tables users,posts").action(async (opts) => {
   try {
     await dbOptimize({
       dialect: opts.dialect,