@vibeorm/migrate 2.0.0-alpha.6 → 2.0.0-alpha.7

package/dist/execute.d.ts

@@ -10,7 +10,10 @@
  *   `usesSelfManagedTransactions` detects them. Plain statements in a
  *   self-managed script auto-commit individually (documented sqlite
  *   limitation: a mixed script is not atomic as a whole; each rebuild block
- *   is).
+ *   is). Because of that, the migration runner records per-statement progress
+ *   for these scripts and resumes with `selfManagedResumeStart`, which rewinds
+ *   INTO the enclosing block so the session-scoped `PRAGMA foreign_keys=OFF`
+ *   is re-issued before the block replays.
  * - `PRAGMA foreign_key_check` RETURNS VIOLATION ROWS instead of failing —
  *   `executeStatement` runs it row-returning (`values: []`, the adapter-sqlite
  *   contract for reads) and throws VIBE_MIGRATION when any come back.
@@ -21,6 +24,28 @@ import type { SqlExecutor } from "./types.ts";
 export declare function usesSelfManagedTransactions(params: {
     sql: readonly string[];
 }): boolean;
+/**
+ * Where a resume of a self-managed sqlite script must actually restart.
+ *
+ * A recorded statement_index can point INSIDE a rebuild block: the progress
+ * UPDATE issued after `PRAGMA foreign_keys=OFF;` auto-commits (no transaction
+ * is open yet), while every UPDATE after the block's `BEGIN;` is rolled back
+ * with the crash — so the persisted index lands on the block's `BEGIN;`, one
+ * past a pragma that is SESSION-scoped and gone in the new session. Resuming
+ * there would run the rebuild — `DROP TABLE` of a possibly-referenced parent
+ * included — with foreign keys ON.
+ *
+ * This rewinds `start` to the nearest preceding `PRAGMA foreign_keys=OFF` that
+ * is not already closed by a `PRAGMA foreign_keys=ON`. Replaying from a
+ * block's start is safe: the block is transactional (nothing of it survived a
+ * crash) and re-running a COMPLETED block is the idempotence the recipe
+ * already relies on. Scripts with no marker before `start` are returned
+ * unchanged.
+ */
+export declare function selfManagedResumeStart(params: {
+    sql: readonly string[];
+    start: number;
+}): number;
 /**
  * Execute one migration statement. On sqlite, `PRAGMA foreign_key_check` is
  * executed row-returning and its violations become a VIBE_MIGRATION error.

package/dist/execute.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"execute.d.ts","sourceRoot":"","sources":["../src/execute.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAGH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAC/C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAO9C,2EAA2E;AAC3E,wBAAgB,2BAA2B,CAAC,MAAM,EAAE;IAAE,GAAG,EAAE,SAAS,MAAM,EAAE,CAAA;CAAE,GAAG,OAAO,CAEvF;AAED;;;GAGG;AACH,wBAAsB,gBAAgB,CAAC,MAAM,EAAE;IAC7C,QAAQ,EAAE,WAAW,CAAC;IACtB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,OAAO,CAAC;CAClB,GAAG,OAAO,CAAC,IAAI,CAAC,CAkBhB;AAED;;;;GAIG;AACH,wBAAsB,yBAAyB,CAAC,MAAM,EAAE;IAAE,QAAQ,EAAE,WAAW,CAAA;CAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAWhG"}
+{"version":3,"file":"execute.d.ts","sourceRoot":"","sources":["../src/execute.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAGH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAC/C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAU9C,2EAA2E;AAC3E,wBAAgB,2BAA2B,CAAC,MAAM,EAAE;IAAE,GAAG,EAAE,SAAS,MAAM,EAAE,CAAA;CAAE,GAAG,OAAO,CAEvF;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE;IAC7C,GAAG,EAAE,SAAS,MAAM,EAAE,CAAC;IACvB,KAAK,EAAE,MAAM,CAAC;CACf,GAAG,MAAM,CAST;AAED;;;GAGG;AACH,wBAAsB,gBAAgB,CAAC,MAAM,EAAE;IAC7C,QAAQ,EAAE,WAAW,CAAC;IACtB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,OAAO,CAAC;CAClB,GAAG,OAAO,CAAC,IAAI,CAAC,CAkBhB;AAED;;;;GAIG;AACH,wBAAsB,yBAAyB,CAAC,MAAM,EAAE;IAAE,QAAQ,EAAE,WAAW,CAAA;CAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAWhG"}

package/dist/index.js

@@ -1957,10 +1957,22 @@ function artifactCreateSql(params) {
 // packages/migrate/src/execute.ts
 import { VibeError as VibeError8 } from "@vibeorm/schema";
 var SELF_MANAGED_MARKER = "PRAGMA foreign_keys=OFF";
+var SELF_MANAGED_RESTORE_MARKER = "PRAGMA foreign_keys=ON";
 var FK_CHECK_PREFIX = "PRAGMA foreign_key_check";
 function usesSelfManagedTransactions(params) {
   return params.sql.some((statement) => statement.startsWith(SELF_MANAGED_MARKER));
 }
+function selfManagedResumeStart(params) {
+  const { sql, start } = params;
+  for (let index = start - 1;index >= 0; index -= 1) {
+    const statement = sql[index];
+    if (statement.startsWith(SELF_MANAGED_RESTORE_MARKER))
+      return start;
+    if (statement.startsWith(SELF_MANAGED_MARKER))
+      return index;
+  }
+  return start;
+}
 async function executeStatement(params) {
   const { executor, statement, dialect } = params;
   if (dialect === "sqlite" && statement.startsWith(FK_CHECK_PREFIX)) {
@@ -2057,10 +2069,9 @@ function generateMigration(params) {
 async function applyMigrations(params) {
   const { executor, migrations } = params;
   const dialect = params.dialect ?? "postgres";
-  const transactional = DIALECT_CAPABILITIES[dialect].transactionalDdl;
-  await ensureMigrationsTable({ executor, dialect });
   await acquireLock({ executor, dialect });
   try {
+    await ensureMigrationsTable({ executor, dialect });
     const recorded = await recordedRows({ executor, dialect });
     const applied = [];
     const skipped = [];
@@ -2074,8 +2085,7 @@ async function applyMigrations(params) {
             meta: { migration: migration.name, statementIndex: stored.statementIndex }
           });
         }
-        const complete = stored.checksum === "" || transactional || stored.statementIndex >= migration.sql.length;
-        if (complete) {
+        if (isCompleteRecord({ dialect, migration, stored })) {
           assertChecksumMatches({ migration, stored: stored.checksum });
           skipped.push(migration.name);
           continue;
@@ -2091,10 +2101,10 @@ async function applyMigrations(params) {
         applied.push(migration.name);
         continue;
       }
-      if (transactional) {
-        await runTransactional({ executor, dialect, migration });
-      } else {
+      if (usesStatementBookkeeping({ dialect, sql: migration.sql })) {
         await runNonTransactional({ executor, dialect, migration, start: 0, insertRecord: true });
+      } else {
+        await runTransactional({ executor, dialect, migration });
       }
       applied.push(migration.name);
     }
@@ -2106,7 +2116,6 @@ async function applyMigrations(params) {
 async function migrationStatus(params) {
   const { executor, migrations } = params;
   const dialect = params.dialect ?? "postgres";
-  const transactional = DIALECT_CAPABILITIES[dialect].transactionalDdl;
   await ensureMigrationsTable({ executor, dialect });
   const recorded = await recordedRows({ executor, dialect });
   const applied = [];
@@ -2131,8 +2140,7 @@ async function migrationStatus(params) {
       mismatched.push(migration.name);
       continue;
     }
-    const complete = transactional || stored.statementIndex >= migration.sql.length;
-    if (complete)
+    if (isCompleteRecord({ dialect, migration, stored }))
       applied.push(migration.name);
     else
       pending.push(migration.name);
@@ -2157,7 +2165,6 @@ async function resolveMigration(params) {
 async function rollbackMigration(params) {
   const { executor, migration } = params;
   const dialect = params.dialect ?? "postgres";
-  const transactional = DIALECT_CAPABILITIES[dialect].transactionalDdl;
   const downSql = migration.downSql;
   if (downSql === undefined) {
     throw new VibeError9({
@@ -2166,9 +2173,9 @@ async function rollbackMigration(params) {
       meta: { migration: migration.name }
     });
   }
-  await ensureMigrationsTable({ executor, dialect });
   await acquireLock({ executor, dialect });
   try {
+    await ensureMigrationsTable({ executor, dialect });
     const recorded = await recordedRows({ executor, dialect });
     const stored = recorded.get(migration.name);
     if (stored === undefined) {
@@ -2181,7 +2188,7 @@ async function rollbackMigration(params) {
     const resumingDown = stored.statementIndex < 0;
     assertChecksumMatches({ migration, stored: stored.checksum });
     if (!resumingDown) {
-      const partialUp = !transactional && stored.checksum !== "" && stored.statementIndex < migration.sql.length;
+      const partialUp = !isCompleteRecord({ dialect, migration, stored });
       if (partialUp) {
         throw new VibeError9({
           code: "VIBE_MIGRATION",
@@ -2190,11 +2197,11 @@ async function rollbackMigration(params) {
         });
       }
     }
-    if (transactional) {
-      await runTransactionalDown({ executor, dialect, migration, downSql });
-    } else {
+    if (usesStatementBookkeeping({ dialect, sql: downSql })) {
       const start = resumingDown ? -stored.statementIndex - 1 : 0;
       await runNonTransactionalDown({ executor, dialect, migration, downSql, start });
+    } else {
+      await runTransactionalDown({ executor, dialect, migration, downSql });
     }
   } finally {
     await releaseLock({ executor, dialect });
@@ -2233,8 +2240,10 @@ async function runTransactionalDown(params) {
   }
 }
 async function runNonTransactionalDown(params) {
-  const { executor, dialect, migration, downSql, start } = params;
+  const { executor, dialect, migration, downSql } = params;
   const table = q4(dialect, MIGRATIONS_TABLE_NAME);
+  const selfManaged = dialect === "sqlite" && usesSelfManagedTransactions({ sql: downSql });
+  const start = selfManaged ? selfManagedResumeStart({ sql: downSql, start: params.start }) : params.start;
   const recordProgress = async (completed) => {
     await executor({
       text: `UPDATE ${table} SET ${q4(dialect, "statement_index")} = ${ph(dialect, 1)}, ${q4(dialect, "error")} = NULL WHERE ${q4(dialect, "name")} = ${ph(dialect, 2)}`,
@@ -2247,6 +2256,8 @@ async function runNonTransactionalDown(params) {
     try {
       await executeStatement({ executor, statement: downSql[index], dialect });
     } catch (error) {
+      if (selfManaged)
+        await cleanupSelfManagedFailure({ executor });
       try {
         await executor({
           text: `UPDATE ${table} SET ${q4(dialect, "error")} = ${ph(dialect, 1)} WHERE ${q4(dialect, "name")} = ${ph(dialect, 2)}`,
@@ -2302,8 +2313,10 @@ async function runTransactional(params) {
   }
 }
 async function runNonTransactional(params) {
-  const { executor, dialect, migration, start, insertRecord } = params;
+  const { executor, dialect, migration, insertRecord } = params;
   const table = q4(dialect, MIGRATIONS_TABLE_NAME);
+  const selfManaged = dialect === "sqlite" && usesSelfManagedTransactions({ sql: migration.sql });
+  const start = selfManaged ? selfManagedResumeStart({ sql: migration.sql, start: params.start }) : params.start;
   if (insertRecord) {
     await executor({
       text: `INSERT INTO ${table} (${q4(dialect, "name")}, ${q4(dialect, "checksum")}, ${q4(dialect, "statement_index")}) VALUES (${ph(dialect, 1)}, ${ph(dialect, 2)}, 0)`,
@@ -2314,6 +2327,8 @@ async function runNonTransactional(params) {
     try {
       await executeStatement({ executor, statement: migration.sql[index], dialect });
     } catch (error) {
+      if (selfManaged)
+        await cleanupSelfManagedFailure({ executor });
       try {
         await executor({
           text: `UPDATE ${table} SET ${q4(dialect, "error")} = ${ph(dialect, 1)} WHERE ${q4(dialect, "name")} = ${ph(dialect, 2)}`,
@@ -2364,6 +2379,20 @@ async function releaseLock(params) {
     }
   } catch {}
 }
+function usesStatementBookkeeping(params) {
+  const { dialect, sql } = params;
+  if (!DIALECT_CAPABILITIES[dialect].transactionalDdl)
+    return true;
+  return dialect === "sqlite" && usesSelfManagedTransactions({ sql });
+}
+function isCompleteRecord(params) {
+  const { dialect, migration, stored } = params;
+  if (stored.checksum === "")
+    return true;
+  if (!usesStatementBookkeeping({ dialect, sql: migration.sql }))
+    return true;
+  return stored.statementIndex >= migration.sql.length;
+}
 async function recordedRows(params) {
   const { executor, dialect } = params;
   const rows = await executor({
@@ -4057,4 +4086,4 @@ export {
   MIGRATIONS_TABLE_NAME
 };
 
-//# debugId=CA4C1473A398313F64756E2164756E21
+//# debugId=DA60A1F7881A22C064756E2164756E21