@dbsp/cli 2.0.0 → 2.1.0

package/dist/index.js

@@ -3,11 +3,11 @@ import {
   createDbConnection,
   generateSchemaFileWithDiagnostics,
   redactDbUrl
-} from "./chunk-VUNVYYOZ.js";
+} from "./chunk-G6NS4BAV.js";
 import {
   loadSchema,
   loadSchemaFromCwd
-} from "./chunk-T4ODDHZQ.js";
+} from "./chunk-EO3GHEFW.js";
 import {
   config,
   validateIdentifier
@@ -52,16 +52,16 @@ var generateCommand = new Command("generate").description("Generate code from sc
       const log = useStdout ? console.error : console.log;
       log(`\u{1F4C4} Loaded schema from: ${schemaPath}`);
       const dialect = options.dialect ?? "postgresql";
-      if (dialect !== "postgresql") {
+      if (!isDialectSupported(dialect)) {
         console.error(
           `\u26A0\uFE0F  Warning: Only 'postgresql' dialect is currently supported. Using postgresql.`
         );
       }
       switch (target) {
         case "ddl": {
-          const casing = options.casing ?? "snake";
+          const dbCasing = mapCasingToDbCasing(options.casing) ?? schema.dbCasing ?? "snake_case";
+          const casingLabel = formatGenerateCasingLabel(dbCasing);
           const { createPgsqlCompileOnlyAdapter } = await import("@dbsp/adapter-pgsql");
-          const dbCasing = casing === "snake" ? "snake_case" : "preserve";
           const adapter = createPgsqlCompileOnlyAdapter({
             dbCasing,
             ...options.schemaName ? { schemaName: options.schemaName } : {}
@@ -81,7 +81,7 @@ var generateCommand = new Command("generate").description("Generate code from sc
               console.log(`\u2705 Generated DDL: ${outPath}`);
               console.log(`   Tables: ${schema.tableNames.length}`);
               console.log(`   Statements: ${ddlStatements.length}`);
-              console.log(`   Casing: ${casing}`);
+              console.log(`   Casing: ${casingLabel}`);
               if (options.drop) {
                 console.log(`   Includes DROP statements`);
               }
@@ -102,6 +102,31 @@ var generateCommand = new Command("generate").description("Generate code from sc
     }
   }
 );
+function isDialectSupported(dialect) {
+  return dialect === "postgresql";
+}
+function mapCasingToDbCasing(casing) {
+  switch (casing) {
+    case "snake":
+      return "snake_case";
+    case "camel":
+      return "camelCase";
+    case "none":
+      return "preserve";
+    default:
+      return void 0;
+  }
+}
+function formatGenerateCasingLabel(dbCasing) {
+  switch (dbCasing) {
+    case "snake_case":
+      return "snake";
+    case "camelCase":
+      return "camel";
+    case "preserve":
+      return "none";
+  }
+}
 
 // src/commands/introspect.ts
 import { mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "fs";
@@ -142,10 +167,10 @@ var introspectCommand = new Command2("introspect").description("Generate schema.
     try {
       const { pool } = await createDbConnection(options.db);
       try {
-        const { introspect: introspect4 } = await import("@dbsp/adapter-pgsql");
+        const { introspect } = await import("@dbsp/adapter-pgsql");
         const excludePatterns = options.exclude ? options.exclude.split(",").map((s) => s.trim()) : void 0;
         const includePatterns = options.include ? options.include.split(",").map((s) => s.trim()) : void 0;
-        const model = await introspect4(pool, {
+        const model = await introspect(pool, {
           schema: options.schemaName,
           ...excludePatterns ? { exclude: excludePatterns } : {},
           ...includePatterns ? { include: includePatterns } : {}
@@ -190,13 +215,13 @@ var introspectCommand = new Command2("introspect").description("Generate schema.
 
 // src/commands/migrate.ts
 import {
-  compareSchemata,
+  comparePgsqlDatabaseSchema,
+  createPgsqlAdapter,
   ensureMigrationsTable,
   generateMigrationFile,
   generateMigrationSQL,
   getAppliedMigrations,
   getNextSchemaVersion,
-  introspect,
   isDestructiveDown,
   parseMigrationFile,
   recordMigration,
@@ -321,6 +346,218 @@ function hasExecutableSql(stmt) {
     return t.length > 0 && !t.startsWith("--");
   });
 }
+var defaultMigrateDeps = {
+  withMigratePool,
+  ensureMigrationsTable,
+  withMigrationLock,
+  getAppliedMigrations,
+  scanMigrationFiles,
+  parseMigrationFile,
+  getNextSchemaVersion,
+  recordMigration,
+  removeMigrationRecord,
+  isDestructiveDown
+};
+function resolveMigrateDeps(deps) {
+  return { ...defaultMigrateDeps, ...deps };
+}
+async function runApply(options, deps) {
+  const d = resolveMigrateDeps(deps);
+  console.log("\u{1F504} Applying migrations");
+  console.log(`   Database: ${redactDbUrl(options.db)}`);
+  console.log(`   Directory: ${options.dir}`);
+  console.log("");
+  await d.withMigratePool(options.db, async (pool) => {
+    await d.ensureMigrationsTable(pool);
+    await d.withMigrationLock(pool, async (client) => {
+      const applied = await d.getAppliedMigrations(client);
+      const appliedMap = new Map(applied.map((m) => [m.name, m.checksum]));
+      const files = d.scanMigrationFiles(options.dir);
+      if (files.length === 0) {
+        console.log(`No migration files found in ${options.dir}`);
+        return;
+      }
+      for (const file of files) {
+        const existingChecksum = appliedMap.get(file.name);
+        if (existingChecksum !== void 0 && existingChecksum !== file.checksum) {
+          throw new MigrationError(
+            `Checksum mismatch for ${file.name}
+   Expected: ${existingChecksum}
+   Got:      ${file.checksum}
+
+Migration file has been tampered with after being applied.`
+          );
+        }
+      }
+      const pending = files.filter((f) => !appliedMap.has(f.name));
+      if (pending.length === 0) {
+        console.log("\u2705 All migrations already applied.");
+        return;
+      }
+      if (options.dryRun) {
+        console.log(`${pending.length} pending migration(s):`);
+        for (const file of pending) {
+          console.log(`   - ${file.name}`);
+        }
+        return;
+      }
+      let appliedCount = 0;
+      for (const file of pending) {
+        console.log(`  Applying: ${file.name}...`);
+        const parsed = d.parseMigrationFile(file.content);
+        const statements = parsed.upStatements.filter(hasExecutableSql);
+        const version = await d.getNextSchemaVersion(client);
+        const destructive = parsed.destructive === true;
+        try {
+          await client.query("BEGIN");
+          for (const stmt of statements) {
+            await client.query(stmt);
+          }
+          await d.recordMigration(
+            client,
+            file.name,
+            file.checksum,
+            version,
+            destructive
+          );
+          await client.query("COMMIT");
+        } catch (applyError) {
+          let rollbackError;
+          try {
+            await client.query("ROLLBACK");
+          } catch (e) {
+            rollbackError = e;
+          }
+          const primary = sanitizePgError(applyError);
+          if (rollbackError !== void 0) {
+            console.error(
+              `   Note: rollback also failed: ${sanitizePgError(rollbackError).message}`
+            );
+          }
+          throw primary;
+        }
+        appliedCount++;
+        console.log(`  \u2705 Applied: ${file.name}`);
+      }
+      console.log(`
+\u2705 ${appliedCount} migration(s) applied successfully.`);
+    });
+  });
+}
+async function runRollback(options, deps) {
+  const d = resolveMigrateDeps(deps);
+  console.log(`\u23EA Rolling back ${options.count} migration(s)`);
+  console.log(`   Database: ${redactDbUrl(options.db)}`);
+  console.log(`   Directory: ${options.dir}`);
+  console.log("");
+  await d.withMigratePool(options.db, async (pool) => {
+    await d.ensureMigrationsTable(pool);
+    await d.withMigrationLock(pool, async (client) => {
+      const applied = await d.getAppliedMigrations(client);
+      const sortedDesc = [...applied].sort(
+        (a, b) => b.name.localeCompare(a.name)
+      );
+      if (options.count > sortedDesc.length) {
+        throw new MigrationError(
+          `Cannot roll back ${options.count} migration(s) \u2014 only ${sortedDesc.length} applied`
+        );
+      }
+      const toRollback = sortedDesc.slice(0, options.count);
+      const files = d.scanMigrationFiles(options.dir);
+      const fileMap = new Map(files.map((f) => [f.name, f]));
+      let rolledBack = 0;
+      for (const record of toRollback) {
+        const file = fileMap.get(record.name);
+        if (!file) {
+          throw new MigrationError(
+            `Migration file not found on disk: ${record.name}`
+          );
+        }
+        if (file.checksum !== record.checksum) {
+          throw new MigrationError(
+            `Checksum mismatch for ${record.name}
+   Expected: ${record.checksum}
+   Got:      ${file.checksum}
+
+Migration file has been modified since it was applied.`
+          );
+        }
+        const parsed = d.parseMigrationFile(file.content);
+        if (!parsed.hasDown) {
+          throw new MigrationError(
+            `Migration ${record.name} has no DOWN section
+   Cannot roll back a migration without a DOWN section.`
+          );
+        }
+        const downStmts = parsed.downStatements.filter(hasExecutableSql);
+        if (downStmts.length === 0 && !options.force) {
+          throw new MigrationError(
+            `Migration ${record.name} has an empty DOWN section
+   Use --force to roll back anyway.`
+          );
+        }
+        const safeHeaderContradictedByDown = parsed.destructive === false && d.isDestructiveDown(downStmts);
+        if ((parsed.destructive !== false || safeHeaderContradictedByDown) && !options.force) {
+          if (parsed.destructive === true) {
+            throw new MigrationError(
+              `Migration ${record.name} has destructive DOWN operations
+   Use --force to proceed with destructive rollback.`
+            );
+          }
+          if (safeHeaderContradictedByDown) {
+            throw new MigrationError(
+              `Migration ${record.name} is marked non-destructive but its DOWN section contains an obvious destructive statement
+   Re-generate the migration with accurate dbsp metadata or pass --force.`
+            );
+          }
+          throw new MigrationError(
+            `Migration ${record.name} is unmarked or legacy
+   Re-generate the migration with dbsp metadata or pass --force.`
+          );
+        }
+        if (downStmts.length > 0 || options.force) {
+          console.log(`  Rolling back: ${record.name}...`);
+        }
+        try {
+          await client.query("BEGIN");
+          for (const stmt of downStmts) {
+            await client.query(stmt);
+          }
+          await d.removeMigrationRecord(client, record.name);
+          await client.query("COMMIT");
+        } catch (rollbackError) {
+          let rollbackCleanupError;
+          try {
+            await client.query("ROLLBACK");
+          } catch (e) {
+            rollbackCleanupError = e;
+          }
+          const primary = sanitizePgError(rollbackError);
+          if (rollbackCleanupError !== void 0) {
+            console.error(
+              `   Note: rollback also failed: ${sanitizePgError(rollbackCleanupError).message}`
+            );
+          }
+          throw primary;
+        }
+        rolledBack++;
+        console.log(`  \u2705 Rolled back: ${record.name}`);
+      }
+      console.log(`
+\u2705 ${rolledBack} migration(s) rolled back successfully.`);
+    });
+  });
+}
+function runRollbackCommand(countArg, options) {
+  const count = Number.parseInt(countArg, 10);
+  if (Number.isNaN(count) || count < 1) {
+    console.error("\u274C Count must be a positive integer");
+    process.exit(1);
+  }
+  return runMigrateAction(async () => {
+    await runRollback({ count, ...options });
+  });
+}
 var devCommand = new Command3("dev").description("Generate a migration from schema changes").option(
   "-s, --schema <path>",
   "Path to schema file (default: dbsp.schema.ts)"
@@ -333,10 +570,12 @@ var devCommand = new Command3("dev").description("Generate a migration from sche
     const loaded = await loadSchema(schemaPath);
     const schemaModel = loaded.model;
     await withMigratePool(options.db, async (pool) => {
-      const dbModel = await introspect(pool, {
-        ...options.schemaName ? { schema: options.schemaName } : {}
+      const adapter = createPgsqlAdapter(pool);
+      const diff = await comparePgsqlDatabaseSchema(adapter, schemaModel, {
+        ...options.schemaName ? { schema: options.schemaName } : {},
+        ...loaded.dbCasing ? { dbCasing: loaded.dbCasing } : {},
+        onWarning: (message) => console.warn(`\u26A0\uFE0F  ${message}`)
       });
-      const diff = compareSchemata(schemaModel, dbModel);
       if (diff.changes.length === 0) {
         console.log("\u2705 No changes detected \u2014 database matches schema.");
         return;
@@ -379,211 +618,10 @@ var devCommand = new Command3("dev").description("Generate a migration from sche
 );
 var applyCommand = new Command3("apply").description("Apply pending migrations").requiredOption("-d, --db <url>", "Database connection URL (required)").option("--dir <path>", "Migrations directory", DEFAULT_MIGRATIONS_DIR).option("--dry-run", "Show pending migrations without applying").action(
   (options) => runMigrateAction(async () => {
-    console.log("\u{1F504} Applying migrations");
-    console.log(`   Database: ${redactDbUrl(options.db)}`);
-    console.log(`   Directory: ${options.dir}`);
-    console.log("");
-    await withMigratePool(options.db, async (pool) => {
-      await ensureMigrationsTable(pool);
-      await withMigrationLock(pool, async (client) => {
-        const applied = await getAppliedMigrations(client);
-        const appliedMap = new Map(applied.map((m) => [m.name, m.checksum]));
-        const files = scanMigrationFiles(options.dir);
-        if (files.length === 0) {
-          console.log(`No migration files found in ${options.dir}`);
-          return;
-        }
-        for (const file of files) {
-          const existingChecksum = appliedMap.get(file.name);
-          if (existingChecksum !== void 0 && existingChecksum !== file.checksum) {
-            throw new MigrationError(
-              `Checksum mismatch for ${file.name}
-   Expected: ${existingChecksum}
-   Got:      ${file.checksum}
-
-Migration file has been tampered with after being applied.`
-            );
-          }
-        }
-        const pending = files.filter((f) => !appliedMap.has(f.name));
-        if (pending.length === 0) {
-          console.log("\u2705 All migrations already applied.");
-          return;
-        }
-        if (options.dryRun) {
-          console.log(`${pending.length} pending migration(s):`);
-          for (const file of pending) {
-            console.log(`   - ${file.name}`);
-          }
-          return;
-        }
-        let appliedCount = 0;
-        for (const file of pending) {
-          console.log(`  Applying: ${file.name}...`);
-          const parsed = parseMigrationFile(file.content);
-          const statements = parsed.upStatements.filter(hasExecutableSql);
-          const version = await getNextSchemaVersion(
-            client
-          );
-          const destructive = parsed.destructive === true;
-          try {
-            await client.query("BEGIN");
-            for (const stmt of statements) {
-              await client.query(stmt);
-            }
-            await recordMigration(
-              client,
-              file.name,
-              file.checksum,
-              version,
-              destructive
-            );
-            await client.query("COMMIT");
-          } catch (applyError) {
-            let rollbackError;
-            try {
-              await client.query("ROLLBACK");
-            } catch (e) {
-              rollbackError = e;
-            }
-            const primary = sanitizePgError(applyError);
-            if (rollbackError !== void 0) {
-              console.error(
-                `   Note: rollback also failed: ${sanitizePgError(rollbackError).message}`
-              );
-            }
-            throw primary;
-          }
-          appliedCount++;
-          console.log(`  \u2705 Applied: ${file.name}`);
-        }
-        console.log(
-          `
-\u2705 ${appliedCount} migration(s) applied successfully.`
-        );
-      });
-    });
+    await runApply(options);
   })
 );
-var rollbackCommand = new Command3("rollback").description("Roll back applied migrations").argument("<count>", "Number of migrations to roll back").requiredOption("-d, --db <url>", "Database connection URL (required)").option("--dir <path>", "Migrations directory", DEFAULT_MIGRATIONS_DIR).option("--force", "Force rollback of destructive or empty DOWN migrations").action(
-  (countArg, options) => {
-    const count = Number.parseInt(countArg, 10);
-    if (Number.isNaN(count) || count < 1) {
-      console.error("\u274C Count must be a positive integer");
-      process.exit(1);
-    }
-    return runMigrateAction(async () => {
-      console.log(`\u23EA Rolling back ${count} migration(s)`);
-      console.log(`   Database: ${redactDbUrl(options.db)}`);
-      console.log(`   Directory: ${options.dir}`);
-      console.log("");
-      await withMigratePool(options.db, async (pool) => {
-        await ensureMigrationsTable(pool);
-        await withMigrationLock(pool, async (client) => {
-          const applied = await getAppliedMigrations(
-            client
-          );
-          const sortedDesc = [...applied].sort(
-            (a, b) => b.name.localeCompare(a.name)
-          );
-          if (count > sortedDesc.length) {
-            throw new MigrationError(
-              `Cannot roll back ${count} migration(s) \u2014 only ${sortedDesc.length} applied`
-            );
-          }
-          const toRollback = sortedDesc.slice(0, count);
-          const files = scanMigrationFiles(options.dir);
-          const fileMap = new Map(files.map((f) => [f.name, f]));
-          let rolledBack = 0;
-          for (const record of toRollback) {
-            const file = fileMap.get(record.name);
-            if (!file) {
-              throw new MigrationError(
-                `Migration file not found on disk: ${record.name}`
-              );
-            }
-            if (file.checksum !== record.checksum) {
-              throw new MigrationError(
-                `Checksum mismatch for ${record.name}
-   Expected: ${record.checksum}
-   Got:      ${file.checksum}
-
-Migration file has been modified since it was applied.`
-              );
-            }
-            const parsed = parseMigrationFile(file.content);
-            if (!parsed.hasDown) {
-              throw new MigrationError(
-                `Migration ${record.name} has no DOWN section
-   Cannot roll back a migration without a DOWN section.`
-              );
-            }
-            const downStmts = parsed.downStatements.filter(hasExecutableSql);
-            if (downStmts.length === 0 && !options.force) {
-              throw new MigrationError(
-                `Migration ${record.name} has an empty DOWN section
-   Use --force to roll back anyway.`
-              );
-            }
-            const safeHeaderContradictedByDown = parsed.destructive === false && isDestructiveDown(downStmts);
-            if ((parsed.destructive !== false || safeHeaderContradictedByDown) && !options.force) {
-              if (parsed.destructive === true) {
-                throw new MigrationError(
-                  `Migration ${record.name} has destructive DOWN operations
-   Use --force to proceed with destructive rollback.`
-                );
-              }
-              if (safeHeaderContradictedByDown) {
-                throw new MigrationError(
-                  `Migration ${record.name} is marked non-destructive but its DOWN section contains an obvious destructive statement
-   Re-generate the migration with accurate dbsp metadata or pass --force.`
-                );
-              }
-              throw new MigrationError(
-                `Migration ${record.name} is unmarked or legacy
-   Re-generate the migration with dbsp metadata or pass --force.`
-              );
-            }
-            if (downStmts.length > 0 || options.force) {
-              console.log(`  Rolling back: ${record.name}...`);
-            }
-            try {
-              await client.query("BEGIN");
-              for (const stmt of downStmts) {
-                await client.query(stmt);
-              }
-              await removeMigrationRecord(
-                client,
-                record.name
-              );
-              await client.query("COMMIT");
-            } catch (rollbackError) {
-              let rollbackCleanupError;
-              try {
-                await client.query("ROLLBACK");
-              } catch (e) {
-                rollbackCleanupError = e;
-              }
-              const primary = sanitizePgError(rollbackError);
-              if (rollbackCleanupError !== void 0) {
-                console.error(
-                  `   Note: rollback also failed: ${sanitizePgError(rollbackCleanupError).message}`
-                );
-              }
-              throw primary;
-            }
-            rolledBack++;
-            console.log(`  \u2705 Rolled back: ${record.name}`);
-          }
-          console.log(
-            `
-\u2705 ${rolledBack} migration(s) rolled back successfully.`
-          );
-        });
-      });
-    });
-  }
-);
+var rollbackCommand = new Command3("rollback").description("Roll back applied migrations").argument("<count>", "Number of migrations to roll back").requiredOption("-d, --db <url>", "Database connection URL (required)").option("--dir <path>", "Migrations directory", DEFAULT_MIGRATIONS_DIR).option("--force", "Force rollback of destructive or empty DOWN migrations").action(runRollbackCommand);
 var statusCommand = new Command3("status").description("Show migration status").requiredOption("-d, --db <url>", "Database connection URL (required)").option("--dir <path>", "Migrations directory", DEFAULT_MIGRATIONS_DIR).option("--json", "Output as JSON").action(
   (options) => runMigrateAction(async () => {
     await withMigratePool(options.db, async (pool) => {
@@ -655,10 +693,11 @@ var migrateCommand = new Command3("migrate").description("Database migration man
 
 // src/commands/push.ts
 import {
-  compareSchemata as compareSchemata2,
+  comparePgsqlDatabaseSchema as comparePgsqlDatabaseSchema2,
+  createPgsqlAdapter as createPgsqlAdapter2,
   generateDDL,
   generateMigrationSQL as generateMigrationSQL2,
-  introspect as introspect2
+  getNamingPluginForDbCasing
 } from "@dbsp/adapter-pgsql";
 import { Command as Command4 } from "commander";
 
@@ -721,16 +760,10 @@ var pushCommand = new Command4("push").description("Push schema to database (add
         if (options.drop) {
           const statements = generateDDL(schemaModel, {
             includeDropStatements: true,
-            ...options.schemaName ? { schemaName: options.schemaName } : {}
+            ...options.schemaName ? { schemaName: options.schemaName } : {},
+            ...loaded.dbCasing !== void 0 ? { naming: getNamingPluginForDbCasing(loaded.dbCasing) } : {}
           });
-          const escapedTable = MIGRATIONS_TABLE.replace(
-            /[.*+?^${}()|[\]\\]/g,
-            "\\$&"
-          );
-          const migrationsPattern = new RegExp(
-            `DROP\\s+TABLE(?:\\s+IF\\s+EXISTS)?(?:\\s+"[^"]*"\\s*\\.)?\\s*"${escapedTable}"`,
-            "i"
-          );
+          const migrationsPattern = buildMigrationsTableDropPattern(MIGRATIONS_TABLE);
           const filtered = statements.filter(
             (stmt) => !migrationsPattern.test(stmt)
           );
@@ -739,10 +772,7 @@ var pushCommand = new Command4("push").description("Push schema to database (add
             ...options.dryRun !== void 0 ? { dryRun: options.dryRun } : {}
           });
           if (options.json) {
-            const droppedTables = statements.filter((s) => /DROP\s+TABLE/i.test(s)).filter((s) => !migrationsPattern.test(s)).map((s) => {
-              const m = s.match(/"([^"]+)"\s*(?:CASCADE\s*)?;?\s*$/i);
-              return m ? m[1] : s;
-            }).filter((t) => t !== void 0);
+            const droppedTables = statements.filter((s) => /DROP\s+TABLE/i.test(s)).filter((s) => !migrationsPattern.test(s)).map(extractDroppedTableName).filter((t) => t !== void 0);
             console.log(
               JSON.stringify(
                 {
@@ -762,10 +792,17 @@ var pushCommand = new Command4("push").description("Push schema to database (add
             );
           }
         } else {
-          const dbModel = await introspect2(pool, {
-            ...options.schemaName ? { schema: options.schemaName } : {}
-          });
-          const diff = compareSchemata2(schemaModel, dbModel);
+          const adapter = createPgsqlAdapter2(pool);
+          const compareOptions = {
+            ...options.schemaName ? { schema: options.schemaName } : {},
+            ...loaded.dbCasing ? { dbCasing: loaded.dbCasing } : {},
+            onWarning: (message) => console.warn(`\u26A0\uFE0F  ${message}`)
+          };
+          const diff = await comparePgsqlDatabaseSchema2(
+            adapter,
+            schemaModel,
+            compareOptions
+          );
           const statements = generateMigrationSQL2(diff, {
             includeDestructive: false,
             ...options.schemaName ? { schemaName: options.schemaName } : {}
@@ -802,6 +839,17 @@ var pushCommand = new Command4("push").description("Push schema to database (add
           const result = await executeDdl(pool, statements, {
             ...options.dryRun !== void 0 ? { dryRun: options.dryRun } : {}
           });
+          if (!options.dryRun) {
+            const postApplyDiff = await comparePgsqlDatabaseSchema2(
+              adapter,
+              schemaModel,
+              {
+                ...compareOptions,
+                previouslyAppliedDiff: diff
+              }
+            );
+            assertNoUnexpectedResidualDrift(postApplyDiff, skippedChanges);
+          }
           if (options.json) {
             console.log(
               JSON.stringify(
@@ -837,6 +885,17 @@ var pushCommand = new Command4("push").description("Push schema to database (add
     }
   }
 );
+function buildMigrationsTableDropPattern(tableName) {
+  const escaped = tableName.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+  return new RegExp(
+    `DROP\\s+TABLE(?:\\s+IF\\s+EXISTS)?(?:\\s+"[^"]*"\\s*\\.)?\\s*"${escaped}"`,
+    "i"
+  );
+}
+function extractDroppedTableName(statement) {
+  const match = statement.match(/"([^"]+)"\s*(?:CASCADE\s*)?;?\s*$/iu);
+  return match?.[1] ?? statement;
+}
 function outputResult(statements, options) {
   if (options.dryRun && !options.json) {
     console.log(`-- Dry run: ${statements.length} statement(s)
@@ -847,6 +906,30 @@ function outputResult(statements, options) {
     }
   }
 }
+function assertNoUnexpectedResidualDrift(postApplyDiff, skippedChanges) {
+  const skippedKeys = new Set(skippedChanges.map(changeIdentity));
+  const unexpected = postApplyDiff.changes.filter(
+    (change) => !(change.destructive && skippedKeys.has(changeIdentity(change)))
+  );
+  if (unexpected.length === 0) return;
+  throw new Error(
+    `Push did not converge after applying DDL; ${unexpected.length} outstanding change(s) remain:
+` + unexpected.map(formatOutstandingChange).join("\n")
+  );
+}
+function changeIdentity(change) {
+  return JSON.stringify([
+    change.kind,
+    change.table,
+    change.column ?? null,
+    change.details,
+    change.destructive
+  ]);
+}
+function formatOutstandingChange(change) {
+  const target = change.column ? `${change.table}.${change.column}` : change.table || "schema";
+  return `   - ${change.details} (${change.kind}: ${target})`;
+}
 
 // src/commands/repl.ts
 import { readFileSync as readFileSync2 } from "fs";
@@ -903,7 +986,7 @@ var replCommand = new Command5("repl").description("Launch interactive REPL for
     if (options.use) {
       validateIdentifier(options.use, "schema");
     }
-    const dbCasing = options.casing === "snake" ? "snake_case" : options.casing === "camel" ? "camelCase" : options.casing === "none" ? "preserve" : void 0;
+    const dbCasing = mapReplCasingOption(options.casing) ?? schema.dbCasing;
     if (options.eval || options.input) {
       const { runBatchMode } = await import("./repl/batch.js");
       const queries = [];
@@ -957,9 +1040,24 @@ var replCommand = new Command5("repl").description("Launch interactive REPL for
     process.exit(1);
   }
 });
+function mapReplCasingOption(casing) {
+  switch (casing) {
+    case "snake":
+      return "snake_case";
+    case "camel":
+      return "camelCase";
+    case "none":
+      return "preserve";
+    default:
+      return void 0;
+  }
+}
 
 // src/commands/verify.ts
-import { compareSchemata as compareSchemata3, introspect as introspect3 } from "@dbsp/adapter-pgsql";
+import {
+  comparePgsqlDatabaseSchema as comparePgsqlDatabaseSchema3,
+  createPgsqlAdapter as createPgsqlAdapter3
+} from "@dbsp/adapter-pgsql";
 import { Command as Command6 } from "commander";
 
 // src/verifier.ts
@@ -1104,10 +1202,15 @@ var verifyCommand = new Command6("verify").description("Compare schema vs real d
       const schemaModel = loaded.model;
       const { pool } = await createDbConnection(options.db);
       try {
-        const dbModel = await introspect3(pool, {
+        const adapter = createPgsqlAdapter3(pool);
+        const diff = await comparePgsqlDatabaseSchema3(adapter, schemaModel, {
+          ...options.schemaName ? { schema: options.schemaName } : {},
+          ...loaded.dbCasing !== void 0 ? { dbCasing: loaded.dbCasing } : {},
+          onWarning: (message) => console.warn(`\u26A0\uFE0F  ${message}`)
+        });
+        const dbModel = await adapter.introspect({
           ...options.schemaName ? { schema: options.schemaName } : {}
         });
-        const diff = compareSchemata3(schemaModel, dbModel);
         const schemaTables = Array.from(schemaModel.tables.keys());
         const dbTables = Array.from(dbModel.tables.keys());
         const result = verifyFromDiff(diff, schemaTables, dbTables);