turbine-orm 0.77.1 → 0.78.0

package/dist/cjs/cli/index.js

@@ -93,6 +93,7 @@ const node_os_1 = require("node:os");
 const node_path_1 = require("node:path");
 const node_url_1 = require("node:url");
 const connection_url_js_1 = require("../connection-url.js");
+const errors_js_1 = require("../errors.js");
 const generate_js_1 = require("../generate.js");
 const index_advisor_js_1 = require("../index-advisor.js");
 const index_stats_js_1 = require("../index-stats.js");
@@ -362,6 +363,8 @@ function parseArgs(argv = process.argv.slice(2)) {
     // command instead, which is the actual problem.
     const accepted = acceptedFlagTokens(result.command);
     const unknownFlags = [];
+    /** The raw `--step` operand, judged after the loop. Absent means unset. */
+    let stepRaw;
     for (; i < args.length; i++) {
         const arg = args[i];
         const next = args[i + 1];
@@ -400,10 +403,17 @@ function parseArgs(argv = process.argv.slice(2)) {
                 i++;
                 break;
             case '--step':
-            case '-n':
-                result.step = next ? parseInt(next, 10) : undefined;
+            case '-n': {
+                // The VALUE is captured here and JUDGED after the loop, see
+                // `stepRaw` below. `--step -1` reached `applied.reverse().slice(0, -1)`,
+                // which is "every migration except the oldest" and began tearing down
+                // the history newest-first; `--step 0` and `--step abc` (NaN) were
+                // silent no-ops that look like a successful rollback. A count of things
+                // to do is a positive integer or it is a mistake.
+                stepRaw = next ?? '';
                 i++;
                 break;
+            }
             case '--dry-run':
                 result.dryRun = true;
                 break;
@@ -566,6 +576,21 @@ function parseArgs(argv = process.argv.slice(2)) {
     // are two lines of one error rather than two runs of the CLI.
     if (unknownFlags.length > 0)
         failUnknownFlags(result.command, unknownFlags);
+    // Flag VALUES are judged last, and only for a command that exists. Both halves
+    // are the fix for one report: `turbine genrate --step 0` used to complain
+    // about `--step` and never mention the misspelled command, because the check
+    // ran mid-loop and threw past `main()`'s dispatch. And it threw a bare
+    // `ValidationError` rather than calling `failArg`, so it printed one unstyled
+    // sentence with no banner and no hint, which reads like an internal crash.
+    // `accepted === undefined` means the command is unknown; main() reports that,
+    // which is the actual problem.
+    if (stepRaw !== undefined && accepted !== undefined) {
+        const parsed = /^\d+$/.test(stepRaw.trim()) ? Number.parseInt(stepRaw, 10) : Number.NaN;
+        if (!Number.isSafeInteger(parsed) || parsed < 1) {
+            failArg(`${(0, ui_js_1.cyan)('--step, -n')} expects a positive whole number of migrations, got ${(0, ui_js_1.bold)(stepRaw === '' ? '(nothing)' : `"${stepRaw}"`)}.`, 'It is a COUNT of migrations to apply or roll back, so the smallest useful value is 1.', 'Example: npx turbine migrate down --step 2');
+        }
+        result.step = parsed;
+    }
     return result;
 }
 // ---------------------------------------------------------------------------
@@ -1348,6 +1373,7 @@ async function runInitGenerate(config, url) {
     const spinner = new ui_js_1.Spinner('Introspecting database').start();
     try {
         const schema = await (0, introspect_js_1.introspect)({
+            keepColumnNames: config.keepColumnNames,
             connectionString: url,
             schema: config.schema,
             include: config.include.length ? config.include : undefined,
@@ -1612,7 +1638,7 @@ async function cmdInit(args, config) {
         }
         switch (step.id) {
             case 'config': {
-                (0, node_fs_1.writeFileSync)('turbine.config.ts', (0, config_js_1.configTemplate)(args.url ?? undefined), 'utf-8');
+                (0, node_fs_1.writeFileSync)('turbine.config.ts', (0, config_js_1.configTemplate)(args.url ?? undefined, config.schema), 'utf-8');
                 (0, ui_js_1.success)(state.configExists ? `Overwrote ${(0, ui_js_1.cyan)('turbine.config.ts')}` : `Created ${(0, ui_js_1.cyan)('turbine.config.ts')}`);
                 tsFilesWritten.push('turbine.config.ts');
                 // A `--url` with a password is never inlined by configTemplate, so the
@@ -1775,6 +1801,7 @@ async function cmdGenerate(args, config) {
     const spinner = new ui_js_1.Spinner('Introspecting database schema').start();
     const skippedInternalTables = [];
     const schema = await (0, introspect_js_1.introspect)({
+        keepColumnNames: config.keepColumnNames,
         connectionString: url,
         schema: config.schema,
         include: config.include.length ? config.include : undefined,
@@ -1975,6 +2002,7 @@ async function cmdMigrateFromPrisma(args, config) {
         (0, ui_js_1.label)('Database', (0, ui_js_1.redactUrl)(url));
         const spinner = new ui_js_1.Spinner('Introspecting database schema').start();
         schemaMeta = await (0, introspect_js_1.introspect)({
+            keepColumnNames: config.keepColumnNames,
             connectionString: url,
             // The Postgres NAMESPACE is fixed to `public` here (`--schema` names the
             // Prisma file, not the namespace).
@@ -2224,7 +2252,7 @@ async function cmdMigrate(args, config) {
         console.log(`    ${(0, ui_js_1.cyan)('--step, -n')}         Number of migrations to apply/rollback`);
         console.log(`    ${(0, ui_js_1.cyan)('--dry-run')}          Show SQL without executing`);
         console.log(`    ${(0, ui_js_1.cyan)('--allow-destructive')} Run data-destroying statements without prompting`);
-        console.log(`    ${(0, ui_js_1.cyan)('--allow-drift')}      Bypass checksum validation on ${(0, ui_js_1.cyan)('up')} / ${(0, ui_js_1.cyan)('deploy')} ${(0, ui_js_1.dim)('(advanced)')}`);
+        console.log(`    ${(0, ui_js_1.cyan)('--allow-drift')}      Re-baseline drifted checksums on ${(0, ui_js_1.cyan)('up')} / ${(0, ui_js_1.cyan)('deploy')} / ${(0, ui_js_1.cyan)('down')} ${(0, ui_js_1.dim)('(advanced)')}`);
         (0, ui_js_1.newline)();
         console.log(`  ${(0, ui_js_1.bold)('Recipes')} ${(0, ui_js_1.dim)('(--recipe):')}`);
         for (const [key, recipe] of Object.entries(migrate_js_1.MIGRATION_RECIPES)) {
@@ -2515,6 +2543,7 @@ async function cmdMigrateUp(args, config) {
     (0, ui_js_1.label)('Database', (0, ui_js_1.redactUrl)(url));
     (0, ui_js_1.label)('Migrations', config.migrationsDir);
     (0, ui_js_1.newline)();
+    warnIgnoredMigrationFiles(config.migrationsDir);
     const allFiles = (0, migrate_js_1.listMigrationFiles)(config.migrationsDir);
     if (allFiles.length === 0) {
         (0, ui_js_1.warn)('No migration files found.');
@@ -2523,19 +2552,29 @@ async function cmdMigrateUp(args, config) {
         return;
     }
     if (args.dryRun) {
-        const status = await (0, migrate_js_1.migrateStatus)(url, config.migrationsDir);
+        const status = await (0, migrate_js_1.migrateStatus)(url, config.migrationsDir, { schema: config.schema });
         let pending = status.filter((st) => !st.applied).map((st) => st.file);
         if (args.step != null && args.step > 0)
             pending = pending.slice(0, args.step);
+        // The same pre-flight the real run does, by calling the same two functions
+        // rather than re-deriving their rules. They live inside `migrateUp`, which a
+        // dry run never reaches, so `--dry-run` used to green-light a batch the real
+        // command refuses outright: an empty-UP migration previewed as "would apply
+        // 1 migration" and exit 0, and the deploy that followed on merge failed.
+        // A preview that is quieter than the run it previews is not a preview.
+        (0, migrate_js_1.assertNoEmbeddedTransactions)(pending, 'up');
+        (0, migrate_js_1.assertUpHasStatements)(pending);
         printMigrationDryRun(pending, 'up');
         return;
     }
     // Big, loud warning when bypassing drift detection, this is a deliberately
     // dangerous operation and the user should see it on every invocation.
     if (args.allowDrift) {
-        (0, ui_js_1.warn)('--allow-drift is set, checksum validation is DISABLED for this run.');
-        console.log(`  ${(0, ui_js_1.dim)('Applied migrations may have been modified or deleted on disk.')}`);
-        console.log(`  ${(0, ui_js_1.dim)('Proceed only if you are intentionally rewriting migration history.')}`);
+        (0, ui_js_1.warn)('--allow-drift is set: a drifted migration will be RE-BASELINED, not skipped.');
+        console.log(`  ${(0, ui_js_1.dim)('Checksum validation still runs, and its result is written back to the history')}`);
+        console.log(`  ${(0, ui_js_1.dim)("table: each modified file's stored checksum becomes its current content.")}`);
+        console.log(`  ${(0, ui_js_1.dim)('The SQL that already ran is NOT re-run. Proceed only if you are')}`);
+        console.log(`  ${(0, ui_js_1.dim)('intentionally rewriting migration history.')}`);
         (0, ui_js_1.newline)();
     }
     if (args.allowDestructive) {
@@ -2561,6 +2600,7 @@ async function cmdMigrateUp(args, config) {
             allowDrift: args.allowDrift,
             allowDestructive: args.allowDestructive,
             onNoTransaction,
+            schema: config.schema,
         });
     }
     catch (err) {
@@ -2578,19 +2618,26 @@ async function cmdMigrateUp(args, config) {
             allowDrift: args.allowDrift,
             allowDestructive: true,
             onNoTransaction,
+            schema: config.schema,
         });
     }
-    if (result.applied.length === 0 && result.errors.length === 0) {
-        spinner.succeed('All migrations are up to date');
-        (0, ui_js_1.newline)();
-        return;
-    }
     if (result.applied.length > 0) {
         spinner.succeed(`Applied ${(0, ui_js_1.bold)(String(result.applied.length))} migration(s)`);
         for (const file of result.applied) {
             console.log(`    ${(0, ui_js_1.green)(ui_js_1.symbols.check)} ${file.filename}`);
         }
     }
+    else if (result.errors.length === 0) {
+        spinner.succeed('All migrations are up to date');
+    }
+    // Reported on EVERY path, including the one where nothing was applied. That is
+    // `--allow-drift`'s most common case by far (you edited an already-applied
+    // file, so nothing is pending), and it used to sit below an early return: the
+    // stored checksum was rewritten and the terminal said everything was up to
+    // date. A write to migration history announced as a no-op is worse than no
+    // report at all, because the reader now believes the file and the database
+    // still disagree.
+    reportRebaselined(result.rebaselined);
     warnOutOfOrder(result.outOfOrder);
     if (result.errors.length > 0) {
         spinner.fail('Migration failed');
@@ -2603,6 +2650,40 @@ async function cmdMigrateUp(args, config) {
     }
     (0, ui_js_1.newline)();
 }
+/**
+ * Report each applied migration whose stored checksum was re-baselined to the
+ * file's current content, naming both hashes so the change is auditable from
+ * the terminal output alone.
+ */
+function reportRebaselined(rebaselined) {
+    if (rebaselined.length === 0)
+        return;
+    (0, ui_js_1.newline)();
+    (0, ui_js_1.warn)(`Re-baselined ${(0, ui_js_1.bold)(String(rebaselined.length))} migration checksum(s) to the current file content:`);
+    for (const r of rebaselined) {
+        console.log(`    ${(0, ui_js_1.yellow)(ui_js_1.symbols.arrowRight)} ${r.name}.sql  ${(0, ui_js_1.dim)(`${r.from.slice(0, 12)} -> ${r.to.slice(0, 12)}`)}`);
+    }
+    console.log(`  ${(0, ui_js_1.dim)('The history table now records what is on disk, so future runs need no --allow-drift.')}`);
+    (0, ui_js_1.newline)();
+}
+/**
+ * Warn about `.sql` files in the migrations directory that the runner will
+ * never see, because their name is not `YYYYMMDDHHMMSS_<name>.sql`.
+ *
+ * They were skipped in silence by `status`, `up` and `deploy` alike, so a
+ * hand-named migration simply never ran and nothing said so.
+ */
+function warnIgnoredMigrationFiles(migrationsDir) {
+    const ignored = (0, migrate_js_1.listIgnoredSqlFiles)(migrationsDir);
+    if (ignored.length === 0)
+        return;
+    (0, ui_js_1.warn)(`${(0, ui_js_1.bold)(String(ignored.length))} .sql file(s) in ${migrationsDir} are NOT migrations and will never run:`);
+    for (const name of ignored)
+        console.log(`    ${(0, ui_js_1.yellow)(ui_js_1.symbols.dot)} ${name}`);
+    console.log(`  ${(0, ui_js_1.dim)('A migration filename must be')} ${(0, ui_js_1.cyan)('YYYYMMDDHHMMSS_name.sql')}${(0, ui_js_1.dim)('.')}`);
+    console.log(`  ${(0, ui_js_1.dim)('Rename the file(s), or create them with')} ${(0, ui_js_1.cyan)('npx turbine migrate create <name>')}${(0, ui_js_1.dim)('.')}`);
+    (0, ui_js_1.newline)();
+}
 /** Print a one-line warning for each migration applied out of timestamp order. */
 function warnOutOfOrder(outOfOrder) {
     if (outOfOrder.length === 0)
@@ -2640,8 +2721,9 @@ async function cmdMigrateDeploy(args, config) {
     (0, ui_js_1.label)('Database', (0, ui_js_1.redactUrl)(url));
     (0, ui_js_1.label)('Migrations', config.migrationsDir);
     (0, ui_js_1.newline)();
+    warnIgnoredMigrationFiles(config.migrationsDir);
     const spinner = new ui_js_1.Spinner('Checking pending migrations').start();
-    const plan = await (0, migrate_js_1.inspectMigrationDeploy)(url, config.migrationsDir);
+    const plan = await (0, migrate_js_1.inspectMigrationDeploy)(url, config.migrationsDir, { schema: config.schema });
     spinner.stop();
     // Drift handling: honor --allow-drift exactly like `up`. Without it, block;
     // with it, warn loudly and proceed.
@@ -2655,8 +2737,10 @@ async function cmdMigrateDeploy(args, config) {
             (0, ui_js_1.errorLine)();
             process.exit(1);
         }
-        (0, ui_js_1.warn)('--allow-drift is set: checksum validation is DISABLED for this deploy.');
-        console.log(`  ${(0, ui_js_1.dim)('Applied migrations may have been modified or deleted on disk.')}`);
+        (0, ui_js_1.warn)('--allow-drift is set: a drifted migration will be RE-BASELINED, not skipped.');
+        console.log(`  ${(0, ui_js_1.dim)('Checksum validation still runs, and its result is written back to the history')}`);
+        console.log(`  ${(0, ui_js_1.dim)("table: each modified file's stored checksum becomes its current content.")}`);
+        console.log(`  ${(0, ui_js_1.dim)('The SQL that already ran is NOT re-run.')}`);
         (0, ui_js_1.newline)();
     }
     if (args.dryRun) {
@@ -2665,10 +2749,21 @@ async function cmdMigrateDeploy(args, config) {
             (0, ui_js_1.newline)();
             return;
         }
+        // The same pre-flight the real run does, by calling the same two functions
+        // rather than re-deriving their rules. They live inside `migrateUp`, which a
+        // dry run never reaches, so `--dry-run` used to green-light a batch the real
+        // command refuses outright: an empty-UP migration previewed as "would apply
+        // 1 migration" and exit 0, and the deploy that followed on merge failed.
+        // A preview that is quieter than the run it previews is not a preview.
+        (0, migrate_js_1.assertNoEmbeddedTransactions)(plan.pending, 'up');
+        (0, migrate_js_1.assertUpHasStatements)(plan.pending);
         (0, ui_js_1.info)(`${(0, ui_js_1.bold)(String(plan.pending.length))} pending migration(s)`);
         for (const file of plan.pending) {
             console.log(`    ${(0, ui_js_1.yellow)(ui_js_1.symbols.dot)} ${file.filename}`);
         }
+        // The real deploy warns about out-of-order applies; a preview that is
+        // quieter than the run it previews is not a preview.
+        warnOutOfOrder(plan.outOfOrder);
         // Surface destructive statements even in a dry run so CI can see them.
         const destructive = (0, migrate_js_1.collectUpDestructive)(plan.pending);
         if (destructive.length > 0) {
@@ -2683,18 +2778,24 @@ async function cmdMigrateDeploy(args, config) {
     if (destructive.length > 0)
         printDestructiveNotice(destructive);
     const runSpinner = new ui_js_1.Spinner('Deploying migrations').start();
-    const result = await (0, migrate_js_1.migrateDeploy)(url, config.migrationsDir, { allowDrift: args.allowDrift });
-    if (result.applied.length === 0 && result.errors.length === 0) {
-        runSpinner.succeed('0 applied, all migrations are up to date');
-        (0, ui_js_1.newline)();
-        return;
-    }
+    const result = await (0, migrate_js_1.migrateDeploy)(url, config.migrationsDir, { allowDrift: args.allowDrift, schema: config.schema });
     if (result.applied.length > 0) {
         runSpinner.succeed(`${(0, ui_js_1.bold)(String(result.applied.length))} applied`);
         for (const file of result.applied) {
             console.log(`    ${(0, ui_js_1.green)(ui_js_1.symbols.check)} ${file.filename}`);
         }
     }
+    else if (result.errors.length === 0) {
+        runSpinner.succeed('0 applied, all migrations are up to date');
+    }
+    // Reported on EVERY path, including the one where nothing was applied. That is
+    // `--allow-drift`'s most common case by far (you edited an already-applied
+    // file, so nothing is pending), and it used to sit below an early return: the
+    // stored checksum was rewritten and the terminal said everything was up to
+    // date. A write to migration history announced as a no-op is worse than no
+    // report at all, because the reader now believes the file and the database
+    // still disagree.
+    reportRebaselined(result.rebaselined);
     warnOutOfOrder(result.outOfOrder);
     if (result.errors.length > 0) {
         runSpinner.fail('Deploy failed');
@@ -2752,11 +2853,24 @@ async function cmdMigrateDown(args, config) {
     (0, ui_js_1.label)('Migrations', config.migrationsDir);
     (0, ui_js_1.newline)();
     if (args.dryRun) {
-        const status = await (0, migrate_js_1.migrateStatus)(url, config.migrationsDir);
-        // Rollback order is newest-applied first, and a migration whose file is
-        // missing has no DOWN section to show.
-        const applied = status.filter((st) => st.applied && !st.missingFile).map((st) => st.file);
-        printMigrationDryRun(applied.reverse().slice(0, args.step ?? 1), 'down');
+        // Computed by the RUNNER'S rule (planMigrationRollback), not re-derived
+        // from `status`. The old derivation sorted by filename and dropped applied
+        // migrations whose file is missing, so with a deleted file it named the
+        // migration AFTER the gap while the real run stopped at the gap.
+        const plan = await (0, migrate_js_1.planMigrationRollback)(url, config.migrationsDir, {
+            step: args.step ?? 1,
+            schema: config.schema,
+            // The real rollback refuses on drift unless this is set, so the preview
+            // has to be told too: without it a deleted migration file previewed as
+            // "would roll back 1 migration" while `migrate down` refused with E006.
+            allowDrift: args.allowDrift,
+        });
+        printMigrationDryRun(plan.toRollback, 'down');
+        if (plan.stoppedAt) {
+            (0, ui_js_1.warn)(`Rollback would STOP at ${(0, ui_js_1.bold)(`${plan.stoppedAt.name}.sql`)}: ${plan.stoppedAt.error}`);
+            console.log(`  ${(0, ui_js_1.dim)('A rollback batch is strictly LIFO with no gaps, so nothing after it would run.')}`);
+            (0, ui_js_1.newline)();
+        }
         return;
     }
     const spinner = new ui_js_1.Spinner('Rolling back migration(s)').start();
@@ -2765,6 +2879,8 @@ async function cmdMigrateDown(args, config) {
         result = await (0, migrate_js_1.migrateDown)(url, config.migrationsDir, {
             step: args.step ?? 1,
             allowDestructive: args.allowDestructive,
+            allowDrift: args.allowDrift,
+            schema: config.schema,
         });
     }
     catch (err) {
@@ -2780,19 +2896,27 @@ async function cmdMigrateDown(args, config) {
         result = await (0, migrate_js_1.migrateDown)(url, config.migrationsDir, {
             step: args.step ?? 1,
             allowDestructive: true,
+            allowDrift: args.allowDrift,
+            schema: config.schema,
         });
     }
-    if (result.rolledBack.length === 0 && result.errors.length === 0) {
-        spinner.succeed('No migrations to roll back');
-        (0, ui_js_1.newline)();
-        return;
-    }
     if (result.rolledBack.length > 0) {
         spinner.succeed(`Rolled back ${(0, ui_js_1.bold)(String(result.rolledBack.length))} migration(s)`);
         for (const file of result.rolledBack) {
             console.log(`    ${(0, ui_js_1.yellow)(ui_js_1.symbols.arrowRight)} ${file.filename}`);
         }
     }
+    else if (result.errors.length === 0) {
+        spinner.succeed('No migrations to roll back');
+    }
+    // Reported on EVERY path, including the one where nothing was applied. That is
+    // `--allow-drift`'s most common case by far (you edited an already-applied
+    // file, so nothing is pending), and it used to sit below an early return: the
+    // stored checksum was rewritten and the terminal said everything was up to
+    // date. A write to migration history announced as a no-op is worse than no
+    // report at all, because the reader now believes the file and the database
+    // still disagree.
+    reportRebaselined(result.rebaselined);
     if (result.errors.length > 0) {
         spinner.fail('Rollback failed');
         for (const { file, error: msg } of result.errors) {
@@ -2817,7 +2941,8 @@ async function cmdMigrateStatus(_args, config) {
         (0, ui_js_1.newline)();
         return;
     }
-    const statuses = await (0, migrate_js_1.migrateStatus)(url, config.migrationsDir);
+    warnIgnoredMigrationFiles(config.migrationsDir);
+    const statuses = await (0, migrate_js_1.migrateStatus)(url, config.migrationsDir, { schema: config.schema });
     const appliedCount = statuses.filter((s) => s.applied).length;
     const pendingCount = statuses.filter((s) => !s.applied).length;
     (0, ui_js_1.info)(`${(0, ui_js_1.bold)(String(appliedCount))} applied, ${pendingCount > 0 ? (0, ui_js_1.yellow)((0, ui_js_1.bold)(String(pendingCount))) : (0, ui_js_1.bold)(String(pendingCount))} pending`);
@@ -2885,10 +3010,61 @@ function getSeedExecutionPlan(seedFile) {
     }
     throw new Error(`Unsupported seed file extension: ${ext || '(none)'}. Use seed.ts, seed.js, or seed.sql.`);
 }
+/**
+ * The seed's pinned connection string, refusing a configured schema that does
+ * not exist before any seed kind runs.
+ *
+ * `migrate` gained that guard and `seed` did not, because the seed reached
+ * `connectionStringForSchema` directly instead of going through the migration
+ * runner's connect helper. So seeding a project whose schema was missing (a
+ * typo, or a fresh database nobody had created it in) failed with a bare
+ * `relation "..." does not exist`: no error code, no schema name, no mention of
+ * search_path or turbine.config.ts. That is verbatim the failure the guard
+ * exists to prevent.
+ *
+ * Checked ONCE here rather than in each of the three seed kinds, because that
+ * is the only place all three still share: the `.sql` kind opens its own client
+ * below, while the `.ts` and `.js` kinds connect somewhere this process cannot
+ * reach (a `tsx` CHILD PROCESS, and the user's own `defineSeed` callback), both
+ * of them through the `DATABASE_URL` this function returns.
+ *
+ * The probe also reads the connection's own `search_path`, so the pin EXTENDS
+ * it rather than replacing it, exactly as `migrate` does. Without that, seeding
+ * into a pinned schema stops resolving extension types and functions that the
+ * unpinned connection could see.
+ */
+async function seedConnectionString(config) {
+    const schema = config.schema;
+    if (schema === undefined || schema === '')
+        return config.url;
+    // Before the connection: an unpinnable NAME is not a missing schema.
+    (0, migrate_js_1.assertPinnableSchema)(schema);
+    const { default: pg } = await Promise.resolve().then(() => __importStar(require('pg')));
+    const probe = new pg.Client({ connectionString: config.url });
+    await probe.connect();
+    let inherited;
+    try {
+        await (0, migrate_js_1.assertSchemaExists)(probe, schema);
+        const shown = await probe.query('SHOW search_path');
+        inherited = (0, connection_url_js_1.parseSearchPathValue)(shown.rows[0]?.search_path ?? '');
+    }
+    finally {
+        await probe.end();
+    }
+    return (0, migrate_js_1.connectionStringForSchema)(config.url, schema, inherited);
+}
 async function runSeedPlan(plan, config) {
     const oldDatabaseUrl = process.env.DATABASE_URL;
-    if (config.url)
-        process.env.DATABASE_URL = config.url;
+    // The seed connects through DATABASE_URL, whichever way it runs: `defineSeed`
+    // reads it in the tsx child and in the in-process `import()`, and the `.sql`
+    // path opens a client on it below. So the configured schema is applied HERE,
+    // once, as the `options=-c search_path` connection parameter (never a `SET`),
+    // and every seed kind inherits it. Without this the seed ran against the
+    // role's default path while `push` and the generated client used
+    // `config.schema`, so the two halves of one project wrote to two namespaces.
+    const seedUrl = config.url ? await seedConnectionString(config) : undefined;
+    if (seedUrl)
+        process.env.DATABASE_URL = seedUrl;
     try {
         if (plan.kind === 'tsx') {
             if (!(0, loader_js_1.canResolveTsx)()) {
@@ -2907,7 +3083,7 @@ async function runSeedPlan(plan, config) {
                     stdio: 'inherit',
                     env: {
                         ...process.env,
-                        DATABASE_URL: config.url || process.env.DATABASE_URL,
+                        DATABASE_URL: seedUrl || process.env.DATABASE_URL,
                         TURBINE_SEED_SENTINEL: sentinel,
                     },
                 });
@@ -2930,7 +3106,10 @@ async function runSeedPlan(plan, config) {
             await mod.default();
             return;
         }
-        const url = requireUrl(config);
+        // `seedUrl` is already pinned and already schema-checked; `requireUrl` is
+        // only reached when no url was configured at all, in which case there is no
+        // schema to pin either.
+        const url = seedUrl ?? requireUrl(config);
         const { default: pg } = await Promise.resolve().then(() => __importStar(require('pg')));
         const client = new pg.Client({ connectionString: url });
         await client.connect();
@@ -2990,6 +3169,7 @@ async function cmdStatus(_args, config) {
     (0, ui_js_1.newline)();
     const spinner = new ui_js_1.Spinner('Introspecting database').start();
     const schema = await (0, introspect_js_1.introspect)({
+        keepColumnNames: config.keepColumnNames,
         connectionString: url,
         schema: config.schema,
         include: config.include.length ? config.include : undefined,
@@ -3135,6 +3315,7 @@ async function cmdDoctor(args, config) {
     }
     const spinner = jsonMode ? null : new ui_js_1.Spinner('Introspecting database').start();
     const schema = await (0, introspect_js_1.introspect)({
+        keepColumnNames: config.keepColumnNames,
         connectionString: url,
         schema: config.schema,
         include: config.include.length ? config.include : undefined,
@@ -4141,6 +4322,7 @@ function showInitHelp() {
     console.log(`    ${(0, ui_js_1.cyan)('--skip-seed')}        Don't create the seed file or run the seed`);
     console.log(`    ${(0, ui_js_1.cyan)('--skip-push')}        Don't push the schema to the database`);
     console.log(`    ${(0, ui_js_1.cyan)('--skip-generate')}    Don't generate the typed client`);
+    console.log(`    ${(0, ui_js_1.cyan)('--schema, -s')} ${(0, ui_js_1.dim)('<name>')} Postgres schema to write into config ${(0, ui_js_1.dim)('(default: public)')}`);
     (0, ui_js_1.newline)();
 }
 function showGenerateHelp() {
@@ -4248,8 +4430,9 @@ function showMigrateHelp() {
     console.log(`    ${(0, ui_js_1.cyan)('--recipe')} ${(0, ui_js_1.dim)('<name>')}   Scaffold a sanctioned migration pattern ${(0, ui_js_1.dim)('(create only, e.g. backfill)')}`);
     console.log(`    ${(0, ui_js_1.cyan)('--step, -n')} ${(0, ui_js_1.dim)('<N>')}    Number of migrations to apply/rollback`);
     console.log(`    ${(0, ui_js_1.cyan)('--dry-run')}         Show SQL without executing`);
-    console.log(`    ${(0, ui_js_1.cyan)('--allow-drift')}     Bypass checksum validation ${(0, ui_js_1.dim)('(migrate up only, advanced)')}`);
+    console.log(`    ${(0, ui_js_1.cyan)('--allow-drift')}     Re-baseline drifted checksums, REWRITING history ${(0, ui_js_1.dim)('(up / deploy / down)')}`);
     console.log(`    ${(0, ui_js_1.cyan)('--allow-destructive')} Run data-destroying migration statements without the interactive confirm`);
+    console.log(`    ${(0, ui_js_1.cyan)('--schema, -s')} ${(0, ui_js_1.dim)('<name>')}  Postgres schema the migrations run in ${(0, ui_js_1.dim)('(default: public)')}`);
     console.log(`    ${(0, ui_js_1.cyan)('--verbose, -v')}     Show detailed output`);
     (0, ui_js_1.newline)();
     console.log(`  ${(0, ui_js_1.bold)('Examples:')}`);
@@ -4276,7 +4459,8 @@ function showSeedHelp() {
     console.log(`  ${(0, ui_js_1.dim)('TypeScript seeds run with')} ${(0, ui_js_1.cyan)('npx tsx')} ${(0, ui_js_1.dim)('and can export')} ${(0, ui_js_1.cyan)('defineSeed(fn)')}${(0, ui_js_1.dim)('.')}`);
     (0, ui_js_1.newline)();
     console.log(`  ${(0, ui_js_1.bold)('Options:')}`);
-    console.log(`    ${(0, ui_js_1.cyan)('--url, -u')} ${(0, ui_js_1.dim)('<url>')}   Postgres connection string`);
+    console.log(`    ${(0, ui_js_1.cyan)('--url, -u')} ${(0, ui_js_1.dim)('<url>')}     Postgres connection string`);
+    console.log(`    ${(0, ui_js_1.cyan)('--schema, -s')} ${(0, ui_js_1.dim)('<name>')}  Postgres schema the seed writes into ${(0, ui_js_1.dim)('(default: public)')}`);
     (0, ui_js_1.newline)();
 }
 function showStatusHelp() {
@@ -4484,7 +4668,7 @@ function showHelp() {
     console.log(`    ${(0, ui_js_1.cyan)('--recipe')} ${(0, ui_js_1.dim)('<name>')}       Scaffold a named migration recipe, e.g. backfill ${(0, ui_js_1.dim)('(create)')}`);
     console.log(`    ${(0, ui_js_1.cyan)('--step, -n')} ${(0, ui_js_1.dim)('<N>')}       Number of migrations to apply/rollback`);
     console.log(`    ${(0, ui_js_1.cyan)('--allow-destructive')}  Run data-destroying statements without prompting ${(0, ui_js_1.dim)('(up/down/push)')}`);
-    console.log(`    ${(0, ui_js_1.cyan)('--allow-drift')}        Bypass checksum validation on ${(0, ui_js_1.cyan)('migrate up')} / ${(0, ui_js_1.cyan)('deploy')} ${(0, ui_js_1.dim)('(advanced)')}`);
+    console.log(`    ${(0, ui_js_1.cyan)('--allow-drift')}        Re-baseline drifted checksums on ${(0, ui_js_1.cyan)('migrate up')} / ${(0, ui_js_1.cyan)('deploy')} / ${(0, ui_js_1.cyan)('down')} ${(0, ui_js_1.dim)('(advanced)')}`);
     (0, ui_js_1.newline)();
     console.log(`  ${(0, ui_js_1.bold)('Init options:')}`);
     console.log(`    ${(0, ui_js_1.cyan)('--yes, -y')}            Accept every step's default (non-interactive)`);
@@ -4656,7 +4840,20 @@ function showVersion() {
 // Main
 // ---------------------------------------------------------------------------
 async function main() {
-    const args = parseArgs();
+    let args;
+    try {
+        args = parseArgs();
+    }
+    catch (err) {
+        // A last-resort net. Every flag refusal parseArgs makes goes through
+        // `failArg` (banner, red line, hints) and exits there, so nothing is
+        // expected here; anything that does arrive is a bug in the parser rather
+        // than in the caller's command line, and printing it beats swallowing it.
+        (0, ui_js_1.errorLine)();
+        (0, ui_js_1.error)(err instanceof Error ? err.message : String(err));
+        (0, ui_js_1.errorLine)();
+        process.exit(1);
+    }
     // Quick exits that don't need config
     if (args.command === 'help' || args.command === '--help' || args.command === '-h') {
         showHelp();
@@ -4786,7 +4983,20 @@ async function main() {
     }
     catch (err) {
         if (err instanceof Error) {
-            if (err.message.includes('ECONNREFUSED') || err.message.includes('connection')) {
+            // TYPE first, message second. These branches sniff for substrings, and
+            // `ValidationError` beat them by accident: a refused `--schema` value says
+            // "used as a connection parameter", which contains "connection", so a bad
+            // flag value was reported under "Could not connect to database" with three
+            // firewall hints. A typed error already knows what it is.
+            if (err instanceof errors_js_1.ValidationError) {
+                (0, ui_js_1.errorLine)();
+                (0, ui_js_1.error)((0, ui_js_1.redactUrl)(err.message));
+                if (args.verbose && err.stack) {
+                    (0, ui_js_1.errorLine)();
+                    console.error((0, ui_js_1.dim)((0, ui_js_1.redactUrl)(err.stack)));
+                }
+            }
+            else if (err.message.includes('ECONNREFUSED') || err.message.includes('connection')) {
                 (0, ui_js_1.errorLine)();
                 (0, ui_js_1.error)(`Could not connect to database`);
                 (0, ui_js_1.errorLine)(`${(0, ui_js_1.dim)((0, ui_js_1.redactUrl)(err.message))}`);

package/dist/cjs/cli/mcp.d.ts

@@ -26,9 +26,32 @@ export interface McpTransport {
      */
     pool?: PgCompatPool;
 }
+/**
+ * Why a session ended: an explicit {@link McpServerHandle.dispose} (a signal,
+ * stdin closing), or the server closing it ITSELF because the peer's framing
+ * was lost. `runMcpServer` exits non-zero on the latter so a supervisor
+ * restarts the server rather than assuming a clean end.
+ */
+export type McpCloseReason = 'disposed' | 'framing-lost';
 export interface McpServerHandle {
     dispose(): Promise<void>;
+    /**
+     * Resolves once the session has ended and the pool is closed, by either
+     * path. After the unframed-buffer refusal the server used to detach its
+     * reader and then neither exit nor answer: a live process that would never
+     * speak again, which a supervisor cannot tell from a healthy idle one.
+     */
+    closed: Promise<McpCloseReason>;
 }
+/**
+ * The most bytes the stdio reader will hold WITHOUT seeing a newline.
+ *
+ * 8 MiB, which is far above any real request: the largest thing a client sends
+ * here is a `compile_query` args object, and the tool schemas cap what can
+ * meaningfully be in one. It is a liveness bound, not a policy: see the check
+ * itself for why an over-long line ends the session instead of being truncated.
+ */
+export declare const MAX_STDIO_BUFFER_BYTES: number;
 export declare function startMcpServer(options: McpServerOptions, transport?: McpTransport): McpServerHandle;
 /**
  * Every SHORTEST relation chain from `from` to `to`, in deterministic order.