turbine-orm 0.40.0 → 0.40.1

package/dist/cli/migrate.js

@@ -19,6 +19,24 @@ import { postgresql } from '../adapters/index.js';
 import { postgresDialect } from '../dialect.js';
 import { MigrationError } from '../errors.js';
 import { DESTRUCTIVE_KIND_LABEL, scanDestructiveSql } from './destructive.js';
+/** Extract the YYYYMMDDHHMMSS timestamp prefix from a migration name, or null. */
+export function migrationTimestamp(name) {
+    const m = name.match(/^(\d{14})(?:_|$)/);
+    return m ? m[1] : null;
+}
+/** Scan a set of migration files' UP sections for data-destroying statements. */
+export function collectUpDestructive(files) {
+    const offenders = [];
+    for (const file of files) {
+        const { up } = parseMigrationSQL(file.path);
+        if (!up)
+            continue;
+        const hits = scanDestructiveSql(up);
+        if (hits.length > 0)
+            offenders.push({ file: file.filename, hits });
+    }
+    return offenders;
+}
 // ---------------------------------------------------------------------------
 // Tracking table management
 // ---------------------------------------------------------------------------
@@ -432,7 +450,7 @@ async function validateChecksums(client, migrationsDir, dialect = postgresDialec
     }
     return mismatches;
 }
-function formatChecksumMismatchError(mismatches) {
+export function formatChecksumMismatchError(mismatches) {
     const modified = mismatches.filter((m) => m.type === 'modified');
     const missing = mismatches.filter((m) => m.type === 'missing');
     const lines = [
@@ -450,7 +468,14 @@ function formatChecksumMismatchError(mismatches) {
     lines.push('');
     lines.push('Fix one of these:');
     lines.push('  1. Restore the file(s) to their original content, OR');
-    lines.push('  2. Roll back the affected migrations with `npx turbine migrate down`, OR');
+    if (modified.length > 0) {
+        // `migrate down` needs the file on disk to read its DOWN section, so it is
+        // only a remedy for MODIFIED files, never for deleted ones.
+        lines.push('  2. Roll back the affected migrations with `npx turbine migrate down` (modified files only), OR');
+    }
+    if (missing.length > 0) {
+        lines.push('     (deleted files cannot be rolled back: restore the file, then run `migrate down` if needed), OR');
+    }
     lines.push('  3. Pass `--allow-drift` to bypass this check (advanced — make sure you know what you are doing).');
     return lines.join('\n');
 }
@@ -559,42 +584,43 @@ export async function migrateUp(connectionString, migrationsDir, options) {
             }
             const applied = await getAppliedMigrations(client, dialect);
             const appliedNames = new Set(applied.map((m) => m.name));
+            // Newest already-applied timestamp. Anything applied below this line is
+            // going in out of order (an older migration created/applied after a newer
+            // one). Used to surface a warning; never blocks.
+            const newestPrior = applied
+                .map((m) => ({ ts: migrationTimestamp(m.name), name: m.name }))
+                .filter((m) => m.ts !== null)
+                .sort((a, b) => (a.ts < b.ts ? 1 : a.ts > b.ts ? -1 : 0))[0];
             const allFiles = listMigrationFiles(migrationsDir);
             let pending = allFiles.filter((f) => !appliedNames.has(f.name));
             if (options?.step != null && options.step > 0) {
                 pending = pending.slice(0, options.step);
             }
+            // Destructive statements in the pending batch, computed once. Returned in
+            // the result regardless of the gate so `deploy` can print a notice even
+            // though it proceeds by design.
+            const destructive = collectUpDestructive(pending);
             // Data-loss gate: refuse to run pending migrations containing destructive
             // statements unless the caller has EXPLICITLY opted in. The CLI layers an
             // interactive typed confirmation on top of this; programmatic callers must
             // pass `allowDestructive: true`. Safe-by-default is the whole point — a
             // DROP TABLE should never run just because a file exists.
-            if (!options?.allowDestructive) {
-                const offenders = [];
-                for (const file of pending) {
-                    const { up } = parseMigrationSQL(file.path);
-                    if (!up)
-                        continue;
-                    const hits = scanDestructiveSql(up);
-                    if (hits.length > 0)
-                        offenders.push({ file: file.filename, hits });
-                }
-                if (offenders.length > 0) {
-                    const lines = ['[turbine] Refusing to apply migrations containing DESTRUCTIVE statements:', ''];
-                    for (const o of offenders) {
-                        lines.push(`  ${o.file}`);
-                        for (const h of o.hits) {
-                            lines.push(`    - [${h.kind}] ${h.target} — ${DESTRUCTIVE_KIND_LABEL[h.kind]}`);
-                        }
+            if (!options?.allowDestructive && destructive.length > 0) {
+                const lines = ['[turbine] Refusing to apply migrations containing DESTRUCTIVE statements:', ''];
+                for (const o of destructive) {
+                    lines.push(`  ${o.file}`);
+                    for (const h of o.hits) {
+                        lines.push(`    - [${h.kind}] ${h.target}: ${DESTRUCTIVE_KIND_LABEL[h.kind]}`);
                     }
-                    lines.push('');
-                    lines.push('Review the statements above. To proceed: run `npx turbine migrate up` interactively');
-                    lines.push('and confirm, pass --allow-destructive, or set allowDestructive: true programmatically.');
-                    throw new MigrationError(lines.join('\n'));
                 }
+                lines.push('');
+                lines.push('Review the statements above. To proceed: run `npx turbine migrate up` interactively');
+                lines.push('and confirm, pass --allow-destructive, or set allowDestructive: true programmatically.');
+                throw new MigrationError(lines.join('\n'));
             }
             const results = [];
             const errors = [];
+            const outOfOrder = [];
             for (const file of pending) {
                 const { up } = parseMigrationSQL(file.path);
                 if (!up) {
@@ -609,6 +635,11 @@ export async function migrateUp(connectionString, migrationsDir, options) {
                     await client.query(dialect.buildMigrationInsertApplied(quotedTrackingTable(dialect)), [file.name, hash]);
                     await client.query('COMMIT');
                     results.push(file);
+                    // Flag an out-of-order apply: this file's timestamp is older than a
+                    // migration that was already applied before this run started.
+                    if (newestPrior && file.timestamp && file.timestamp < newestPrior.ts) {
+                        outOfOrder.push({ applied: file.filename, newestPrior: `${newestPrior.name}.sql` });
+                    }
                 }
                 catch (err) {
                     await client.query('ROLLBACK');
@@ -618,7 +649,7 @@ export async function migrateUp(connectionString, migrationsDir, options) {
                     break;
                 }
             }
-            return { applied: results, errors };
+            return { applied: results, errors, destructive, outOfOrder };
         }
         finally {
             await releaseLock(client, lockId, adapter);
@@ -634,7 +665,9 @@ export async function migrateUp(connectionString, migrationsDir, options) {
  */
 export async function migrateDeploy(connectionString, migrationsDir, options) {
     return migrateUp(connectionString, migrationsDir, {
-        allowDrift: false,
+        // Honor `--allow-drift` on deploy exactly as `up` does: deploy's own drift
+        // error recommends this flag, so it must actually bypass the checksum block.
+        allowDrift: options?.allowDrift === true,
         allowDestructive: true,
         adapter: options?.adapter,
         dialect: options?.dialect,
@@ -693,7 +726,7 @@ export async function migrateDown(connectionString, migrationsDir, options) {
                     for (const o of offenders) {
                         lines.push(`  ${o.file}`);
                         for (const h of o.hits) {
-                            lines.push(`    - [${h.kind}] ${h.target} — ${DESTRUCTIVE_KIND_LABEL[h.kind]}`);
+                            lines.push(`    - [${h.kind}] ${h.target}: ${DESTRUCTIVE_KIND_LABEL[h.kind]}`);
                         }
                     }
                     lines.push('');
@@ -755,7 +788,8 @@ export async function migrateStatus(connectionString, migrationsDir, options) {
         const applied = await getAppliedMigrations(client, dialect);
         const appliedMap = new Map(applied.map((m) => [m.name, m]));
         const allFiles = listMigrationFiles(migrationsDir);
-        return allFiles.map((file) => {
+        const fileNames = new Set(allFiles.map((f) => f.name));
+        const fromFiles = allFiles.map((file) => {
             const record = appliedMap.get(file.name);
             let checksumValid;
             if (record) {
@@ -770,6 +804,25 @@ export async function migrateStatus(connectionString, migrationsDir, options) {
                 checksumValid,
             };
         });
+        // Applied migrations whose file was deleted from disk. up/deploy already
+        // catch this as drift; status must not silently drop them from history.
+        const missing = applied
+            .filter((m) => !fileNames.has(m.name))
+            .map((m) => ({
+            file: parseMigrationFilename(`${m.name}.sql`) ?? {
+                filename: `${m.name}.sql`,
+                path: '',
+                name: m.name,
+                timestamp: '',
+            },
+            applied: true,
+            appliedAt: m.applied_at,
+            checksumValid: false,
+            missingFile: true,
+        }));
+        // Keep the overall list in timestamp order so a deleted entry appears where
+        // it belongs in history, not tacked on at the end.
+        return [...fromFiles, ...missing].sort((a, b) => a.file.name < b.file.name ? -1 : a.file.name > b.file.name ? 1 : 0);
     }
     finally {
         await client.end();

package/dist/schema-sql.js

@@ -821,14 +821,23 @@ export async function schemaDiff(schema, connectionString) {
                     }
                 }
             }
-            // Check for columns in DB that are not in schema
+            // Check for columns in DB that are not in schema.
+            // The DROP COLUMN statement stays IN `result.statements` so the destructive
+            // gate (findDestructivePushStatements / scanDestructiveSql, and the migrate
+            // up gate) can see it and refuse by default. Safety is enforced by that
+            // gate, not by hiding the statement: withholding it here previously made
+            // `push` report "already in sync" for a destructive-only diff and print a
+            // false "Altered" for a mixed one, since the 0.36 guard never received it.
+            // No reverse is emitted (a dropped column and its data cannot be recreated
+            // automatically), so diff-generated migrations fall back to the documented
+            // irreversible-DOWN placeholder for this change.
             for (const dbColName of Object.keys(dbCols)) {
                 const hasField = Object.entries(tableDef.columns).some(([fieldName]) => camelToSnake(fieldName) === dbColName);
                 if (!hasField) {
                     const sql = `ALTER TABLE ${dialect.quoteIdentifier(tableName)} DROP COLUMN ${dialect.quoteIdentifier(dbColName)};`;
-                    const reverseSql = `-- Cannot auto-reverse DROP COLUMN for "${dbColName}" — add it back manually`;
+                    const reverseSql = `-- Cannot auto-reverse DROP COLUMN for "${dbColName}"; add it back manually`;
                     alterDef.columns.push({ column: dbColName, action: 'drop', sql, reverseSql });
-                    // Don't auto-add drops to statements for safety — user must opt in
+                    result.statements.push(sql);
                 }
             }
             if (alterDef.columns.length > 0) {

package/dist/seed.d.ts

@@ -1,4 +1,15 @@
 import { TurbineClient } from './client.js';
 export type SeedFunction = (db: TurbineClient) => Promise<void> | void;
 export type DefinedSeed = () => Promise<void>;
+/**
+ * Extract the filesystem path from a single V8 stack-trace line, regardless of
+ * whether the frame is a `file://` URL (ESM), a bare absolute path (CJS / tsx),
+ * or a wrapped `(… )` location. The trailing `:line:col` (and any surrounding
+ * parens) are peeled from the END so a Windows drive colon or a URL scheme colon
+ * inside the path never confuses the match. Non-file frames (`node:internal/…`,
+ * `<anonymous>`) return null.
+ *
+ * Exported for unit testing the frame parser in isolation.
+ */
+export declare function parseStackFramePath(line: string): string | null;
 export declare function defineSeed(fn: SeedFunction): DefinedSeed;

package/dist/seed.js

@@ -1,32 +1,104 @@
-import { realpathSync } from 'node:fs';
+import { realpathSync, writeFileSync } from 'node:fs';
 import { resolve } from 'node:path';
-import { pathToFileURL } from 'node:url';
+import { fileURLToPath, pathToFileURL } from 'node:url';
 import { TurbineClient } from './client.js';
 import { ConnectionError } from './errors.js';
 const emptySchema = { tables: {}, enums: {} };
-function entryUrl() {
-    const entry = process.argv[1];
-    if (!entry)
+/**
+ * Extract the filesystem path from a single V8 stack-trace line, regardless of
+ * whether the frame is a `file://` URL (ESM), a bare absolute path (CJS / tsx),
+ * or a wrapped `(… )` location. The trailing `:line:col` (and any surrounding
+ * parens) are peeled from the END so a Windows drive colon or a URL scheme colon
+ * inside the path never confuses the match. Non-file frames (`node:internal/…`,
+ * `<anonymous>`) return null.
+ *
+ * Exported for unit testing the frame parser in isolation.
+ */
+export function parseStackFramePath(line) {
+    // Peel the trailing `:line:col` (with any closing paren) from the END so a
+    // Windows drive colon or a `file://` scheme colon earlier in the path is never
+    // mistaken for the location separator.
+    const loc = line.match(/:(\d+):(\d+)\)?\s*$/);
+    if (!loc || loc.index === undefined)
         return null;
+    let head = line.slice(0, loc.index);
+    const paren = head.lastIndexOf('(');
+    if (paren !== -1) {
+        // `at fn (PATH:line:col)`: the path is whatever the last "(" wraps.
+        head = head.slice(paren + 1);
+    }
+    else {
+        // `at PATH:line:col`: drop the leading "    at " prefix.
+        head = head.replace(/^\s*at\s+/, '');
+    }
+    head = head.trim();
+    if (head.startsWith('file://')) {
+        try {
+            return fileURLToPath(head);
+        }
+        catch {
+            return null;
+        }
+    }
+    // Accept only absolute filesystem paths (POSIX `/…` or Windows `C:\…` / `C:/…`).
+    if (/^(\/|[A-Za-z]:[\\/])/.test(head))
+        return head;
+    return null;
+}
+/** Best-effort canonicalization so two spellings of the same file compare equal. */
+function canonicalPath(p) {
     try {
-        return pathToFileURL(realpathSync(entry)).href;
+        return realpathSync(p);
     }
     catch {
-        return pathToFileURL(resolve(entry)).href;
+        return resolve(p);
+    }
+}
+/**
+ * The canonical path of THIS module's own file, captured once at load time from
+ * a fresh stack. It is used to skip the library's own frames when locating the
+ * caller. This is robust to the src (`seed.ts`) vs published dist (`seed.js`)
+ * basename difference AND to the fact that the user's own file is ALSO named
+ * `seed.ts`, which a basename skip-list would wrongly exclude. This fixes the
+ * silent no-op: previously the plain-path skip-list only knew `src/seed.ts`, so
+ * the library's own `dist/seed.js` frame (or a tsx plain-path frame) was
+ * mistaken for the caller and the entry===caller self-run check never passed.
+ */
+const SELF_PATH = (() => {
+    const stack = new Error().stack;
+    if (!stack)
+        return null;
+    // Frame [1] (after the "Error" header) is this IIFE, i.e. the current module.
+    for (const line of stack.split('\n').slice(1)) {
+        const p = parseStackFramePath(line);
+        if (p)
+            return canonicalPath(p);
     }
+    return null;
+})();
+function entryUrl() {
+    const entry = process.argv[1];
+    if (!entry)
+        return null;
+    return pathToFileURL(canonicalPath(entry)).href;
 }
+/**
+ * The first stack frame that is NOT part of this module, expressed as a
+ * canonical `file://` URL. That frame is whoever invoked `defineSeed`: the
+ * user's seed module when the file is run directly.
+ */
 function callerUrl() {
     const stack = new Error().stack;
     if (!stack)
         return null;
     for (const line of stack.split('\n').slice(2)) {
-        const fileUrl = line.match(/(file:\/\/\/[^):]+):\d+:\d+/)?.[1];
-        if (fileUrl && !fileUrl.endsWith('/seed.ts') && !fileUrl.endsWith('/seed.js'))
-            return fileUrl;
-        const filePath = line.match(/\(?((?:\/|[A-Za-z]:\\)[^):]+):\d+:\d+\)?/)?.[1];
-        if (filePath && !filePath.endsWith('/src/seed.ts') && !filePath.endsWith('\\src\\seed.ts')) {
-            return pathToFileURL(resolve(filePath)).href;
-        }
+        const p = parseStackFramePath(line);
+        if (!p)
+            continue;
+        const canonical = canonicalPath(p);
+        if (SELF_PATH && canonical === SELF_PATH)
+            continue; // skip the library's own frames
+        return pathToFileURL(canonical).href;
     }
     return null;
 }
@@ -35,6 +107,24 @@ function isDirectSeedModule() {
     const caller = callerUrl();
     return process.env.NODE_TEST_CONTEXT === undefined && !!entry && !!caller && entry === caller;
 }
+/**
+ * Signal, to a parent `turbine seed` process, that a defineSeed callback
+ * actually executed to completion. The CLI sets `TURBINE_SEED_SENTINEL` to a
+ * temp path before spawning the seed; if the file never appears the CLI knows
+ * the seed module loaded but no callback ran, and reports that as a failure
+ * instead of a false "Seed completed".
+ */
+function markSeedRan() {
+    const sentinel = process.env.TURBINE_SEED_SENTINEL;
+    if (!sentinel)
+        return;
+    try {
+        writeFileSync(sentinel, 'ran');
+    }
+    catch {
+        // Best-effort only: an unwritable sentinel must never fail a good seed run.
+    }
+}
 async function runSeed(fn) {
     const connectionString = process.env.DATABASE_URL;
     if (!connectionString) {
@@ -43,6 +133,7 @@ async function runSeed(fn) {
     const db = new TurbineClient({ connectionString }, emptySchema);
     try {
         await fn(db);
+        markSeedRan();
     }
     finally {
         await db.disconnect();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "turbine-orm",
-  "version": "0.40.0",
+  "version": "0.40.1",
   "description": "Postgres-native TypeScript ORM — runs on Neon, Vercel Postgres, Cloudflare, Supabase. Streaming cursors, typed errors, single-query nested relations. One dependency, no WASM engine",
   "type": "module",
   "exports": {