velocious 1.0.548 → 1.0.551

package/README.md

@@ -141,6 +141,19 @@ Slowest 10 tests:
 
 The report is skipped for single-test runs. See [docs/testing-guidelines.md](docs/testing-guidelines.md).
 
+Prefer waiting for a real signal or condition over sleeping a fixed duration. `waitForEvent(emitter, eventName, {timeoutMs, filter})` resolves the instant a matching event fires (a background job finishing, a model update, a websocket message) and rejects on timeout; for polling an arbitrary condition, use awaitery's `waitFor`.
+
+```js
+import {waitForEvent} from "velocious/build/src/testing/test.js"
+import waitFor from "awaitery/build/wait-for.js"
+
+// Event-driven: resolves as soon as the matching event fires (no polling latency).
+const {result} = await waitForEvent(jobRunner, "jobFinished", {filter: (event) => event.jobId === jobId})
+
+// Condition polling: retries the callback until it stops throwing.
+await waitFor(() => expect(await Message.count()).toEqual(1))
+```
+
 Velocious captures console output emitted while each test executes, but does not print passing-test output by default. When a test fails, Velocious prints a truncated `Console output:` block for that failed test and saves the full captured log under `tmp/screenshots` next to failure screenshots/browser logs/HTML. Each failed test summary prints the saved console log path.
 
 Configure console output behavior in your testing config file.
@@ -1187,6 +1200,16 @@ npx velocious db:schema:load
 
 `db:schema:load` reads `db/structure-<identifier>.sql` for each configured database identifier and executes those statements against the current connections. Because the structure file includes the migration ledger rows, a load marks every listed version as already applied. The next `db:migrate` sees those versions and skips them, so migrations whose schema changes are already part of the loaded structure do not run again.
 
+The same load logic is available programmatically for provisioning a database from a structure dump (for example a tenant or test database) in one pass — much faster than materializing a schema table by table:
+
+```js
+import StructureSqlLoader from "velocious/build/src/database/structure-sql-loader.js"
+
+await new StructureSqlLoader().load({db, structureSql})
+```
+
+`load({db, structureSql})` disables foreign keys around the load (so the order tables reference each other in the dump does not matter) and uses the driver's native multi-statement `exec` in a single round-trip when available. See [docs/database-migrations.md](docs/database-migrations.md).
+
 ## Schema metadata cache
 
 Velocious caches schema metadata on each database driver instance so repeated model initialization, table lookups, column introspection, and structure SQL generation can reuse the same database results. The cache is cleared automatically after schema-changing SQL runs through Velocious, such as migrations, `createTable`, `dropTable`, `renameColumn`, `ALTER TABLE`, `CREATE INDEX`, and `COMMENT ON`. See [docs/schema-metadata-cache.md](docs/schema-metadata-cache.md) for details.

package/build/database/advisory-lock-runner.js

@@ -1,6 +1,6 @@
 // @ts-check
 
-import timeout from "awaitery/build/timeout.js"
+import timeout, {TimeoutError} from "awaitery/build/timeout.js"
 
 /**
  * Thrown when an advisory lock could not be acquired before `timeoutMs` elapsed.
@@ -67,9 +67,12 @@ export default class AdvisoryLockRunner {
 
   /**
    * Runs a callback after acquiring the advisory lock, waiting up to `timeoutMs`.
+   * When a `holdTimeoutMs` is set the callback receives a `TimeoutControl` from
+   * awaitery for cooperative cancellation (`control.check()`, `control.signal`,
+   * `control.timedOut`, `control.remaining()`).
    * @template T
    * @param {string} name - Lock name.
-   * @param {() => Promise<T>} callback - Callback to invoke while the lock is held.
+   * @param {(args?: {control: import("awaitery/build/timeout.js").TimeoutControl}) => Promise<T>} callback - Callback to invoke while the lock is held.
    * @param {{timeoutMs?: number | null, holdTimeoutMs?: number | null}} [args] - Lock and hold timeout options.
    * @returns {Promise<T>} - Resolves with the callback result.
    */
@@ -87,9 +90,11 @@ export default class AdvisoryLockRunner {
 
   /**
    * Runs a callback only if the advisory lock can be acquired immediately.
+   * When a `holdTimeoutMs` is set the callback receives a `TimeoutControl` from
+   * awaitery for cooperative cancellation.
    * @template T
    * @param {string} name - Lock name.
-   * @param {() => Promise<T>} callback - Callback to invoke while the lock is held.
+   * @param {(args?: {control: import("awaitery/build/timeout.js").TimeoutControl}) => Promise<T>} callback - Callback to invoke while the lock is held.
    * @param {{holdTimeoutMs?: number | null}} [args] - Hold timeout options.
    * @returns {Promise<T>} - Resolves with the callback result.
    */
@@ -108,7 +113,7 @@ export default class AdvisoryLockRunner {
   /**
    * Runs the lock holder callback and releases the lock from its owning connection.
    * @template T
-   * @param {{callback: () => Promise<T>, connection: import("./drivers/base.js").default, holdTimeoutMs?: number | null, name: string}} args - Locked callback args.
+   * @param {{callback: (args?: {control: import("awaitery/build/timeout.js").TimeoutControl}) => Promise<T>, connection: import("./drivers/base.js").default, holdTimeoutMs?: number | null, name: string}} args - Locked callback args.
    * @returns {Promise<T>} - Resolves with the callback result.
    */
   async runLockedCallback({callback, connection, holdTimeoutMs, name}) {
@@ -160,9 +165,13 @@ export default class AdvisoryLockRunner {
    * Runs `callback`, rejecting with `AdvisoryLockHoldTimeoutError` if it has
    * not settled within `holdTimeoutMs`. The callback is not cancelled; callers
    * use a dedicated advisory-lock connection so the lock can still be released.
+   *
+   * The callback receives a `TimeoutControl` from awaitery, enabling cooperative
+   * cancellation via `control.check()`, `control.signal`, `control.timedOut`,
+   * and `control.remaining()`.
    * @template T
    * @param {string} name - Lock name (for the error message).
-   * @param {() => Promise<T>} callback - Callback holding the lock.
+   * @param {(args?: {control: import("awaitery/build/timeout.js").TimeoutControl}) => Promise<T>} callback - Callback holding the lock.
    * @param {number | null} [holdTimeoutMs] - Max hold time; falsy disables the timeout.
    * @returns {Promise<T>} - Resolves with the callback result.
    */
@@ -174,15 +183,15 @@ export default class AdvisoryLockRunner {
     let callbackSettled = false
 
     try {
-      return await timeout({timeout: holdTimeoutMs}, async () => {
+      return await timeout({timeout: holdTimeoutMs}, async ({control}) => {
         try {
-          return await callback()
+          return await callback({control})
         } finally {
           callbackSettled = true
         }
       })
     } catch (error) {
-      if (!callbackSettled) {
+      if (!callbackSettled || error instanceof TimeoutError) {
         throw new AdvisoryLockHoldTimeoutError(`Advisory lock ${JSON.stringify(name)} held longer than ${holdTimeoutMs}ms`, {name})
       }
 

package/build/database/structure-sql-loader.js

@@ -0,0 +1,68 @@
+// @ts-check
+
+import splitSqlStatements from "../utils/split-sql-statements.js"
+
+/**
+ * Loads a database structure SQL dump into a connection in one pass. Foreign keys are
+ * disabled around the load so tables can be created in any order, and the driver's
+ * native multi-statement `exec` is used when available (a single round-trip) instead
+ * of issuing every statement separately. This is much faster than materializing a
+ * schema table by table (e.g. cloning), so it is the preferred way to provision a
+ * tenant/test database from a structure dump.
+ *
+ * Used by the `db:schema:load` CLI command and reusable by any caller that needs to
+ * apply a structure dump to a specific connection.
+ */
+export default class StructureSqlLoader {
+  /**
+   * Loads `structureSql` into `db`.
+   * @param {object} args - Options object.
+   * @param {import("./drivers/base.js").default} args.db - Target database connection.
+   * @param {string} args.structureSql - Structure SQL to load.
+   * @returns {Promise<void>} - Resolves when the structure has been loaded.
+   */
+  async load({db, structureSql}) {
+    const statements = splitSqlStatements(structureSql)
+
+    if (statements.length == 0) return
+
+    const executableConnection = this.executableConnection(db)
+
+    await db.disableForeignKeys()
+
+    try {
+      if (executableConnection) {
+        await executableConnection.exec(structureSql)
+      } else {
+        for (const statement of statements) {
+          await db.query(statement)
+        }
+      }
+    } finally {
+      await db.enableForeignKeys()
+
+      // The native `exec` path mutates the schema outside `Base#query`, so the
+      // usual post-DDL schema-cache invalidation never runs. Clear it here so a
+      // caller that read schema metadata before provisioning (e.g. an empty table
+      // list) does not keep seeing the pre-load schema afterwards. Harmless for the
+      // per-statement path, which already invalidates as each DDL statement runs.
+      db.clearSchemaCache()
+    }
+  }
+
+  /**
+   * Returns the underlying connection when it exposes a native multi-statement
+   * `exec` (a single round-trip for the whole dump), otherwise undefined so the
+   * caller falls back to per-statement execution.
+   * @param {import("./drivers/base.js").default} db - Database connection.
+   * @returns {{exec: (sql: string) => Promise<?>} | undefined} - Connection with exec support.
+   */
+  executableConnection(db) {
+    const dbWithConnection = /** @type {import("./drivers/base.js").default & {connection?: ?}} */ (db)
+    const connection = dbWithConnection.connection
+
+    if (connection && typeof connection == "object" && "exec" in connection && typeof connection.exec == "function") {
+      return /** @type {{exec: (sql: string) => Promise<?>}} */ (connection)
+    }
+  }
+}

package/build/environment-handlers/node/cli/commands/db/schema/load.js

@@ -1,7 +1,7 @@
 import BaseCommand from "../../../../../../cli/base-command.js"
 import fs from "fs/promises"
 import path from "path"
-import splitSqlStatements from "../../../../../../utils/split-sql-statements.js"
+import StructureSqlLoader from "../../../../../../database/structure-sql-loader.js"
 
 /** Node CLI command for loading DB structure SQL files. */
 export default class DbSchemaLoad extends BaseCommand {
@@ -11,57 +11,15 @@ export default class DbSchemaLoad extends BaseCommand {
   async execute() {
     await this.getConfiguration().ensureConnections({name: "DB schema load"}, async (dbs) => {
       const dbDir = path.join(this.directory(), "db")
+      const loader = new StructureSqlLoader()
 
       for (const identifier of Object.keys(dbs)) {
         const db = dbs[identifier]
         const structureFilePath = path.join(dbDir, `structure-${identifier}.sql`)
         const structureSql = await fs.readFile(structureFilePath, "utf8")
 
-        await this.loadStructureSql({db, structureSql})
+        await loader.load({db, structureSql})
       }
     })
   }
-
-  /**
-   * Runs load structure sql.
-   * @param {object} args - Options object.
-   * @param {import("../../../../../../database/drivers/base.js").default} args.db - Database connection.
-   * @param {string} args.structureSql - Structure SQL to load.
-   * @returns {Promise<void>} - Resolves when complete.
-   */
-  async loadStructureSql({db, structureSql}) {
-    const statements = splitSqlStatements(structureSql)
-
-    if (statements.length == 0) return
-
-    const executableConnection = this.executableConnection(db)
-
-    await db.disableForeignKeys()
-
-    try {
-      if (executableConnection) {
-        await executableConnection.exec(structureSql)
-      } else {
-        for (const statement of statements) {
-          await db.query(statement)
-        }
-      }
-    } finally {
-      await db.enableForeignKeys()
-    }
-  }
-
-  /**
-   * Runs executable connection.
-   * @param {import("../../../../../../database/drivers/base.js").default} db - Database connection.
-   * @returns {{exec: (sql: string) => Promise<?>} | undefined} - Connection with exec support.
-   */
-  executableConnection(db) {
-    const dbWithConnection = /** @type {import("../../../../../../database/drivers/base.js").default & {connection?: ?}} */ (db)
-    const connection = dbWithConnection.connection
-
-    if (connection && typeof connection == "object" && "exec" in connection && typeof connection.exec == "function") {
-      return /** @type {{exec: (sql: string) => Promise<?>}} */ (connection)
-    }
-  }
 }

package/build/src/database/advisory-lock-runner.d.ts

@@ -7,13 +7,19 @@ export default class AdvisoryLockRunner {
      * Runs `callback`, rejecting with `AdvisoryLockHoldTimeoutError` if it has
      * not settled within `holdTimeoutMs`. The callback is not cancelled; callers
      * use a dedicated advisory-lock connection so the lock can still be released.
+     *
+     * The callback receives a `TimeoutControl` from awaitery, enabling cooperative
+     * cancellation via `control.check()`, `control.signal`, `control.timedOut`,
+     * and `control.remaining()`.
      * @template T
      * @param {string} name - Lock name (for the error message).
-     * @param {() => Promise<T>} callback - Callback holding the lock.
+     * @param {(args?: {control: import("awaitery/build/timeout.js").TimeoutControl}) => Promise<T>} callback - Callback holding the lock.
      * @param {number | null} [holdTimeoutMs] - Max hold time; falsy disables the timeout.
      * @returns {Promise<T>} - Resolves with the callback result.
      */
-    static runWithAdvisoryLockHoldTimeout<T>(name: string, callback: () => Promise<T>, holdTimeoutMs?: number | null): Promise<T>;
+    static runWithAdvisoryLockHoldTimeout<T>(name: string, callback: (args?: {
+        control: import("awaitery/build/timeout.js").TimeoutControl;
+    }) => Promise<T>, holdTimeoutMs?: number | null): Promise<T>;
     /**
      * Creates an advisory-lock runner for one model database identifier.
      * @param {{configuration: import("../configuration.js").default, connectionProvider: () => import("./drivers/base.js").default, databaseIdentifier: string}} args - Runner dependencies.
@@ -28,35 +34,46 @@ export default class AdvisoryLockRunner {
     databaseIdentifier: string;
     /**
      * Runs a callback after acquiring the advisory lock, waiting up to `timeoutMs`.
+     * When a `holdTimeoutMs` is set the callback receives a `TimeoutControl` from
+     * awaitery for cooperative cancellation (`control.check()`, `control.signal`,
+     * `control.timedOut`, `control.remaining()`).
      * @template T
      * @param {string} name - Lock name.
-     * @param {() => Promise<T>} callback - Callback to invoke while the lock is held.
+     * @param {(args?: {control: import("awaitery/build/timeout.js").TimeoutControl}) => Promise<T>} callback - Callback to invoke while the lock is held.
      * @param {{timeoutMs?: number | null, holdTimeoutMs?: number | null}} [args] - Lock and hold timeout options.
      * @returns {Promise<T>} - Resolves with the callback result.
      */
-    withAdvisoryLock<T>(name: string, callback: () => Promise<T>, args?: {
+    withAdvisoryLock<T>(name: string, callback: (args?: {
+        control: import("awaitery/build/timeout.js").TimeoutControl;
+    }) => Promise<T>, args?: {
         timeoutMs?: number | null;
         holdTimeoutMs?: number | null;
     }): Promise<T>;
     /**
      * Runs a callback only if the advisory lock can be acquired immediately.
+     * When a `holdTimeoutMs` is set the callback receives a `TimeoutControl` from
+     * awaitery for cooperative cancellation.
      * @template T
      * @param {string} name - Lock name.
-     * @param {() => Promise<T>} callback - Callback to invoke while the lock is held.
+     * @param {(args?: {control: import("awaitery/build/timeout.js").TimeoutControl}) => Promise<T>} callback - Callback to invoke while the lock is held.
      * @param {{holdTimeoutMs?: number | null}} [args] - Hold timeout options.
      * @returns {Promise<T>} - Resolves with the callback result.
      */
-    withAdvisoryLockOrFail<T>(name: string, callback: () => Promise<T>, args?: {
+    withAdvisoryLockOrFail<T>(name: string, callback: (args?: {
+        control: import("awaitery/build/timeout.js").TimeoutControl;
+    }) => Promise<T>, args?: {
         holdTimeoutMs?: number | null;
     }): Promise<T>;
     /**
      * Runs the lock holder callback and releases the lock from its owning connection.
      * @template T
-     * @param {{callback: () => Promise<T>, connection: import("./drivers/base.js").default, holdTimeoutMs?: number | null, name: string}} args - Locked callback args.
+     * @param {{callback: (args?: {control: import("awaitery/build/timeout.js").TimeoutControl}) => Promise<T>, connection: import("./drivers/base.js").default, holdTimeoutMs?: number | null, name: string}} args - Locked callback args.
      * @returns {Promise<T>} - Resolves with the callback result.
      */
     runLockedCallback<T>({ callback, connection, holdTimeoutMs, name }: {
-        callback: () => Promise<T>;
+        callback: (args?: {
+            control: import("awaitery/build/timeout.js").TimeoutControl;
+        }) => Promise<T>;
         connection: import("./drivers/base.js").default;
         holdTimeoutMs?: number | null;
         name: string;

package/build/src/database/advisory-lock-runner.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"advisory-lock-runner.d.ts","sourceRoot":"","sources":["../../../src/database/advisory-lock-runner.js"],"names":[],"mappings":"AAoDA;;;GAGG;AACH;IAsGE;;;;;;;;;OASG;IACH,sCANa,CAAC,QACH,MAAM,YACN,MAAM,OAAO,CAAC,CAAC,CAAC,kBAChB,MAAM,GAAG,IAAI,GACX,OAAO,CAAC,CAAC,CAAC,CAwBtB;IArID;;;OAGG;IACH,uEAFW;QAAC,aAAa,EAAE,OAAO,qBAAqB,EAAE,OAAO,CAAC;QAAC,kBAAkB,EAAE,MAAM,OAAO,mBAAmB,EAAE,OAAO,CAAC;QAAC,kBAAkB,EAAE,MAAM,CAAA;KAAC,EAM3J;IAHC,qDAAkC;IAClC,0BAJ0F,OAAO,mBAAmB,EAAE,OAAO,CAIjF;IAC5C,2BAA4C;IAG9C;;;;;;;OAOG;IACH,iBANa,CAAC,QACH,MAAM,YACN,MAAM,OAAO,CAAC,CAAC,CAAC,SAChB;QAAC,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;QAAC,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;KAAC,GACxD,OAAO,CAAC,CAAC,CAAC,CAYtB;IAED;;;;;;;OAOG;IACH,uBANa,CAAC,QACH,MAAM,YACN,MAAM,OAAO,CAAC,CAAC,CAAC,SAChB;QAAC,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;KAAC,GAC7B,OAAO,CAAC,CAAC,CAAC,CAYtB;IAED;;;;;OAKG;IACH,kBAJa,CAAC,iDACH;QAAC,QAAQ,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,CAAC;QAAC,UAAU,EAAE,OAAO,mBAAmB,EAAE,OAAO,CAAC;QAAC,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC,GACxH,OAAO,CAAC,CAAC,CAAC,CAQtB;IAED;;;;;;;OAOG;IACH,mBALa,CAAC,iBACH,MAAM,GAAG,IAAI,GAAG,SAAS,YACzB,CAAC,UAAU,EAAE,OAAO,mBAAmB,EAAE,OAAO,KAAK,OAAO,CAAC,CAAC,CAAC,GAC7D,OAAO,CAAC,CAAC,CAAC,CAQtB;IAED;;;;;;OAMG;IACH,wBAJa,CAAC,YACH,CAAC,UAAU,EAAE,OAAO,mBAAmB,EAAE,OAAO,KAAK,OAAO,CAAC,CAAC,CAAC,GAC7D,OAAO,CAAC,CAAC,CAAC,CActB;CAmCF;AA3KD;;GAEG;AACH;IACE;;;;OAIG;IACH,qBAHW,MAAM,YACN;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC,EAMxB;IADC,iBAAoB;CAEvB;AAED;;GAEG;AACH;IACE;;;;OAIG;IACH,qBAHW,MAAM,YACN;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC,EAMxB;IADC,iBAAoB;CAEvB;AA9CD;;GAEG;AACH;IACE;;;;OAIG;IACH,qBAHW,MAAM,YACN;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC,EAMxB;IADC,iBAAoB;CAEvB"}
+{"version":3,"file":"advisory-lock-runner.d.ts","sourceRoot":"","sources":["../../../src/database/advisory-lock-runner.js"],"names":[],"mappings":"AAoDA;;;GAGG;AACH;IA2GE;;;;;;;;;;;;;OAaG;IACH,sCANa,CAAC,QACH,MAAM,YACN,CAAC,IAAI,CAAC,EAAE;QAAC,OAAO,EAAE,OAAO,2BAA2B,EAAE,cAAc,CAAA;KAAC,KAAK,OAAO,CAAC,CAAC,CAAC,kBACpF,MAAM,GAAG,IAAI,GACX,OAAO,CAAC,CAAC,CAAC,CAwBtB;IA9ID;;;OAGG;IACH,uEAFW;QAAC,aAAa,EAAE,OAAO,qBAAqB,EAAE,OAAO,CAAC;QAAC,kBAAkB,EAAE,MAAM,OAAO,mBAAmB,EAAE,OAAO,CAAC;QAAC,kBAAkB,EAAE,MAAM,CAAA;KAAC,EAM3J;IAHC,qDAAkC;IAClC,0BAJ0F,OAAO,mBAAmB,EAAE,OAAO,CAIjF;IAC5C,2BAA4C;IAG9C;;;;;;;;;;OAUG;IACH,iBANa,CAAC,QACH,MAAM,YACN,CAAC,IAAI,CAAC,EAAE;QAAC,OAAO,EAAE,OAAO,2BAA2B,EAAE,cAAc,CAAA;KAAC,KAAK,OAAO,CAAC,CAAC,CAAC,SACpF;QAAC,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;QAAC,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;KAAC,GACxD,OAAO,CAAC,CAAC,CAAC,CAYtB;IAED;;;;;;;;;OASG;IACH,uBANa,CAAC,QACH,MAAM,YACN,CAAC,IAAI,CAAC,EAAE;QAAC,OAAO,EAAE,OAAO,2BAA2B,EAAE,cAAc,CAAA;KAAC,KAAK,OAAO,CAAC,CAAC,CAAC,SACpF;QAAC,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;KAAC,GAC7B,OAAO,CAAC,CAAC,CAAC,CAYtB;IAED;;;;;OAKG;IACH,kBAJa,CAAC,iDACH;QAAC,QAAQ,EAAE,CAAC,IAAI,CAAC,EAAE;YAAC,OAAO,EAAE,OAAO,2BAA2B,EAAE,cAAc,CAAA;SAAC,KAAK,OAAO,CAAC,CAAC,CAAC,CAAC;QAAC,UAAU,EAAE,OAAO,mBAAmB,EAAE,OAAO,CAAC;QAAC,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC,GAC5L,OAAO,CAAC,CAAC,CAAC,CAQtB;IAED;;;;;;;OAOG;IACH,mBALa,CAAC,iBACH,MAAM,GAAG,IAAI,GAAG,SAAS,YACzB,CAAC,UAAU,EAAE,OAAO,mBAAmB,EAAE,OAAO,KAAK,OAAO,CAAC,CAAC,CAAC,GAC7D,OAAO,CAAC,CAAC,CAAC,CAQtB;IAED;;;;;;OAMG;IACH,wBAJa,CAAC,YACH,CAAC,UAAU,EAAE,OAAO,mBAAmB,EAAE,OAAO,KAAK,OAAO,CAAC,CAAC,CAAC,GAC7D,OAAO,CAAC,CAAC,CAAC,CActB;CAuCF;AApLD;;GAEG;AACH;IACE;;;;OAIG;IACH,qBAHW,MAAM,YACN;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC,EAMxB;IADC,iBAAoB;CAEvB;AAED;;GAEG;AACH;IACE;;;;OAIG;IACH,qBAHW,MAAM,YACN;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC,EAMxB;IADC,iBAAoB;CAEvB;AA9CD;;GAEG;AACH;IACE;;;;OAIG;IACH,qBAHW,MAAM,YACN;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC,EAMxB;IADC,iBAAoB;CAEvB"}

package/build/src/database/advisory-lock-runner.js

@@ -1,5 +1,5 @@
 // @ts-check
-import timeout from "awaitery/build/timeout.js";
+import timeout, { TimeoutError } from "awaitery/build/timeout.js";
 /**
  * Thrown when an advisory lock could not be acquired before `timeoutMs` elapsed.
  */
@@ -61,9 +61,12 @@ export default class AdvisoryLockRunner {
     }
     /**
      * Runs a callback after acquiring the advisory lock, waiting up to `timeoutMs`.
+     * When a `holdTimeoutMs` is set the callback receives a `TimeoutControl` from
+     * awaitery for cooperative cancellation (`control.check()`, `control.signal`,
+     * `control.timedOut`, `control.remaining()`).
      * @template T
      * @param {string} name - Lock name.
-     * @param {() => Promise<T>} callback - Callback to invoke while the lock is held.
+     * @param {(args?: {control: import("awaitery/build/timeout.js").TimeoutControl}) => Promise<T>} callback - Callback to invoke while the lock is held.
      * @param {{timeoutMs?: number | null, holdTimeoutMs?: number | null}} [args] - Lock and hold timeout options.
      * @returns {Promise<T>} - Resolves with the callback result.
      */
@@ -78,9 +81,11 @@ export default class AdvisoryLockRunner {
     }
     /**
      * Runs a callback only if the advisory lock can be acquired immediately.
+     * When a `holdTimeoutMs` is set the callback receives a `TimeoutControl` from
+     * awaitery for cooperative cancellation.
      * @template T
      * @param {string} name - Lock name.
-     * @param {() => Promise<T>} callback - Callback to invoke while the lock is held.
+     * @param {(args?: {control: import("awaitery/build/timeout.js").TimeoutControl}) => Promise<T>} callback - Callback to invoke while the lock is held.
      * @param {{holdTimeoutMs?: number | null}} [args] - Hold timeout options.
      * @returns {Promise<T>} - Resolves with the callback result.
      */
@@ -96,7 +101,7 @@ export default class AdvisoryLockRunner {
     /**
      * Runs the lock holder callback and releases the lock from its owning connection.
      * @template T
-     * @param {{callback: () => Promise<T>, connection: import("./drivers/base.js").default, holdTimeoutMs?: number | null, name: string}} args - Locked callback args.
+     * @param {{callback: (args?: {control: import("awaitery/build/timeout.js").TimeoutControl}) => Promise<T>, connection: import("./drivers/base.js").default, holdTimeoutMs?: number | null, name: string}} args - Locked callback args.
      * @returns {Promise<T>} - Resolves with the callback result.
      */
     async runLockedCallback({ callback, connection, holdTimeoutMs, name }) {
@@ -146,9 +151,13 @@ export default class AdvisoryLockRunner {
      * Runs `callback`, rejecting with `AdvisoryLockHoldTimeoutError` if it has
      * not settled within `holdTimeoutMs`. The callback is not cancelled; callers
      * use a dedicated advisory-lock connection so the lock can still be released.
+     *
+     * The callback receives a `TimeoutControl` from awaitery, enabling cooperative
+     * cancellation via `control.check()`, `control.signal`, `control.timedOut`,
+     * and `control.remaining()`.
      * @template T
      * @param {string} name - Lock name (for the error message).
-     * @param {() => Promise<T>} callback - Callback holding the lock.
+     * @param {(args?: {control: import("awaitery/build/timeout.js").TimeoutControl}) => Promise<T>} callback - Callback holding the lock.
      * @param {number | null} [holdTimeoutMs] - Max hold time; falsy disables the timeout.
      * @returns {Promise<T>} - Resolves with the callback result.
      */
@@ -158,9 +167,9 @@ export default class AdvisoryLockRunner {
         }
         let callbackSettled = false;
         try {
-            return await timeout({ timeout: holdTimeoutMs }, async () => {
+            return await timeout({ timeout: holdTimeoutMs }, async ({ control }) => {
                 try {
-                    return await callback();
+                    return await callback({ control });
                 }
                 finally {
                     callbackSettled = true;
@@ -168,7 +177,7 @@ export default class AdvisoryLockRunner {
             });
         }
         catch (error) {
-            if (!callbackSettled) {
+            if (!callbackSettled || error instanceof TimeoutError) {
                 throw new AdvisoryLockHoldTimeoutError(`Advisory lock ${JSON.stringify(name)} held longer than ${holdTimeoutMs}ms`, { name });
             }
             throw error;
@@ -176,4 +185,4 @@ export default class AdvisoryLockRunner {
     }
 }
 export { AdvisoryLockBusyError, AdvisoryLockHoldTimeoutError, AdvisoryLockTimeoutError };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"advisory-lock-runner.js","sourceRoot":"","sources":["../../../src/database/advisory-lock-runner.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport timeout from \"awaitery/build/timeout.js\"\n\n/**\n * Thrown when an advisory lock could not be acquired before `timeoutMs` elapsed.\n */\nclass AdvisoryLockTimeoutError extends Error {\n  /**\n   * Runs constructor.\n   * @param {string} message - Error message.\n   * @param {{name: string}} args - The advisory lock name that timed out.\n   */\n  constructor(message, {name}) {\n    super(message)\n    this.name = \"AdvisoryLockTimeoutError\"\n    this.lockName = name\n  }\n}\n\n/**\n * Thrown when `withAdvisoryLockOrFail` finds the lock already held.\n */\nclass AdvisoryLockBusyError extends Error {\n  /**\n   * Runs constructor.\n   * @param {string} message - Error message.\n   * @param {{name: string}} args - The advisory lock name that was already held.\n   */\n  constructor(message, {name}) {\n    super(message)\n    this.name = \"AdvisoryLockBusyError\"\n    this.lockName = name\n  }\n}\n\n/**\n * Thrown when a callback holds an advisory lock longer than `holdTimeoutMs`.\n */\nclass AdvisoryLockHoldTimeoutError extends Error {\n  /**\n   * Runs constructor.\n   * @param {string} message - Error message.\n   * @param {{name: string}} args - The advisory lock name whose hold timed out.\n   */\n  constructor(message, {name}) {\n    super(message)\n    this.name = \"AdvisoryLockHoldTimeoutError\"\n    this.lockName = name\n  }\n}\n\n/**\n * Runs advisory locks on the caller connection by default, using a dedicated\n * lock connection only when a positive hold timeout needs separate ownership.\n */\nexport default class AdvisoryLockRunner {\n  /**\n   * Creates an advisory-lock runner for one model database identifier.\n   * @param {{configuration: import(\"../configuration.js\").default, connectionProvider: () => import(\"./drivers/base.js\").default, databaseIdentifier: string}} args - Runner dependencies.\n   */\n  constructor({configuration, connectionProvider, databaseIdentifier}) {\n    this.configuration = configuration\n    this.connectionProvider = connectionProvider\n    this.databaseIdentifier = databaseIdentifier\n  }\n\n  /**\n   * Runs a callback after acquiring the advisory lock, waiting up to `timeoutMs`.\n   * @template T\n   * @param {string} name - Lock name.\n   * @param {() => Promise<T>} callback - Callback to invoke while the lock is held.\n   * @param {{timeoutMs?: number | null, holdTimeoutMs?: number | null}} [args] - Lock and hold timeout options.\n   * @returns {Promise<T>} - Resolves with the callback result.\n   */\n  async withAdvisoryLock(name, callback, args = {}) {\n    return await this.withLockConnection(args.holdTimeoutMs, async (connection) => {\n      const acquired = await connection.acquireAdvisoryLock(name, args)\n\n      if (!acquired) {\n        throw new AdvisoryLockTimeoutError(`Timed out waiting for advisory lock ${JSON.stringify(name)}`, {name})\n      }\n\n      return await this.runLockedCallback({callback, connection, holdTimeoutMs: args.holdTimeoutMs, name})\n    })\n  }\n\n  /**\n   * Runs a callback only if the advisory lock can be acquired immediately.\n   * @template T\n   * @param {string} name - Lock name.\n   * @param {() => Promise<T>} callback - Callback to invoke while the lock is held.\n   * @param {{holdTimeoutMs?: number | null}} [args] - Hold timeout options.\n   * @returns {Promise<T>} - Resolves with the callback result.\n   */\n  async withAdvisoryLockOrFail(name, callback, args = {}) {\n    return await this.withLockConnection(args.holdTimeoutMs, async (connection) => {\n      const acquired = await connection.tryAcquireAdvisoryLock(name)\n\n      if (!acquired) {\n        throw new AdvisoryLockBusyError(`Advisory lock ${JSON.stringify(name)} is already held`, {name})\n      }\n\n      return await this.runLockedCallback({callback, connection, holdTimeoutMs: args.holdTimeoutMs, name})\n    })\n  }\n\n  /**\n   * Runs the lock holder callback and releases the lock from its owning connection.\n   * @template T\n   * @param {{callback: () => Promise<T>, connection: import(\"./drivers/base.js\").default, holdTimeoutMs?: number | null, name: string}} args - Locked callback args.\n   * @returns {Promise<T>} - Resolves with the callback result.\n   */\n  async runLockedCallback({callback, connection, holdTimeoutMs, name}) {\n    try {\n      return await AdvisoryLockRunner.runWithAdvisoryLockHoldTimeout(name, callback, holdTimeoutMs)\n    } finally {\n      await connection.releaseAdvisoryLock(name)\n    }\n  }\n\n  /**\n   * Runs lock work on the caller connection unless a positive hold timeout needs\n   * its own lock connection.\n   * @template T\n   * @param {number | null | undefined} holdTimeoutMs - Max hold time; positive values use a dedicated lock connection.\n   * @param {(connection: import(\"./drivers/base.js\").default) => Promise<T>} callback - Callback receiving the connection that owns the advisory lock.\n   * @returns {Promise<T>} - Resolves with the callback result.\n   */\n  async withLockConnection(holdTimeoutMs, callback) {\n    if (holdTimeoutMs && holdTimeoutMs > 0) {\n      return await this.withDedicatedConnection(callback)\n    }\n\n    return await callback(this.connectionProvider())\n  }\n\n  /**\n   * Spawns a hold-timeout lock connection and closes it after lock work completes when\n   * the spawned driver owns the underlying physical connection.\n   * @template T\n   * @param {(connection: import(\"./drivers/base.js\").default) => Promise<T>} callback - Callback that receives the dedicated lock connection.\n   * @returns {Promise<T>} - Resolves with the callback result.\n   */\n  async withDedicatedConnection(callback) {\n    const connection = await this.configuration.getDatabasePool(this.databaseIdentifier).spawnConnection()\n\n    try {\n      return await callback(connection)\n    } finally {\n      if (connection.getArgs().getConnection) {\n        await connection.releaseHeldAdvisoryLocks()\n      } else {\n        await connection.close()\n      }\n    }\n  }\n\n  /**\n   * Runs `callback`, rejecting with `AdvisoryLockHoldTimeoutError` if it has\n   * not settled within `holdTimeoutMs`. The callback is not cancelled; callers\n   * use a dedicated advisory-lock connection so the lock can still be released.\n   * @template T\n   * @param {string} name - Lock name (for the error message).\n   * @param {() => Promise<T>} callback - Callback holding the lock.\n   * @param {number | null} [holdTimeoutMs] - Max hold time; falsy disables the timeout.\n   * @returns {Promise<T>} - Resolves with the callback result.\n   */\n  static async runWithAdvisoryLockHoldTimeout(name, callback, holdTimeoutMs) {\n    if (!holdTimeoutMs || holdTimeoutMs <= 0) {\n      return await callback()\n    }\n\n    let callbackSettled = false\n\n    try {\n      return await timeout({timeout: holdTimeoutMs}, async () => {\n        try {\n          return await callback()\n        } finally {\n          callbackSettled = true\n        }\n      })\n    } catch (error) {\n      if (!callbackSettled) {\n        throw new AdvisoryLockHoldTimeoutError(`Advisory lock ${JSON.stringify(name)} held longer than ${holdTimeoutMs}ms`, {name})\n      }\n\n      throw error\n    }\n  }\n}\n\nexport {AdvisoryLockBusyError, AdvisoryLockHoldTimeoutError, AdvisoryLockTimeoutError}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"advisory-lock-runner.js","sourceRoot":"","sources":["../../../src/database/advisory-lock-runner.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport timeout, {TimeoutError} from \"awaitery/build/timeout.js\"\n\n/**\n * Thrown when an advisory lock could not be acquired before `timeoutMs` elapsed.\n */\nclass AdvisoryLockTimeoutError extends Error {\n  /**\n   * Runs constructor.\n   * @param {string} message - Error message.\n   * @param {{name: string}} args - The advisory lock name that timed out.\n   */\n  constructor(message, {name}) {\n    super(message)\n    this.name = \"AdvisoryLockTimeoutError\"\n    this.lockName = name\n  }\n}\n\n/**\n * Thrown when `withAdvisoryLockOrFail` finds the lock already held.\n */\nclass AdvisoryLockBusyError extends Error {\n  /**\n   * Runs constructor.\n   * @param {string} message - Error message.\n   * @param {{name: string}} args - The advisory lock name that was already held.\n   */\n  constructor(message, {name}) {\n    super(message)\n    this.name = \"AdvisoryLockBusyError\"\n    this.lockName = name\n  }\n}\n\n/**\n * Thrown when a callback holds an advisory lock longer than `holdTimeoutMs`.\n */\nclass AdvisoryLockHoldTimeoutError extends Error {\n  /**\n   * Runs constructor.\n   * @param {string} message - Error message.\n   * @param {{name: string}} args - The advisory lock name whose hold timed out.\n   */\n  constructor(message, {name}) {\n    super(message)\n    this.name = \"AdvisoryLockHoldTimeoutError\"\n    this.lockName = name\n  }\n}\n\n/**\n * Runs advisory locks on the caller connection by default, using a dedicated\n * lock connection only when a positive hold timeout needs separate ownership.\n */\nexport default class AdvisoryLockRunner {\n  /**\n   * Creates an advisory-lock runner for one model database identifier.\n   * @param {{configuration: import(\"../configuration.js\").default, connectionProvider: () => import(\"./drivers/base.js\").default, databaseIdentifier: string}} args - Runner dependencies.\n   */\n  constructor({configuration, connectionProvider, databaseIdentifier}) {\n    this.configuration = configuration\n    this.connectionProvider = connectionProvider\n    this.databaseIdentifier = databaseIdentifier\n  }\n\n  /**\n   * Runs a callback after acquiring the advisory lock, waiting up to `timeoutMs`.\n   * When a `holdTimeoutMs` is set the callback receives a `TimeoutControl` from\n   * awaitery for cooperative cancellation (`control.check()`, `control.signal`,\n   * `control.timedOut`, `control.remaining()`).\n   * @template T\n   * @param {string} name - Lock name.\n   * @param {(args?: {control: import(\"awaitery/build/timeout.js\").TimeoutControl}) => Promise<T>} callback - Callback to invoke while the lock is held.\n   * @param {{timeoutMs?: number | null, holdTimeoutMs?: number | null}} [args] - Lock and hold timeout options.\n   * @returns {Promise<T>} - Resolves with the callback result.\n   */\n  async withAdvisoryLock(name, callback, args = {}) {\n    return await this.withLockConnection(args.holdTimeoutMs, async (connection) => {\n      const acquired = await connection.acquireAdvisoryLock(name, args)\n\n      if (!acquired) {\n        throw new AdvisoryLockTimeoutError(`Timed out waiting for advisory lock ${JSON.stringify(name)}`, {name})\n      }\n\n      return await this.runLockedCallback({callback, connection, holdTimeoutMs: args.holdTimeoutMs, name})\n    })\n  }\n\n  /**\n   * Runs a callback only if the advisory lock can be acquired immediately.\n   * When a `holdTimeoutMs` is set the callback receives a `TimeoutControl` from\n   * awaitery for cooperative cancellation.\n   * @template T\n   * @param {string} name - Lock name.\n   * @param {(args?: {control: import(\"awaitery/build/timeout.js\").TimeoutControl}) => Promise<T>} callback - Callback to invoke while the lock is held.\n   * @param {{holdTimeoutMs?: number | null}} [args] - Hold timeout options.\n   * @returns {Promise<T>} - Resolves with the callback result.\n   */\n  async withAdvisoryLockOrFail(name, callback, args = {}) {\n    return await this.withLockConnection(args.holdTimeoutMs, async (connection) => {\n      const acquired = await connection.tryAcquireAdvisoryLock(name)\n\n      if (!acquired) {\n        throw new AdvisoryLockBusyError(`Advisory lock ${JSON.stringify(name)} is already held`, {name})\n      }\n\n      return await this.runLockedCallback({callback, connection, holdTimeoutMs: args.holdTimeoutMs, name})\n    })\n  }\n\n  /**\n   * Runs the lock holder callback and releases the lock from its owning connection.\n   * @template T\n   * @param {{callback: (args?: {control: import(\"awaitery/build/timeout.js\").TimeoutControl}) => Promise<T>, connection: import(\"./drivers/base.js\").default, holdTimeoutMs?: number | null, name: string}} args - Locked callback args.\n   * @returns {Promise<T>} - Resolves with the callback result.\n   */\n  async runLockedCallback({callback, connection, holdTimeoutMs, name}) {\n    try {\n      return await AdvisoryLockRunner.runWithAdvisoryLockHoldTimeout(name, callback, holdTimeoutMs)\n    } finally {\n      await connection.releaseAdvisoryLock(name)\n    }\n  }\n\n  /**\n   * Runs lock work on the caller connection unless a positive hold timeout needs\n   * its own lock connection.\n   * @template T\n   * @param {number | null | undefined} holdTimeoutMs - Max hold time; positive values use a dedicated lock connection.\n   * @param {(connection: import(\"./drivers/base.js\").default) => Promise<T>} callback - Callback receiving the connection that owns the advisory lock.\n   * @returns {Promise<T>} - Resolves with the callback result.\n   */\n  async withLockConnection(holdTimeoutMs, callback) {\n    if (holdTimeoutMs && holdTimeoutMs > 0) {\n      return await this.withDedicatedConnection(callback)\n    }\n\n    return await callback(this.connectionProvider())\n  }\n\n  /**\n   * Spawns a hold-timeout lock connection and closes it after lock work completes when\n   * the spawned driver owns the underlying physical connection.\n   * @template T\n   * @param {(connection: import(\"./drivers/base.js\").default) => Promise<T>} callback - Callback that receives the dedicated lock connection.\n   * @returns {Promise<T>} - Resolves with the callback result.\n   */\n  async withDedicatedConnection(callback) {\n    const connection = await this.configuration.getDatabasePool(this.databaseIdentifier).spawnConnection()\n\n    try {\n      return await callback(connection)\n    } finally {\n      if (connection.getArgs().getConnection) {\n        await connection.releaseHeldAdvisoryLocks()\n      } else {\n        await connection.close()\n      }\n    }\n  }\n\n  /**\n   * Runs `callback`, rejecting with `AdvisoryLockHoldTimeoutError` if it has\n   * not settled within `holdTimeoutMs`. The callback is not cancelled; callers\n   * use a dedicated advisory-lock connection so the lock can still be released.\n   *\n   * The callback receives a `TimeoutControl` from awaitery, enabling cooperative\n   * cancellation via `control.check()`, `control.signal`, `control.timedOut`,\n   * and `control.remaining()`.\n   * @template T\n   * @param {string} name - Lock name (for the error message).\n   * @param {(args?: {control: import(\"awaitery/build/timeout.js\").TimeoutControl}) => Promise<T>} callback - Callback holding the lock.\n   * @param {number | null} [holdTimeoutMs] - Max hold time; falsy disables the timeout.\n   * @returns {Promise<T>} - Resolves with the callback result.\n   */\n  static async runWithAdvisoryLockHoldTimeout(name, callback, holdTimeoutMs) {\n    if (!holdTimeoutMs || holdTimeoutMs <= 0) {\n      return await callback()\n    }\n\n    let callbackSettled = false\n\n    try {\n      return await timeout({timeout: holdTimeoutMs}, async ({control}) => {\n        try {\n          return await callback({control})\n        } finally {\n          callbackSettled = true\n        }\n      })\n    } catch (error) {\n      if (!callbackSettled || error instanceof TimeoutError) {\n        throw new AdvisoryLockHoldTimeoutError(`Advisory lock ${JSON.stringify(name)} held longer than ${holdTimeoutMs}ms`, {name})\n      }\n\n      throw error\n    }\n  }\n}\n\nexport {AdvisoryLockBusyError, AdvisoryLockHoldTimeoutError, AdvisoryLockTimeoutError}\n"]}

package/build/src/database/structure-sql-loader.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Loads a database structure SQL dump into a connection in one pass. Foreign keys are
+ * disabled around the load so tables can be created in any order, and the driver's
+ * native multi-statement `exec` is used when available (a single round-trip) instead
+ * of issuing every statement separately. This is much faster than materializing a
+ * schema table by table (e.g. cloning), so it is the preferred way to provision a
+ * tenant/test database from a structure dump.
+ *
+ * Used by the `db:schema:load` CLI command and reusable by any caller that needs to
+ * apply a structure dump to a specific connection.
+ */
+export default class StructureSqlLoader {
+    /**
+     * Loads `structureSql` into `db`.
+     * @param {object} args - Options object.
+     * @param {import("./drivers/base.js").default} args.db - Target database connection.
+     * @param {string} args.structureSql - Structure SQL to load.
+     * @returns {Promise<void>} - Resolves when the structure has been loaded.
+     */
+    load({ db, structureSql }: {
+        db: import("./drivers/base.js").default;
+        structureSql: string;
+    }): Promise<void>;
+    /**
+     * Returns the underlying connection when it exposes a native multi-statement
+     * `exec` (a single round-trip for the whole dump), otherwise undefined so the
+     * caller falls back to per-statement execution.
+     * @param {import("./drivers/base.js").default} db - Database connection.
+     * @returns {{exec: (sql: string) => Promise<?>} | undefined} - Connection with exec support.
+     */
+    executableConnection(db: import("./drivers/base.js").default): {
+        exec: (sql: string) => Promise<unknown>;
+    } | undefined;
+}
+//# sourceMappingURL=structure-sql-loader.d.ts.map

package/build/src/database/structure-sql-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"structure-sql-loader.d.ts","sourceRoot":"","sources":["../../../src/database/structure-sql-loader.js"],"names":[],"mappings":"AAIA;;;;;;;;;;GAUG;AACH;IACE;;;;;;OAMG;IACH,2BAJG;QAAkD,EAAE,EAA5C,OAAO,mBAAmB,EAAE,OAAO;QACtB,YAAY,EAAzB,MAAM;KACd,GAAU,OAAO,CAAC,IAAI,CAAC,CA6BzB;IAED;;;;;;OAMG;IACH,yBAHW,OAAO,mBAAmB,EAAE,OAAO,GACjC;QAAC,IAAI,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,OAAC,CAAC,CAAA;KAAC,GAAG,SAAS,CAS3D;CACF"}

package/build/src/database/structure-sql-loader.js

@@ -0,0 +1,63 @@
+// @ts-check
+import splitSqlStatements from "../utils/split-sql-statements.js";
+/**
+ * Loads a database structure SQL dump into a connection in one pass. Foreign keys are
+ * disabled around the load so tables can be created in any order, and the driver's
+ * native multi-statement `exec` is used when available (a single round-trip) instead
+ * of issuing every statement separately. This is much faster than materializing a
+ * schema table by table (e.g. cloning), so it is the preferred way to provision a
+ * tenant/test database from a structure dump.
+ *
+ * Used by the `db:schema:load` CLI command and reusable by any caller that needs to
+ * apply a structure dump to a specific connection.
+ */
+export default class StructureSqlLoader {
+    /**
+     * Loads `structureSql` into `db`.
+     * @param {object} args - Options object.
+     * @param {import("./drivers/base.js").default} args.db - Target database connection.
+     * @param {string} args.structureSql - Structure SQL to load.
+     * @returns {Promise<void>} - Resolves when the structure has been loaded.
+     */
+    async load({ db, structureSql }) {
+        const statements = splitSqlStatements(structureSql);
+        if (statements.length == 0)
+            return;
+        const executableConnection = this.executableConnection(db);
+        await db.disableForeignKeys();
+        try {
+            if (executableConnection) {
+                await executableConnection.exec(structureSql);
+            }
+            else {
+                for (const statement of statements) {
+                    await db.query(statement);
+                }
+            }
+        }
+        finally {
+            await db.enableForeignKeys();
+            // The native `exec` path mutates the schema outside `Base#query`, so the
+            // usual post-DDL schema-cache invalidation never runs. Clear it here so a
+            // caller that read schema metadata before provisioning (e.g. an empty table
+            // list) does not keep seeing the pre-load schema afterwards. Harmless for the
+            // per-statement path, which already invalidates as each DDL statement runs.
+            db.clearSchemaCache();
+        }
+    }
+    /**
+     * Returns the underlying connection when it exposes a native multi-statement
+     * `exec` (a single round-trip for the whole dump), otherwise undefined so the
+     * caller falls back to per-statement execution.
+     * @param {import("./drivers/base.js").default} db - Database connection.
+     * @returns {{exec: (sql: string) => Promise<?>} | undefined} - Connection with exec support.
+     */
+    executableConnection(db) {
+        const dbWithConnection = /** @type {import("./drivers/base.js").default & {connection?: ?}} */ (db);
+        const connection = dbWithConnection.connection;
+        if (connection && typeof connection == "object" && "exec" in connection && typeof connection.exec == "function") {
+            return /** @type {{exec: (sql: string) => Promise<?>}} */ (connection);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/src/environment-handlers/node/cli/commands/db/schema/load.d.ts

@@ -4,25 +4,6 @@ export default class DbSchemaLoad extends BaseCommand {
      * Runs execute.
      * @returns {Promise<void>} */
     execute(): Promise<void>;
-    /**
-     * Runs load structure sql.
-     * @param {object} args - Options object.
-     * @param {import("../../../../../../database/drivers/base.js").default} args.db - Database connection.
-     * @param {string} args.structureSql - Structure SQL to load.
-     * @returns {Promise<void>} - Resolves when complete.
-     */
-    loadStructureSql({ db, structureSql }: {
-        db: import("../../../../../../database/drivers/base.js").default;
-        structureSql: string;
-    }): Promise<void>;
-    /**
-     * Runs executable connection.
-     * @param {import("../../../../../../database/drivers/base.js").default} db - Database connection.
-     * @returns {{exec: (sql: string) => Promise<?>} | undefined} - Connection with exec support.
-     */
-    executableConnection(db: import("../../../../../../database/drivers/base.js").default): {
-        exec: (sql: string) => Promise<unknown>;
-    } | undefined;
 }
 import BaseCommand from "../../../../../../cli/base-command.js";
 //# sourceMappingURL=load.d.ts.map