velocious 1.0.549 → 1.0.552

package/build/src/database/drivers/mysql/index.js

@@ -165,6 +165,11 @@ export default class VelociousDatabaseDriversMysql extends Base {
             connectArgs["user"] = args["username"];
         if ("charset" in args)
             connectArgs["charset"] = args["charset"];
+        // Opt-in only. Lets a whole structure SQL dump run in one round-trip via
+        // {@link execStructureScript}; off by default so ordinary queries keep rejecting
+        // stacked statements.
+        if ("multipleStatements" in args)
+            connectArgs["multipleStatements"] = Boolean(digg(args, "multipleStatements"));
         return connectArgs;
     }
     /**
@@ -364,6 +369,35 @@ export default class VelociousDatabaseDriversMysql extends Base {
             });
         });
     }
+    /**
+     * Executes a full multi-statement structure SQL script in one round-trip when the
+     * connection was configured with `multipleStatements: true`. Runs on the pooled
+     * connection so the caller's `SET FOREIGN_KEY_CHECKS = 0` applies. Returns false so
+     * the caller runs statements individually when multi-statement queries are off.
+     * @param {string} structureSql - Full multi-statement structure SQL.
+     * @returns {Promise<boolean>} - Whether the script was executed as one batch.
+     */
+    async execStructureScript(structureSql) {
+        if (!this.getArgs().multipleStatements)
+            return false;
+        // The batched pool call below bypasses Base#query, so re-run the same read-only
+        // write guard the per-statement path applies before executing the dump.
+        this._assertWritableQuery(structureSql);
+        if (!this.pool)
+            await this.connect();
+        if (!this.pool)
+            throw new Error("MySQL pool failed to initialize");
+        const pool = this.pool;
+        await new Promise((resolve, reject) => {
+            pool.query(structureSql, (error) => {
+                if (error)
+                    reject(error);
+                else
+                    resolve(undefined);
+            });
+        });
+        return true;
+    }
     /**
      * Runs query to sql.
      * @param {import("../../query/index.js").default} query - Query instance.
@@ -543,4 +577,4 @@ export default class VelociousDatabaseDriversMysql extends Base {
         return holder !== null && holder !== undefined;
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../src/database/drivers/mysql/index.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport AlterTable from \"./sql/alter-table.js\"\nimport Base from \"../base.js\"\nimport CreateDatabase from \"./sql/create-database.js\"\nimport CreateIndex from \"./sql/create-index.js\"\nimport CreateTable from \"./sql/create-table.js\"\nimport Delete from \"./sql/delete.js\"\nimport {digg} from \"diggerize\"\nimport DropDatabase from \"./sql/drop-database.js\"\nimport DropTable from \"./sql/drop-table.js\"\nimport Insert from \"./sql/insert.js\"\nimport Options from \"./options.js\"\nimport mysql from \"mysql\"\nimport query from \"./query.js\"\nimport QueryParser from \"./query-parser.js\"\nimport streamQuery from \"./query-stream.js\"\nimport RemoveIndex from \"./sql/remove-index.js\"\nimport Table from \"./table.js\"\nimport StructureSql from \"./structure-sql.js\"\nimport Upsert from \"./sql/upsert.js\"\nimport Update from \"./sql/update.js\"\n\n/**\n * Sentinel timeout (in seconds) used as the \"block forever\" value when a\n * caller asks for an indefinite advisory lock acquire. MySQL historically\n * accepted negative timeouts as \"infinite\", but MariaDB 10+ silently\n * returns NULL from `GET_LOCK` when the timeout is negative, so the\n * driver clamps to a comfortably large positive value (1 year ≫ any\n * realistic critical section) instead.\n */\nconst MYSQL_INDEFINITE_LOCK_TIMEOUT_SECONDS = 60 * 60 * 24 * 365\n\nexport default class VelociousDatabaseDriversMysql extends Base{\n  /** @type {import(\"mysql\").Pool | undefined} */\n  pool = undefined\n\n  /** @type {string | null} */\n  _desiredSessionTimeZone = \"+00:00\"\n\n  /** @type {string | null} */\n  _currentSessionTimeZone = null\n\n  /**\n   * Runs connect.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async connect() {\n    this.resetCurrentSessionTimeZone()\n    this.pool = mysql.createPool(Object.assign({connectionLimit: 1}, this.connectArgs()))\n    this.pool.on(\"error\", this.onPoolError)\n  }\n\n  /**\n   * On pool error.\n   * @param {Error} error - Error from the connection attempt.\n   */\n  onPoolError = (error) => {\n    console.error(\"Velocious / MySQL driver / Pool error\", error)\n  }\n\n  /**\n   * Runs close.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async _close() {\n    await this.pool?.end()\n    this.pool = undefined\n    this.resetCurrentSessionTimeZone()\n  }\n\n  /**\n   * Runs set connection checkout name.\n   * @param {string | undefined} name - Human-readable name for this active checkout.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async setConnectionCheckoutName(name) {\n    const previousName = this._connectionCheckoutName\n\n    await super.setConnectionCheckoutName(name)\n\n    if (name === undefined) {\n      if (previousName !== undefined) {\n        await this.query(\"SET @velocious_connection_checkout_name = NULL\", {logName: \"Clear Connection Checkout Name\", processListComment: false, sessionTimeZone: false})\n      }\n\n      return\n    }\n\n    await this.query(`SET @velocious_connection_checkout_name = ${this.quote(name)}`, {logName: \"Set Connection Checkout Name\", processListComment: false, sessionTimeZone: false})\n  }\n\n  /**\n   * Runs clear connection checkout name.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async clearConnectionCheckoutName() {\n    if (this._connectionCheckoutName !== undefined) {\n      await this.query(\"SET @velocious_connection_checkout_name = NULL\", {logName: \"Clear Connection Checkout Name\", processListComment: false, sessionTimeZone: false})\n    }\n\n    await super.clearConnectionCheckoutName()\n  }\n\n  /**\n   * Hook before every query.\n   * @param {string} _sql - SQL string.\n   * @param {import(\"../base.js\").QueryOptions} options - Query options.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async beforeQuery(_sql, options) {\n    if (options.sessionTimeZone !== false) await this.ensureSessionTimeZone()\n  }\n\n  /**\n   * Gets the desired database session time zone for this connection context.\n   * @returns {string | null} - Desired session time zone.\n   */\n  getDesiredSessionTimeZone() {\n    return this._desiredSessionTimeZone\n  }\n\n  /**\n   * Sets the desired database session time zone without querying MySQL immediately.\n   * @param {string | null} timeZone - Desired session time zone.\n   */\n  setDesiredSessionTimeZone(timeZone) {\n    this._desiredSessionTimeZone = timeZone\n  }\n\n  /**\n   * Gets the database session time zone last confirmed through SET time_zone.\n   * @returns {string | null} - Current known session time zone.\n   */\n  getCurrentSessionTimeZone() {\n    return this._currentSessionTimeZone\n  }\n\n  /**\n   * Clears the current known database session time zone when the physical connection changes.\n   */\n  resetCurrentSessionTimeZone() {\n    this._currentSessionTimeZone = null\n  }\n\n  /**\n   * Ensures MySQL has the desired session time zone before user SQL runs.\n   * @returns {Promise<boolean>} - True when SET time_zone was executed.\n   */\n  async ensureSessionTimeZone() {\n    const desiredSessionTimeZone = this.getDesiredSessionTimeZone()\n\n    if (desiredSessionTimeZone === null || this.getCurrentSessionTimeZone() === desiredSessionTimeZone) return false\n\n    await this.setSessionTimeZone(desiredSessionTimeZone)\n\n    return true\n  }\n\n  /**\n   * Sets the database session time zone if it changed from the last confirmed value.\n   * @param {string} timeZone - Session time zone value accepted by MySQL.\n   * @returns {Promise<boolean>} - True when SET time_zone was executed.\n   */\n  async setSessionTimeZone(timeZone) {\n    if (this.getCurrentSessionTimeZone() === timeZone) return false\n\n    await this._queryActual(`SET time_zone = ${this.quote(timeZone)}`)\n    this._currentSessionTimeZone = timeZone\n\n    return true\n  }\n\n  /**\n   * Runs connect args.\n   * @returns {Record<string, ?>} - The connect args.\n   */\n  connectArgs() {\n    const args = this.getArgs()\n    const forward = [\"database\", \"host\", \"password\"]\n\n    /**\n     * Connect args.\n     * @type {Record<string, ?>} */\n    const connectArgs = {charset: \"utf8mb4\", timezone: \"Z\"}\n\n    for (const forwardValue of forward) {\n      if (forwardValue in args) connectArgs[forwardValue] = digg(args, forwardValue)\n    }\n\n    if (\"username\" in args) connectArgs[\"user\"] = args[\"username\"]\n    if (\"charset\" in args) connectArgs[\"charset\"] = args[\"charset\"]\n\n    return connectArgs\n  }\n\n  /**\n   * Runs alter table sqls.\n   * @param {import(\"../../table-data/index.js\").default} tableData - Table data.\n   * @returns {Promise<string[]>} - Resolves with SQL statements.\n   */\n  async alterTableSQLs(tableData) {\n    const alterArgs = {tableData, driver: this}\n    const alterTable = new AlterTable(alterArgs)\n\n    return await alterTable.toSQLs()\n  }\n\n  /**\n   * Runs create database sql.\n   * @param {string} databaseName - Database name.\n   * @param {object} [args] - Options object.\n   * @param {boolean} [args.ifNotExists] - Whether if not exists.\n   * @returns {string[]} - SQL statements.\n   */\n  createDatabaseSql(databaseName, args) {\n    const createArgs = Object.assign({databaseName, driver: this}, args)\n    const createDatabase = new CreateDatabase(createArgs)\n\n    return createDatabase.toSql()\n  }\n\n  /**\n   * Runs drop database sql.\n   * @param {string} databaseName - Database name.\n   * @param {object} [args] - Options object.\n   * @param {boolean} [args.ifExists] - Whether if exists.\n   * @returns {string[]} - SQL statements.\n   */\n  dropDatabaseSql(databaseName, args) {\n    const dropArgs = Object.assign({databaseName, driver: this}, args)\n    const dropDatabase = new DropDatabase(dropArgs)\n\n    return dropDatabase.toSql()\n  }\n\n  /**\n   * Runs create index sqls.\n   * @param {import(\"../base.js\").CreateIndexSqlArgs} indexData - Index data.\n   * @returns {Promise<string[]>} - Resolves with SQL statements.\n   */\n  async createIndexSQLs(indexData) {\n    const createArgs = Object.assign({driver: this}, indexData)\n    const createIndex = new CreateIndex(createArgs)\n\n    return await createIndex.toSQLs()\n  }\n\n  /**\n   * Runs remove index sqls.\n   * @param {import(\"../base.js\").RemoveIndexSqlArgs} indexData - Index data.\n   * @returns {Promise<string[]>} - Resolves with SQL statements.\n   */\n  async removeIndexSQLs(indexData) {\n    const removeArgs = Object.assign({driver: this}, indexData)\n    const removeIndex = new RemoveIndex(removeArgs)\n\n    return await removeIndex.toSQLs()\n  }\n\n  /**\n   * Runs create table sql.\n   * @param {import(\"../../table-data/index.js\").default} tableData - Table data.\n   * @returns {Promise<string[]>} - Resolves with SQL statements.\n   */\n  async createTableSql(tableData) {\n    const createArgs = {tableData, driver: this}\n    const createTable = new CreateTable(createArgs)\n\n    return createTable.toSql()\n  }\n\n  /**\n   * Runs current database.\n   * @returns {Promise<string>} - Resolves with the current database.\n   */\n  async currentDatabase() {\n    const rows = await this.query(\"SELECT DATABASE() AS db_name\")\n\n    return digg(rows, 0, \"db_name\")\n  }\n\n  /**\n   * Runs disable foreign keys.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async disableForeignKeys() {\n    await this.query(\"SET FOREIGN_KEY_CHECKS = 0\")\n  }\n\n  /**\n   * Runs enable foreign keys.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async enableForeignKeys() {\n    await this.query(\"SET FOREIGN_KEY_CHECKS = 1\")\n  }\n\n  /**\n   * Runs drop table sqls.\n   * @param {string} tableName - Table name.\n   * @param {import(\"../base.js\").DropTableSqlArgsType} [args] - Options object.\n   * @returns {Promise<string[]>} - Resolves with SQL statements.\n   */\n  async dropTableSQLs(tableName, args = {}) {\n    const dropArgs = Object.assign({tableName, driver: this}, args)\n    const dropTable = new DropTable(dropArgs)\n\n    return await dropTable.toSQLs()\n  }\n\n  /**\n   * Runs get type.\n   * @returns {string} - The type.\n   */\n  getType() { return \"mysql\" }\n\n  /**\n   * Runs retryable database error.\n   * @param {Error} error - Error instance.\n   * @returns {import(\"../base.js\").RetryableDatabaseErrorResult} - Retry info.\n   */\n  retryableDatabaseError(error) {\n    /** @type {Error | undefined} */\n    let currentError = error\n    let shouldReconnect = false\n\n    while (currentError) {\n      const errorCode = \"code\" in currentError && typeof currentError.code == \"string\" ? currentError.code : undefined\n      const message = currentError.message || \"\"\n\n      if (errorCode == \"ER_CHECKREAD\" || message.includes(\"Record has changed since last read\")) {\n        return {retry: true, reconnect: false, waitMs: 50}\n      }\n\n      // A deadlock or lock-wait-timeout aborts the whole transaction; it must be retried at the\n      // transaction level (re-running the callback), not the query level, so flag it as such and\n      // keep `retry` false so an in-transaction query does not retry against the dead transaction.\n      if (\n        errorCode == \"ER_LOCK_DEADLOCK\" ||\n        errorCode == \"ER_LOCK_WAIT_TIMEOUT\" ||\n        message.includes(\"ER_LOCK_DEADLOCK\") ||\n        message.includes(\"Deadlock found\") ||\n        message.includes(\"Lock wait timeout exceeded\")\n      ) {\n        return {retry: false, reconnect: false, deadlock: true, waitMs: 50}\n      }\n\n      shouldReconnect ||= (\n        errorCode == \"ECONNREFUSED\" ||\n        message.includes(\"ECONNREFUSED\") ||\n        message.includes(\"connect ECONNREFUSED\") ||\n        message.includes(\"PROTOCOL_CONNECTION_LOST\") ||\n        message.includes(\"Connection lost\")\n      )\n\n      currentError = currentError.cause instanceof Error ? currentError.cause : undefined\n    }\n\n    return {\n      retry: shouldReconnect,\n      reconnect: shouldReconnect,\n      waitMs: 50\n    }\n  }\n\n  /**\n   * Runs query actual.\n   * @param {string} sql - SQL string.\n   * @returns {Promise<import(\"../base.js\").QueryResultType>} - Resolves with the query actual.\n   */\n  async _queryActual(sql) {\n    if (!this.pool) await this.connect()\n    if (!this.pool) throw new Error(\"MySQL pool failed to initialize\")\n\n    try {\n      return await query(this.pool, sql)\n    } catch (error) {\n      // Re-throw to un-corrupt stacktrace\n      if (error instanceof Error) {\n        throw new Error(`Query failed: ${error.message}`, {cause: error})\n      } else {\n        throw new Error(`Query failed: ${error}`, {cause: error})\n      }\n    }\n  }\n\n  /**\n   * Streams the rows of `sql` from a dedicated pooled connection using the MySQL cursor, so a\n   * large result set is read incrementally instead of being buffered. Overrides the base\n   * buffered fallback with true server-side streaming.\n   * @param {string} sql - SQL string to stream.\n   * @yields {Record<string, unknown>} - The result rows, one at a time.\n   */\n  async *queryStream(sql) {\n    if (!this.pool) await this.connect()\n    if (!this.pool) throw new Error(\"MySQL pool failed to initialize\")\n\n    yield* streamQuery(this.pool, sql)\n  }\n\n  /**\n   * Executes a mutation with affected-row metadata.\n   * @param {string} sql - Mutation SQL.\n   * @returns {Promise<number>} - Affected row count.\n   */\n  async _affectedRowsActual(sql) {\n    if (!this.pool) await this.connect()\n    if (!this.pool) throw new Error(\"MySQL pool failed to initialize\")\n    const pool = this.pool\n\n    return await new Promise((resolve, reject) => {\n      pool.query(sql, (error, result) => {\n        if (error) reject(error)\n        else resolve(\"affectedRows\" in result ? result.affectedRows : 0)\n      })\n    })\n  }\n\n  /**\n   * Runs query to sql.\n   * @param {import(\"../../query/index.js\").default} query - Query instance.\n   * @returns {string} - SQL string.\n   */\n  queryToSql(query) { return new QueryParser({query}).toSql() }\n\n  /**\n   * Runs should set auto increment when primary key.\n   * @returns {boolean} - Whether set auto increment when primary key.\n   */\n  shouldSetAutoIncrementWhenPrimaryKey() { return true }\n  supportsDefaultPrimaryKeyUUID() { return false }\n  supportsCrossDatabaseReferences() { return true }\n\n  /**\n   * Runs escape.\n   * @param {?} value - Value to use.\n   * @returns {?} - The escape.\n   */\n  escape(value) {\n    const escapedValueWithQuotes = this.pool\n      ? this.pool.escape(this._convertValue(value))\n      : mysql.escape(this._convertValue(value))\n\n    return escapedValueWithQuotes.slice(1, escapedValueWithQuotes.length - 1)\n  }\n\n  /**\n   * Runs quote.\n   * @param {string} value - Value to use.\n   * @returns {string} - The quote.\n   */\n  quote(value) {\n    if (this.pool) {\n      return this.pool.escape(this._convertValue(value))\n    }\n\n    return mysql.escape(this._convertValue(value))\n  }\n\n  /**\n   * Runs delete sql.\n   * @param {import(\"../base.js\").DeleteSqlArgsType} args - Options object.\n   * @returns {string} - SQL string.\n   */\n  deleteSql({tableName, conditions}) {\n    const deleteInstruction = new Delete({conditions, driver: this, tableName})\n\n    return deleteInstruction.toSql()\n  }\n\n  /**\n   * Runs insert sql.\n   * @abstract\n   * @param {import(\"../base.js\").InsertSqlArgsType} args - Options object.\n   * @returns {string} - SQL string.\n   */\n  insertSql(args) {\n    const insertArgs = Object.assign({driver: this}, args)\n    const insert = new Insert(insertArgs)\n\n    return insert.toSql()\n  }\n\n  /**\n   * Runs get tables.\n   * @returns {Promise<Array<import(\"../base-table.js\").default>>} - Resolves with the tables.\n   */\n  async getTables() {\n    return await this._cachedSchemaMetadata(\"tables\", async () => {\n      const result = await this.query(\"SHOW FULL TABLES\")\n      const tables = []\n\n      for (const row of result) {\n        const table = new Table(this, /** @type {Record<string, string>} */ (row))\n\n        tables.push(table)\n      }\n\n      return tables\n    })\n  }\n\n  /**\n   * Runs structure sql.\n   * @returns {Promise<string | null>} - Resolves with SQL string.\n   */\n  async structureSql() {\n    return await this._cachedSchemaMetadata(\"structureSql\", async () => await new StructureSql({driver: this}).toSql())\n  }\n\n  /**\n   * Runs last insert id.\n   * @returns {Promise<number>} - Resolves with the last insert id.\n   */\n  async lastInsertID() {\n    const result = await this.query(\"SELECT LAST_INSERT_ID() AS last_insert_id\")\n\n    return digg(result, 0, \"last_insert_id\")\n  }\n\n  /**\n   * Runs options.\n   * @returns {Options} - The options options.\n   */\n  options() {\n    if (!this._options) this._options = new Options({driver: this})\n\n    return this._options\n  }\n\n  /**\n   * Runs start transaction action.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async _startTransactionAction() {\n    await this.query(\"START TRANSACTION\")\n  }\n\n  /**\n   * Runs update sql.\n   * @param {import(\"../base.js\").UpdateSqlArgsType} args - Options object.\n   * @returns {string} - SQL string.\n   */\n  updateSql({conditions, data, tableName}) {\n    const update = new Update({conditions, data, driver: this, tableName})\n\n    return update.toSql()\n  }\n\n  /**\n   * Runs upsert sql.\n   * @param {import(\"../base.js\").UpsertSqlArgsType} args - Options object.\n   * @returns {string} - SQL string.\n   */\n  upsertSql(args) {\n    const upsert = new Upsert({...args, driver: this})\n\n    return upsert.toSql()\n  }\n\n  /**\n   * Blocks until a MySQL/MariaDB user-level lock is acquired on this\n   * connection. Implemented via `GET_LOCK(name, timeout)`, where the\n   * timeout is in seconds.\n   *\n   * MySQL historically documented a negative timeout as \"infinite\",\n   * but MariaDB 10+ silently rejects negative timeouts and returns\n   * `NULL` from `GET_LOCK`. To make the helper portable across MySQL\n   * and MariaDB the \"indefinite\" case is encoded as a large positive\n   * timeout (one year), which is comfortably longer than any\n   * realistic critical section and works on every supported version.\n   * @param {string} name - Lock name.\n   * @param {{timeoutMs?: number | null}} [args] - Optional timeout in milliseconds; `null`, `undefined`, or negative blocks for `MYSQL_INDEFINITE_LOCK_TIMEOUT_SECONDS`.\n   * @returns {Promise<boolean>} - True if acquired, false if the timeout elapsed.\n   */\n  async _acquireAdvisoryLock(name, {timeoutMs} = {}) {\n    const timeoutSeconds = typeof timeoutMs === \"number\" && timeoutMs >= 0\n      ? Math.ceil(timeoutMs / 1000)\n      : MYSQL_INDEFINITE_LOCK_TIMEOUT_SECONDS\n    const rows = await this.query(`SELECT GET_LOCK(${this.quote(name)}, ${timeoutSeconds}) AS velocious_advisory_lock_result`)\n    const result = rows?.[0]?.velocious_advisory_lock_result\n\n    if (result === null || result === undefined) {\n      throw new Error(`GET_LOCK returned NULL for advisory lock ${JSON.stringify(name)} (typically an out-of-memory or thread-killed condition)`)\n    }\n\n    return Number(result) === 1\n  }\n\n  /**\n   * Runs try acquire advisory lock.\n   * @param {string} name - Lock name.\n   * @returns {Promise<boolean>} - True if the lock was acquired, false if it was already held.\n   */\n  async _tryAcquireAdvisoryLock(name) {\n    const rows = await this.query(`SELECT GET_LOCK(${this.quote(name)}, 0) AS velocious_advisory_lock_result`)\n    const result = rows?.[0]?.velocious_advisory_lock_result\n\n    if (result === null || result === undefined) {\n      throw new Error(`GET_LOCK returned NULL for advisory lock ${JSON.stringify(name)} (typically an out-of-memory or thread-killed condition)`)\n    }\n\n    return Number(result) === 1\n  }\n\n  /**\n   * Runs release advisory lock.\n   * @param {string} name - Lock name.\n   * @returns {Promise<boolean>} - True if the lock was held by this session and has now been released.\n   */\n  async _releaseAdvisoryLock(name) {\n    const rows = await this.query(`SELECT RELEASE_LOCK(${this.quote(name)}) AS velocious_advisory_lock_result`, {retry: false})\n    const result = rows?.[0]?.velocious_advisory_lock_result\n\n    return Number(result) === 1\n  }\n\n  /**\n   * Runs is advisory lock held.\n   * @param {string} name - Lock name.\n   * @returns {Promise<boolean>} - True if any session currently holds the lock.\n   */\n  async isAdvisoryLockHeld(name) {\n    const rows = await this.query(`SELECT IS_USED_LOCK(${this.quote(name)}) AS velocious_advisory_lock_holder`)\n    const holder = rows?.[0]?.velocious_advisory_lock_holder\n\n    return holder !== null && holder !== undefined\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../src/database/drivers/mysql/index.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport AlterTable from \"./sql/alter-table.js\"\nimport Base from \"../base.js\"\nimport CreateDatabase from \"./sql/create-database.js\"\nimport CreateIndex from \"./sql/create-index.js\"\nimport CreateTable from \"./sql/create-table.js\"\nimport Delete from \"./sql/delete.js\"\nimport {digg} from \"diggerize\"\nimport DropDatabase from \"./sql/drop-database.js\"\nimport DropTable from \"./sql/drop-table.js\"\nimport Insert from \"./sql/insert.js\"\nimport Options from \"./options.js\"\nimport mysql from \"mysql\"\nimport query from \"./query.js\"\nimport QueryParser from \"./query-parser.js\"\nimport streamQuery from \"./query-stream.js\"\nimport RemoveIndex from \"./sql/remove-index.js\"\nimport Table from \"./table.js\"\nimport StructureSql from \"./structure-sql.js\"\nimport Upsert from \"./sql/upsert.js\"\nimport Update from \"./sql/update.js\"\n\n/**\n * Sentinel timeout (in seconds) used as the \"block forever\" value when a\n * caller asks for an indefinite advisory lock acquire. MySQL historically\n * accepted negative timeouts as \"infinite\", but MariaDB 10+ silently\n * returns NULL from `GET_LOCK` when the timeout is negative, so the\n * driver clamps to a comfortably large positive value (1 year ≫ any\n * realistic critical section) instead.\n */\nconst MYSQL_INDEFINITE_LOCK_TIMEOUT_SECONDS = 60 * 60 * 24 * 365\n\nexport default class VelociousDatabaseDriversMysql extends Base{\n  /** @type {import(\"mysql\").Pool | undefined} */\n  pool = undefined\n\n  /** @type {string | null} */\n  _desiredSessionTimeZone = \"+00:00\"\n\n  /** @type {string | null} */\n  _currentSessionTimeZone = null\n\n  /**\n   * Runs connect.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async connect() {\n    this.resetCurrentSessionTimeZone()\n    this.pool = mysql.createPool(Object.assign({connectionLimit: 1}, this.connectArgs()))\n    this.pool.on(\"error\", this.onPoolError)\n  }\n\n  /**\n   * On pool error.\n   * @param {Error} error - Error from the connection attempt.\n   */\n  onPoolError = (error) => {\n    console.error(\"Velocious / MySQL driver / Pool error\", error)\n  }\n\n  /**\n   * Runs close.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async _close() {\n    await this.pool?.end()\n    this.pool = undefined\n    this.resetCurrentSessionTimeZone()\n  }\n\n  /**\n   * Runs set connection checkout name.\n   * @param {string | undefined} name - Human-readable name for this active checkout.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async setConnectionCheckoutName(name) {\n    const previousName = this._connectionCheckoutName\n\n    await super.setConnectionCheckoutName(name)\n\n    if (name === undefined) {\n      if (previousName !== undefined) {\n        await this.query(\"SET @velocious_connection_checkout_name = NULL\", {logName: \"Clear Connection Checkout Name\", processListComment: false, sessionTimeZone: false})\n      }\n\n      return\n    }\n\n    await this.query(`SET @velocious_connection_checkout_name = ${this.quote(name)}`, {logName: \"Set Connection Checkout Name\", processListComment: false, sessionTimeZone: false})\n  }\n\n  /**\n   * Runs clear connection checkout name.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async clearConnectionCheckoutName() {\n    if (this._connectionCheckoutName !== undefined) {\n      await this.query(\"SET @velocious_connection_checkout_name = NULL\", {logName: \"Clear Connection Checkout Name\", processListComment: false, sessionTimeZone: false})\n    }\n\n    await super.clearConnectionCheckoutName()\n  }\n\n  /**\n   * Hook before every query.\n   * @param {string} _sql - SQL string.\n   * @param {import(\"../base.js\").QueryOptions} options - Query options.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async beforeQuery(_sql, options) {\n    if (options.sessionTimeZone !== false) await this.ensureSessionTimeZone()\n  }\n\n  /**\n   * Gets the desired database session time zone for this connection context.\n   * @returns {string | null} - Desired session time zone.\n   */\n  getDesiredSessionTimeZone() {\n    return this._desiredSessionTimeZone\n  }\n\n  /**\n   * Sets the desired database session time zone without querying MySQL immediately.\n   * @param {string | null} timeZone - Desired session time zone.\n   */\n  setDesiredSessionTimeZone(timeZone) {\n    this._desiredSessionTimeZone = timeZone\n  }\n\n  /**\n   * Gets the database session time zone last confirmed through SET time_zone.\n   * @returns {string | null} - Current known session time zone.\n   */\n  getCurrentSessionTimeZone() {\n    return this._currentSessionTimeZone\n  }\n\n  /**\n   * Clears the current known database session time zone when the physical connection changes.\n   */\n  resetCurrentSessionTimeZone() {\n    this._currentSessionTimeZone = null\n  }\n\n  /**\n   * Ensures MySQL has the desired session time zone before user SQL runs.\n   * @returns {Promise<boolean>} - True when SET time_zone was executed.\n   */\n  async ensureSessionTimeZone() {\n    const desiredSessionTimeZone = this.getDesiredSessionTimeZone()\n\n    if (desiredSessionTimeZone === null || this.getCurrentSessionTimeZone() === desiredSessionTimeZone) return false\n\n    await this.setSessionTimeZone(desiredSessionTimeZone)\n\n    return true\n  }\n\n  /**\n   * Sets the database session time zone if it changed from the last confirmed value.\n   * @param {string} timeZone - Session time zone value accepted by MySQL.\n   * @returns {Promise<boolean>} - True when SET time_zone was executed.\n   */\n  async setSessionTimeZone(timeZone) {\n    if (this.getCurrentSessionTimeZone() === timeZone) return false\n\n    await this._queryActual(`SET time_zone = ${this.quote(timeZone)}`)\n    this._currentSessionTimeZone = timeZone\n\n    return true\n  }\n\n  /**\n   * Runs connect args.\n   * @returns {Record<string, ?>} - The connect args.\n   */\n  connectArgs() {\n    const args = this.getArgs()\n    const forward = [\"database\", \"host\", \"password\"]\n\n    /**\n     * Connect args.\n     * @type {Record<string, ?>} */\n    const connectArgs = {charset: \"utf8mb4\", timezone: \"Z\"}\n\n    for (const forwardValue of forward) {\n      if (forwardValue in args) connectArgs[forwardValue] = digg(args, forwardValue)\n    }\n\n    if (\"username\" in args) connectArgs[\"user\"] = args[\"username\"]\n    if (\"charset\" in args) connectArgs[\"charset\"] = args[\"charset\"]\n    // Opt-in only. Lets a whole structure SQL dump run in one round-trip via\n    // {@link execStructureScript}; off by default so ordinary queries keep rejecting\n    // stacked statements.\n    if (\"multipleStatements\" in args) connectArgs[\"multipleStatements\"] = Boolean(digg(args, \"multipleStatements\"))\n\n    return connectArgs\n  }\n\n  /**\n   * Runs alter table sqls.\n   * @param {import(\"../../table-data/index.js\").default} tableData - Table data.\n   * @returns {Promise<string[]>} - Resolves with SQL statements.\n   */\n  async alterTableSQLs(tableData) {\n    const alterArgs = {tableData, driver: this}\n    const alterTable = new AlterTable(alterArgs)\n\n    return await alterTable.toSQLs()\n  }\n\n  /**\n   * Runs create database sql.\n   * @param {string} databaseName - Database name.\n   * @param {object} [args] - Options object.\n   * @param {boolean} [args.ifNotExists] - Whether if not exists.\n   * @returns {string[]} - SQL statements.\n   */\n  createDatabaseSql(databaseName, args) {\n    const createArgs = Object.assign({databaseName, driver: this}, args)\n    const createDatabase = new CreateDatabase(createArgs)\n\n    return createDatabase.toSql()\n  }\n\n  /**\n   * Runs drop database sql.\n   * @param {string} databaseName - Database name.\n   * @param {object} [args] - Options object.\n   * @param {boolean} [args.ifExists] - Whether if exists.\n   * @returns {string[]} - SQL statements.\n   */\n  dropDatabaseSql(databaseName, args) {\n    const dropArgs = Object.assign({databaseName, driver: this}, args)\n    const dropDatabase = new DropDatabase(dropArgs)\n\n    return dropDatabase.toSql()\n  }\n\n  /**\n   * Runs create index sqls.\n   * @param {import(\"../base.js\").CreateIndexSqlArgs} indexData - Index data.\n   * @returns {Promise<string[]>} - Resolves with SQL statements.\n   */\n  async createIndexSQLs(indexData) {\n    const createArgs = Object.assign({driver: this}, indexData)\n    const createIndex = new CreateIndex(createArgs)\n\n    return await createIndex.toSQLs()\n  }\n\n  /**\n   * Runs remove index sqls.\n   * @param {import(\"../base.js\").RemoveIndexSqlArgs} indexData - Index data.\n   * @returns {Promise<string[]>} - Resolves with SQL statements.\n   */\n  async removeIndexSQLs(indexData) {\n    const removeArgs = Object.assign({driver: this}, indexData)\n    const removeIndex = new RemoveIndex(removeArgs)\n\n    return await removeIndex.toSQLs()\n  }\n\n  /**\n   * Runs create table sql.\n   * @param {import(\"../../table-data/index.js\").default} tableData - Table data.\n   * @returns {Promise<string[]>} - Resolves with SQL statements.\n   */\n  async createTableSql(tableData) {\n    const createArgs = {tableData, driver: this}\n    const createTable = new CreateTable(createArgs)\n\n    return createTable.toSql()\n  }\n\n  /**\n   * Runs current database.\n   * @returns {Promise<string>} - Resolves with the current database.\n   */\n  async currentDatabase() {\n    const rows = await this.query(\"SELECT DATABASE() AS db_name\")\n\n    return digg(rows, 0, \"db_name\")\n  }\n\n  /**\n   * Runs disable foreign keys.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async disableForeignKeys() {\n    await this.query(\"SET FOREIGN_KEY_CHECKS = 0\")\n  }\n\n  /**\n   * Runs enable foreign keys.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async enableForeignKeys() {\n    await this.query(\"SET FOREIGN_KEY_CHECKS = 1\")\n  }\n\n  /**\n   * Runs drop table sqls.\n   * @param {string} tableName - Table name.\n   * @param {import(\"../base.js\").DropTableSqlArgsType} [args] - Options object.\n   * @returns {Promise<string[]>} - Resolves with SQL statements.\n   */\n  async dropTableSQLs(tableName, args = {}) {\n    const dropArgs = Object.assign({tableName, driver: this}, args)\n    const dropTable = new DropTable(dropArgs)\n\n    return await dropTable.toSQLs()\n  }\n\n  /**\n   * Runs get type.\n   * @returns {string} - The type.\n   */\n  getType() { return \"mysql\" }\n\n  /**\n   * Runs retryable database error.\n   * @param {Error} error - Error instance.\n   * @returns {import(\"../base.js\").RetryableDatabaseErrorResult} - Retry info.\n   */\n  retryableDatabaseError(error) {\n    /** @type {Error | undefined} */\n    let currentError = error\n    let shouldReconnect = false\n\n    while (currentError) {\n      const errorCode = \"code\" in currentError && typeof currentError.code == \"string\" ? currentError.code : undefined\n      const message = currentError.message || \"\"\n\n      if (errorCode == \"ER_CHECKREAD\" || message.includes(\"Record has changed since last read\")) {\n        return {retry: true, reconnect: false, waitMs: 50}\n      }\n\n      // A deadlock or lock-wait-timeout aborts the whole transaction; it must be retried at the\n      // transaction level (re-running the callback), not the query level, so flag it as such and\n      // keep `retry` false so an in-transaction query does not retry against the dead transaction.\n      if (\n        errorCode == \"ER_LOCK_DEADLOCK\" ||\n        errorCode == \"ER_LOCK_WAIT_TIMEOUT\" ||\n        message.includes(\"ER_LOCK_DEADLOCK\") ||\n        message.includes(\"Deadlock found\") ||\n        message.includes(\"Lock wait timeout exceeded\")\n      ) {\n        return {retry: false, reconnect: false, deadlock: true, waitMs: 50}\n      }\n\n      shouldReconnect ||= (\n        errorCode == \"ECONNREFUSED\" ||\n        message.includes(\"ECONNREFUSED\") ||\n        message.includes(\"connect ECONNREFUSED\") ||\n        message.includes(\"PROTOCOL_CONNECTION_LOST\") ||\n        message.includes(\"Connection lost\")\n      )\n\n      currentError = currentError.cause instanceof Error ? currentError.cause : undefined\n    }\n\n    return {\n      retry: shouldReconnect,\n      reconnect: shouldReconnect,\n      waitMs: 50\n    }\n  }\n\n  /**\n   * Runs query actual.\n   * @param {string} sql - SQL string.\n   * @returns {Promise<import(\"../base.js\").QueryResultType>} - Resolves with the query actual.\n   */\n  async _queryActual(sql) {\n    if (!this.pool) await this.connect()\n    if (!this.pool) throw new Error(\"MySQL pool failed to initialize\")\n\n    try {\n      return await query(this.pool, sql)\n    } catch (error) {\n      // Re-throw to un-corrupt stacktrace\n      if (error instanceof Error) {\n        throw new Error(`Query failed: ${error.message}`, {cause: error})\n      } else {\n        throw new Error(`Query failed: ${error}`, {cause: error})\n      }\n    }\n  }\n\n  /**\n   * Streams the rows of `sql` from a dedicated pooled connection using the MySQL cursor, so a\n   * large result set is read incrementally instead of being buffered. Overrides the base\n   * buffered fallback with true server-side streaming.\n   * @param {string} sql - SQL string to stream.\n   * @yields {Record<string, unknown>} - The result rows, one at a time.\n   */\n  async *queryStream(sql) {\n    if (!this.pool) await this.connect()\n    if (!this.pool) throw new Error(\"MySQL pool failed to initialize\")\n\n    yield* streamQuery(this.pool, sql)\n  }\n\n  /**\n   * Executes a mutation with affected-row metadata.\n   * @param {string} sql - Mutation SQL.\n   * @returns {Promise<number>} - Affected row count.\n   */\n  async _affectedRowsActual(sql) {\n    if (!this.pool) await this.connect()\n    if (!this.pool) throw new Error(\"MySQL pool failed to initialize\")\n    const pool = this.pool\n\n    return await new Promise((resolve, reject) => {\n      pool.query(sql, (error, result) => {\n        if (error) reject(error)\n        else resolve(\"affectedRows\" in result ? result.affectedRows : 0)\n      })\n    })\n  }\n\n  /**\n   * Executes a full multi-statement structure SQL script in one round-trip when the\n   * connection was configured with `multipleStatements: true`. Runs on the pooled\n   * connection so the caller's `SET FOREIGN_KEY_CHECKS = 0` applies. Returns false so\n   * the caller runs statements individually when multi-statement queries are off.\n   * @param {string} structureSql - Full multi-statement structure SQL.\n   * @returns {Promise<boolean>} - Whether the script was executed as one batch.\n   */\n  async execStructureScript(structureSql) {\n    if (!this.getArgs().multipleStatements) return false\n\n    // The batched pool call below bypasses Base#query, so re-run the same read-only\n    // write guard the per-statement path applies before executing the dump.\n    this._assertWritableQuery(structureSql)\n\n    if (!this.pool) await this.connect()\n    if (!this.pool) throw new Error(\"MySQL pool failed to initialize\")\n\n    const pool = this.pool\n\n    await new Promise((resolve, reject) => {\n      pool.query(structureSql, (error) => {\n        if (error) reject(error)\n        else resolve(undefined)\n      })\n    })\n\n    return true\n  }\n\n  /**\n   * Runs query to sql.\n   * @param {import(\"../../query/index.js\").default} query - Query instance.\n   * @returns {string} - SQL string.\n   */\n  queryToSql(query) { return new QueryParser({query}).toSql() }\n\n  /**\n   * Runs should set auto increment when primary key.\n   * @returns {boolean} - Whether set auto increment when primary key.\n   */\n  shouldSetAutoIncrementWhenPrimaryKey() { return true }\n  supportsDefaultPrimaryKeyUUID() { return false }\n  supportsCrossDatabaseReferences() { return true }\n\n  /**\n   * Runs escape.\n   * @param {?} value - Value to use.\n   * @returns {?} - The escape.\n   */\n  escape(value) {\n    const escapedValueWithQuotes = this.pool\n      ? this.pool.escape(this._convertValue(value))\n      : mysql.escape(this._convertValue(value))\n\n    return escapedValueWithQuotes.slice(1, escapedValueWithQuotes.length - 1)\n  }\n\n  /**\n   * Runs quote.\n   * @param {string} value - Value to use.\n   * @returns {string} - The quote.\n   */\n  quote(value) {\n    if (this.pool) {\n      return this.pool.escape(this._convertValue(value))\n    }\n\n    return mysql.escape(this._convertValue(value))\n  }\n\n  /**\n   * Runs delete sql.\n   * @param {import(\"../base.js\").DeleteSqlArgsType} args - Options object.\n   * @returns {string} - SQL string.\n   */\n  deleteSql({tableName, conditions}) {\n    const deleteInstruction = new Delete({conditions, driver: this, tableName})\n\n    return deleteInstruction.toSql()\n  }\n\n  /**\n   * Runs insert sql.\n   * @abstract\n   * @param {import(\"../base.js\").InsertSqlArgsType} args - Options object.\n   * @returns {string} - SQL string.\n   */\n  insertSql(args) {\n    const insertArgs = Object.assign({driver: this}, args)\n    const insert = new Insert(insertArgs)\n\n    return insert.toSql()\n  }\n\n  /**\n   * Runs get tables.\n   * @returns {Promise<Array<import(\"../base-table.js\").default>>} - Resolves with the tables.\n   */\n  async getTables() {\n    return await this._cachedSchemaMetadata(\"tables\", async () => {\n      const result = await this.query(\"SHOW FULL TABLES\")\n      const tables = []\n\n      for (const row of result) {\n        const table = new Table(this, /** @type {Record<string, string>} */ (row))\n\n        tables.push(table)\n      }\n\n      return tables\n    })\n  }\n\n  /**\n   * Runs structure sql.\n   * @returns {Promise<string | null>} - Resolves with SQL string.\n   */\n  async structureSql() {\n    return await this._cachedSchemaMetadata(\"structureSql\", async () => await new StructureSql({driver: this}).toSql())\n  }\n\n  /**\n   * Runs last insert id.\n   * @returns {Promise<number>} - Resolves with the last insert id.\n   */\n  async lastInsertID() {\n    const result = await this.query(\"SELECT LAST_INSERT_ID() AS last_insert_id\")\n\n    return digg(result, 0, \"last_insert_id\")\n  }\n\n  /**\n   * Runs options.\n   * @returns {Options} - The options options.\n   */\n  options() {\n    if (!this._options) this._options = new Options({driver: this})\n\n    return this._options\n  }\n\n  /**\n   * Runs start transaction action.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async _startTransactionAction() {\n    await this.query(\"START TRANSACTION\")\n  }\n\n  /**\n   * Runs update sql.\n   * @param {import(\"../base.js\").UpdateSqlArgsType} args - Options object.\n   * @returns {string} - SQL string.\n   */\n  updateSql({conditions, data, tableName}) {\n    const update = new Update({conditions, data, driver: this, tableName})\n\n    return update.toSql()\n  }\n\n  /**\n   * Runs upsert sql.\n   * @param {import(\"../base.js\").UpsertSqlArgsType} args - Options object.\n   * @returns {string} - SQL string.\n   */\n  upsertSql(args) {\n    const upsert = new Upsert({...args, driver: this})\n\n    return upsert.toSql()\n  }\n\n  /**\n   * Blocks until a MySQL/MariaDB user-level lock is acquired on this\n   * connection. Implemented via `GET_LOCK(name, timeout)`, where the\n   * timeout is in seconds.\n   *\n   * MySQL historically documented a negative timeout as \"infinite\",\n   * but MariaDB 10+ silently rejects negative timeouts and returns\n   * `NULL` from `GET_LOCK`. To make the helper portable across MySQL\n   * and MariaDB the \"indefinite\" case is encoded as a large positive\n   * timeout (one year), which is comfortably longer than any\n   * realistic critical section and works on every supported version.\n   * @param {string} name - Lock name.\n   * @param {{timeoutMs?: number | null}} [args] - Optional timeout in milliseconds; `null`, `undefined`, or negative blocks for `MYSQL_INDEFINITE_LOCK_TIMEOUT_SECONDS`.\n   * @returns {Promise<boolean>} - True if acquired, false if the timeout elapsed.\n   */\n  async _acquireAdvisoryLock(name, {timeoutMs} = {}) {\n    const timeoutSeconds = typeof timeoutMs === \"number\" && timeoutMs >= 0\n      ? Math.ceil(timeoutMs / 1000)\n      : MYSQL_INDEFINITE_LOCK_TIMEOUT_SECONDS\n    const rows = await this.query(`SELECT GET_LOCK(${this.quote(name)}, ${timeoutSeconds}) AS velocious_advisory_lock_result`)\n    const result = rows?.[0]?.velocious_advisory_lock_result\n\n    if (result === null || result === undefined) {\n      throw new Error(`GET_LOCK returned NULL for advisory lock ${JSON.stringify(name)} (typically an out-of-memory or thread-killed condition)`)\n    }\n\n    return Number(result) === 1\n  }\n\n  /**\n   * Runs try acquire advisory lock.\n   * @param {string} name - Lock name.\n   * @returns {Promise<boolean>} - True if the lock was acquired, false if it was already held.\n   */\n  async _tryAcquireAdvisoryLock(name) {\n    const rows = await this.query(`SELECT GET_LOCK(${this.quote(name)}, 0) AS velocious_advisory_lock_result`)\n    const result = rows?.[0]?.velocious_advisory_lock_result\n\n    if (result === null || result === undefined) {\n      throw new Error(`GET_LOCK returned NULL for advisory lock ${JSON.stringify(name)} (typically an out-of-memory or thread-killed condition)`)\n    }\n\n    return Number(result) === 1\n  }\n\n  /**\n   * Runs release advisory lock.\n   * @param {string} name - Lock name.\n   * @returns {Promise<boolean>} - True if the lock was held by this session and has now been released.\n   */\n  async _releaseAdvisoryLock(name) {\n    const rows = await this.query(`SELECT RELEASE_LOCK(${this.quote(name)}) AS velocious_advisory_lock_result`, {retry: false})\n    const result = rows?.[0]?.velocious_advisory_lock_result\n\n    return Number(result) === 1\n  }\n\n  /**\n   * Runs is advisory lock held.\n   * @param {string} name - Lock name.\n   * @returns {Promise<boolean>} - True if any session currently holds the lock.\n   */\n  async isAdvisoryLockHeld(name) {\n    const rows = await this.query(`SELECT IS_USED_LOCK(${this.quote(name)}) AS velocious_advisory_lock_holder`)\n    const holder = rows?.[0]?.velocious_advisory_lock_holder\n\n    return holder !== null && holder !== undefined\n  }\n}\n"]}

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

@@ -1 +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"}
+{"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,CAmCzB;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

@@ -26,18 +26,24 @@ export default class StructureSqlLoader {
         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);
+            // Prefer a single round-trip for the whole dump: a driver-native multi-statement
+            // batch (e.g. MySQL with `multipleStatements`) first, then a native `exec`
+            // connection (e.g. SQLite), and finally per-statement execution. Running the
+            // whole dump at once is far faster than issuing every CREATE separately.
+            if (!await db.execStructureScript(structureSql)) {
+                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
+            // The batch / native `exec` paths mutate 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
@@ -60,4 +66,4 @@ export default class StructureSqlLoader {
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RydWN0dXJlLXNxbC1sb2FkZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvZGF0YWJhc2Uvc3RydWN0dXJlLXNxbC1sb2FkZXIuanMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsWUFBWTtBQUVaLE9BQU8sa0JBQWtCLE1BQU0sa0NBQWtDLENBQUE7QUFFakU7Ozs7Ozs7Ozs7R0FVRztBQUNILE1BQU0sQ0FBQyxPQUFPLE9BQU8sa0JBQWtCO0lBQ3JDOzs7Ozs7T0FNRztJQUNILEtBQUssQ0FBQyxJQUFJLENBQUMsRUFBQyxFQUFFLEVBQUUsWUFBWSxFQUFDO1FBQzNCLE1BQU0sVUFBVSxHQUFHLGtCQUFrQixDQUFDLFlBQVksQ0FBQyxDQUFBO1FBRW5ELElBQUksVUFBVSxDQUFDLE1BQU0sSUFBSSxDQUFDO1lBQUUsT0FBTTtRQUVsQyxNQUFNLG9CQUFvQixHQUFHLElBQUksQ0FBQyxvQkFBb0IsQ0FBQyxFQUFFLENBQUMsQ0FBQTtRQUUxRCxNQUFNLEVBQUUsQ0FBQyxrQkFBa0IsRUFBRSxDQUFBO1FBRTdCLElBQUksQ0FBQztZQUNILElBQUksb0JBQW9CLEVBQUUsQ0FBQztnQkFDekIsTUFBTSxvQkFBb0IsQ0FBQyxJQUFJLENBQUMsWUFBWSxDQUFDLENBQUE7WUFDL0MsQ0FBQztpQkFBTSxDQUFDO2dCQUNOLEtBQUssTUFBTSxTQUFTLElBQUksVUFBVSxFQUFFLENBQUM7b0JBQ25DLE1BQU0sRUFBRSxDQUFDLEtBQUssQ0FBQyxTQUFTLENBQUMsQ0FBQTtnQkFDM0IsQ0FBQztZQUNILENBQUM7UUFDSCxDQUFDO2dCQUFTLENBQUM7WUFDVCxNQUFNLEVBQUUsQ0FBQyxpQkFBaUIsRUFBRSxDQUFBO1lBRTVCLHlFQUF5RTtZQUN6RSwwRUFBMEU7WUFDMUUsNEVBQTRFO1lBQzVFLDhFQUE4RTtZQUM5RSw0RUFBNEU7WUFDNUUsRUFBRSxDQUFDLGdCQUFnQixFQUFFLENBQUE7UUFDdkIsQ0FBQztJQUNILENBQUM7SUFFRDs7Ozs7O09BTUc7SUFDSCxvQkFBb0IsQ0FBQyxFQUFFO1FBQ3JCLE1BQU0sZ0JBQWdCLEdBQUcscUVBQXFFLENBQUMsQ0FBQyxFQUFFLENBQUMsQ0FBQTtRQUNuRyxNQUFNLFVBQVUsR0FBRyxnQkFBZ0IsQ0FBQyxVQUFVLENBQUE7UUFFOUMsSUFBSSxVQUFVLElBQUksT0FBTyxVQUFVLElBQUksUUFBUSxJQUFJLE1BQU0sSUFBSSxVQUFVLElBQUksT0FBTyxVQUFVLENBQUMsSUFBSSxJQUFJLFVBQVUsRUFBRSxDQUFDO1lBQ2hILE9BQU8sa0RBQWtELENBQUMsQ0FBQyxVQUFVLENBQUMsQ0FBQTtRQUN4RSxDQUFDO0lBQ0gsQ0FBQztDQUNGIiwic291cmNlc0NvbnRlbnQiOlsiLy8gQHRzLWNoZWNrXG5cbmltcG9ydCBzcGxpdFNxbFN0YXRlbWVudHMgZnJvbSBcIi4uL3V0aWxzL3NwbGl0LXNxbC1zdGF0ZW1lbnRzLmpzXCJcblxuLyoqXG4gKiBMb2FkcyBhIGRhdGFiYXNlIHN0cnVjdHVyZSBTUUwgZHVtcCBpbnRvIGEgY29ubmVjdGlvbiBpbiBvbmUgcGFzcy4gRm9yZWlnbiBrZXlzIGFyZVxuICogZGlzYWJsZWQgYXJvdW5kIHRoZSBsb2FkIHNvIHRhYmxlcyBjYW4gYmUgY3JlYXRlZCBpbiBhbnkgb3JkZXIsIGFuZCB0aGUgZHJpdmVyJ3NcbiAqIG5hdGl2ZSBtdWx0aS1zdGF0ZW1lbnQgYGV4ZWNgIGlzIHVzZWQgd2hlbiBhdmFpbGFibGUgKGEgc2luZ2xlIHJvdW5kLXRyaXApIGluc3RlYWRcbiAqIG9mIGlzc3VpbmcgZXZlcnkgc3RhdGVtZW50IHNlcGFyYXRlbHkuIFRoaXMgaXMgbXVjaCBmYXN0ZXIgdGhhbiBtYXRlcmlhbGl6aW5nIGFcbiAqIHNjaGVtYSB0YWJsZSBieSB0YWJsZSAoZS5nLiBjbG9uaW5nKSwgc28gaXQgaXMgdGhlIHByZWZlcnJlZCB3YXkgdG8gcHJvdmlzaW9uIGFcbiAqIHRlbmFudC90ZXN0IGRhdGFiYXNlIGZyb20gYSBzdHJ1Y3R1cmUgZHVtcC5cbiAqXG4gKiBVc2VkIGJ5IHRoZSBgZGI6c2NoZW1hOmxvYWRgIENMSSBjb21tYW5kIGFuZCByZXVzYWJsZSBieSBhbnkgY2FsbGVyIHRoYXQgbmVlZHMgdG9cbiAqIGFwcGx5IGEgc3RydWN0dXJlIGR1bXAgdG8gYSBzcGVjaWZpYyBjb25uZWN0aW9uLlxuICovXG5leHBvcnQgZGVmYXVsdCBjbGFzcyBTdHJ1Y3R1cmVTcWxMb2FkZXIge1xuICAvKipcbiAgICogTG9hZHMgYHN0cnVjdHVyZVNxbGAgaW50byBgZGJgLlxuICAgKiBAcGFyYW0ge29iamVjdH0gYXJncyAtIE9wdGlvbnMgb2JqZWN0LlxuICAgKiBAcGFyYW0ge2ltcG9ydChcIi4vZHJpdmVycy9iYXNlLmpzXCIpLmRlZmF1bHR9IGFyZ3MuZGIgLSBUYXJnZXQgZGF0YWJhc2UgY29ubmVjdGlvbi5cbiAgICogQHBhcmFtIHtzdHJpbmd9IGFyZ3Muc3RydWN0dXJlU3FsIC0gU3RydWN0dXJlIFNRTCB0byBsb2FkLlxuICAgKiBAcmV0dXJucyB7UHJvbWlzZTx2b2lkPn0gLSBSZXNvbHZlcyB3aGVuIHRoZSBzdHJ1Y3R1cmUgaGFzIGJlZW4gbG9hZGVkLlxuICAgKi9cbiAgYXN5bmMgbG9hZCh7ZGIsIHN0cnVjdHVyZVNxbH0pIHtcbiAgICBjb25zdCBzdGF0ZW1lbnRzID0gc3BsaXRTcWxTdGF0ZW1lbnRzKHN0cnVjdHVyZVNxbClcblxuICAgIGlmIChzdGF0ZW1lbnRzLmxlbmd0aCA9PSAwKSByZXR1cm5cblxuICAgIGNvbnN0IGV4ZWN1dGFibGVDb25uZWN0aW9uID0gdGhpcy5leGVjdXRhYmxlQ29ubmVjdGlvbihkYilcblxuICAgIGF3YWl0IGRiLmRpc2FibGVGb3JlaWduS2V5cygpXG5cbiAgICB0cnkge1xuICAgICAgaWYgKGV4ZWN1dGFibGVDb25uZWN0aW9uKSB7XG4gICAgICAgIGF3YWl0IGV4ZWN1dGFibGVDb25uZWN0aW9uLmV4ZWMoc3RydWN0dXJlU3FsKVxuICAgICAgfSBlbHNlIHtcbiAgICAgICAgZm9yIChjb25zdCBzdGF0ZW1lbnQgb2Ygc3RhdGVtZW50cykge1xuICAgICAgICAgIGF3YWl0IGRiLnF1ZXJ5KHN0YXRlbWVudClcbiAgICAgICAgfVxuICAgICAgfVxuICAgIH0gZmluYWxseSB7XG4gICAgICBhd2FpdCBkYi5lbmFibGVGb3JlaWduS2V5cygpXG5cbiAgICAgIC8vIFRoZSBuYXRpdmUgYGV4ZWNgIHBhdGggbXV0YXRlcyB0aGUgc2NoZW1hIG91dHNpZGUgYEJhc2UjcXVlcnlgLCBzbyB0aGVcbiAgICAgIC8vIHVzdWFsIHBvc3QtRERMIHNjaGVtYS1jYWNoZSBpbnZhbGlkYXRpb24gbmV2ZXIgcnVucy4gQ2xlYXIgaXQgaGVyZSBzbyBhXG4gICAgICAvLyBjYWxsZXIgdGhhdCByZWFkIHNjaGVtYSBtZXRhZGF0YSBiZWZvcmUgcHJvdmlzaW9uaW5nIChlLmcuIGFuIGVtcHR5IHRhYmxlXG4gICAgICAvLyBsaXN0KSBkb2VzIG5vdCBrZWVwIHNlZWluZyB0aGUgcHJlLWxvYWQgc2NoZW1hIGFmdGVyd2FyZHMuIEhhcm1sZXNzIGZvciB0aGVcbiAgICAgIC8vIHBlci1zdGF0ZW1lbnQgcGF0aCwgd2hpY2ggYWxyZWFkeSBpbnZhbGlkYXRlcyBhcyBlYWNoIERETCBzdGF0ZW1lbnQgcnVucy5cbiAgICAgIGRiLmNsZWFyU2NoZW1hQ2FjaGUoKVxuICAgIH1cbiAgfVxuXG4gIC8qKlxuICAgKiBSZXR1cm5zIHRoZSB1bmRlcmx5aW5nIGNvbm5lY3Rpb24gd2hlbiBpdCBleHBvc2VzIGEgbmF0aXZlIG11bHRpLXN0YXRlbWVudFxuICAgKiBgZXhlY2AgKGEgc2luZ2xlIHJvdW5kLXRyaXAgZm9yIHRoZSB3aG9sZSBkdW1wKSwgb3RoZXJ3aXNlIHVuZGVmaW5lZCBzbyB0aGVcbiAgICogY2FsbGVyIGZhbGxzIGJhY2sgdG8gcGVyLXN0YXRlbWVudCBleGVjdXRpb24uXG4gICAqIEBwYXJhbSB7aW1wb3J0KFwiLi9kcml2ZXJzL2Jhc2UuanNcIikuZGVmYXVsdH0gZGIgLSBEYXRhYmFzZSBjb25uZWN0aW9uLlxuICAgKiBAcmV0dXJucyB7e2V4ZWM6IChzcWw6IHN0cmluZykgPT4gUHJvbWlzZTw/Pn0gfCB1bmRlZmluZWR9IC0gQ29ubmVjdGlvbiB3aXRoIGV4ZWMgc3VwcG9ydC5cbiAgICovXG4gIGV4ZWN1dGFibGVDb25uZWN0aW9uKGRiKSB7XG4gICAgY29uc3QgZGJXaXRoQ29ubmVjdGlvbiA9IC8qKiBAdHlwZSB7aW1wb3J0KFwiLi9kcml2ZXJzL2Jhc2UuanNcIikuZGVmYXVsdCAmIHtjb25uZWN0aW9uPzogP319ICovIChkYilcbiAgICBjb25zdCBjb25uZWN0aW9uID0gZGJXaXRoQ29ubmVjdGlvbi5jb25uZWN0aW9uXG5cbiAgICBpZiAoY29ubmVjdGlvbiAmJiB0eXBlb2YgY29ubmVjdGlvbiA9PSBcIm9iamVjdFwiICYmIFwiZXhlY1wiIGluIGNvbm5lY3Rpb24gJiYgdHlwZW9mIGNvbm5lY3Rpb24uZXhlYyA9PSBcImZ1bmN0aW9uXCIpIHtcbiAgICAgIHJldHVybiAvKiogQHR5cGUge3tleGVjOiAoc3FsOiBzdHJpbmcpID0+IFByb21pc2U8Pz59fSAqLyAoY29ubmVjdGlvbilcbiAgICB9XG4gIH1cbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,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

package/build/src/testing/test.d.ts

@@ -103,6 +103,7 @@ export const testEvents: import("eventemitter3").EventEmitter<string | symbol, a
  * Tests.
  * @type {import("./test-runner.js").TestsArgument} */
 export const tests: import("./test-runner.js").TestsArgument;
+import waitForEvent from "./wait-for-event.js";
 import Expect from "./expect.js";
-export { arrayContaining, objectContaining };
+export { arrayContaining, objectContaining, waitForEvent };
 //# sourceMappingURL=test.d.ts.map

package/build/src/testing/test.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"test.d.ts","sourceRoot":"","sources":["../../../src/testing/test.js"],"names":[],"mappings":";;;;;;;mBAqWc,SAAS,GAAG,MAAM;;;;iBAClB,MAAM,EAAE;;;;2BACR,MAAM;;;;iCACN,MAAM;;AAxKpB;;;;GAIG;AACH,mCAHW,OAAO,kBAAkB,EAAE,0BAA0B,GACnD,IAAI,CAMhB;AApBD;;;;GAIG;AACH,oCAHW,OAAO,kBAAkB,EAAE,2BAA2B,GACpD,IAAI,CAMhB;AApBD;;;;GAIG;AACH,oCAHW,OAAO,kBAAkB,EAAE,0BAA0B,GACnD,IAAI,CAMhB;AApBD;;;;GAIG;AACH,qCAHW,OAAO,kBAAkB,EAAE,2BAA2B,GACpD,IAAI,CAMhB;AA3DD;;;;;;;;GAQG;AACH,oHANG;IAAkC,aAAa;IACd,WAAW;IACtB,qBAAqB;IACrB,2BAA2B;CACjD,GAAU,IAAI,CAsBhB;AAkED;;;;;;GAMG;AACH,sCALW,MAAM,QACN,MAAM,GAAC,CAAC,MAAM,CAAC,IAAI,GAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,SACnC,SAAS,GAAC,CAAC,MAAM,CAAC,IAAI,GAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,GACpC,OAAO,CAAC,IAAI,CAAC,CA8CzB;AAED;;;;GAIG;AACH,4BAHW,OAAC,GACC,MAAM,CAIlB;;;;;AA8CD;;;;;;GAMG;AACH,iCALW,MAAM,QACN,MAAM,GAAC,CAAC,MAAM,CAAC,IAAI,GAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,SACnC,SAAS,GAAC,CAAC,MAAM,CAAC,IAAI,GAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,GACpC,IAAI,CAwBhB;AAtED;;;;;;GAMG;AACH,gCALW,MAAM,QACN,MAAM,GAAC,CAAC,MAAM,CAAC,IAAI,GAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,SACnC,SAAS,GAAC,CAAC,MAAM,CAAC,IAAI,GAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,GACpC,IAAI,CAkChB;gCA9S+C,mBAAmB;iCAAnB,mBAAmB;AA6FnE;;iCAEiC;AACjC,yBADU,mBAAmB,CAM5B;AAvED,oFAAqC;AA5BrC;;sDAEsD;AACtD,oBADU,OAAO,kBAAkB,EAAE,aAAa,CAwBjD;mBA7BkB,aAAa"}
+{"version":3,"file":"test.d.ts","sourceRoot":"","sources":["../../../src/testing/test.js"],"names":[],"mappings":";;;;;;;mBAsWc,SAAS,GAAG,MAAM;;;;iBAClB,MAAM,EAAE;;;;2BACR,MAAM;;;;iCACN,MAAM;;AAxKpB;;;;GAIG;AACH,mCAHW,OAAO,kBAAkB,EAAE,0BAA0B,GACnD,IAAI,CAMhB;AApBD;;;;GAIG;AACH,oCAHW,OAAO,kBAAkB,EAAE,2BAA2B,GACpD,IAAI,CAMhB;AApBD;;;;GAIG;AACH,oCAHW,OAAO,kBAAkB,EAAE,0BAA0B,GACnD,IAAI,CAMhB;AApBD;;;;GAIG;AACH,qCAHW,OAAO,kBAAkB,EAAE,2BAA2B,GACpD,IAAI,CAMhB;AA3DD;;;;;;;;GAQG;AACH,oHANG;IAAkC,aAAa;IACd,WAAW;IACtB,qBAAqB;IACrB,2BAA2B;CACjD,GAAU,IAAI,CAsBhB;AAkED;;;;;;GAMG;AACH,sCALW,MAAM,QACN,MAAM,GAAC,CAAC,MAAM,CAAC,IAAI,GAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,SACnC,SAAS,GAAC,CAAC,MAAM,CAAC,IAAI,GAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,GACpC,OAAO,CAAC,IAAI,CAAC,CA8CzB;AAED;;;;GAIG;AACH,4BAHW,OAAC,GACC,MAAM,CAIlB;;;;;AA8CD;;;;;;GAMG;AACH,iCALW,MAAM,QACN,MAAM,GAAC,CAAC,MAAM,CAAC,IAAI,GAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,SACnC,SAAS,GAAC,CAAC,MAAM,CAAC,IAAI,GAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,GACpC,IAAI,CAwBhB;AAtED;;;;;;GAMG;AACH,gCALW,MAAM,QACN,MAAM,GAAC,CAAC,MAAM,CAAC,IAAI,GAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,SACnC,SAAS,GAAC,CAAC,MAAM,CAAC,IAAI,GAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,GACpC,IAAI,CAkChB;gCA9S+C,mBAAmB;iCAAnB,mBAAmB;AA6FnE;;iCAEiC;AACjC,yBADU,mBAAmB,CAM5B;AAvED,oFAAqC;AA5BrC;;sDAEsD;AACtD,oBADU,OAAO,kBAAkB,EAAE,aAAa,CAwBjD;yBA7BwB,qBAAqB;mBAD3B,aAAa"}

package/build/src/testing/test.js

@@ -3,6 +3,7 @@ import path from "path";
 import { fileURLToPath } from "url";
 import EventEmitter from "../utils/event-emitter.js";
 import Expect from "./expect.js";
+import waitForEvent from "./wait-for-event.js";
 import { arrayContaining, objectContaining } from "./expect-utils.js";
 /**
  * Tests.
@@ -306,7 +307,7 @@ globalThis.it = it;
 globalThis.fit = fit;
 globalThis.testEvents = testEvents;
 globalThis.configureTests = configureTests;
-export { afterAll, afterEach, beforeAll, beforeEach, configureTests, describe, expect, fit, it, arrayContaining, objectContaining, testConfig, testEvents, tests };
+export { afterAll, afterEach, beforeAll, beforeEach, configureTests, describe, expect, fit, it, arrayContaining, objectContaining, testConfig, testEvents, tests, waitForEvent };
 /**
  * VelociousTestConfig type.
  * @typedef {object} VelociousTestConfig
@@ -315,4 +316,4 @@ export { afterAll, afterEach, beforeAll, beforeEach, configureTests, describe, e
  * @property {number} defaultTimeoutSeconds - Default timeout in seconds.
  * @property {number} failedConsoleOutputMaxLines - Maximum failed console lines to print inline.
  */
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"test.js","sourceRoot":"","sources":["../../../src/testing/test.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport path from \"path\"\nimport {fileURLToPath} from \"url\"\nimport EventEmitter from \"../utils/event-emitter.js\"\nimport Expect from \"./expect.js\"\nimport {arrayContaining, objectContaining} from \"./expect-utils.js\"\n\n/**\n * Tests.\n * @type {import(\"./test-runner.js\").TestsArgument} */\nconst tests = {\n  /**\n   * Narrows the runtime value to the documented type.\n   * @type {import(\"./test-runner.js\").AfterBeforeEachCallbackObjectType[]} */\n  afterEaches: [],\n  /**\n   * Narrows the runtime value to the documented type.\n   * @type {import(\"./test-runner.js\").BeforeAfterAllCallbackObjectType[]} */\n  afterAlls: [],\n  args: {},\n\n  /**\n   * Narrows the runtime value to the documented type.\n   * @type {import(\"./test-runner.js\").BeforeAfterAllCallbackObjectType[]} */\n  beforeAlls: [],\n  /**\n   * Narrows the runtime value to the documented type.\n   * @type {import(\"./test-runner.js\").AfterBeforeEachCallbackObjectType[]} */\n  beforeEaches: [],\n  filePath: undefined,\n  line: undefined,\n  subs: {},\n  tests: {}\n}\n\nconst testEvents = new EventEmitter()\n\nlet currentPath = [tests]\n\n/**\n * Runs capture location.\n * @returns {{filePath?: string, line?: number}} - Location.\n */\nfunction captureLocation() {\n  const error = new Error()\n  const stack = typeof error.stack === \"string\" ? error.stack.split(\"\\n\") : []\n\n  for (const line of stack) {\n    const trimmed = line.trim()\n\n    if (!trimmed.includes(\"at\")) continue\n    if (trimmed.includes(\"/src/testing/test.js\")) continue\n\n    const match = trimmed.match(/(?:\\(|\\s)(file:\\/\\/.*?|\\/.*?):(\\d+):(\\d+)\\)?$/)\n\n    if (!match) continue\n\n    const rawPath = match[1]\n    const lineNumber = Number(match[2])\n    const filePath = rawPath.startsWith(\"file://\")\n      ? fileURLToPath(rawPath)\n      : rawPath\n\n    return {\n      filePath: path.resolve(filePath),\n      line: Number.isFinite(lineNumber) ? lineNumber : undefined\n    }\n  }\n\n  return {}\n}\n\n/**\n * Runs normalize tags.\n * @param {string[] | string | undefined} tags - Tags.\n * @returns {string[]} - Normalized tags.\n */\nfunction normalizeTags(tags) {\n  if (!tags) return []\n\n  const values = []\n  const rawTags = Array.isArray(tags) ? tags : [tags]\n\n  for (const rawTag of rawTags) {\n    if (rawTag === undefined || rawTag === null) continue\n\n    const parts = String(rawTag).split(\",\")\n\n    for (const part of parts) {\n      const trimmed = part.trim()\n\n      if (trimmed) values.push(trimmed)\n    }\n  }\n\n  return Array.from(new Set(values))\n}\n\n/**\n * Test config.\n * @type {VelociousTestConfig} */\nconst testConfig = {\n  consoleOutput: \"failure\",\n  failedConsoleOutputMaxLines: 200,\n  excludeTags: [],\n  defaultTimeoutSeconds: 60\n}\n\n/**\n * Runs configure tests.\n * @param {object} args - Options.\n * @param {\"failure\" | \"live\"} [args.consoleOutput] - Console output mode.\n * @param {string[] | string} [args.excludeTags] - Tags to exclude.\n * @param {number} [args.defaultTimeoutSeconds] - Default timeout in seconds.\n * @param {number} [args.failedConsoleOutputMaxLines] - Maximum failed console lines to print inline.\n * @returns {void}\n */\nfunction configureTests({consoleOutput, excludeTags, defaultTimeoutSeconds, failedConsoleOutputMaxLines} = {}) {\n  if (excludeTags !== undefined) {\n    testConfig.excludeTags = normalizeTags(excludeTags)\n  }\n\n  if (consoleOutput !== undefined) {\n    if (consoleOutput !== \"failure\" && consoleOutput !== \"live\") {\n      throw new Error(`Invalid consoleOutput config: ${consoleOutput}`)\n    }\n\n    testConfig.consoleOutput = consoleOutput\n  }\n\n  if (typeof defaultTimeoutSeconds === \"number\") {\n    testConfig.defaultTimeoutSeconds = defaultTimeoutSeconds\n  }\n\n  if (typeof failedConsoleOutputMaxLines === \"number\") {\n    testConfig.failedConsoleOutputMaxLines = failedConsoleOutputMaxLines\n  }\n}\n\n/**\n * Runs merge test args.\n * @param {Record<string, ?>} baseArgs - Base args.\n * @param {Record<string, ?>} extraArgs - Extra args.\n * @returns {Record<string, ?>} - Merged args.\n */\nfunction mergeTestArgs(baseArgs, extraArgs) {\n  const merged = Object.assign({}, baseArgs, extraArgs)\n  const mergedTags = [...normalizeTags(baseArgs?.tags), ...normalizeTags(extraArgs?.tags)]\n\n  if (mergedTags.length > 0) {\n    merged.tags = Array.from(new Set(mergedTags))\n  } else if (\"tags\" in merged) {\n    delete merged.tags\n  }\n\n  return merged\n}\n\n/**\n * Runs before each.\n * @param {import(\"./test-runner.js\").AfterBeforeEachCallbackType} callback - Callback function.\n * @returns {void} - No return value.\n */\nfunction beforeEach(callback) {\n  const currentTest = currentPath[currentPath.length - 1]\n\n  currentTest.beforeEaches.push({callback})\n}\n\n/**\n * Runs before all.\n * @param {import(\"./test-runner.js\").BeforeAfterAllCallbackType} callback - Callback function.\n * @returns {void} - No return value.\n */\nfunction beforeAll(callback) {\n  const currentTest = currentPath[currentPath.length - 1]\n\n  currentTest.beforeAlls.push({callback})\n}\n\n/**\n * Runs after each.\n * @param {import(\"./test-runner.js\").AfterBeforeEachCallbackType} callback - Callback function.\n * @returns {void} - No return value.\n */\nfunction afterEach(callback) {\n  const currentTest = currentPath[currentPath.length - 1]\n\n  currentTest.afterEaches.push({callback})\n}\n\n/**\n * Runs after all.\n * @param {import(\"./test-runner.js\").BeforeAfterAllCallbackType} callback - Callback function.\n * @returns {void} - No return value.\n */\nfunction afterAll(callback) {\n  const currentTest = currentPath[currentPath.length - 1]\n\n  currentTest.afterAlls.push({callback})\n}\n\n\n/**\n * Runs describe.\n * @param {string} description - Description.\n * @param {object|(() => (void|Promise<void>))} arg1 - Arg1.\n * @param {undefined|(() => (void|Promise<void>))} [arg2] - Arg2.\n * @returns {Promise<void>} - Resolves when complete.\n */\nasync function describe(description, arg1, arg2) {\n  /**\n   * Defines testArgs.\n   * @type {Record<string, ?>} */\n  let testArgs, testFunction\n\n  if (typeof arg2 == \"function\") {\n    testFunction = arg2\n    testArgs = arg1\n  } else if (typeof arg1 == \"function\") {\n    testFunction = arg1\n    testArgs = {}\n  } else {\n    throw new Error(`Invalid arguments for describe: ${arg1}, ${arg2}`)\n  }\n\n  const currentTest = currentPath[currentPath.length - 1]\n  const newTestArgs = mergeTestArgs(currentTest.args, testArgs)\n\n  if (description in currentTest.subs) {\n    throw new Error(`Duplicate test description: ${description}`)\n  }\n\n  const location = captureLocation()\n  const newTestData = {\n    afterEaches: [],\n    afterAlls: [],\n    args: newTestArgs,\n    beforeAlls: [],\n    beforeEaches: [],\n    filePath: location.filePath,\n    line: location.line,\n    subs: {},\n    tests: {}\n  }\n\n  currentTest.subs[description] = newTestData\n  currentPath.push(newTestData)\n\n  try {\n    await testFunction()\n  } finally {\n    currentPath.pop()\n  }\n}\n\n/**\n * Runs expect.\n * @param {?} arg - Arg.\n * @returns {Expect} - The expect.\n */\nfunction expect(arg) {\n  return new Expect(arg)\n}\n\nexpect.objectContaining = objectContaining\nexpect.arrayContaining = arrayContaining\n\n/**\n * Runs it.\n * @param {string} description - Description.\n * @param {object|(() => (void|Promise<void>))} arg1 - Arg1.\n * @param {undefined|(() => (void|Promise<void>))} [arg2] - Arg2.\n * @returns {void} - No return value.\n */\nfunction it(description, arg1, arg2) {\n  const currentTest = currentPath[currentPath.length - 1]\n  /**\n   * Defines testArgs.\n   * @type {Record<string, ?>} */\n  let testArgs\n\n  /**\n   * Defines testFunction.\n   * @type {() => (void|Promise<void>)} */\n  let testFunction\n\n  if (typeof arg1 == \"function\") {\n    testFunction = /** @type {() => (void|Promise<void>)} */ (arg1)\n    testArgs = {}\n  } else if (typeof arg2 == \"function\") {\n    testFunction = /** @type {() => (void|Promise<void>)} */ (arg2)\n    testArgs = arg1\n  } else {\n    throw new Error(`Invalid arguments for it: ${description}, ${arg1}`)\n  }\n\n  const newTestArgs = mergeTestArgs(currentTest.args, testArgs)\n\n  const location = captureLocation()\n\n  currentTest.tests[description] = {\n    args: newTestArgs,\n    function: testFunction,\n    filePath: location.filePath,\n    line: location.line\n  }\n}\n\n/**\n * Runs fit.\n * @param {string} description - Description.\n * @param {object|(() => (void|Promise<void>))} arg1 - Arg1.\n * @param {undefined|(() => (void|Promise<void>))} [arg2] - Arg2.\n * @returns {void} - No return value.\n */\nfunction fit(description, arg1, arg2) {\n  /**\n   * Defines testArgs.\n   * @type {Record<string, ?>} */\n  let testArgs\n\n  /**\n   * Defines testFunction.\n   * @type {() => (void|Promise<void>)} */\n  let testFunction\n\n  if (typeof arg1 == \"function\") {\n    testFunction = /** @type {() => (void|Promise<void>)} */ (arg1)\n    testArgs = {focus: true}\n  } else if (typeof arg2 == \"function\") {\n    testFunction = /** @type {() => (void|Promise<void>)} */ (arg2)\n    testArgs = Object.assign({focus: true}, arg1)\n  } else {\n    throw new Error(`Invalid arguments for it: ${description}, ${arg1}`)\n  }\n\n  return it(description, testArgs, testFunction)\n}\n\n// Make the methods global so they can be used in test files\nglobalThis.afterEach = afterEach\nglobalThis.afterAll = afterAll\nglobalThis.beforeEach = beforeEach\nglobalThis.beforeAll = beforeAll\nglobalThis.describe = describe\nglobalThis.expect = expect\nglobalThis.it = it\nglobalThis.fit = fit\nglobalThis.testEvents = testEvents\nglobalThis.configureTests = configureTests\n\nexport {afterAll, afterEach, beforeAll, beforeEach, configureTests, describe, expect, fit, it, arrayContaining, objectContaining, testConfig, testEvents, tests}\n/**\n * VelociousTestConfig type.\n * @typedef {object} VelociousTestConfig\n * @property {\"failure\" | \"live\"} consoleOutput - Console output mode.\n * @property {string[]} excludeTags - Tags excluded by default.\n * @property {number} defaultTimeoutSeconds - Default timeout in seconds.\n * @property {number} failedConsoleOutputMaxLines - Maximum failed console lines to print inline.\n */\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"test.js","sourceRoot":"","sources":["../../../src/testing/test.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport path from \"path\"\nimport {fileURLToPath} from \"url\"\nimport EventEmitter from \"../utils/event-emitter.js\"\nimport Expect from \"./expect.js\"\nimport waitForEvent from \"./wait-for-event.js\"\nimport {arrayContaining, objectContaining} from \"./expect-utils.js\"\n\n/**\n * Tests.\n * @type {import(\"./test-runner.js\").TestsArgument} */\nconst tests = {\n  /**\n   * Narrows the runtime value to the documented type.\n   * @type {import(\"./test-runner.js\").AfterBeforeEachCallbackObjectType[]} */\n  afterEaches: [],\n  /**\n   * Narrows the runtime value to the documented type.\n   * @type {import(\"./test-runner.js\").BeforeAfterAllCallbackObjectType[]} */\n  afterAlls: [],\n  args: {},\n\n  /**\n   * Narrows the runtime value to the documented type.\n   * @type {import(\"./test-runner.js\").BeforeAfterAllCallbackObjectType[]} */\n  beforeAlls: [],\n  /**\n   * Narrows the runtime value to the documented type.\n   * @type {import(\"./test-runner.js\").AfterBeforeEachCallbackObjectType[]} */\n  beforeEaches: [],\n  filePath: undefined,\n  line: undefined,\n  subs: {},\n  tests: {}\n}\n\nconst testEvents = new EventEmitter()\n\nlet currentPath = [tests]\n\n/**\n * Runs capture location.\n * @returns {{filePath?: string, line?: number}} - Location.\n */\nfunction captureLocation() {\n  const error = new Error()\n  const stack = typeof error.stack === \"string\" ? error.stack.split(\"\\n\") : []\n\n  for (const line of stack) {\n    const trimmed = line.trim()\n\n    if (!trimmed.includes(\"at\")) continue\n    if (trimmed.includes(\"/src/testing/test.js\")) continue\n\n    const match = trimmed.match(/(?:\\(|\\s)(file:\\/\\/.*?|\\/.*?):(\\d+):(\\d+)\\)?$/)\n\n    if (!match) continue\n\n    const rawPath = match[1]\n    const lineNumber = Number(match[2])\n    const filePath = rawPath.startsWith(\"file://\")\n      ? fileURLToPath(rawPath)\n      : rawPath\n\n    return {\n      filePath: path.resolve(filePath),\n      line: Number.isFinite(lineNumber) ? lineNumber : undefined\n    }\n  }\n\n  return {}\n}\n\n/**\n * Runs normalize tags.\n * @param {string[] | string | undefined} tags - Tags.\n * @returns {string[]} - Normalized tags.\n */\nfunction normalizeTags(tags) {\n  if (!tags) return []\n\n  const values = []\n  const rawTags = Array.isArray(tags) ? tags : [tags]\n\n  for (const rawTag of rawTags) {\n    if (rawTag === undefined || rawTag === null) continue\n\n    const parts = String(rawTag).split(\",\")\n\n    for (const part of parts) {\n      const trimmed = part.trim()\n\n      if (trimmed) values.push(trimmed)\n    }\n  }\n\n  return Array.from(new Set(values))\n}\n\n/**\n * Test config.\n * @type {VelociousTestConfig} */\nconst testConfig = {\n  consoleOutput: \"failure\",\n  failedConsoleOutputMaxLines: 200,\n  excludeTags: [],\n  defaultTimeoutSeconds: 60\n}\n\n/**\n * Runs configure tests.\n * @param {object} args - Options.\n * @param {\"failure\" | \"live\"} [args.consoleOutput] - Console output mode.\n * @param {string[] | string} [args.excludeTags] - Tags to exclude.\n * @param {number} [args.defaultTimeoutSeconds] - Default timeout in seconds.\n * @param {number} [args.failedConsoleOutputMaxLines] - Maximum failed console lines to print inline.\n * @returns {void}\n */\nfunction configureTests({consoleOutput, excludeTags, defaultTimeoutSeconds, failedConsoleOutputMaxLines} = {}) {\n  if (excludeTags !== undefined) {\n    testConfig.excludeTags = normalizeTags(excludeTags)\n  }\n\n  if (consoleOutput !== undefined) {\n    if (consoleOutput !== \"failure\" && consoleOutput !== \"live\") {\n      throw new Error(`Invalid consoleOutput config: ${consoleOutput}`)\n    }\n\n    testConfig.consoleOutput = consoleOutput\n  }\n\n  if (typeof defaultTimeoutSeconds === \"number\") {\n    testConfig.defaultTimeoutSeconds = defaultTimeoutSeconds\n  }\n\n  if (typeof failedConsoleOutputMaxLines === \"number\") {\n    testConfig.failedConsoleOutputMaxLines = failedConsoleOutputMaxLines\n  }\n}\n\n/**\n * Runs merge test args.\n * @param {Record<string, ?>} baseArgs - Base args.\n * @param {Record<string, ?>} extraArgs - Extra args.\n * @returns {Record<string, ?>} - Merged args.\n */\nfunction mergeTestArgs(baseArgs, extraArgs) {\n  const merged = Object.assign({}, baseArgs, extraArgs)\n  const mergedTags = [...normalizeTags(baseArgs?.tags), ...normalizeTags(extraArgs?.tags)]\n\n  if (mergedTags.length > 0) {\n    merged.tags = Array.from(new Set(mergedTags))\n  } else if (\"tags\" in merged) {\n    delete merged.tags\n  }\n\n  return merged\n}\n\n/**\n * Runs before each.\n * @param {import(\"./test-runner.js\").AfterBeforeEachCallbackType} callback - Callback function.\n * @returns {void} - No return value.\n */\nfunction beforeEach(callback) {\n  const currentTest = currentPath[currentPath.length - 1]\n\n  currentTest.beforeEaches.push({callback})\n}\n\n/**\n * Runs before all.\n * @param {import(\"./test-runner.js\").BeforeAfterAllCallbackType} callback - Callback function.\n * @returns {void} - No return value.\n */\nfunction beforeAll(callback) {\n  const currentTest = currentPath[currentPath.length - 1]\n\n  currentTest.beforeAlls.push({callback})\n}\n\n/**\n * Runs after each.\n * @param {import(\"./test-runner.js\").AfterBeforeEachCallbackType} callback - Callback function.\n * @returns {void} - No return value.\n */\nfunction afterEach(callback) {\n  const currentTest = currentPath[currentPath.length - 1]\n\n  currentTest.afterEaches.push({callback})\n}\n\n/**\n * Runs after all.\n * @param {import(\"./test-runner.js\").BeforeAfterAllCallbackType} callback - Callback function.\n * @returns {void} - No return value.\n */\nfunction afterAll(callback) {\n  const currentTest = currentPath[currentPath.length - 1]\n\n  currentTest.afterAlls.push({callback})\n}\n\n\n/**\n * Runs describe.\n * @param {string} description - Description.\n * @param {object|(() => (void|Promise<void>))} arg1 - Arg1.\n * @param {undefined|(() => (void|Promise<void>))} [arg2] - Arg2.\n * @returns {Promise<void>} - Resolves when complete.\n */\nasync function describe(description, arg1, arg2) {\n  /**\n   * Defines testArgs.\n   * @type {Record<string, ?>} */\n  let testArgs, testFunction\n\n  if (typeof arg2 == \"function\") {\n    testFunction = arg2\n    testArgs = arg1\n  } else if (typeof arg1 == \"function\") {\n    testFunction = arg1\n    testArgs = {}\n  } else {\n    throw new Error(`Invalid arguments for describe: ${arg1}, ${arg2}`)\n  }\n\n  const currentTest = currentPath[currentPath.length - 1]\n  const newTestArgs = mergeTestArgs(currentTest.args, testArgs)\n\n  if (description in currentTest.subs) {\n    throw new Error(`Duplicate test description: ${description}`)\n  }\n\n  const location = captureLocation()\n  const newTestData = {\n    afterEaches: [],\n    afterAlls: [],\n    args: newTestArgs,\n    beforeAlls: [],\n    beforeEaches: [],\n    filePath: location.filePath,\n    line: location.line,\n    subs: {},\n    tests: {}\n  }\n\n  currentTest.subs[description] = newTestData\n  currentPath.push(newTestData)\n\n  try {\n    await testFunction()\n  } finally {\n    currentPath.pop()\n  }\n}\n\n/**\n * Runs expect.\n * @param {?} arg - Arg.\n * @returns {Expect} - The expect.\n */\nfunction expect(arg) {\n  return new Expect(arg)\n}\n\nexpect.objectContaining = objectContaining\nexpect.arrayContaining = arrayContaining\n\n/**\n * Runs it.\n * @param {string} description - Description.\n * @param {object|(() => (void|Promise<void>))} arg1 - Arg1.\n * @param {undefined|(() => (void|Promise<void>))} [arg2] - Arg2.\n * @returns {void} - No return value.\n */\nfunction it(description, arg1, arg2) {\n  const currentTest = currentPath[currentPath.length - 1]\n  /**\n   * Defines testArgs.\n   * @type {Record<string, ?>} */\n  let testArgs\n\n  /**\n   * Defines testFunction.\n   * @type {() => (void|Promise<void>)} */\n  let testFunction\n\n  if (typeof arg1 == \"function\") {\n    testFunction = /** @type {() => (void|Promise<void>)} */ (arg1)\n    testArgs = {}\n  } else if (typeof arg2 == \"function\") {\n    testFunction = /** @type {() => (void|Promise<void>)} */ (arg2)\n    testArgs = arg1\n  } else {\n    throw new Error(`Invalid arguments for it: ${description}, ${arg1}`)\n  }\n\n  const newTestArgs = mergeTestArgs(currentTest.args, testArgs)\n\n  const location = captureLocation()\n\n  currentTest.tests[description] = {\n    args: newTestArgs,\n    function: testFunction,\n    filePath: location.filePath,\n    line: location.line\n  }\n}\n\n/**\n * Runs fit.\n * @param {string} description - Description.\n * @param {object|(() => (void|Promise<void>))} arg1 - Arg1.\n * @param {undefined|(() => (void|Promise<void>))} [arg2] - Arg2.\n * @returns {void} - No return value.\n */\nfunction fit(description, arg1, arg2) {\n  /**\n   * Defines testArgs.\n   * @type {Record<string, ?>} */\n  let testArgs\n\n  /**\n   * Defines testFunction.\n   * @type {() => (void|Promise<void>)} */\n  let testFunction\n\n  if (typeof arg1 == \"function\") {\n    testFunction = /** @type {() => (void|Promise<void>)} */ (arg1)\n    testArgs = {focus: true}\n  } else if (typeof arg2 == \"function\") {\n    testFunction = /** @type {() => (void|Promise<void>)} */ (arg2)\n    testArgs = Object.assign({focus: true}, arg1)\n  } else {\n    throw new Error(`Invalid arguments for it: ${description}, ${arg1}`)\n  }\n\n  return it(description, testArgs, testFunction)\n}\n\n// Make the methods global so they can be used in test files\nglobalThis.afterEach = afterEach\nglobalThis.afterAll = afterAll\nglobalThis.beforeEach = beforeEach\nglobalThis.beforeAll = beforeAll\nglobalThis.describe = describe\nglobalThis.expect = expect\nglobalThis.it = it\nglobalThis.fit = fit\nglobalThis.testEvents = testEvents\nglobalThis.configureTests = configureTests\n\nexport {afterAll, afterEach, beforeAll, beforeEach, configureTests, describe, expect, fit, it, arrayContaining, objectContaining, testConfig, testEvents, tests, waitForEvent}\n/**\n * VelociousTestConfig type.\n * @typedef {object} VelociousTestConfig\n * @property {\"failure\" | \"live\"} consoleOutput - Console output mode.\n * @property {string[]} excludeTags - Tags excluded by default.\n * @property {number} defaultTimeoutSeconds - Default timeout in seconds.\n * @property {number} failedConsoleOutputMaxLines - Maximum failed console lines to print inline.\n */\n"]}

package/build/src/testing/wait-for-event.d.ts

@@ -0,0 +1,46 @@
+/**
+ * @typedef {object} WaitForEventOptions
+ * @property {number} [timeoutMs] Timeout in milliseconds (default: 5000).
+ * @property {(...args: Array<?>) => boolean} [filter] Only resolve when this predicate returns true for the emitted arguments.
+ */
+/**
+ * @typedef {object} EventEmitterLike
+ * @property {(event: string, listener: (...args: Array<?>) => void) => void} on Registers a listener.
+ * @property {(event: string, listener: (...args: Array<?>) => void) => void} off Removes a listener.
+ */
+/**
+ * Resolves the moment `eventName` fires on `emitter` — optionally only when `filter`
+ * matches the emitted arguments — instead of sleeping a fixed duration. Rejects with a
+ * timeout error if the event does not fire within `timeoutMs`. The listener is always
+ * removed (on resolve and on timeout).
+ *
+ * Use this to await a real signal (a background job finishing, a model update, a
+ * websocket message) rather than guessing a delay. To poll an arbitrary condition
+ * instead of a discrete event, use awaitery's `waitFor`.
+ * @param {EventEmitterLike} emitter - Event emitter exposing `on`/`off` (Node EventEmitter, eventemitter3, velocious `testEvents`, ...).
+ * @param {string} eventName - The event to wait for.
+ * @param {WaitForEventOptions} [options] - Options.
+ * @returns {Promise<?>} - Resolves with the single emitted argument, an array when the event emits multiple, or undefined when it emits none.
+ */
+export default function waitForEvent(emitter: EventEmitterLike, eventName: string, options?: WaitForEventOptions): Promise<unknown>;
+export type WaitForEventOptions = {
+    /**
+     * Timeout in milliseconds (default: 5000).
+     */
+    timeoutMs?: number | undefined;
+    /**
+     * Only resolve when this predicate returns true for the emitted arguments.
+     */
+    filter?: ((...args: Array<unknown>) => boolean) | undefined;
+};
+export type EventEmitterLike = {
+    /**
+     * Registers a listener.
+     */
+    on: (event: string, listener: (...args: Array<unknown>) => void) => void;
+    /**
+     * Removes a listener.
+     */
+    off: (event: string, listener: (...args: Array<unknown>) => void) => void;
+};
+//# sourceMappingURL=wait-for-event.d.ts.map

package/build/src/testing/wait-for-event.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wait-for-event.d.ts","sourceRoot":"","sources":["../../../src/testing/wait-for-event.js"],"names":[],"mappings":"AAEA;;;;GAIG;AAEH;;;;GAIG;AAEH;;;;;;;;;;;;;GAaG;AACH,8CALW,gBAAgB,aAChB,MAAM,YACN,mBAAmB,GACjB,OAAO,CAAC,OAAC,CAAC,CA6CtB;;;;;;;;;wBAlEuB,KAAK,CAAC,OAAC,CAAC,KAAK,OAAO;;;;;;QAK9B,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,GAAG,IAAI,EAAE,KAAK,CAAC,OAAC,CAAC,KAAK,IAAI,KAAK,IAAI;;;;SAC9D,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,GAAG,IAAI,EAAE,KAAK,CAAC,OAAC,CAAC,KAAK,IAAI,KAAK,IAAI"}

package/build/src/testing/wait-for-event.js

@@ -0,0 +1,64 @@
+// @ts-check
+/**
+ * @typedef {object} WaitForEventOptions
+ * @property {number} [timeoutMs] Timeout in milliseconds (default: 5000).
+ * @property {(...args: Array<?>) => boolean} [filter] Only resolve when this predicate returns true for the emitted arguments.
+ */
+/**
+ * @typedef {object} EventEmitterLike
+ * @property {(event: string, listener: (...args: Array<?>) => void) => void} on Registers a listener.
+ * @property {(event: string, listener: (...args: Array<?>) => void) => void} off Removes a listener.
+ */
+/**
+ * Resolves the moment `eventName` fires on `emitter` — optionally only when `filter`
+ * matches the emitted arguments — instead of sleeping a fixed duration. Rejects with a
+ * timeout error if the event does not fire within `timeoutMs`. The listener is always
+ * removed (on resolve and on timeout).
+ *
+ * Use this to await a real signal (a background job finishing, a model update, a
+ * websocket message) rather than guessing a delay. To poll an arbitrary condition
+ * instead of a discrete event, use awaitery's `waitFor`.
+ * @param {EventEmitterLike} emitter - Event emitter exposing `on`/`off` (Node EventEmitter, eventemitter3, velocious `testEvents`, ...).
+ * @param {string} eventName - The event to wait for.
+ * @param {WaitForEventOptions} [options] - Options.
+ * @returns {Promise<?>} - Resolves with the single emitted argument, an array when the event emits multiple, or undefined when it emits none.
+ */
+export default function waitForEvent(emitter, eventName, options = {}) {
+    const { timeoutMs = 5000, filter } = options;
+    return new Promise((resolve, reject) => {
+        /** @type {ReturnType<typeof setTimeout>} */
+        let timer;
+        /**
+         * Resolves the wait when a matching event fires, removing itself first. A filter
+         * that throws (e.g. it assumes an event shape an intermediate emission doesn't
+         * have) rejects immediately rather than leaving the waiter pending until timeout.
+         * @param {...?} args - Emitted arguments.
+         * @returns {void}
+         */
+        const listener = (...args) => {
+            if (filter) {
+                let matched;
+                try {
+                    matched = filter(...args);
+                }
+                catch (error) {
+                    clearTimeout(timer);
+                    emitter.off(eventName, listener);
+                    reject(error);
+                    return;
+                }
+                if (!matched)
+                    return;
+            }
+            clearTimeout(timer);
+            emitter.off(eventName, listener);
+            resolve(args.length > 1 ? args : args[0]);
+        };
+        timer = setTimeout(() => {
+            emitter.off(eventName, listener);
+            reject(new Error(`Timed out after ${timeoutMs}ms waiting for event ${JSON.stringify(eventName)}`));
+        }, timeoutMs);
+        emitter.on(eventName, listener);
+    });
+}
+//# sourceMappingURL=data:application/json;base64,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