velocious 1.0.695 → 1.0.696

package/build/database/migrations-ledger.js

@@ -4,6 +4,11 @@ import {digg} from "diggerize"
 import TableData from "./table-data/index.js"
 
 const TABLE_NAME = "schema_migrations"
+/** SQL Server "There is already an object named ..." — raised when two sessions race to create the same table. */
+const MSSQL_OBJECT_ALREADY_EXISTS_ERROR_NUMBER = 2714
+/** SQL Server deadlock victim — raised when concurrent sessions deadlock on the same catalog reads. */
+const MSSQL_DEADLOCK_VICTIM_ERROR_NUMBER = 1205
+
 
 /**
  * Single owner of the `schema_migrations` ledger shape and the only place that reads
@@ -35,24 +40,107 @@ export default class MigrationsLedger {
     return Boolean(table)
   }
 
+  /**
+   * Whether the error means a concurrent session already created the ledger table.
+   *
+   * Several processes bootstrap the same database at the same time (for example every
+   * CI test shard), and the MSSQL `IF NOT EXISTS (...) BEGIN CREATE TABLE ... END` guard
+   * is NOT atomic: two sessions can both evaluate the check as false and then both
+   * create, so the loser is rejected. Walks the wrapped-error cause chain because
+   * `db.query` re-wraps the driver's `RequestError` in a plain `Error`, and matches the
+   * stable numeric error number instead of the localized message text.
+   * @param {unknown} error - Error thrown while creating the ledger table.
+   * @returns {boolean} - True if the table was created by a concurrent session.
+   */
+  static isConcurrentCreationError(error) {
+    let current = error
+
+    while (current instanceof Error) {
+      const errorNumber = /** @type {{number?: unknown}} */ (current).number
+
+      if (typeof errorNumber === "number" && errorNumber === MSSQL_OBJECT_ALREADY_EXISTS_ERROR_NUMBER) return true
+
+      current = current.cause
+    }
+
+    return false
+  }
+
+  /**
+   * Whether the error is a transient deadlock that should be retried.
+   *
+   * Concurrent boots also deadlock on the `INFORMATION_SCHEMA` metadata scan that
+   * `getTableByName` performs on SQL Server; the victim transaction rolled back cleanly,
+   * so retrying it is safe. Matched by numeric error number, never by message text.
+   * @param {unknown} error - Error thrown while inspecting or creating the ledger table.
+   * @returns {boolean} - True if the error is a retryable deadlock.
+   */
+  static isDeadlockError(error) {
+    let current = error
+
+    while (current instanceof Error) {
+      const errorNumber = /** @type {{number?: unknown}} */ (current).number
+
+      if (typeof errorNumber === "number" && errorNumber === MSSQL_DEADLOCK_VICTIM_ERROR_NUMBER) return true
+
+      current = current.cause
+    }
+
+    return false
+  }
+
   /**
    * Creates the ledger table if it does not exist. This is the single definition of
    * the `schema_migrations` table shape.
+   *
+   * Safe under concurrency: a session that loses the create race (or deadlocks on the
+   * catalog read) converges on the existing table instead of failing its caller. That
+   * matters because this runs on every boot of a database configured for migrations
+   * (see `Migrator#createMigrationsTableForDatabase` and
+   * `migrateRequireContextForDatabase`), so a crash here takes down a whole test shard
+   * or deployment over a table that provably already exists.
    * @param {import("./drivers/base.js").default} db - Database that should contain the ledger table.
+   * @param {{maxAttempts?: number}} [args] - Retry budget for transient catalog deadlocks.
    * @returns {Promise<void>}
    */
-  static async ensureTable(db) {
-    if (await MigrationsLedger.tableExists(db)) return
+  static async ensureTable(db, {maxAttempts = 3} = {}) {
+    let attempt = 0
 
-    const tableData = new TableData(TABLE_NAME, {ifNotExists: true})
+    while (true) {
+      attempt++
 
-    tableData.string("version", {null: false, primaryKey: true})
+      try {
+        if (await MigrationsLedger.tableExists(db)) return
 
-    for (const sql of await db.createTableSql(tableData)) {
-      await db.query(sql)
-    }
+        const tableData = new TableData(TABLE_NAME, {ifNotExists: true})
+
+        tableData.string("version", {null: false, primaryKey: true})
 
-    db.clearSchemaCache()
+        for (const sql of await db.createTableSql(tableData)) {
+          await db.query(sql)
+        }
+
+        db.clearSchemaCache()
+
+        return
+      } catch (error) {
+        if (MigrationsLedger.isConcurrentCreationError(error)) {
+          // Another session created the ledger between our check and our create. The
+          // table exists with exactly this shape, so the goal state is already reached.
+          db.clearSchemaCache()
+
+          return
+        }
+
+        if (MigrationsLedger.isDeadlockError(error) && attempt < maxAttempts) {
+          db.clearSchemaCache()
+
+          continue
+        }
+
+        throw error
+      }
+    }
   }
 
   /**

package/build/src/database/migrations-ledger.d.ts

@@ -20,13 +20,46 @@ export default class MigrationsLedger {
      * @returns {Promise<boolean>} - Whether the ledger table exists.
      */
     static tableExists(db: import("./drivers/base.js").default): Promise<boolean>;
+    /**
+     * Whether the error means a concurrent session already created the ledger table.
+     *
+     * Several processes bootstrap the same database at the same time (for example every
+     * CI test shard), and the MSSQL `IF NOT EXISTS (...) BEGIN CREATE TABLE ... END` guard
+     * is NOT atomic: two sessions can both evaluate the check as false and then both
+     * create, so the loser is rejected. Walks the wrapped-error cause chain because
+     * `db.query` re-wraps the driver's `RequestError` in a plain `Error`, and matches the
+     * stable numeric error number instead of the localized message text.
+     * @param {unknown} error - Error thrown while creating the ledger table.
+     * @returns {boolean} - True if the table was created by a concurrent session.
+     */
+    static isConcurrentCreationError(error: unknown): boolean;
+    /**
+     * Whether the error is a transient deadlock that should be retried.
+     *
+     * Concurrent boots also deadlock on the `INFORMATION_SCHEMA` metadata scan that
+     * `getTableByName` performs on SQL Server; the victim transaction rolled back cleanly,
+     * so retrying it is safe. Matched by numeric error number, never by message text.
+     * @param {unknown} error - Error thrown while inspecting or creating the ledger table.
+     * @returns {boolean} - True if the error is a retryable deadlock.
+     */
+    static isDeadlockError(error: unknown): boolean;
     /**
      * Creates the ledger table if it does not exist. This is the single definition of
      * the `schema_migrations` table shape.
+     *
+     * Safe under concurrency: a session that loses the create race (or deadlocks on the
+     * catalog read) converges on the existing table instead of failing its caller. That
+     * matters because this runs on every boot of a database configured for migrations
+     * (see `Migrator#createMigrationsTableForDatabase` and
+     * `migrateRequireContextForDatabase`), so a crash here takes down a whole test shard
+     * or deployment over a table that provably already exists.
      * @param {import("./drivers/base.js").default} db - Database that should contain the ledger table.
+     * @param {{maxAttempts?: number}} [args] - Retry budget for transient catalog deadlocks.
      * @returns {Promise<void>}
      */
-    static ensureTable(db: import("./drivers/base.js").default): Promise<void>;
+    static ensureTable(db: import("./drivers/base.js").default, { maxAttempts }?: {
+        maxAttempts?: number;
+    }): Promise<void>;
     /**
      * Every applied migration version recorded in the ledger.
      * @param {import("./drivers/base.js").default} db - Database whose applied versions are loaded.

package/build/src/database/migrations-ledger.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"migrations-ledger.d.ts","sourceRoot":"","sources":["../../../src/database/migrations-ledger.js"],"names":[],"mappings":"AAOA;;;;;;;;;GASG;AACH,MAAM,CAAC,OAAO,OAAO,gBAAgB;IACnC;;;OAGG;IACH,MAAM,CAAC,SAAS,IAFH,MAAM,CAIlB;IAED;;;;OAIG;IACH,OAAa,WAAW,CAAC,EAAE,EAHhB,OAAO,mBAAmB,EAAE,OAGZ,GAFd,OAAO,CAAC,OAAO,CAAC,CAM5B;IAED;;;;;OAKG;IACH,OAAa,WAAW,CAAC,EAAE,EAHhB,OAAO,mBAAmB,EAAE,OAGZ,GAFd,OAAO,CAAC,IAAI,CAAC,CAczB;IAED;;;;OAIG;IACH,OAAa,eAAe,CAAC,EAAE,EAHpB,OAAO,mBAAmB,EAAE,OAGR,GAFlB,OAAO,CAAC,MAAM,EAAE,CAAC,CAM7B;IAED;;;;;OAKG;IACH,OAAa,UAAU,CAAC,EAAE,EAJf,OAAO,mBAAmB,EAAE,OAIb,EAAE,OAAO,EAHxB,MAGwB,GAFtB,OAAO,CAAC,OAAO,CAAC,CAS5B;IAED;;;;;;OAMG;IACH,OAAa,aAAa,CAAC,EAAE,EAJlB,OAAO,mBAAmB,EAAE,OAIV,EAAE,OAAO,EAH3B,MAG2B,GAFzB,OAAO,CAAC,IAAI,CAAC,CAMzB;IAED;;;;;OAKG;IACH,OAAa,aAAa,CAAC,EAAE,EAJlB,OAAO,mBAAmB,EAAE,OAIV,EAAE,OAAO,EAH3B,MAG2B,GAFzB,OAAO,CAAC,IAAI,CAAC,CAIzB;IAED;;;;;;;OAOG;IACH,OAAa,WAAW,CAAC,EAAE,EAJhB,OAAO,mBAAmB,EAAE,OAIZ,EAAE,QAAQ,EAH1B,MAAM,EAGoB,GAFxB,OAAO,CAAC,MAAM,EAAE,CAAC,CAmB7B;IAED;;;;;;;OAOG;IACH,OAAa,oBAAoB,CAAC,EAAC,QAAQ,EAAE,QAAQ,EAAC,EAH3C;QAAC,QAAQ,EAAE,OAAO,mBAAmB,EAAE,OAAO,CAAC;QAAC,QAAQ,EAAE,OAAO,mBAAmB,EAAE,OAAO,CAAA;KAGlD,GAFzC,OAAO,CAAC,MAAM,EAAE,CAAC,CAM7B;CACF"}
+{"version":3,"file":"migrations-ledger.d.ts","sourceRoot":"","sources":["../../../src/database/migrations-ledger.js"],"names":[],"mappings":"AAYA;;;;;;;;;GASG;AACH,MAAM,CAAC,OAAO,OAAO,gBAAgB;IACnC;;;OAGG;IACH,MAAM,CAAC,SAAS,IAFH,MAAM,CAIlB;IAED;;;;OAIG;IACH,OAAa,WAAW,CAAC,EAAE,EAHhB,OAAO,mBAAmB,EAAE,OAGZ,GAFd,OAAO,CAAC,OAAO,CAAC,CAM5B;IAED;;;;;;;;;;;OAWG;IACH,MAAM,CAAC,yBAAyB,CAAC,KAAK,EAH3B,OAG2B,GAFzB,OAAO,CAcnB;IAED;;;;;;;;OAQG;IACH,MAAM,CAAC,eAAe,CAAC,KAAK,EAHjB,OAGiB,GAFf,OAAO,CAcnB;IAED;;;;;;;;;;;;;OAaG;IACH,OAAa,WAAW,CAAC,EAAE,EAJhB,OAAO,mBAAmB,EAAE,OAIZ,EAAE,EAAC,WAAe,EAAC,AAH3C,CACA,EADQ;QAAC,WAAW,CAAC,EAAE,MAAM,CAAA;KAGmB,GAFtC,OAAO,CAAC,IAAI,CAAC,CAwCzB;IAED;;;;OAIG;IACH,OAAa,eAAe,CAAC,EAAE,EAHpB,OAAO,mBAAmB,EAAE,OAGR,GAFlB,OAAO,CAAC,MAAM,EAAE,CAAC,CAM7B;IAED;;;;;OAKG;IACH,OAAa,UAAU,CAAC,EAAE,EAJf,OAAO,mBAAmB,EAAE,OAIb,EAAE,OAAO,EAHxB,MAGwB,GAFtB,OAAO,CAAC,OAAO,CAAC,CAS5B;IAED;;;;;;OAMG;IACH,OAAa,aAAa,CAAC,EAAE,EAJlB,OAAO,mBAAmB,EAAE,OAIV,EAAE,OAAO,EAH3B,MAG2B,GAFzB,OAAO,CAAC,IAAI,CAAC,CAMzB;IAED;;;;;OAKG;IACH,OAAa,aAAa,CAAC,EAAE,EAJlB,OAAO,mBAAmB,EAAE,OAIV,EAAE,OAAO,EAH3B,MAG2B,GAFzB,OAAO,CAAC,IAAI,CAAC,CAIzB;IAED;;;;;;;OAOG;IACH,OAAa,WAAW,CAAC,EAAE,EAJhB,OAAO,mBAAmB,EAAE,OAIZ,EAAE,QAAQ,EAH1B,MAAM,EAGoB,GAFxB,OAAO,CAAC,MAAM,EAAE,CAAC,CAmB7B;IAED;;;;;;;OAOG;IACH,OAAa,oBAAoB,CAAC,EAAC,QAAQ,EAAE,QAAQ,EAAC,EAH3C;QAAC,QAAQ,EAAE,OAAO,mBAAmB,EAAE,OAAO,CAAC;QAAC,QAAQ,EAAE,OAAO,mBAAmB,EAAE,OAAO,CAAA;KAGlD,GAFzC,OAAO,CAAC,MAAM,EAAE,CAAC,CAM7B;CACF"}

package/build/src/database/migrations-ledger.js

@@ -2,6 +2,10 @@
 import { digg } from "diggerize";
 import TableData from "./table-data/index.js";
 const TABLE_NAME = "schema_migrations";
+/** SQL Server "There is already an object named ..." — raised when two sessions race to create the same table. */
+const MSSQL_OBJECT_ALREADY_EXISTS_ERROR_NUMBER = 2714;
+/** SQL Server deadlock victim — raised when concurrent sessions deadlock on the same catalog reads. */
+const MSSQL_DEADLOCK_VICTIM_ERROR_NUMBER = 1205;
 /**
  * Single owner of the `schema_migrations` ledger shape and the only place that reads
  * or writes applied migration versions for a database connection. The migrator uses
@@ -29,21 +33,90 @@ export default class MigrationsLedger {
         const table = await db.getTableByName(TABLE_NAME, { throwError: false });
         return Boolean(table);
     }
+    /**
+     * Whether the error means a concurrent session already created the ledger table.
+     *
+     * Several processes bootstrap the same database at the same time (for example every
+     * CI test shard), and the MSSQL `IF NOT EXISTS (...) BEGIN CREATE TABLE ... END` guard
+     * is NOT atomic: two sessions can both evaluate the check as false and then both
+     * create, so the loser is rejected. Walks the wrapped-error cause chain because
+     * `db.query` re-wraps the driver's `RequestError` in a plain `Error`, and matches the
+     * stable numeric error number instead of the localized message text.
+     * @param {unknown} error - Error thrown while creating the ledger table.
+     * @returns {boolean} - True if the table was created by a concurrent session.
+     */
+    static isConcurrentCreationError(error) {
+        let current = error;
+        while (current instanceof Error) {
+            const errorNumber = /** @type {{number?: unknown}} */ (current).number;
+            if (typeof errorNumber === "number" && errorNumber === MSSQL_OBJECT_ALREADY_EXISTS_ERROR_NUMBER)
+                return true;
+            current = current.cause;
+        }
+        return false;
+    }
+    /**
+     * Whether the error is a transient deadlock that should be retried.
+     *
+     * Concurrent boots also deadlock on the `INFORMATION_SCHEMA` metadata scan that
+     * `getTableByName` performs on SQL Server; the victim transaction rolled back cleanly,
+     * so retrying it is safe. Matched by numeric error number, never by message text.
+     * @param {unknown} error - Error thrown while inspecting or creating the ledger table.
+     * @returns {boolean} - True if the error is a retryable deadlock.
+     */
+    static isDeadlockError(error) {
+        let current = error;
+        while (current instanceof Error) {
+            const errorNumber = /** @type {{number?: unknown}} */ (current).number;
+            if (typeof errorNumber === "number" && errorNumber === MSSQL_DEADLOCK_VICTIM_ERROR_NUMBER)
+                return true;
+            current = current.cause;
+        }
+        return false;
+    }
     /**
      * Creates the ledger table if it does not exist. This is the single definition of
      * the `schema_migrations` table shape.
+     *
+     * Safe under concurrency: a session that loses the create race (or deadlocks on the
+     * catalog read) converges on the existing table instead of failing its caller. That
+     * matters because this runs on every boot of a database configured for migrations
+     * (see `Migrator#createMigrationsTableForDatabase` and
+     * `migrateRequireContextForDatabase`), so a crash here takes down a whole test shard
+     * or deployment over a table that provably already exists.
      * @param {import("./drivers/base.js").default} db - Database that should contain the ledger table.
+     * @param {{maxAttempts?: number}} [args] - Retry budget for transient catalog deadlocks.
      * @returns {Promise<void>}
      */
-    static async ensureTable(db) {
-        if (await MigrationsLedger.tableExists(db))
-            return;
-        const tableData = new TableData(TABLE_NAME, { ifNotExists: true });
-        tableData.string("version", { null: false, primaryKey: true });
-        for (const sql of await db.createTableSql(tableData)) {
-            await db.query(sql);
+    static async ensureTable(db, { maxAttempts = 3 } = {}) {
+        let attempt = 0;
+        while (true) {
+            attempt++;
+            try {
+                if (await MigrationsLedger.tableExists(db))
+                    return;
+                const tableData = new TableData(TABLE_NAME, { ifNotExists: true });
+                tableData.string("version", { null: false, primaryKey: true });
+                for (const sql of await db.createTableSql(tableData)) {
+                    await db.query(sql);
+                }
+                db.clearSchemaCache();
+                return;
+            }
+            catch (error) {
+                if (MigrationsLedger.isConcurrentCreationError(error)) {
+                    // Another session created the ledger between our check and our create. The
+                    // table exists with exactly this shape, so the goal state is already reached.
+                    db.clearSchemaCache();
+                    return;
+                }
+                if (MigrationsLedger.isDeadlockError(error) && attempt < maxAttempts) {
+                    db.clearSchemaCache();
+                    continue;
+                }
+                throw error;
+            }
         }
-        db.clearSchemaCache();
     }
     /**
      * Every applied migration version recorded in the ledger.
@@ -123,4 +196,4 @@ export default class MigrationsLedger {
         return await MigrationsLedger.markApplied(targetDb, sourceVersions);
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"migrations-ledger.js","sourceRoot":"","sources":["../../../src/database/migrations-ledger.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport {digg} from \"diggerize\"\nimport TableData from \"./table-data/index.js\"\n\nconst TABLE_NAME = \"schema_migrations\"\n\n/**\n * Single owner of the `schema_migrations` ledger shape and the only place that reads\n * or writes applied migration versions for a database connection. The migrator uses\n * it to record versions as it runs migrations; provisioning / schema-clone paths use\n * `markApplied` / `baselineFromDatabase` to record versions as applied WITHOUT\n * re-running them (the Rails `schema:load` / Flyway `baseline` idea). That keeps the\n * ledger honest when a database's schema was advanced out of band — e.g. by cloning\n * table structure between databases — so the migrator does not later re-run a\n * migration whose schema object already exists.\n */\nexport default class MigrationsLedger {\n  /**\n   * The ledger table name.\n   * @returns {string} - Ledger table name.\n   */\n  static tableName() {\n    return TABLE_NAME\n  }\n\n  /**\n   * Whether the ledger table exists on the given database.\n   * @param {import(\"./drivers/base.js\").default} db - Database whose migration ledger is inspected.\n   * @returns {Promise<boolean>} - Whether the ledger table exists.\n   */\n  static async tableExists(db) {\n    const table = await db.getTableByName(TABLE_NAME, {throwError: false})\n\n    return Boolean(table)\n  }\n\n  /**\n   * Creates the ledger table if it does not exist. This is the single definition of\n   * the `schema_migrations` table shape.\n   * @param {import(\"./drivers/base.js\").default} db - Database that should contain the ledger table.\n   * @returns {Promise<void>}\n   */\n  static async ensureTable(db) {\n    if (await MigrationsLedger.tableExists(db)) return\n\n    const tableData = new TableData(TABLE_NAME, {ifNotExists: true})\n\n    tableData.string(\"version\", {null: false, primaryKey: true})\n\n    for (const sql of await db.createTableSql(tableData)) {\n      await db.query(sql)\n    }\n\n    db.clearSchemaCache()\n  }\n\n  /**\n   * Every applied migration version recorded in the ledger.\n   * @param {import(\"./drivers/base.js\").default} db - Database whose applied versions are loaded.\n   * @returns {Promise<string[]>} - Applied migration versions.\n   */\n  static async appliedVersions(db) {\n    const rows = await db.select(TABLE_NAME)\n\n    return rows.map((row) => `${digg(row, \"version\")}`)\n  }\n\n  /**\n   * Whether the given version is recorded as applied.\n   * @param {import(\"./drivers/base.js\").default} db - Database whose ledger is queried.\n   * @param {string} version - Migration version to look up.\n   * @returns {Promise<boolean>} - Whether the migration version is applied.\n   */\n  static async hasVersion(db, version) {\n    const rows = await db.newQuery()\n      .from(TABLE_NAME)\n      .where({version})\n      .results()\n\n    return rows.length > 0\n  }\n\n  /**\n   * Records a single version as applied. The targeted existence check keeps the\n   * migrator's per-migration hot path cheap (no full-table load per migration).\n   * @param {import(\"./drivers/base.js\").default} db - Database whose ledger receives the version.\n   * @param {string} version - Migration version to record as applied.\n   * @returns {Promise<void>}\n   */\n  static async recordVersion(db, version) {\n    if (await MigrationsLedger.hasVersion(db, version)) return\n\n    await db.insert({tableName: TABLE_NAME, data: {version}})\n  }\n\n  /**\n   * Removes a version from the ledger (used when migrating down).\n   * @param {import(\"./drivers/base.js\").default} db - Database whose ledger loses the version.\n   * @param {string} version - Migration version to mark as unapplied.\n   * @returns {Promise<void>}\n   */\n  static async removeVersion(db, version) {\n    await db.delete({tableName: TABLE_NAME, conditions: {version}})\n  }\n\n  /**\n   * Baselines a database's ledger: records each version as applied without running\n   * its migration. Idempotent — already-recorded versions are skipped. Ensures the\n   * ledger table exists first, then loads the existing set once for the whole batch.\n   * @param {import(\"./drivers/base.js\").default} db - Database whose ledger should be baselined.\n   * @param {string[]} versions - Migration versions to record without running them.\n   * @returns {Promise<string[]>} The versions that were newly recorded.\n   */\n  static async markApplied(db, versions) {\n    await MigrationsLedger.ensureTable(db)\n\n    const existing = new Set(await MigrationsLedger.appliedVersions(db))\n    const recorded = []\n\n    for (const version of versions) {\n      const normalizedVersion = `${version}`\n\n      if (existing.has(normalizedVersion)) continue\n\n      await db.insert({tableName: TABLE_NAME, data: {version: normalizedVersion}})\n      existing.add(normalizedVersion)\n      recorded.push(normalizedVersion)\n    }\n\n    return recorded\n  }\n\n  /**\n   * Baselines `targetDb` to match the applied versions of `sourceDb`. Use when a\n   * provisioning path advanced `targetDb`'s schema to match `sourceDb` out of band\n   * (e.g. cloning table structure between databases): the migrations are, by\n   * construction, already applied on the target, so record them without re-running.\n   * @param {{sourceDb: import(\"./drivers/base.js\").default, targetDb: import(\"./drivers/base.js\").default}} args - Source ledger and target database to baseline.\n   * @returns {Promise<string[]>} The versions that were newly recorded on the target.\n   */\n  static async baselineFromDatabase({sourceDb, targetDb}) {\n    const sourceVersions = await MigrationsLedger.appliedVersions(sourceDb)\n\n    return await MigrationsLedger.markApplied(targetDb, sourceVersions)\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"migrations-ledger.js","sourceRoot":"","sources":["../../../src/database/migrations-ledger.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport {digg} from \"diggerize\"\nimport TableData from \"./table-data/index.js\"\n\nconst TABLE_NAME = \"schema_migrations\"\n/** SQL Server \"There is already an object named ...\" — raised when two sessions race to create the same table. */\nconst MSSQL_OBJECT_ALREADY_EXISTS_ERROR_NUMBER = 2714\n/** SQL Server deadlock victim — raised when concurrent sessions deadlock on the same catalog reads. */\nconst MSSQL_DEADLOCK_VICTIM_ERROR_NUMBER = 1205\n\n\n/**\n * Single owner of the `schema_migrations` ledger shape and the only place that reads\n * or writes applied migration versions for a database connection. The migrator uses\n * it to record versions as it runs migrations; provisioning / schema-clone paths use\n * `markApplied` / `baselineFromDatabase` to record versions as applied WITHOUT\n * re-running them (the Rails `schema:load` / Flyway `baseline` idea). That keeps the\n * ledger honest when a database's schema was advanced out of band — e.g. by cloning\n * table structure between databases — so the migrator does not later re-run a\n * migration whose schema object already exists.\n */\nexport default class MigrationsLedger {\n  /**\n   * The ledger table name.\n   * @returns {string} - Ledger table name.\n   */\n  static tableName() {\n    return TABLE_NAME\n  }\n\n  /**\n   * Whether the ledger table exists on the given database.\n   * @param {import(\"./drivers/base.js\").default} db - Database whose migration ledger is inspected.\n   * @returns {Promise<boolean>} - Whether the ledger table exists.\n   */\n  static async tableExists(db) {\n    const table = await db.getTableByName(TABLE_NAME, {throwError: false})\n\n    return Boolean(table)\n  }\n\n  /**\n   * Whether the error means a concurrent session already created the ledger table.\n   *\n   * Several processes bootstrap the same database at the same time (for example every\n   * CI test shard), and the MSSQL `IF NOT EXISTS (...) BEGIN CREATE TABLE ... END` guard\n   * is NOT atomic: two sessions can both evaluate the check as false and then both\n   * create, so the loser is rejected. Walks the wrapped-error cause chain because\n   * `db.query` re-wraps the driver's `RequestError` in a plain `Error`, and matches the\n   * stable numeric error number instead of the localized message text.\n   * @param {unknown} error - Error thrown while creating the ledger table.\n   * @returns {boolean} - True if the table was created by a concurrent session.\n   */\n  static isConcurrentCreationError(error) {\n    let current = error\n\n    while (current instanceof Error) {\n      const errorNumber = /** @type {{number?: unknown}} */ (current).number\n\n      if (typeof errorNumber === \"number\" && errorNumber === MSSQL_OBJECT_ALREADY_EXISTS_ERROR_NUMBER) return true\n\n      current = current.cause\n    }\n\n    return false\n  }\n\n  /**\n   * Whether the error is a transient deadlock that should be retried.\n   *\n   * Concurrent boots also deadlock on the `INFORMATION_SCHEMA` metadata scan that\n   * `getTableByName` performs on SQL Server; the victim transaction rolled back cleanly,\n   * so retrying it is safe. Matched by numeric error number, never by message text.\n   * @param {unknown} error - Error thrown while inspecting or creating the ledger table.\n   * @returns {boolean} - True if the error is a retryable deadlock.\n   */\n  static isDeadlockError(error) {\n    let current = error\n\n    while (current instanceof Error) {\n      const errorNumber = /** @type {{number?: unknown}} */ (current).number\n\n      if (typeof errorNumber === \"number\" && errorNumber === MSSQL_DEADLOCK_VICTIM_ERROR_NUMBER) return true\n\n      current = current.cause\n    }\n\n    return false\n  }\n\n  /**\n   * Creates the ledger table if it does not exist. This is the single definition of\n   * the `schema_migrations` table shape.\n   *\n   * Safe under concurrency: a session that loses the create race (or deadlocks on the\n   * catalog read) converges on the existing table instead of failing its caller. That\n   * matters because this runs on every boot of a database configured for migrations\n   * (see `Migrator#createMigrationsTableForDatabase` and\n   * `migrateRequireContextForDatabase`), so a crash here takes down a whole test shard\n   * or deployment over a table that provably already exists.\n   * @param {import(\"./drivers/base.js\").default} db - Database that should contain the ledger table.\n   * @param {{maxAttempts?: number}} [args] - Retry budget for transient catalog deadlocks.\n   * @returns {Promise<void>}\n   */\n  static async ensureTable(db, {maxAttempts = 3} = {}) {\n    let attempt = 0\n\n    while (true) {\n      attempt++\n\n      try {\n        if (await MigrationsLedger.tableExists(db)) return\n\n        const tableData = new TableData(TABLE_NAME, {ifNotExists: true})\n\n        tableData.string(\"version\", {null: false, primaryKey: true})\n\n        for (const sql of await db.createTableSql(tableData)) {\n          await db.query(sql)\n        }\n\n        db.clearSchemaCache()\n\n        return\n      } catch (error) {\n        if (MigrationsLedger.isConcurrentCreationError(error)) {\n          // Another session created the ledger between our check and our create. The\n          // table exists with exactly this shape, so the goal state is already reached.\n          db.clearSchemaCache()\n\n          return\n        }\n\n        if (MigrationsLedger.isDeadlockError(error) && attempt < maxAttempts) {\n          db.clearSchemaCache()\n\n          continue\n        }\n\n        throw error\n      }\n    }\n  }\n\n  /**\n   * Every applied migration version recorded in the ledger.\n   * @param {import(\"./drivers/base.js\").default} db - Database whose applied versions are loaded.\n   * @returns {Promise<string[]>} - Applied migration versions.\n   */\n  static async appliedVersions(db) {\n    const rows = await db.select(TABLE_NAME)\n\n    return rows.map((row) => `${digg(row, \"version\")}`)\n  }\n\n  /**\n   * Whether the given version is recorded as applied.\n   * @param {import(\"./drivers/base.js\").default} db - Database whose ledger is queried.\n   * @param {string} version - Migration version to look up.\n   * @returns {Promise<boolean>} - Whether the migration version is applied.\n   */\n  static async hasVersion(db, version) {\n    const rows = await db.newQuery()\n      .from(TABLE_NAME)\n      .where({version})\n      .results()\n\n    return rows.length > 0\n  }\n\n  /**\n   * Records a single version as applied. The targeted existence check keeps the\n   * migrator's per-migration hot path cheap (no full-table load per migration).\n   * @param {import(\"./drivers/base.js\").default} db - Database whose ledger receives the version.\n   * @param {string} version - Migration version to record as applied.\n   * @returns {Promise<void>}\n   */\n  static async recordVersion(db, version) {\n    if (await MigrationsLedger.hasVersion(db, version)) return\n\n    await db.insert({tableName: TABLE_NAME, data: {version}})\n  }\n\n  /**\n   * Removes a version from the ledger (used when migrating down).\n   * @param {import(\"./drivers/base.js\").default} db - Database whose ledger loses the version.\n   * @param {string} version - Migration version to mark as unapplied.\n   * @returns {Promise<void>}\n   */\n  static async removeVersion(db, version) {\n    await db.delete({tableName: TABLE_NAME, conditions: {version}})\n  }\n\n  /**\n   * Baselines a database's ledger: records each version as applied without running\n   * its migration. Idempotent — already-recorded versions are skipped. Ensures the\n   * ledger table exists first, then loads the existing set once for the whole batch.\n   * @param {import(\"./drivers/base.js\").default} db - Database whose ledger should be baselined.\n   * @param {string[]} versions - Migration versions to record without running them.\n   * @returns {Promise<string[]>} The versions that were newly recorded.\n   */\n  static async markApplied(db, versions) {\n    await MigrationsLedger.ensureTable(db)\n\n    const existing = new Set(await MigrationsLedger.appliedVersions(db))\n    const recorded = []\n\n    for (const version of versions) {\n      const normalizedVersion = `${version}`\n\n      if (existing.has(normalizedVersion)) continue\n\n      await db.insert({tableName: TABLE_NAME, data: {version: normalizedVersion}})\n      existing.add(normalizedVersion)\n      recorded.push(normalizedVersion)\n    }\n\n    return recorded\n  }\n\n  /**\n   * Baselines `targetDb` to match the applied versions of `sourceDb`. Use when a\n   * provisioning path advanced `targetDb`'s schema to match `sourceDb` out of band\n   * (e.g. cloning table structure between databases): the migrations are, by\n   * construction, already applied on the target, so record them without re-running.\n   * @param {{sourceDb: import(\"./drivers/base.js\").default, targetDb: import(\"./drivers/base.js\").default}} args - Source ledger and target database to baseline.\n   * @returns {Promise<string[]>} The versions that were newly recorded on the target.\n   */\n  static async baselineFromDatabase({sourceDb, targetDb}) {\n    const sourceVersions = await MigrationsLedger.appliedVersions(sourceDb)\n\n    return await MigrationsLedger.markApplied(targetDb, sourceVersions)\n  }\n}\n"]}

package/package.json

@@ -3,7 +3,7 @@
     "velocious": "build/bin/velocious.js"
   },
   "name": "velocious",
-  "version": "1.0.695",
+  "version": "1.0.696",
   "main": "build/index.js",
   "types": "build/index.d.ts",
   "files": [

package/src/database/migrations-ledger.js

@@ -4,6 +4,11 @@ import {digg} from "diggerize"
 import TableData from "./table-data/index.js"
 
 const TABLE_NAME = "schema_migrations"
+/** SQL Server "There is already an object named ..." — raised when two sessions race to create the same table. */
+const MSSQL_OBJECT_ALREADY_EXISTS_ERROR_NUMBER = 2714
+/** SQL Server deadlock victim — raised when concurrent sessions deadlock on the same catalog reads. */
+const MSSQL_DEADLOCK_VICTIM_ERROR_NUMBER = 1205
+
 
 /**
  * Single owner of the `schema_migrations` ledger shape and the only place that reads
@@ -35,24 +40,107 @@ export default class MigrationsLedger {
     return Boolean(table)
   }
 
+  /**
+   * Whether the error means a concurrent session already created the ledger table.
+   *
+   * Several processes bootstrap the same database at the same time (for example every
+   * CI test shard), and the MSSQL `IF NOT EXISTS (...) BEGIN CREATE TABLE ... END` guard
+   * is NOT atomic: two sessions can both evaluate the check as false and then both
+   * create, so the loser is rejected. Walks the wrapped-error cause chain because
+   * `db.query` re-wraps the driver's `RequestError` in a plain `Error`, and matches the
+   * stable numeric error number instead of the localized message text.
+   * @param {unknown} error - Error thrown while creating the ledger table.
+   * @returns {boolean} - True if the table was created by a concurrent session.
+   */
+  static isConcurrentCreationError(error) {
+    let current = error
+
+    while (current instanceof Error) {
+      const errorNumber = /** @type {{number?: unknown}} */ (current).number
+
+      if (typeof errorNumber === "number" && errorNumber === MSSQL_OBJECT_ALREADY_EXISTS_ERROR_NUMBER) return true
+
+      current = current.cause
+    }
+
+    return false
+  }
+
+  /**
+   * Whether the error is a transient deadlock that should be retried.
+   *
+   * Concurrent boots also deadlock on the `INFORMATION_SCHEMA` metadata scan that
+   * `getTableByName` performs on SQL Server; the victim transaction rolled back cleanly,
+   * so retrying it is safe. Matched by numeric error number, never by message text.
+   * @param {unknown} error - Error thrown while inspecting or creating the ledger table.
+   * @returns {boolean} - True if the error is a retryable deadlock.
+   */
+  static isDeadlockError(error) {
+    let current = error
+
+    while (current instanceof Error) {
+      const errorNumber = /** @type {{number?: unknown}} */ (current).number
+
+      if (typeof errorNumber === "number" && errorNumber === MSSQL_DEADLOCK_VICTIM_ERROR_NUMBER) return true
+
+      current = current.cause
+    }
+
+    return false
+  }
+
   /**
    * Creates the ledger table if it does not exist. This is the single definition of
    * the `schema_migrations` table shape.
+   *
+   * Safe under concurrency: a session that loses the create race (or deadlocks on the
+   * catalog read) converges on the existing table instead of failing its caller. That
+   * matters because this runs on every boot of a database configured for migrations
+   * (see `Migrator#createMigrationsTableForDatabase` and
+   * `migrateRequireContextForDatabase`), so a crash here takes down a whole test shard
+   * or deployment over a table that provably already exists.
    * @param {import("./drivers/base.js").default} db - Database that should contain the ledger table.
+   * @param {{maxAttempts?: number}} [args] - Retry budget for transient catalog deadlocks.
    * @returns {Promise<void>}
    */
-  static async ensureTable(db) {
-    if (await MigrationsLedger.tableExists(db)) return
+  static async ensureTable(db, {maxAttempts = 3} = {}) {
+    let attempt = 0
 
-    const tableData = new TableData(TABLE_NAME, {ifNotExists: true})
+    while (true) {
+      attempt++
 
-    tableData.string("version", {null: false, primaryKey: true})
+      try {
+        if (await MigrationsLedger.tableExists(db)) return
 
-    for (const sql of await db.createTableSql(tableData)) {
-      await db.query(sql)
-    }
+        const tableData = new TableData(TABLE_NAME, {ifNotExists: true})
+
+        tableData.string("version", {null: false, primaryKey: true})
 
-    db.clearSchemaCache()
+        for (const sql of await db.createTableSql(tableData)) {
+          await db.query(sql)
+        }
+
+        db.clearSchemaCache()
+
+        return
+      } catch (error) {
+        if (MigrationsLedger.isConcurrentCreationError(error)) {
+          // Another session created the ledger between our check and our create. The
+          // table exists with exactly this shape, so the goal state is already reached.
+          db.clearSchemaCache()
+
+          return
+        }
+
+        if (MigrationsLedger.isDeadlockError(error) && attempt < maxAttempts) {
+          db.clearSchemaCache()
+
+          continue
+        }
+
+        throw error
+      }
+    }
   }
 
   /**