velocious 1.0.499 → 1.0.501

package/build/src/database/drivers/mssql/index.d.ts

@@ -16,6 +16,28 @@ export default class VelociousDatabaseDriversMssql extends Base {
      * @returns {Promise<string>} - Resolves with the current database.
      */
     currentDatabase(): Promise<string>;
+    /**
+     * Runs a bulk constraint-toggle statement. `ALTER TABLE ... NOCHECK/CHECK
+     * CONSTRAINT` needs a schema-modification lock on every table, so if the
+     * request times out it is almost always blocked by another session that is
+     * still holding a lock (a leaked/uncommitted connection). On a timeout,
+     * capture which sessions were blocking so the real culprit is named instead
+     * of leaving a bare "Request failed to complete in 15000ms".
+     * @param {string} sql - Constraint-toggle SQL.
+     * @param {string} label - Operation label for the error.
+     * @returns {Promise<void>} - Resolves when the toggle completes.
+     */
+    _execConstraintToggle(sql: string, label: string): Promise<void>;
+    /**
+     * Snapshots the sessions that could be blocking a constraint toggle in THIS
+     * database — every session other than this one that holds a lock in `DB_ID()`
+     * or is running a request against it — with its last statement, wait state,
+     * and blocking session, enough to identify a connection that leaked a lock.
+     * Scoped to the current database so a multi-database server does not leak
+     * unrelated sessions' SQL into the error and bury the real blocker.
+     * @returns {Promise<string>} - JSON snapshot, or a "(none)" marker.
+     */
+    _captureBlockingSessionsForDebug(): Promise<string>;
     /**
      * Drops the foreign key constraints that reference the given table. MSSQL
      * refuses to drop a table that is still referenced by a FOREIGN KEY

package/build/src/database/drivers/mssql/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/database/drivers/mssql/index.js"],"names":[],"mappings":"AAyBA;IAgBM,6CAAqD;IAavD,0DAA+B;IAsBjC;;;;;;OAMG;IACH,gCALW,MAAM,SAEd;QAAuB,WAAW;KAClC,GAAU,MAAM,EAAE,CAOpB;IAoDD;;;OAGG;IACH,mBAFa,OAAO,CAAC,MAAM,CAAC,CAM3B;IAuBD;;;;;;;;;OASG;IACH,uCAHW,MAAM,GACJ,OAAO,CAAC,IAAI,CAAC,CAczB;IAsED;;;;OAIG;IACH,cAHW,OAAC,GACC,MAAM,CAUlB;IAwFD,6BAOC;IAOqB,8BAA2C;CA4NlE;iBAnlBgB,YAAY;kBAWX,OAAO;oBADL,cAAc"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/database/drivers/mssql/index.js"],"names":[],"mappings":"AAyBA;IAgBM,6CAAqD;IAavD,0DAA+B;IAsBjC;;;;;;OAMG;IACH,gCALW,MAAM,SAEd;QAAuB,WAAW;KAClC,GAAU,MAAM,EAAE,CAOpB;IAoDD;;;OAGG;IACH,mBAFa,OAAO,CAAC,MAAM,CAAC,CAM3B;IAkBD;;;;;;;;;;OAUG;IACH,2BAJW,MAAM,SACN,MAAM,GACJ,OAAO,CAAC,IAAI,CAAC,CAgBzB;IAED;;;;;;;;OAQG;IACH,oCAFa,OAAO,CAAC,MAAM,CAAC,CAiC3B;IAeD;;;;;;;;;OASG;IACH,uCAHW,MAAM,GACJ,OAAO,CAAC,IAAI,CAAC,CAczB;IAsED;;;;OAIG;IACH,cAHW,OAAC,GACC,MAAM,CAUlB;IAwFD,6BAOC;IAOqB,8BAA2C;CA4NlE;iBAhqBgB,YAAY;kBAWX,OAAO;oBADL,cAAc"}

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

@@ -128,11 +128,82 @@ export default class VelociousDatabaseDriversMssql extends Base {
         const rows = await this.query("SELECT DB_NAME() AS db_name");
         return digg(rows, 0, "db_name");
     }
+    /**
+     * Disables every foreign key constraint (bulk `NOCHECK`).
+     * @returns {Promise<void>} - Resolves when foreign keys are disabled.
+     */
     async disableForeignKeys() {
-        await this.query("EXEC sp_MSforeachtable \"ALTER TABLE ? NOCHECK CONSTRAINT all\"");
+        await this._execConstraintToggle("EXEC sp_MSforeachtable \"ALTER TABLE ? NOCHECK CONSTRAINT all\"", "disableForeignKeys");
     }
+    /**
+     * Re-enables and re-validates every foreign key constraint (`WITH CHECK`).
+     * @returns {Promise<void>} - Resolves when foreign keys are enabled.
+     */
     async enableForeignKeys() {
-        await this.query("EXEC sp_MSforeachtable @command1=\"print '?'\", @command2=\"ALTER TABLE ? WITH CHECK CHECK CONSTRAINT all\"");
+        await this._execConstraintToggle("EXEC sp_MSforeachtable @command1=\"print '?'\", @command2=\"ALTER TABLE ? WITH CHECK CHECK CONSTRAINT all\"", "enableForeignKeys");
+    }
+    /**
+     * Runs a bulk constraint-toggle statement. `ALTER TABLE ... NOCHECK/CHECK
+     * CONSTRAINT` needs a schema-modification lock on every table, so if the
+     * request times out it is almost always blocked by another session that is
+     * still holding a lock (a leaked/uncommitted connection). On a timeout,
+     * capture which sessions were blocking so the real culprit is named instead
+     * of leaving a bare "Request failed to complete in 15000ms".
+     * @param {string} sql - Constraint-toggle SQL.
+     * @param {string} label - Operation label for the error.
+     * @returns {Promise<void>} - Resolves when the toggle completes.
+     */
+    async _execConstraintToggle(sql, label) {
+        try {
+            await this.query(sql);
+        }
+        catch (error) {
+            if (error instanceof Error && /Timeout: Request failed to complete/i.test(error.message)) {
+                const snapshot = await this._captureBlockingSessionsForDebug().catch((diagError) => `(blocking diagnostics query failed: ${diagError instanceof Error ? diagError.message : diagError})`);
+                throw new Error(`${error.message}\n\n[${label} blocked] other user sessions with open transactions or active requests:\n${snapshot}`, { cause: error });
+            }
+            throw error;
+        }
+    }
+    /**
+     * Snapshots the sessions that could be blocking a constraint toggle in THIS
+     * database — every session other than this one that holds a lock in `DB_ID()`
+     * or is running a request against it — with its last statement, wait state,
+     * and blocking session, enough to identify a connection that leaked a lock.
+     * Scoped to the current database so a multi-database server does not leak
+     * unrelated sessions' SQL into the error and bury the real blocker.
+     * @returns {Promise<string>} - JSON snapshot, or a "(none)" marker.
+     */
+    async _captureBlockingSessionsForDebug() {
+        const rows = await this.query(`
+      WITH lock_sessions AS (
+        SELECT DISTINCT request_session_id AS session_id
+        FROM sys.dm_tran_locks
+        WHERE resource_database_id = DB_ID()
+      )
+      SELECT
+        s.session_id AS sessionId,
+        s.status AS sessionStatus,
+        s.login_time AS loginTime,
+        s.last_request_start_time AS lastRequestStart,
+        s.last_request_end_time AS lastRequestEnd,
+        s.open_transaction_count AS openTransactionCount,
+        r.status AS requestStatus,
+        r.command AS command,
+        r.wait_type AS waitType,
+        r.wait_time AS waitTimeMs,
+        r.blocking_session_id AS blockingSessionId,
+        CAST(ib.event_info AS NVARCHAR(MAX)) AS lastSql
+      FROM sys.dm_exec_sessions s
+      LEFT JOIN sys.dm_exec_requests r ON r.session_id = s.session_id
+      OUTER APPLY sys.dm_exec_input_buffer(s.session_id, NULL) ib
+      WHERE s.is_user_process = 1
+        AND s.session_id <> @@SPID
+        AND (s.session_id IN (SELECT session_id FROM lock_sessions) OR r.database_id = DB_ID())
+    `);
+        if (rows.length === 0)
+            return "(none — no other session held a lock or ran a request in this database when queried)";
+        return JSON.stringify(rows, null, 2);
     }
     /**
      * Runs drop table sqls.
@@ -514,4 +585,4 @@ export default class VelociousDatabaseDriversMssql extends Base {
         return testResult === 0;
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../src/database/drivers/mssql/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 DropDatabase from \"./sql/drop-database.js\"\nimport DropTable from \"./sql/drop-table.js\"\nimport {digg} from \"diggerize\"\nimport escapeString from \"sql-escape-string\"\nimport Insert from \"./sql/insert.js\"\nimport Options from \"./options.js\"\nimport mssql from \"mssql\"\nimport net from \"node:net\"\nimport QueryParser from \"./query-parser.js\"\nimport RemoveIndex from \"./sql/remove-index.js\"\nimport Table from \"./table.js\"\nimport StructureSql from \"./structure-sql.js\"\nimport timeout from \"awaitery/build/timeout.js\"\nimport Upsert from \"./sql/upsert.js\"\nimport Update from \"./sql/update.js\"\nimport UUID from \"pure-uuid\"\n\nexport default class VelociousDatabaseDriversMssql extends Base{\n  async connect() {\n    const args = this.getArgs()\n    const sqlConfig = digg(args, \"sqlConfig\")\n\n    try {\n      if (this.connection) await this.close()\n\n      if (sqlConfig) {\n        sqlConfig.options = Object.assign({}, sqlConfig.options, {useUTC: true})\n      }\n\n      if (sqlConfig?.server && !sqlConfig.options?.serverName && net.isIP(sqlConfig.server)) {\n        sqlConfig.options = Object.assign({}, sqlConfig.options, {serverName: \"\"})\n      }\n\n      this.connection = new mssql.ConnectionPool(sqlConfig)\n      await this.connection.connect()\n    } catch (error) {\n      // Re-throw to fix unuseable stack trace.\n      throw new Error(`Couldn't connect to database: ${error instanceof Error ? error.message : error}`, {cause: error})\n    }\n  }\n\n  async close() {\n    if (!this.connection) return\n\n    const connection = this.connection\n    this.connection = undefined\n    this._currentTransaction = null\n    this._transactionsCount = 0\n\n    try {\n      await timeout({timeout: 2000}, () => connection.close())\n    } catch (error) {\n      this.logger.warn(\"Failed to close MSSQL connection cleanly\", {error})\n    }\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, indexInCreateTable: false}\n    const createTable = new CreateTable(createArgs)\n\n    return await 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 DB_NAME() AS db_name\")\n\n    return digg(rows, 0, \"db_name\")\n  }\n\n  async disableForeignKeys() {\n    await this.query(\"EXEC sp_MSforeachtable \\\"ALTER TABLE ? NOCHECK CONSTRAINT all\\\"\")\n  }\n\n  async enableForeignKeys() {\n    await this.query(\"EXEC sp_MSforeachtable @command1=\\\"print '?'\\\", @command2=\\\"ALTER TABLE ? WITH CHECK CHECK CONSTRAINT all\\\"\")\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   * Drops the foreign key constraints that reference the given table. MSSQL\n   * refuses to drop a table that is still referenced by a FOREIGN KEY\n   * constraint even when constraints are disabled via NOCHECK, so the\n   * referencing constraints must be removed before the table can be dropped.\n   * This lets callers drop tables in any order (e.g. wiping a whole schema)\n   * without first dropping every dependent table.\n   * @param {string} tableName - Table name.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async _dropReferencingForeignKeys(tableName) {\n    const rows = await this.query(\n      \"SELECT fk.name AS constraint_name, OBJECT_NAME(fk.parent_object_id) AS parent_table \" +\n      `FROM sys.foreign_keys fk WHERE fk.referenced_object_id = OBJECT_ID(${this.quote(tableName)})`\n    )\n\n    for (const row of rows) {\n      const constraintName = row.constraint_name ?? row.CONSTRAINT_NAME\n      const parentTable = row.parent_table ?? row.PARENT_TABLE\n\n      await this.query(`ALTER TABLE [${parentTable}] DROP CONSTRAINT [${constraintName}]`)\n    }\n  }\n\n  /**\n   * Runs drop table.\n   * @param {string} tableName - Table name.\n   * @param {import(\"../base.js\").DropTableSqlArgsType} [args] - Options object.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async dropTable(tableName, args = {}) {\n    this._assertNotReadOnly()\n    await this._dropReferencingForeignKeys(tableName)\n\n    const sqls = await this.dropTableSQLs(tableName, args)\n\n    for (const sql of sqls) {\n      await this.query(sql)\n    }\n  }\n\n  /**\n   * Runs get type.\n   * @returns {string} - The type.\n   */\n  getType() { return \"mssql\" }\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    let result\n    let tries = 0\n\n    while (true) {\n      tries++\n\n      try {\n        const request = this._currentTransaction\n          ? new mssql.Request(this._currentTransaction)\n          : new mssql.Request(this.connection)\n        result = await request.query(sql)\n        break\n      } catch (error) {\n        if (error instanceof Error && error.message == \"No connection is specified for that request.\" && tries <= 3) {\n          this.logger.warn(\"Reconnecting to database\")\n          await this.reconnect()\n          // Retry\n        } else if (error instanceof Error) {\n          // Re-throw error because the stack-trace is broken and can't be used for app-development.\n          throw new Error(`Query failed '${error.message}': ${sql}`, {cause: error})\n        } else {\n          throw new Error(`Query failed '${error}': ${sql}`, {cause: error})\n        }\n      }\n    }\n\n    return Array.isArray(result.recordsets) ? result.recordsets[0] || [] : []\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  shouldSetAutoIncrementWhenPrimaryKey() { return true }\n  supportsDefaultPrimaryKeyUUID() { return true }\n\n  /**\n   * Runs escape.\n   * @param {?} value - Value to use.\n   * @returns {string} - The escape.\n   */\n  escape(value) {\n    value = this._convertValue(value)\n    const stringValue = typeof value == \"string\" ? value : `${value}`\n\n    const resultWithQuotes = escapeString(stringValue, null)\n    const result = resultWithQuotes.substring(1, resultWithQuotes.length - 1)\n\n    return result\n  }\n\n  /**\n   * Runs quote.\n   * @param {?} value - Value to use.\n   * @returns {string | number} - The quoted value.\n   */\n  quote(value) {\n    value = this._convertValue(value)\n\n    if (typeof value == \"number\") return value\n    const stringValue = typeof value == \"string\" ? value : String(value)\n\n    return `N${escapeString(stringValue, null)}`\n  }\n\n  /**\n   * Runs quote column.\n   * @param {string} columnName - Column name.\n   * @returns {string} - The quote column.\n   */\n  quoteColumn(columnName) { return this.options().quoteColumnName(columnName) }\n\n  /**\n   * Runs quote table.\n   * @param {string} string - String.\n   * @returns {string} - The quote table.\n   */\n  quoteTable(string) { return this.options().quoteTableName(string) }\n\n  /**\n   * Runs rename column.\n   * @param {string} tableName - Table name.\n   * @param {string} oldColumnName - Previous column name.\n   * @param {string} newColumnName - New column name.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async renameColumn(tableName, oldColumnName, newColumnName) {\n    await this.query(`EXEC sp_rename ${this.quote(`${tableName}.${oldColumnName}`)}, ${this.quote(newColumnName)}, 'COLUMN'`)\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 schema = this.getArgs()?.schema || this.getArgs()?.sqlConfig?.options?.schema\n      const schemaClause = schema\n        ? ` AND [TABLE_SCHEMA] = ${this.quote(schema)}`\n        : \" AND [TABLE_SCHEMA] = SCHEMA_NAME()\"\n      const result = await this.query(`SELECT [TABLE_NAME] FROM [INFORMATION_SCHEMA].[TABLES] WHERE [TABLE_CATALOG] = DB_NAME()${schemaClause}`)\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  async lastInsertID() {\n    const result = await this.query(\"SELECT SCOPE_IDENTITY() AS last_insert_id\")\n    const lastInsertID = digg(result, 0, \"last_insert_id\")\n\n    if (lastInsertID === null) throw new Error(\"Couldn't get the last inserted ID\")\n\n    return lastInsertID\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  async _startTransactionAction() {\n    if (this._currentTransaction) throw new Error(\"A transaction is already running\")\n    if (!this.connection) await this.connect()\n\n    this._currentTransaction = new mssql.Transaction(this.connection)\n\n    try {\n      await this._currentTransaction.begin()\n    } catch (error) {\n      this._currentTransaction = null\n      throw error\n    }\n  }\n\n  async _commitTransactionAction() {\n    if (!this._currentTransaction) throw new Error(\"A transaction isn't running\")\n\n    await this._currentTransaction.commit()\n    this._currentTransaction = null\n  }\n\n  async _rollbackTransactionAction() {\n    if (!this._currentTransaction) {\n      this.logger.debug(\"A transaction isn't running - ignoring because that can happen if something else has failed in the db\")\n      return\n    }\n\n    try {\n      await this._currentTransaction.rollback()\n    } catch (transactionRollbackError) {\n      // When SQL Server has already aborted the transaction (e.g., a\n      // stale concurrent request triggered XACT_ABORT), the\n      // mssql.Transaction.rollback() call fails because the\n      // Transaction object is dead.  Issue a raw ROLLBACK on the\n      // underlying connection to clear SQL Server's session-level\n      // aborted-transaction state so the connection is usable for the\n      // next BEGIN TRANSACTION.\n      this.logger.warn(\"Transaction.rollback() failed, clearing session state with raw ROLLBACK\", {\n        error: transactionRollbackError instanceof Error ? transactionRollbackError.message : transactionRollbackError\n      })\n\n      const request = new mssql.Request(this.connection)\n\n      await request.query(\"IF @@TRANCOUNT > 0 ROLLBACK\")\n    } finally {\n      this._currentTransaction = null\n    }\n  }\n\n  /**\n   * Runs start save point action.\n   * @param {string} savePointName - Save point name.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async _startSavePointAction(savePointName) {\n    await this.query(`SAVE TRANSACTION [${savePointName}]`)\n  }\n\n  /**\n   * Runs release save point action.\n   * @param {string} savePointName - Save point name.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async _releaseSavePointAction(savePointName) { // eslint-disable-line no-unused-vars\n    // Do nothing in MS-SQL.\n  }\n\n  /**\n   * Runs rollback save point action.\n   * @param {string} savePointName - Save point name.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async _rollbackSavePointAction(savePointName) {\n    try {\n      await this.query(`ROLLBACK TRANSACTION [${savePointName}]`)\n    } catch (error) {\n      const message = error instanceof Error ? error.message : `${error}`\n\n      // When XACT_ABORT kills the entire transaction, the savepoint\n      // no longer exists and the ROLLBACK TRANSACTION [name] fails.\n      // Issue a raw IF @@TRANCOUNT > 0 ROLLBACK to clear whatever\n      // session state remains, then let the error propagate so the\n      // outer transaction() call knows the transaction is dead.\n      if (message.includes(\"Transaction has not begun\") || message.includes(\"Transaction has been aborted\")) {\n        this.logger.debug(\"Savepoint rollback failed; transaction already dead, clearing session state\")\n\n        const request = new mssql.Request(this.connection)\n\n        await request.query(\"IF @@TRANCOUNT > 0 ROLLBACK\")\n\n        return\n      }\n\n      throw error\n    }\n  }\n\n  generateSavePointName() {\n    return `sp${new UUID(4).format().replaceAll(\"-\", \"\")}`.substring(0, 32)\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   * 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   * Blocks until a SQL Server application lock is acquired on this\n   * connection via `sp_getapplock`. The Session lock owner scopes the lock\n   * to the current session, matching the connection-scoped semantics on\n   * MySQL and PostgreSQL.\n   *\n   * `sp_getapplock` returns 0 on immediate grant, 1 after waiting, and\n   * negative values on failure (timeout, deadlock, canceled, parameter\n   * error). We treat 0/1 as success and -1 (timeout) as a clean `false`;\n   * anything else throws.\n   * @param {string} name - Lock name.\n   * @param {{timeoutMs?: number | null}} [args] - Optional timeout in milliseconds; `null`, `undefined`, or negative blocks forever.\n   * @returns {Promise<boolean>} - True if the lock was acquired, false if the timeout elapsed.\n   */\n  async acquireAdvisoryLock(name, {timeoutMs} = {}) {\n    const timeoutValue = typeof timeoutMs === \"number\" && timeoutMs >= 0 ? Math.ceil(timeoutMs) : -1\n    const rows = await this.query(\n      `DECLARE @velocious_advisory_lock_result INT; EXEC @velocious_advisory_lock_result = sp_getapplock @Resource = ${this.quote(name)}, @LockMode = 'Exclusive', @LockOwner = 'Session', @LockTimeout = ${timeoutValue}; SELECT @velocious_advisory_lock_result AS velocious_advisory_lock_result`\n    )\n    const result = Number(rows?.[0]?.velocious_advisory_lock_result)\n\n    if (result === 0 || result === 1) return true\n    if (result === -1) return false\n\n    throw new Error(`sp_getapplock returned ${result} for advisory lock ${JSON.stringify(name)} (see SQL Server documentation for sp_getapplock return codes)`)\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    return await this.acquireAdvisoryLock(name, {timeoutMs: 0})\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(\n      `DECLARE @velocious_advisory_lock_result INT; EXEC @velocious_advisory_lock_result = sp_releaseapplock @Resource = ${this.quote(name)}, @LockOwner = 'Session'; SELECT @velocious_advisory_lock_result AS velocious_advisory_lock_result`\n    )\n    const result = Number(rows?.[0]?.velocious_advisory_lock_result)\n\n    return result === 0\n  }\n\n  /**\n   * Returns true if any session currently holds the application lock.\n   *\n   * This combines two probes because neither is sufficient on its own:\n   *   - `APPLOCK_MODE(..., 'Session')` only reports locks held by the\n   *     **current** session, so it misses locks held by any other\n   *     session and would return `NoLock` even under cross-session\n   *     contention.\n   *   - `APPLOCK_TEST(..., 'Exclusive', 'Session')` returns whether an\n   *     Exclusive lock could be granted to *this* session right now. A\n   *     return value of 0 means somebody else holds an incompatible\n   *     lock; a value of 1 means it is either free **or** already held\n   *     by us re-entrantly (which the `APPLOCK_MODE` check catches).\n   *\n   * The combined result is \"held\" iff we hold it ourselves or\n   * `APPLOCK_TEST` reports we cannot acquire it without waiting.\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(\n      `SELECT ` +\n        `APPLOCK_MODE('public', ${this.quote(name)}, 'Session') AS velocious_advisory_self_mode, ` +\n        `APPLOCK_TEST('public', ${this.quote(name)}, 'Exclusive', 'Session') AS velocious_advisory_test_result`\n    )\n    const selfMode = rows?.[0]?.velocious_advisory_self_mode\n    const heldBySelf = typeof selfMode === \"string\" && selfMode.length > 0 && selfMode !== \"NoLock\"\n\n    if (heldBySelf) return true\n\n    const testResult = Number(rows?.[0]?.velocious_advisory_test_result)\n\n    return testResult === 0\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../src/database/drivers/mssql/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 DropDatabase from \"./sql/drop-database.js\"\nimport DropTable from \"./sql/drop-table.js\"\nimport {digg} from \"diggerize\"\nimport escapeString from \"sql-escape-string\"\nimport Insert from \"./sql/insert.js\"\nimport Options from \"./options.js\"\nimport mssql from \"mssql\"\nimport net from \"node:net\"\nimport QueryParser from \"./query-parser.js\"\nimport RemoveIndex from \"./sql/remove-index.js\"\nimport Table from \"./table.js\"\nimport StructureSql from \"./structure-sql.js\"\nimport timeout from \"awaitery/build/timeout.js\"\nimport Upsert from \"./sql/upsert.js\"\nimport Update from \"./sql/update.js\"\nimport UUID from \"pure-uuid\"\n\nexport default class VelociousDatabaseDriversMssql extends Base{\n  async connect() {\n    const args = this.getArgs()\n    const sqlConfig = digg(args, \"sqlConfig\")\n\n    try {\n      if (this.connection) await this.close()\n\n      if (sqlConfig) {\n        sqlConfig.options = Object.assign({}, sqlConfig.options, {useUTC: true})\n      }\n\n      if (sqlConfig?.server && !sqlConfig.options?.serverName && net.isIP(sqlConfig.server)) {\n        sqlConfig.options = Object.assign({}, sqlConfig.options, {serverName: \"\"})\n      }\n\n      this.connection = new mssql.ConnectionPool(sqlConfig)\n      await this.connection.connect()\n    } catch (error) {\n      // Re-throw to fix unuseable stack trace.\n      throw new Error(`Couldn't connect to database: ${error instanceof Error ? error.message : error}`, {cause: error})\n    }\n  }\n\n  async close() {\n    if (!this.connection) return\n\n    const connection = this.connection\n    this.connection = undefined\n    this._currentTransaction = null\n    this._transactionsCount = 0\n\n    try {\n      await timeout({timeout: 2000}, () => connection.close())\n    } catch (error) {\n      this.logger.warn(\"Failed to close MSSQL connection cleanly\", {error})\n    }\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, indexInCreateTable: false}\n    const createTable = new CreateTable(createArgs)\n\n    return await 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 DB_NAME() AS db_name\")\n\n    return digg(rows, 0, \"db_name\")\n  }\n\n  /**\n   * Disables every foreign key constraint (bulk `NOCHECK`).\n   * @returns {Promise<void>} - Resolves when foreign keys are disabled.\n   */\n  async disableForeignKeys() {\n    await this._execConstraintToggle(\"EXEC sp_MSforeachtable \\\"ALTER TABLE ? NOCHECK CONSTRAINT all\\\"\", \"disableForeignKeys\")\n  }\n\n  /**\n   * Re-enables and re-validates every foreign key constraint (`WITH CHECK`).\n   * @returns {Promise<void>} - Resolves when foreign keys are enabled.\n   */\n  async enableForeignKeys() {\n    await this._execConstraintToggle(\"EXEC sp_MSforeachtable @command1=\\\"print '?'\\\", @command2=\\\"ALTER TABLE ? WITH CHECK CHECK CONSTRAINT all\\\"\", \"enableForeignKeys\")\n  }\n\n  /**\n   * Runs a bulk constraint-toggle statement. `ALTER TABLE ... NOCHECK/CHECK\n   * CONSTRAINT` needs a schema-modification lock on every table, so if the\n   * request times out it is almost always blocked by another session that is\n   * still holding a lock (a leaked/uncommitted connection). On a timeout,\n   * capture which sessions were blocking so the real culprit is named instead\n   * of leaving a bare \"Request failed to complete in 15000ms\".\n   * @param {string} sql - Constraint-toggle SQL.\n   * @param {string} label - Operation label for the error.\n   * @returns {Promise<void>} - Resolves when the toggle completes.\n   */\n  async _execConstraintToggle(sql, label) {\n    try {\n      await this.query(sql)\n    } catch (error) {\n      if (error instanceof Error && /Timeout: Request failed to complete/i.test(error.message)) {\n        const snapshot = await this._captureBlockingSessionsForDebug().catch(\n          (diagError) => `(blocking diagnostics query failed: ${diagError instanceof Error ? diagError.message : diagError})`\n        )\n\n        throw new Error(`${error.message}\\n\\n[${label} blocked] other user sessions with open transactions or active requests:\\n${snapshot}`, {cause: error})\n      }\n\n      throw error\n    }\n  }\n\n  /**\n   * Snapshots the sessions that could be blocking a constraint toggle in THIS\n   * database — every session other than this one that holds a lock in `DB_ID()`\n   * or is running a request against it — with its last statement, wait state,\n   * and blocking session, enough to identify a connection that leaked a lock.\n   * Scoped to the current database so a multi-database server does not leak\n   * unrelated sessions' SQL into the error and bury the real blocker.\n   * @returns {Promise<string>} - JSON snapshot, or a \"(none)\" marker.\n   */\n  async _captureBlockingSessionsForDebug() {\n    const rows = await this.query(`\n      WITH lock_sessions AS (\n        SELECT DISTINCT request_session_id AS session_id\n        FROM sys.dm_tran_locks\n        WHERE resource_database_id = DB_ID()\n      )\n      SELECT\n        s.session_id AS sessionId,\n        s.status AS sessionStatus,\n        s.login_time AS loginTime,\n        s.last_request_start_time AS lastRequestStart,\n        s.last_request_end_time AS lastRequestEnd,\n        s.open_transaction_count AS openTransactionCount,\n        r.status AS requestStatus,\n        r.command AS command,\n        r.wait_type AS waitType,\n        r.wait_time AS waitTimeMs,\n        r.blocking_session_id AS blockingSessionId,\n        CAST(ib.event_info AS NVARCHAR(MAX)) AS lastSql\n      FROM sys.dm_exec_sessions s\n      LEFT JOIN sys.dm_exec_requests r ON r.session_id = s.session_id\n      OUTER APPLY sys.dm_exec_input_buffer(s.session_id, NULL) ib\n      WHERE s.is_user_process = 1\n        AND s.session_id <> @@SPID\n        AND (s.session_id IN (SELECT session_id FROM lock_sessions) OR r.database_id = DB_ID())\n    `)\n\n    if (rows.length === 0) return \"(none — no other session held a lock or ran a request in this database when queried)\"\n\n    return JSON.stringify(rows, null, 2)\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   * Drops the foreign key constraints that reference the given table. MSSQL\n   * refuses to drop a table that is still referenced by a FOREIGN KEY\n   * constraint even when constraints are disabled via NOCHECK, so the\n   * referencing constraints must be removed before the table can be dropped.\n   * This lets callers drop tables in any order (e.g. wiping a whole schema)\n   * without first dropping every dependent table.\n   * @param {string} tableName - Table name.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async _dropReferencingForeignKeys(tableName) {\n    const rows = await this.query(\n      \"SELECT fk.name AS constraint_name, OBJECT_NAME(fk.parent_object_id) AS parent_table \" +\n      `FROM sys.foreign_keys fk WHERE fk.referenced_object_id = OBJECT_ID(${this.quote(tableName)})`\n    )\n\n    for (const row of rows) {\n      const constraintName = row.constraint_name ?? row.CONSTRAINT_NAME\n      const parentTable = row.parent_table ?? row.PARENT_TABLE\n\n      await this.query(`ALTER TABLE [${parentTable}] DROP CONSTRAINT [${constraintName}]`)\n    }\n  }\n\n  /**\n   * Runs drop table.\n   * @param {string} tableName - Table name.\n   * @param {import(\"../base.js\").DropTableSqlArgsType} [args] - Options object.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async dropTable(tableName, args = {}) {\n    this._assertNotReadOnly()\n    await this._dropReferencingForeignKeys(tableName)\n\n    const sqls = await this.dropTableSQLs(tableName, args)\n\n    for (const sql of sqls) {\n      await this.query(sql)\n    }\n  }\n\n  /**\n   * Runs get type.\n   * @returns {string} - The type.\n   */\n  getType() { return \"mssql\" }\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    let result\n    let tries = 0\n\n    while (true) {\n      tries++\n\n      try {\n        const request = this._currentTransaction\n          ? new mssql.Request(this._currentTransaction)\n          : new mssql.Request(this.connection)\n        result = await request.query(sql)\n        break\n      } catch (error) {\n        if (error instanceof Error && error.message == \"No connection is specified for that request.\" && tries <= 3) {\n          this.logger.warn(\"Reconnecting to database\")\n          await this.reconnect()\n          // Retry\n        } else if (error instanceof Error) {\n          // Re-throw error because the stack-trace is broken and can't be used for app-development.\n          throw new Error(`Query failed '${error.message}': ${sql}`, {cause: error})\n        } else {\n          throw new Error(`Query failed '${error}': ${sql}`, {cause: error})\n        }\n      }\n    }\n\n    return Array.isArray(result.recordsets) ? result.recordsets[0] || [] : []\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  shouldSetAutoIncrementWhenPrimaryKey() { return true }\n  supportsDefaultPrimaryKeyUUID() { return true }\n\n  /**\n   * Runs escape.\n   * @param {?} value - Value to use.\n   * @returns {string} - The escape.\n   */\n  escape(value) {\n    value = this._convertValue(value)\n    const stringValue = typeof value == \"string\" ? value : `${value}`\n\n    const resultWithQuotes = escapeString(stringValue, null)\n    const result = resultWithQuotes.substring(1, resultWithQuotes.length - 1)\n\n    return result\n  }\n\n  /**\n   * Runs quote.\n   * @param {?} value - Value to use.\n   * @returns {string | number} - The quoted value.\n   */\n  quote(value) {\n    value = this._convertValue(value)\n\n    if (typeof value == \"number\") return value\n    const stringValue = typeof value == \"string\" ? value : String(value)\n\n    return `N${escapeString(stringValue, null)}`\n  }\n\n  /**\n   * Runs quote column.\n   * @param {string} columnName - Column name.\n   * @returns {string} - The quote column.\n   */\n  quoteColumn(columnName) { return this.options().quoteColumnName(columnName) }\n\n  /**\n   * Runs quote table.\n   * @param {string} string - String.\n   * @returns {string} - The quote table.\n   */\n  quoteTable(string) { return this.options().quoteTableName(string) }\n\n  /**\n   * Runs rename column.\n   * @param {string} tableName - Table name.\n   * @param {string} oldColumnName - Previous column name.\n   * @param {string} newColumnName - New column name.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async renameColumn(tableName, oldColumnName, newColumnName) {\n    await this.query(`EXEC sp_rename ${this.quote(`${tableName}.${oldColumnName}`)}, ${this.quote(newColumnName)}, 'COLUMN'`)\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 schema = this.getArgs()?.schema || this.getArgs()?.sqlConfig?.options?.schema\n      const schemaClause = schema\n        ? ` AND [TABLE_SCHEMA] = ${this.quote(schema)}`\n        : \" AND [TABLE_SCHEMA] = SCHEMA_NAME()\"\n      const result = await this.query(`SELECT [TABLE_NAME] FROM [INFORMATION_SCHEMA].[TABLES] WHERE [TABLE_CATALOG] = DB_NAME()${schemaClause}`)\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  async lastInsertID() {\n    const result = await this.query(\"SELECT SCOPE_IDENTITY() AS last_insert_id\")\n    const lastInsertID = digg(result, 0, \"last_insert_id\")\n\n    if (lastInsertID === null) throw new Error(\"Couldn't get the last inserted ID\")\n\n    return lastInsertID\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  async _startTransactionAction() {\n    if (this._currentTransaction) throw new Error(\"A transaction is already running\")\n    if (!this.connection) await this.connect()\n\n    this._currentTransaction = new mssql.Transaction(this.connection)\n\n    try {\n      await this._currentTransaction.begin()\n    } catch (error) {\n      this._currentTransaction = null\n      throw error\n    }\n  }\n\n  async _commitTransactionAction() {\n    if (!this._currentTransaction) throw new Error(\"A transaction isn't running\")\n\n    await this._currentTransaction.commit()\n    this._currentTransaction = null\n  }\n\n  async _rollbackTransactionAction() {\n    if (!this._currentTransaction) {\n      this.logger.debug(\"A transaction isn't running - ignoring because that can happen if something else has failed in the db\")\n      return\n    }\n\n    try {\n      await this._currentTransaction.rollback()\n    } catch (transactionRollbackError) {\n      // When SQL Server has already aborted the transaction (e.g., a\n      // stale concurrent request triggered XACT_ABORT), the\n      // mssql.Transaction.rollback() call fails because the\n      // Transaction object is dead.  Issue a raw ROLLBACK on the\n      // underlying connection to clear SQL Server's session-level\n      // aborted-transaction state so the connection is usable for the\n      // next BEGIN TRANSACTION.\n      this.logger.warn(\"Transaction.rollback() failed, clearing session state with raw ROLLBACK\", {\n        error: transactionRollbackError instanceof Error ? transactionRollbackError.message : transactionRollbackError\n      })\n\n      const request = new mssql.Request(this.connection)\n\n      await request.query(\"IF @@TRANCOUNT > 0 ROLLBACK\")\n    } finally {\n      this._currentTransaction = null\n    }\n  }\n\n  /**\n   * Runs start save point action.\n   * @param {string} savePointName - Save point name.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async _startSavePointAction(savePointName) {\n    await this.query(`SAVE TRANSACTION [${savePointName}]`)\n  }\n\n  /**\n   * Runs release save point action.\n   * @param {string} savePointName - Save point name.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async _releaseSavePointAction(savePointName) { // eslint-disable-line no-unused-vars\n    // Do nothing in MS-SQL.\n  }\n\n  /**\n   * Runs rollback save point action.\n   * @param {string} savePointName - Save point name.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async _rollbackSavePointAction(savePointName) {\n    try {\n      await this.query(`ROLLBACK TRANSACTION [${savePointName}]`)\n    } catch (error) {\n      const message = error instanceof Error ? error.message : `${error}`\n\n      // When XACT_ABORT kills the entire transaction, the savepoint\n      // no longer exists and the ROLLBACK TRANSACTION [name] fails.\n      // Issue a raw IF @@TRANCOUNT > 0 ROLLBACK to clear whatever\n      // session state remains, then let the error propagate so the\n      // outer transaction() call knows the transaction is dead.\n      if (message.includes(\"Transaction has not begun\") || message.includes(\"Transaction has been aborted\")) {\n        this.logger.debug(\"Savepoint rollback failed; transaction already dead, clearing session state\")\n\n        const request = new mssql.Request(this.connection)\n\n        await request.query(\"IF @@TRANCOUNT > 0 ROLLBACK\")\n\n        return\n      }\n\n      throw error\n    }\n  }\n\n  generateSavePointName() {\n    return `sp${new UUID(4).format().replaceAll(\"-\", \"\")}`.substring(0, 32)\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   * 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   * Blocks until a SQL Server application lock is acquired on this\n   * connection via `sp_getapplock`. The Session lock owner scopes the lock\n   * to the current session, matching the connection-scoped semantics on\n   * MySQL and PostgreSQL.\n   *\n   * `sp_getapplock` returns 0 on immediate grant, 1 after waiting, and\n   * negative values on failure (timeout, deadlock, canceled, parameter\n   * error). We treat 0/1 as success and -1 (timeout) as a clean `false`;\n   * anything else throws.\n   * @param {string} name - Lock name.\n   * @param {{timeoutMs?: number | null}} [args] - Optional timeout in milliseconds; `null`, `undefined`, or negative blocks forever.\n   * @returns {Promise<boolean>} - True if the lock was acquired, false if the timeout elapsed.\n   */\n  async acquireAdvisoryLock(name, {timeoutMs} = {}) {\n    const timeoutValue = typeof timeoutMs === \"number\" && timeoutMs >= 0 ? Math.ceil(timeoutMs) : -1\n    const rows = await this.query(\n      `DECLARE @velocious_advisory_lock_result INT; EXEC @velocious_advisory_lock_result = sp_getapplock @Resource = ${this.quote(name)}, @LockMode = 'Exclusive', @LockOwner = 'Session', @LockTimeout = ${timeoutValue}; SELECT @velocious_advisory_lock_result AS velocious_advisory_lock_result`\n    )\n    const result = Number(rows?.[0]?.velocious_advisory_lock_result)\n\n    if (result === 0 || result === 1) return true\n    if (result === -1) return false\n\n    throw new Error(`sp_getapplock returned ${result} for advisory lock ${JSON.stringify(name)} (see SQL Server documentation for sp_getapplock return codes)`)\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    return await this.acquireAdvisoryLock(name, {timeoutMs: 0})\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(\n      `DECLARE @velocious_advisory_lock_result INT; EXEC @velocious_advisory_lock_result = sp_releaseapplock @Resource = ${this.quote(name)}, @LockOwner = 'Session'; SELECT @velocious_advisory_lock_result AS velocious_advisory_lock_result`\n    )\n    const result = Number(rows?.[0]?.velocious_advisory_lock_result)\n\n    return result === 0\n  }\n\n  /**\n   * Returns true if any session currently holds the application lock.\n   *\n   * This combines two probes because neither is sufficient on its own:\n   *   - `APPLOCK_MODE(..., 'Session')` only reports locks held by the\n   *     **current** session, so it misses locks held by any other\n   *     session and would return `NoLock` even under cross-session\n   *     contention.\n   *   - `APPLOCK_TEST(..., 'Exclusive', 'Session')` returns whether an\n   *     Exclusive lock could be granted to *this* session right now. A\n   *     return value of 0 means somebody else holds an incompatible\n   *     lock; a value of 1 means it is either free **or** already held\n   *     by us re-entrantly (which the `APPLOCK_MODE` check catches).\n   *\n   * The combined result is \"held\" iff we hold it ourselves or\n   * `APPLOCK_TEST` reports we cannot acquire it without waiting.\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(\n      `SELECT ` +\n        `APPLOCK_MODE('public', ${this.quote(name)}, 'Session') AS velocious_advisory_self_mode, ` +\n        `APPLOCK_TEST('public', ${this.quote(name)}, 'Exclusive', 'Session') AS velocious_advisory_test_result`\n    )\n    const selfMode = rows?.[0]?.velocious_advisory_self_mode\n    const heldBySelf = typeof selfMode === \"string\" && selfMode.length > 0 && selfMode !== \"NoLock\"\n\n    if (heldBySelf) return true\n\n    const testResult = Number(rows?.[0]?.velocious_advisory_test_result)\n\n    return testResult === 0\n  }\n}\n"]}

package/build/src/database/tenants/data-copier.d.ts

@@ -56,6 +56,22 @@ export default class DataCopier {
      * @returns {Promise<Map<string, Record<string, unknown>[]>>}
      */
     copy(keyValue: string): Promise<Map<string, Record<string, unknown>[]>>;
+    /**
+     * Deletes one tenant's rows from the target database, children before parents, with
+     * foreign keys disabled inside a single transaction. This is `copy` without the reinsert:
+     * the same plan traversal selects the tenant's current target rows and `deleteTargetRows`
+     * removes them children-first so the ordering never trips a foreign key. Multi-tenant apps
+     * use it to purge a tenant — for example clearing the tenant's master copy in the
+     * global/default database on teardown, so foreign keys stop referencing the tenant's
+     * about-to-be-removed root row.
+     *
+     * Returns the deleted rows keyed by table name so the caller can perform any app-specific
+     * post-delete work (record-location cleanup, auditing) without that policy leaking into the
+     * framework.
+     * @param {string} keyValue - Tenant key whose rows should be removed from the target.
+     * @returns {Promise<Map<string, Record<string, unknown>[]>>} - The deleted rows by table name.
+     */
+    deleteTenantRows(keyValue: string): Promise<Map<string, Record<string, unknown>[]>>;
     /**
      * Loads the rows for `keyValue` for every table in the plan from `db`, resolving
      * parent-scoped tables from the ids already selected for their parent table. Used for

package/build/src/database/tenants/data-copier.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"data-copier.d.ts","sourceRoot":"","sources":["../../../../src/database/tenants/data-copier.js"],"names":[],"mappings":"AA+BA;;;;;;;;;;;;;;;;;;;GAmBG;AACH;IACE;;;;;;;;;;;OAWG;IACH,sGAVW;QACN,QAAQ,EAAE,OAAO,oBAAoB,EAAE,OAAO,CAAC;QAC/C,QAAQ,EAAE,OAAO,oBAAoB,EAAE,OAAO,CAAC;QAC/C,SAAS,EAAE,OAAO,wBAAwB,EAAE,oBAAoB,EAAE,CAAC;QACnE,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,eAAe,CAAC,EAAE,MAAM,CAAC;QACzB,cAAc,CAAC,EAAE,MAAM,CAAC;QACxB,UAAU,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAA;KACvC,EAUH;IAPC,+CAAwB;IACxB,+CAAwB;IACxB,mEAA0B;IAC1B,iBAAwB;IACxB,wBAAsC;IACtC,uBAAoC;IACpC,uBAV0B,MAAM,KAAK,IAAI,cAUb;IAG9B;;;;;;;OAOG;IACH,eAHW,MAAM,GACJ,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC,CAAC,CAc3D;IAED;;;;;;;OAOG;IACH,aAJW,OAAO,oBAAoB,EAAE,OAAO,YACpC,MAAM,GACJ,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC,CAAC,CA4C3D;IAED;;;;OAIG;IACH,yDAHW;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,EAAE,EAAE,OAAO,oBAAoB,EAAE,OAAO,CAAC;QAAC,SAAS,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,EAAE,CAAA;KAAC,GACjG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC,CAoB9C;IAED;;;;;OAKG;IACH,kCAHW,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC,GACpC,OAAO,CAAC,IAAI,CAAC,CAoBzB;IAED;;;;;OAKG;IACH,kCAHW,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC,GACpC,OAAO,CAAC,IAAI,CAAC,CAwBzB;IAED;;;;;OAKG;IACH,oBAJW,OAAO,oBAAoB,EAAE,OAAO,UACpC,MAAM,EAAE,GACN,MAAM,CAIlB;IAED;;;;;OAKG;IACH,sBAJW,OAAO,oBAAoB,EAAE,OAAO,OACpC,MAAM,GACJ,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC,CAI9C;IAED;;;;OAIG;IACH,oDAHW;QAAC,OAAO,EAAE,MAAM,EAAE,CAAC;QAAC,EAAE,EAAE,OAAO,oBAAoB,EAAE,OAAO,CAAC;QAAC,IAAI,EAAE,KAAK,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAC,GAC3G,OAAO,CAAC,IAAI,CAAC,CAIzB;IAED;;;;OAIG;IACH,wBAHW,MAAM,GACJ,IAAI,CAMhB;CACF"}
+{"version":3,"file":"data-copier.d.ts","sourceRoot":"","sources":["../../../../src/database/tenants/data-copier.js"],"names":[],"mappings":"AA+BA;;;;;;;;;;;;;;;;;;;GAmBG;AACH;IACE;;;;;;;;;;;OAWG;IACH,sGAVW;QACN,QAAQ,EAAE,OAAO,oBAAoB,EAAE,OAAO,CAAC;QAC/C,QAAQ,EAAE,OAAO,oBAAoB,EAAE,OAAO,CAAC;QAC/C,SAAS,EAAE,OAAO,wBAAwB,EAAE,oBAAoB,EAAE,CAAC;QACnE,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,eAAe,CAAC,EAAE,MAAM,CAAC;QACzB,cAAc,CAAC,EAAE,MAAM,CAAC;QACxB,UAAU,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAA;KACvC,EAUH;IAPC,+CAAwB;IACxB,+CAAwB;IACxB,mEAA0B;IAC1B,iBAAwB;IACxB,wBAAsC;IACtC,uBAAoC;IACpC,uBAV0B,MAAM,KAAK,IAAI,cAUb;IAG9B;;;;;;;OAOG;IACH,eAHW,MAAM,GACJ,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC,CAAC,CAc3D;IAED;;;;;;;;;;;;;;OAcG;IACH,2BAHW,MAAM,GACJ,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC,CAAC,CAY3D;IAED;;;;;;;OAOG;IACH,aAJW,OAAO,oBAAoB,EAAE,OAAO,YACpC,MAAM,GACJ,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC,CAAC,CA4C3D;IAED;;;;OAIG;IACH,yDAHW;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,EAAE,EAAE,OAAO,oBAAoB,EAAE,OAAO,CAAC;QAAC,SAAS,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,EAAE,CAAA;KAAC,GACjG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC,CAoB9C;IAED;;;;;OAKG;IACH,kCAHW,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC,GACpC,OAAO,CAAC,IAAI,CAAC,CAoBzB;IAED;;;;;OAKG;IACH,kCAHW,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC,GACpC,OAAO,CAAC,IAAI,CAAC,CAwBzB;IAED;;;;;OAKG;IACH,oBAJW,OAAO,oBAAoB,EAAE,OAAO,UACpC,MAAM,EAAE,GACN,MAAM,CAIlB;IAED;;;;;OAKG;IACH,sBAJW,OAAO,oBAAoB,EAAE,OAAO,OACpC,MAAM,GACJ,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC,CAI9C;IAED;;;;OAIG;IACH,oDAHW;QAAC,OAAO,EAAE,MAAM,EAAE,CAAC;QAAC,EAAE,EAAE,OAAO,oBAAoB,EAAE,OAAO,CAAC;QAAC,IAAI,EAAE,KAAK,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAC,GAC3G,OAAO,CAAC,IAAI,CAAC,CAIzB;IAED;;;;OAIG;IACH,wBAHW,MAAM,GACJ,IAAI,CAMhB;CACF"}

package/build/src/database/tenants/data-copier.js

@@ -84,6 +84,30 @@ export default class DataCopier {
         });
         return sourceRowsByTableName;
     }
+    /**
+     * Deletes one tenant's rows from the target database, children before parents, with
+     * foreign keys disabled inside a single transaction. This is `copy` without the reinsert:
+     * the same plan traversal selects the tenant's current target rows and `deleteTargetRows`
+     * removes them children-first so the ordering never trips a foreign key. Multi-tenant apps
+     * use it to purge a tenant — for example clearing the tenant's master copy in the
+     * global/default database on teardown, so foreign keys stop referencing the tenant's
+     * about-to-be-removed root row.
+     *
+     * Returns the deleted rows keyed by table name so the caller can perform any app-specific
+     * post-delete work (record-location cleanup, auditing) without that policy leaking into the
+     * framework.
+     * @param {string} keyValue - Tenant key whose rows should be removed from the target.
+     * @returns {Promise<Map<string, Record<string, unknown>[]>>} - The deleted rows by table name.
+     */
+    async deleteTenantRows(keyValue) {
+        const rowsByTableName = await this.loadRows(this.targetDb, keyValue);
+        await this.targetDb.withDisabledForeignKeys(async () => {
+            await this.targetDb.transaction(async () => {
+                await this.deleteTargetRows(rowsByTableName);
+            });
+        });
+        return rowsByTableName;
+    }
     /**
      * Loads the rows for `keyValue` for every table in the plan from `db`, resolving
      * parent-scoped tables from the ids already selected for their parent table. Used for
@@ -229,4 +253,4 @@ export default class DataCopier {
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"data-copier.js","sourceRoot":"","sources":["../../../../src/database/tenants/data-copier.js"],"names":[],"mappings":"AAAA,YAAY;AAEZ,MAAM,yBAAyB,GAAG,GAAG,CAAA;AACrC,MAAM,wBAAwB,GAAG,GAAG,CAAA;AAEpC;;;;;;GAMG;AACH,SAAS,MAAM,CAAC,MAAM,EAAE,SAAS;IAC/B,MAAM,aAAa,GAAG,EAAE,CAAA;IAExB,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,MAAM,CAAC,MAAM,EAAE,KAAK,IAAI,SAAS,EAAE,CAAC;QAC9D,aAAa,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,KAAK,EAAE,KAAK,GAAG,SAAS,CAAC,CAAC,CAAA;IAC5D,CAAC;IAED,OAAO,aAAa,CAAA;AACtB,CAAC;AAED;;;;GAIG;AACH,SAAS,aAAa,CAAC,MAAM;IAC3B,OAAO,KAAK,CAAC,IAAI,CAAC,IAAI,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,CAAA;AAClG,CAAC;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,CAAC,OAAO,OAAO,UAAU;IAC7B;;;;;;;;;;;OAWG;IACH,YAAY,EAAC,QAAQ,EAAE,QAAQ,EAAE,SAAS,EAAE,QAAQ,GAAG,IAAI,EAAE,eAAe,GAAG,yBAAyB,EAAE,cAAc,GAAG,wBAAwB,EAAE,UAAU,EAAC;QAC9J,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAA;QACxB,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAA;QACxB,IAAI,CAAC,SAAS,GAAG,SAAS,CAAA;QAC1B,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAA;QACxB,IAAI,CAAC,eAAe,GAAG,eAAe,CAAA;QACtC,IAAI,CAAC,cAAc,GAAG,cAAc,CAAA;QACpC,IAAI,CAAC,UAAU,GAAG,UAAU,CAAA;IAC9B,CAAC;IAED;;;;;;;OAOG;IACH,KAAK,CAAC,IAAI,CAAC,QAAQ;QACjB,MAAM,qBAAqB,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAA;QAC1E,MAAM,qBAAqB,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAA;QAE1E,MAAM,IAAI,CAAC,QAAQ,CAAC,uBAAuB,CAAC,KAAK,IAAI,EAAE;YACrD,MAAM,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,KAAK,IAAI,EAAE;gBACzC,MAAM,IAAI,CAAC,gBAAgB,CAAC,qBAAqB,CAAC,CAAA;gBAClD,MAAM,IAAI,CAAC,gBAAgB,CAAC,qBAAqB,CAAC,CAAA;YACpD,CAAC,CAAC,CAAA;QACJ,CAAC,CAAC,CAAA;QAEF,OAAO,qBAAqB,CAAA;IAC9B,CAAC;IAED;;;;;;;OAOG;IACH,KAAK,CAAC,QAAQ,CAAC,EAAE,EAAE,QAAQ;QACzB,oCAAoC;QACpC,MAAM,cAAc,GAAG,IAAI,GAAG,EAAE,CAAA;QAChC,qDAAqD;QACrD,MAAM,eAAe,GAAG,IAAI,GAAG,EAAE,CAAA;QAEjC,KAAK,MAAM,WAAW,IAAI,IAAI,CAAC,SAAS,EAAE,CAAC;YACzC,IAAI,IAAI,CAAA;YAER,IAAI,WAAW,CAAC,SAAS,EAAE,CAAC;gBAC1B,IAAI,GAAG,MAAM,IAAI,CAAC,iBAAiB,CAAC;oBAClC,UAAU,EAAE,WAAW,CAAC,SAAS;oBACjC,EAAE;oBACF,SAAS,EAAE,WAAW,CAAC,SAAS;oBAChC,MAAM,EAAE,CAAC,QAAQ,CAAC;iBACnB,CAAC,CAAA;YACJ,CAAC;iBAAM,CAAC;gBACN,IAAI,CAAC,WAAW,CAAC,YAAY,IAAI,CAAC,WAAW,CAAC,eAAe,EAAE,CAAC;oBAC9D,MAAM,IAAI,KAAK,CAAC,gEAAgE,WAAW,CAAC,SAAS,4BAA4B,CAAC,CAAA;gBACpI,CAAC;gBAED,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,WAAW,CAAC,eAAe,CAAC,EAAE,CAAC;oBACrD,MAAM,IAAI,KAAK,CAAC,2BAA2B,WAAW,CAAC,SAAS,4BAA4B,WAAW,CAAC,eAAe,2FAA2F,CAAC,CAAA;gBACrN,CAAC;gBAED,IAAI,GAAG,MAAM,IAAI,CAAC,iBAAiB,CAAC;oBAClC,UAAU,EAAE,WAAW,CAAC,YAAY;oBACpC,EAAE;oBACF,SAAS,EAAE,WAAW,CAAC,SAAS;oBAChC,MAAM,EAAE,cAAc,CAAC,GAAG,CAAC,WAAW,CAAC,eAAe,CAAC,IAAI,EAAE;iBAC9D,CAAC,CAAA;YACJ,CAAC;YAED,IAAI,IAAI,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;gBACpB,IAAI,CAAC,cAAc,CAAC,GAAG,WAAW,CAAC,SAAS,YAAY,IAAI,CAAC,MAAM,SAAS,CAAC,CAAA;YAC/E,CAAC;YAED,cAAc,CAAC,GAAG,CAAC,WAAW,CAAC,SAAS,EAAE,aAAa,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAA;YAC/F,eAAe,CAAC,GAAG,CAAC,WAAW,CAAC,SAAS,EAAE,IAAI,CAAC,CAAA;QAClD,CAAC;QAED,OAAO,eAAe,CAAA;IACxB,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,iBAAiB,CAAC,EAAC,UAAU,EAAE,EAAE,EAAE,SAAS,EAAE,MAAM,EAAC;QACzD,MAAM,gBAAgB,GAAG,aAAa,CAAC,MAAM,CAAC,CAAA;QAE9C,IAAI,gBAAgB,CAAC,MAAM,IAAI,CAAC,EAAE,CAAC;YACjC,OAAO,EAAE,CAAA;QACX,CAAC;QAED,MAAM,IAAI,GAAG,EAAE,CAAA;QACf,MAAM,WAAW,GAAG,EAAE,CAAC,UAAU,CAAC,SAAS,CAAC,CAAA;QAC5C,MAAM,YAAY,GAAG,EAAE,CAAC,WAAW,CAAC,UAAU,CAAC,CAAA;QAE/C,KAAK,MAAM,WAAW,IAAI,MAAM,CAAC,gBAAgB,EAAE,IAAI,CAAC,cAAc,CAAC,EAAE,CAAC;YACxE,MAAM,GAAG,GAAG,UAAU,WAAW,WAAW,WAAW,UAAU,YAAY,QAAQ,IAAI,CAAC,eAAe,CAAC,EAAE,EAAE,WAAW,CAAC,GAAG,CAAA;YAE7H,IAAI,CAAC,IAAI,CAAC,GAAG,MAAM,IAAI,CAAC,iBAAiB,CAAC,EAAE,EAAE,GAAG,CAAC,CAAC,CAAA;QACrD,CAAC;QAED,OAAO,IAAI,CAAA;IACb,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,gBAAgB,CAAC,eAAe;QACpC,KAAK,MAAM,WAAW,IAAI,CAAC,GAAG,IAAI,CAAC,SAAS,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC;YACxD,MAAM,MAAM,GAAG,aAAa,CAAC,CAAC,eAAe,CAAC,GAAG,CAAC,WAAW,CAAC,SAAS,CAAC,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAA;YAEjH,IAAI,MAAM,CAAC,MAAM,IAAI,CAAC,EAAE,CAAC;gBACvB,SAAQ;YACV,CAAC;YAED,MAAM,WAAW,GAAG,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,WAAW,CAAC,SAAS,CAAC,CAAA;YACnE,MAAM,cAAc,GAAG,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAA;YAE/D,KAAK,MAAM,WAAW,IAAI,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,cAAc,CAAC,EAAE,CAAC;gBAC9D,MAAM,IAAI,CAAC,iBAAiB,CAC1B,IAAI,CAAC,QAAQ,EACb,eAAe,WAAW,UAAU,cAAc,QAAQ,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,QAAQ,EAAE,WAAW,CAAC,GAAG,CAC9G,CAAA;YACH,CAAC;QACH,CAAC;IACH,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,gBAAgB,CAAC,eAAe;QACpC,KAAK,MAAM,WAAW,IAAI,IAAI,CAAC,SAAS,EAAE,CAAC;YACzC,MAAM,IAAI,GAAG,eAAe,CAAC,GAAG,CAAC,WAAW,CAAC,SAAS,CAAC,IAAI,EAAE,CAAA;YAE7D,IAAI,IAAI,CAAC,MAAM,IAAI,CAAC,EAAE,CAAC;gBACrB,SAAQ;YACV,CAAC;YAED,MAAM,OAAO,GAAG,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAA;YACpC,MAAM,YAAY,GAAG,MAAM,CAAC,IAAI,EAAE,IAAI,CAAC,eAAe,CAAC,CAAA;YAEvD,IAAI,CAAC,cAAc,CAAC,GAAG,WAAW,CAAC,SAAS,eAAe,IAAI,CAAC,MAAM,cAAc,YAAY,CAAC,MAAM,WAAW,CAAC,CAAA;YAEnH,KAAK,MAAM,SAAS,IAAI,YAAY,EAAE,CAAC;gBACrC,MAAM,IAAI,CAAC,iBAAiB,CAAC;oBAC3B,OAAO;oBACP,EAAE,EAAE,IAAI,CAAC,QAAQ;oBACjB,IAAI,EAAE,SAAS,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC;oBAClE,SAAS,EAAE,WAAW,CAAC,SAAS;iBACjC,CAAC,CAAA;YACJ,CAAC;QACH,CAAC;IACH,CAAC;IAED;;;;;OAKG;IACH,eAAe,CAAC,EAAE,EAAE,MAAM;QACxB,OAAO,MAAM,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;IAC1D,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,iBAAiB,CAAC,EAAE,EAAE,GAAG;QAC7B,OAAO,MAAM,EAAE,CAAC,KAAK,CAAC,GAAG,EAAE,EAAC,QAAQ,EAAE,KAAK,EAAC,CAAC,CAAA;IAC/C,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,iBAAiB,CAAC,EAAC,OAAO,EAAE,EAAE,EAAE,IAAI,EAAE,SAAS,EAAC;QACpD,MAAM,IAAI,CAAC,iBAAiB,CAAC,EAAE,EAAE,EAAE,CAAC,SAAS,CAAC,EAAC,OAAO,EAAE,SAAS,EAAE,IAAI,EAAC,CAAC,CAAC,CAAA;IAC5E,CAAC;IAED;;;;OAIG;IACH,cAAc,CAAC,OAAO;QACpB,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC;YACpB,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,CAAA;QAC1B,CAAC;IACH,CAAC;CACF","sourcesContent":["// @ts-check\n\nconst DEFAULT_INSERT_CHUNK_SIZE = 100\nconst DEFAULT_QUERY_CHUNK_SIZE = 500\n\n/**\n * Splits an array into chunks of at most `chunkSize` items.\n * @template T\n * @param {T[]} values\n * @param {number} chunkSize\n * @returns {T[][]}\n */\nfunction chunks(values, chunkSize) {\n  const chunkedValues = []\n\n  for (let index = 0; index < values.length; index += chunkSize) {\n    chunkedValues.push(values.slice(index, index + chunkSize))\n  }\n\n  return chunkedValues\n}\n\n/**\n * Stringifies values and returns the distinct, non-blank ones, preserving first-seen order.\n * @param {unknown[]} values\n * @returns {string[]}\n */\nfunction uniqueStrings(values) {\n  return Array.from(new Set(values.map((value) => String(value)).filter((value) => value.trim())))\n}\n\n/**\n * Copies a single tenant's rows from a source database into a target database, following a\n * table plan that partitions each table either by a direct tenant key column or by\n * parent-id traversal. This is the row-level counterpart to schema cloning: multi-tenant\n * apps that keep each tenant's data in its own database use it to (re)materialise the\n * tenant's rows from a global/template database.\n *\n * The copy is delete-then-reinsert and therefore idempotent, and it mirrors the source\n * snapshot: the rows to delete are the tenant's *current* rows in the target (selected with\n * the same plan traversal run against the target), so a row that was removed from the source\n * since the last copy is dropped from the target too rather than lingering. The deletes run\n * children first and the source inserts parents first, all inside one target transaction with\n * foreign-key enforcement disabled so the ordering never trips a constraint. Reads, deletes\n * and inserts are chunked to bound statement size.\n *\n * The copier is policy-free: the caller supplies the plan, the source/target databases and\n * the tenant key, and {@link DataCopier#copy} returns the loaded rows keyed by table name so\n * the caller can perform any app-specific post-copy work (for example registering record\n * locations) without that policy leaking into the framework.\n */\nexport default class DataCopier {\n  /**\n   * Creates a copier that moves tenant-owned rows from `sourceDb` into `targetDb`.\n   * @param {{\n   *   sourceDb: import(\"../drivers/base.js\").default,\n   *   targetDb: import(\"../drivers/base.js\").default,\n   *   tablePlan: import(\"./tenant-table-plan.js\").TenantTablePlanEntry[],\n   *   idColumn?: string,\n   *   insertChunkSize?: number,\n   *   queryChunkSize?: number,\n   *   onProgress?: (message: string) => void\n   * }} args\n   */\n  constructor({sourceDb, targetDb, tablePlan, idColumn = \"id\", insertChunkSize = DEFAULT_INSERT_CHUNK_SIZE, queryChunkSize = DEFAULT_QUERY_CHUNK_SIZE, onProgress}) {\n    this.sourceDb = sourceDb\n    this.targetDb = targetDb\n    this.tablePlan = tablePlan\n    this.idColumn = idColumn\n    this.insertChunkSize = insertChunkSize\n    this.queryChunkSize = queryChunkSize\n    this.onProgress = onProgress\n  }\n\n  /**\n   * Copies every plan table's rows for `keyValue` from the source into the target and\n   * returns the copied source rows keyed by table name. The target's current tenant rows\n   * are deleted (children first) and the source rows inserted (parents first) in a single\n   * target transaction with foreign keys disabled.\n   * @param {string} keyValue\n   * @returns {Promise<Map<string, Record<string, unknown>[]>>}\n   */\n  async copy(keyValue) {\n    const sourceRowsByTableName = await this.loadRows(this.sourceDb, keyValue)\n    const targetRowsByTableName = await this.loadRows(this.targetDb, keyValue)\n\n    await this.targetDb.withDisabledForeignKeys(async () => {\n      await this.targetDb.transaction(async () => {\n        await this.deleteTargetRows(targetRowsByTableName)\n        await this.insertTargetRows(sourceRowsByTableName)\n      })\n    })\n\n    return sourceRowsByTableName\n  }\n\n  /**\n   * Loads the rows for `keyValue` for every table in the plan from `db`, resolving\n   * parent-scoped tables from the ids already selected for their parent table. Used for\n   * both the source rows to copy and the target's current tenant rows to delete.\n   * @param {import(\"../drivers/base.js\").default} db\n   * @param {string} keyValue\n   * @returns {Promise<Map<string, Record<string, unknown>[]>>}\n   */\n  async loadRows(db, keyValue) {\n    /** @type {Map<string, string[]>} */\n    const idsByTableName = new Map()\n    /** @type {Map<string, Record<string, unknown>[]>} */\n    const rowsByTableName = new Map()\n\n    for (const tableConfig of this.tablePlan) {\n      let rows\n\n      if (tableConfig.keyColumn) {\n        rows = await this.queryRowsByColumn({\n          columnName: tableConfig.keyColumn,\n          db,\n          tableName: tableConfig.tableName,\n          values: [keyValue]\n        })\n      } else {\n        if (!tableConfig.parentColumn || !tableConfig.parentTableName) {\n          throw new Error(`Expected keyColumn or parentTableName+parentColumn for table ${tableConfig.tableName} in the tenant table plan.`)\n        }\n\n        if (!idsByTableName.has(tableConfig.parentTableName)) {\n          throw new Error(`Tenant table plan entry ${tableConfig.tableName} references parent table ${tableConfig.parentTableName}, which has not been loaded; parent tables must appear before their children in the plan.`)\n        }\n\n        rows = await this.queryRowsByColumn({\n          columnName: tableConfig.parentColumn,\n          db,\n          tableName: tableConfig.tableName,\n          values: idsByTableName.get(tableConfig.parentTableName) || []\n        })\n      }\n\n      if (rows.length > 0) {\n        this.reportProgress(`${tableConfig.tableName}: loaded ${rows.length} row(s)`)\n      }\n\n      idsByTableName.set(tableConfig.tableName, uniqueStrings(rows.map((row) => row[this.idColumn])))\n      rowsByTableName.set(tableConfig.tableName, rows)\n    }\n\n    return rowsByTableName\n  }\n\n  /**\n   * Selects all rows of `tableName` in `db` whose `columnName` is in `values`, chunked.\n   * @param {{columnName: string, db: import(\"../drivers/base.js\").default, tableName: string, values: string[]}} args\n   * @returns {Promise<Record<string, unknown>[]>}\n   */\n  async queryRowsByColumn({columnName, db, tableName, values}) {\n    const normalizedValues = uniqueStrings(values)\n\n    if (normalizedValues.length <= 0) {\n      return []\n    }\n\n    const rows = []\n    const quotedTable = db.quoteTable(tableName)\n    const quotedColumn = db.quoteColumn(columnName)\n\n    for (const valuesChunk of chunks(normalizedValues, this.queryChunkSize)) {\n      const sql = `SELECT ${quotedTable}.* FROM ${quotedTable} WHERE ${quotedColumn} IN (${this.quotedValuesSql(db, valuesChunk)})`\n\n      rows.push(...await this.executeQuietQuery(db, sql))\n    }\n\n    return rows\n  }\n\n  /**\n   * Deletes the matching target rows for every plan table, children before parents, so the\n   * reinsert that follows starts from a clean slate without violating foreign keys.\n   * @param {Map<string, Record<string, unknown>[]>} rowsByTableName\n   * @returns {Promise<void>}\n   */\n  async deleteTargetRows(rowsByTableName) {\n    for (const tableConfig of [...this.tablePlan].reverse()) {\n      const rowIds = uniqueStrings((rowsByTableName.get(tableConfig.tableName) || []).map((row) => row[this.idColumn]))\n\n      if (rowIds.length <= 0) {\n        continue\n      }\n\n      const quotedTable = this.targetDb.quoteTable(tableConfig.tableName)\n      const quotedIdColumn = this.targetDb.quoteColumn(this.idColumn)\n\n      for (const rowIdsChunk of chunks(rowIds, this.queryChunkSize)) {\n        await this.executeQuietQuery(\n          this.targetDb,\n          `DELETE FROM ${quotedTable} WHERE ${quotedIdColumn} IN (${this.quotedValuesSql(this.targetDb, rowIdsChunk)})`\n        )\n      }\n    }\n  }\n\n  /**\n   * Inserts the loaded source rows into the target for every plan table, parents before\n   * children, chunked to bound statement size.\n   * @param {Map<string, Record<string, unknown>[]>} rowsByTableName\n   * @returns {Promise<void>}\n   */\n  async insertTargetRows(rowsByTableName) {\n    for (const tableConfig of this.tablePlan) {\n      const rows = rowsByTableName.get(tableConfig.tableName) || []\n\n      if (rows.length <= 0) {\n        continue\n      }\n\n      const columns = Object.keys(rows[0])\n      const insertChunks = chunks(rows, this.insertChunkSize)\n\n      this.reportProgress(`${tableConfig.tableName}: inserting ${rows.length} row(s) in ${insertChunks.length} chunk(s)`)\n\n      for (const rowsChunk of insertChunks) {\n        await this.insertRowsQuietly({\n          columns,\n          db: this.targetDb,\n          rows: rowsChunk.map((row) => columns.map((column) => row[column])),\n          tableName: tableConfig.tableName\n        })\n      }\n    }\n  }\n\n  /**\n   * Quotes and comma-joins values for an SQL `IN (...)` list against the given database.\n   * @param {import(\"../drivers/base.js\").default} db\n   * @param {string[]} values\n   * @returns {string}\n   */\n  quotedValuesSql(db, values) {\n    return values.map((value) => db.quote(value)).join(\", \")\n  }\n\n  /**\n   * Runs a query without per-query logging, used for the high-volume copy statements.\n   * @param {import(\"../drivers/base.js\").default} db\n   * @param {string} sql\n   * @returns {Promise<Record<string, unknown>[]>}\n   */\n  async executeQuietQuery(db, sql) {\n    return await db.query(sql, {logQuery: false})\n  }\n\n  /**\n   * Inserts column-aligned row tuples into a table without per-query logging.\n   * @param {{columns: string[], db: import(\"../drivers/base.js\").default, rows: Array<Array<unknown>>, tableName: string}} args\n   * @returns {Promise<void>}\n   */\n  async insertRowsQuietly({columns, db, rows, tableName}) {\n    await this.executeQuietQuery(db, db.insertSql({columns, tableName, rows}))\n  }\n\n  /**\n   * Forwards a progress message to the optional `onProgress` callback when one was given.\n   * @param {string} message\n   * @returns {void}\n   */\n  reportProgress(message) {\n    if (this.onProgress) {\n      this.onProgress(message)\n    }\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"data-copier.js","sourceRoot":"","sources":["../../../../src/database/tenants/data-copier.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nconst DEFAULT_INSERT_CHUNK_SIZE = 100\nconst DEFAULT_QUERY_CHUNK_SIZE = 500\n\n/**\n * Splits an array into chunks of at most `chunkSize` items.\n * @template T\n * @param {T[]} values\n * @param {number} chunkSize\n * @returns {T[][]}\n */\nfunction chunks(values, chunkSize) {\n  const chunkedValues = []\n\n  for (let index = 0; index < values.length; index += chunkSize) {\n    chunkedValues.push(values.slice(index, index + chunkSize))\n  }\n\n  return chunkedValues\n}\n\n/**\n * Stringifies values and returns the distinct, non-blank ones, preserving first-seen order.\n * @param {unknown[]} values\n * @returns {string[]}\n */\nfunction uniqueStrings(values) {\n  return Array.from(new Set(values.map((value) => String(value)).filter((value) => value.trim())))\n}\n\n/**\n * Copies a single tenant's rows from a source database into a target database, following a\n * table plan that partitions each table either by a direct tenant key column or by\n * parent-id traversal. This is the row-level counterpart to schema cloning: multi-tenant\n * apps that keep each tenant's data in its own database use it to (re)materialise the\n * tenant's rows from a global/template database.\n *\n * The copy is delete-then-reinsert and therefore idempotent, and it mirrors the source\n * snapshot: the rows to delete are the tenant's *current* rows in the target (selected with\n * the same plan traversal run against the target), so a row that was removed from the source\n * since the last copy is dropped from the target too rather than lingering. The deletes run\n * children first and the source inserts parents first, all inside one target transaction with\n * foreign-key enforcement disabled so the ordering never trips a constraint. Reads, deletes\n * and inserts are chunked to bound statement size.\n *\n * The copier is policy-free: the caller supplies the plan, the source/target databases and\n * the tenant key, and {@link DataCopier#copy} returns the loaded rows keyed by table name so\n * the caller can perform any app-specific post-copy work (for example registering record\n * locations) without that policy leaking into the framework.\n */\nexport default class DataCopier {\n  /**\n   * Creates a copier that moves tenant-owned rows from `sourceDb` into `targetDb`.\n   * @param {{\n   *   sourceDb: import(\"../drivers/base.js\").default,\n   *   targetDb: import(\"../drivers/base.js\").default,\n   *   tablePlan: import(\"./tenant-table-plan.js\").TenantTablePlanEntry[],\n   *   idColumn?: string,\n   *   insertChunkSize?: number,\n   *   queryChunkSize?: number,\n   *   onProgress?: (message: string) => void\n   * }} args\n   */\n  constructor({sourceDb, targetDb, tablePlan, idColumn = \"id\", insertChunkSize = DEFAULT_INSERT_CHUNK_SIZE, queryChunkSize = DEFAULT_QUERY_CHUNK_SIZE, onProgress}) {\n    this.sourceDb = sourceDb\n    this.targetDb = targetDb\n    this.tablePlan = tablePlan\n    this.idColumn = idColumn\n    this.insertChunkSize = insertChunkSize\n    this.queryChunkSize = queryChunkSize\n    this.onProgress = onProgress\n  }\n\n  /**\n   * Copies every plan table's rows for `keyValue` from the source into the target and\n   * returns the copied source rows keyed by table name. The target's current tenant rows\n   * are deleted (children first) and the source rows inserted (parents first) in a single\n   * target transaction with foreign keys disabled.\n   * @param {string} keyValue\n   * @returns {Promise<Map<string, Record<string, unknown>[]>>}\n   */\n  async copy(keyValue) {\n    const sourceRowsByTableName = await this.loadRows(this.sourceDb, keyValue)\n    const targetRowsByTableName = await this.loadRows(this.targetDb, keyValue)\n\n    await this.targetDb.withDisabledForeignKeys(async () => {\n      await this.targetDb.transaction(async () => {\n        await this.deleteTargetRows(targetRowsByTableName)\n        await this.insertTargetRows(sourceRowsByTableName)\n      })\n    })\n\n    return sourceRowsByTableName\n  }\n\n  /**\n   * Deletes one tenant's rows from the target database, children before parents, with\n   * foreign keys disabled inside a single transaction. This is `copy` without the reinsert:\n   * the same plan traversal selects the tenant's current target rows and `deleteTargetRows`\n   * removes them children-first so the ordering never trips a foreign key. Multi-tenant apps\n   * use it to purge a tenant — for example clearing the tenant's master copy in the\n   * global/default database on teardown, so foreign keys stop referencing the tenant's\n   * about-to-be-removed root row.\n   *\n   * Returns the deleted rows keyed by table name so the caller can perform any app-specific\n   * post-delete work (record-location cleanup, auditing) without that policy leaking into the\n   * framework.\n   * @param {string} keyValue - Tenant key whose rows should be removed from the target.\n   * @returns {Promise<Map<string, Record<string, unknown>[]>>} - The deleted rows by table name.\n   */\n  async deleteTenantRows(keyValue) {\n    const rowsByTableName = await this.loadRows(this.targetDb, keyValue)\n\n    await this.targetDb.withDisabledForeignKeys(async () => {\n      await this.targetDb.transaction(async () => {\n        await this.deleteTargetRows(rowsByTableName)\n      })\n    })\n\n    return rowsByTableName\n  }\n\n  /**\n   * Loads the rows for `keyValue` for every table in the plan from `db`, resolving\n   * parent-scoped tables from the ids already selected for their parent table. Used for\n   * both the source rows to copy and the target's current tenant rows to delete.\n   * @param {import(\"../drivers/base.js\").default} db\n   * @param {string} keyValue\n   * @returns {Promise<Map<string, Record<string, unknown>[]>>}\n   */\n  async loadRows(db, keyValue) {\n    /** @type {Map<string, string[]>} */\n    const idsByTableName = new Map()\n    /** @type {Map<string, Record<string, unknown>[]>} */\n    const rowsByTableName = new Map()\n\n    for (const tableConfig of this.tablePlan) {\n      let rows\n\n      if (tableConfig.keyColumn) {\n        rows = await this.queryRowsByColumn({\n          columnName: tableConfig.keyColumn,\n          db,\n          tableName: tableConfig.tableName,\n          values: [keyValue]\n        })\n      } else {\n        if (!tableConfig.parentColumn || !tableConfig.parentTableName) {\n          throw new Error(`Expected keyColumn or parentTableName+parentColumn for table ${tableConfig.tableName} in the tenant table plan.`)\n        }\n\n        if (!idsByTableName.has(tableConfig.parentTableName)) {\n          throw new Error(`Tenant table plan entry ${tableConfig.tableName} references parent table ${tableConfig.parentTableName}, which has not been loaded; parent tables must appear before their children in the plan.`)\n        }\n\n        rows = await this.queryRowsByColumn({\n          columnName: tableConfig.parentColumn,\n          db,\n          tableName: tableConfig.tableName,\n          values: idsByTableName.get(tableConfig.parentTableName) || []\n        })\n      }\n\n      if (rows.length > 0) {\n        this.reportProgress(`${tableConfig.tableName}: loaded ${rows.length} row(s)`)\n      }\n\n      idsByTableName.set(tableConfig.tableName, uniqueStrings(rows.map((row) => row[this.idColumn])))\n      rowsByTableName.set(tableConfig.tableName, rows)\n    }\n\n    return rowsByTableName\n  }\n\n  /**\n   * Selects all rows of `tableName` in `db` whose `columnName` is in `values`, chunked.\n   * @param {{columnName: string, db: import(\"../drivers/base.js\").default, tableName: string, values: string[]}} args\n   * @returns {Promise<Record<string, unknown>[]>}\n   */\n  async queryRowsByColumn({columnName, db, tableName, values}) {\n    const normalizedValues = uniqueStrings(values)\n\n    if (normalizedValues.length <= 0) {\n      return []\n    }\n\n    const rows = []\n    const quotedTable = db.quoteTable(tableName)\n    const quotedColumn = db.quoteColumn(columnName)\n\n    for (const valuesChunk of chunks(normalizedValues, this.queryChunkSize)) {\n      const sql = `SELECT ${quotedTable}.* FROM ${quotedTable} WHERE ${quotedColumn} IN (${this.quotedValuesSql(db, valuesChunk)})`\n\n      rows.push(...await this.executeQuietQuery(db, sql))\n    }\n\n    return rows\n  }\n\n  /**\n   * Deletes the matching target rows for every plan table, children before parents, so the\n   * reinsert that follows starts from a clean slate without violating foreign keys.\n   * @param {Map<string, Record<string, unknown>[]>} rowsByTableName\n   * @returns {Promise<void>}\n   */\n  async deleteTargetRows(rowsByTableName) {\n    for (const tableConfig of [...this.tablePlan].reverse()) {\n      const rowIds = uniqueStrings((rowsByTableName.get(tableConfig.tableName) || []).map((row) => row[this.idColumn]))\n\n      if (rowIds.length <= 0) {\n        continue\n      }\n\n      const quotedTable = this.targetDb.quoteTable(tableConfig.tableName)\n      const quotedIdColumn = this.targetDb.quoteColumn(this.idColumn)\n\n      for (const rowIdsChunk of chunks(rowIds, this.queryChunkSize)) {\n        await this.executeQuietQuery(\n          this.targetDb,\n          `DELETE FROM ${quotedTable} WHERE ${quotedIdColumn} IN (${this.quotedValuesSql(this.targetDb, rowIdsChunk)})`\n        )\n      }\n    }\n  }\n\n  /**\n   * Inserts the loaded source rows into the target for every plan table, parents before\n   * children, chunked to bound statement size.\n   * @param {Map<string, Record<string, unknown>[]>} rowsByTableName\n   * @returns {Promise<void>}\n   */\n  async insertTargetRows(rowsByTableName) {\n    for (const tableConfig of this.tablePlan) {\n      const rows = rowsByTableName.get(tableConfig.tableName) || []\n\n      if (rows.length <= 0) {\n        continue\n      }\n\n      const columns = Object.keys(rows[0])\n      const insertChunks = chunks(rows, this.insertChunkSize)\n\n      this.reportProgress(`${tableConfig.tableName}: inserting ${rows.length} row(s) in ${insertChunks.length} chunk(s)`)\n\n      for (const rowsChunk of insertChunks) {\n        await this.insertRowsQuietly({\n          columns,\n          db: this.targetDb,\n          rows: rowsChunk.map((row) => columns.map((column) => row[column])),\n          tableName: tableConfig.tableName\n        })\n      }\n    }\n  }\n\n  /**\n   * Quotes and comma-joins values for an SQL `IN (...)` list against the given database.\n   * @param {import(\"../drivers/base.js\").default} db\n   * @param {string[]} values\n   * @returns {string}\n   */\n  quotedValuesSql(db, values) {\n    return values.map((value) => db.quote(value)).join(\", \")\n  }\n\n  /**\n   * Runs a query without per-query logging, used for the high-volume copy statements.\n   * @param {import(\"../drivers/base.js\").default} db\n   * @param {string} sql\n   * @returns {Promise<Record<string, unknown>[]>}\n   */\n  async executeQuietQuery(db, sql) {\n    return await db.query(sql, {logQuery: false})\n  }\n\n  /**\n   * Inserts column-aligned row tuples into a table without per-query logging.\n   * @param {{columns: string[], db: import(\"../drivers/base.js\").default, rows: Array<Array<unknown>>, tableName: string}} args\n   * @returns {Promise<void>}\n   */\n  async insertRowsQuietly({columns, db, rows, tableName}) {\n    await this.executeQuietQuery(db, db.insertSql({columns, tableName, rows}))\n  }\n\n  /**\n   * Forwards a progress message to the optional `onProgress` callback when one was given.\n   * @param {string} message\n   * @returns {void}\n   */\n  reportProgress(message) {\n    if (this.onProgress) {\n      this.onProgress(message)\n    }\n  }\n}\n"]}

package/build/src/environment-handlers/node/cli/commands/generate/frontend-models.d.ts

@@ -108,15 +108,6 @@ export default class DbGenerateFrontendModels extends BaseCommand {
         modelConfig: import("../../../../../configuration-types.js").NormalizedFrontendModelResourceConfiguration;
         resourceClass?: import("../../../../../configuration-types.js").FrontendModelResourceClassType | null | undefined;
     }): Promise<string>;
-    /**
-     * Runs build index file content.
-     * @param {Array<{className: string, fileName: string}>} generatedFiles - Generated model files.
-     * @returns {string} - Index file content that imports and re-exports all models.
-     */
-    buildIndexFileContent(generatedFiles: Array<{
-        className: string;
-        fileName: string;
-    }>): string;
     /**
      * Runs build setup file content.
      * @param {Array<{className: string, fileName: string}>} generatedFiles - Generated model files.

package/build/src/environment-handlers/node/cli/commands/generate/frontend-models.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"frontend-models.d.ts","sourceRoot":"","sources":["../../../../../../../src/environment-handlers/node/cli/commands/generate/frontend-models.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"frontend-models.d.ts","sourceRoot":"","sources":["../../../../../../../src/environment-handlers/node/cli/commands/generate/frontend-models.js"],"names":[],"mappings":"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"}