velocious 1.0.568 → 1.0.570

package/build/database/drivers/base.js

@@ -42,6 +42,12 @@
  * @typedef {Record<string, ?>} QueryRowType
  * @typedef {Array<QueryRowType>} QueryResultType
  */
+/**
+ * TransactionCallbackFrame type.
+ * @typedef {object} TransactionCallbackFrame
+ * @property {Array<() => void | Promise<void>>} afterCommitCallbacks - Callbacks to merge or run after commit.
+ * @property {Array<() => void | Promise<void>>} beforeCommitCallbacks - Guards to run before this frame completes.
+ */
 /**
  * RetryableDatabaseErrorResult type.
  * @typedef {object} RetryableDatabaseErrorResult
@@ -61,6 +67,7 @@
  * @property {boolean} [sessionTimeZone] - Whether to ensure the configured database session time zone before the query.
  * @property {AbortSignal} [signal] - Aborts the in-flight query (destroying its connection) when it fires.
  * @property {string} [sourceStack] - Stack captured at the caller boundary.
+ * @property {symbol} [operationOwner] - Opaque owner for an operation-leased connection.
  */
 
 /**
@@ -127,6 +134,21 @@ import TableForeignKey from "../table-data/table-foreign-key.js"
 import wait from "awaitery/build/wait.js"
 import {optionalPositiveInteger} from "typanic"
 
+/**
+ * Marks a callback failure that happened after the owning transaction was durably committed.
+ * The public transaction boundary unwraps it before deadlock classification.
+ */
+class VelociousDatabaseAfterCommitCallbackError extends Error {
+  /**
+   * Runs constructor.
+   * @param {?} callbackError - Original callback failure.
+   */
+  constructor(callbackError) {
+    super("Database afterCommit callback failed")
+    this.callbackError = callbackError
+  }
+}
+
 /**
  * Runs now ms.
  * @returns {number} - Current high-resolution-ish timestamp in milliseconds.
@@ -155,8 +177,8 @@ export default class VelociousDatabaseDriversBase {
   idSeq = undefined
   /**
    * Narrows the runtime value to the documented type.
-   * @type {Array<Array<() => void | Promise<void>>>} */
-  _afterCommitCallbackFrames
+   * @type {TransactionCallbackFrame[]} */
+  _transactionCallbackFrames
   /**
    * Narrows the runtime value to the documented type.
    * @type {Map<string, Promise<?>>} */
@@ -175,6 +197,11 @@ export default class VelociousDatabaseDriversBase {
   _activeQuery = null
   /** @type {Map<string, number>} */
   _heldAdvisoryLocks = new Map()
+  /**
+   * Exclusive operation lease installed by a single-multi-use pool.
+   * @type {import("../operation-lease.js").default | undefined}
+   */
+  _operationLease = undefined
 
   /**
    * Runs constructor.
@@ -186,7 +213,7 @@ export default class VelociousDatabaseDriversBase {
     this.configuration = configuration
     this.mutex = new Mutex() // Can be used to lock this instance for exclusive use
     this.logger = new Logger(this)
-    this._afterCommitCallbackFrames = []
+    this._transactionCallbackFrames = []
     this._transactionsCount = 0
     this._transactionsActionsMutex = new Mutex()
     this._schemaCache = new Map()
@@ -488,6 +515,46 @@ export default class VelociousDatabaseDriversBase {
     return this.configuration
   }
 
+  /**
+   * Installs an operation lease atomically with ordinary transaction admission.
+   * @param {import("../operation-lease.js").default} operationLease - Active lease.
+   * @returns {Promise<void>} - Resolves once the lease owns transaction admission.
+   */
+  async setOperationLease(operationLease) {
+    await this._transactionsActionsMutex.sync(async () => {
+      if (this._operationLease) throw new Error("A database operation lease is already active")
+      if (this._transactionsCount > 0) {
+        throw new Error("Cannot start a database operation while an unrelated ordinary transaction is already active")
+      }
+
+      this._operationLease = operationLease
+    })
+  }
+
+  /**
+   * Clears the matching operation lease.
+   * @param {import("../operation-lease.js").default} operationLease - Lease to clear.
+   * @returns {void}
+   */
+  clearOperationLease(operationLease) {
+    if (this._operationLease !== operationLease) {
+      throw new Error("Cannot clear a database operation lease owned by another operation")
+    }
+
+    this._operationLease = undefined
+  }
+
+  /**
+   * Waits for an unrelated operation lease to release.
+   * @param {symbol | undefined} operationOwner - Candidate operation owner.
+   * @returns {Promise<void>}
+   */
+  async _waitForOperationLease(operationOwner) {
+    const operationLease = this._operationLease
+
+    if (operationLease) await operationLease.wait(operationOwner)
+  }
+
   /**
    * Runs get id seq.
    * @returns {number | undefined} - The id seq.
@@ -739,9 +806,10 @@ export default class VelociousDatabaseDriversBase {
   /**
    * Runs last insert id.
    * @abstract
+   * @param {QueryOptions} [_options] - Query ownership options.
    * @returns {Promise<number>} - Resolves with the last insert id.
    */
-  lastInsertID() {
+  lastInsertID(_options = {}) {
     throw new Error(`${this.constructor.name}#lastInsertID not implemented`)
   }
 
@@ -932,12 +1000,16 @@ export default class VelociousDatabaseDriversBase {
    * The outermost transaction retries the whole callback on a deadlock / lock-wait-timeout,
    * because such errors roll the entire transaction back and the standard recovery is to
    * restart it. Nested savepoints let the deadlock bubble up to this outer retry.
-   * @param {() => Promise<void>} callback - Callback function.
-   * @returns {Promise<?>} - Resolves with the transaction result.
+   * @template T
+   * @param {() => Promise<T>} callback - Callback function.
+   * @param {Pick<QueryOptions, "operationOwner">} [options] - Transaction ownership.
+   * @returns {Promise<T>} - Resolves with the transaction result.
    */
-  async transaction(callback) {
+  async transaction(callback, options = {}) {
+    await this._waitForOperationLease(options.operationOwner)
+
     if (this._transactionsCount > 0) {
-      return await this._runTransactionAttempt(callback)
+      return await this._runTransactionAttempt(callback, options)
     }
 
     const args = this.getArgs()
@@ -950,8 +1022,10 @@ export default class VelociousDatabaseDriversBase {
       attempt++
 
       try {
-        return await this._runTransactionAttempt(callback)
+        return await this._runTransactionAttempt(callback, options)
       } catch (error) {
+        if (error instanceof VelociousDatabaseAfterCommitCallbackError) throw error.callbackError
+
         const retryInfo = error instanceof Error ? this.retryableDatabaseError(error) : {retry: false, reconnect: false}
 
         if (retryInfo.deadlock && attempt < maxAttempts && this._transactionsCount == 0) {
@@ -993,46 +1067,53 @@ export default class VelociousDatabaseDriversBase {
    * Runs a single transaction attempt: starts a transaction (or a savepoint when nested), runs
    * `callback`, and commits — rolling back on error. {@link transaction} wraps this with deadlock
    * retry at the outermost level.
-   * @param {() => Promise<void>} callback - Callback function.
+   * @template T
+   * @param {() => Promise<T>} callback - Callback function.
+   * @param {Pick<QueryOptions, "operationOwner">} options - Transaction ownership.
    * @returns {Promise<?>} - Resolves with the transaction result.
    */
-  async _runTransactionAttempt(callback) {
+  async _runTransactionAttempt(callback, options) {
     const savePointName = this.generateSavePointName()
-    /**
-     * Callback frame.
-     * @type {Array<() => void | Promise<void>>} */
-    const callbackFrame = []
+    /** @type {TransactionCallbackFrame} */
+    const callbackFrame = {
+      afterCommitCallbacks: [],
+      beforeCommitCallbacks: []
+    }
     let transactionStarted = false
     let savePointStarted = false
 
-    this._afterCommitCallbackFrames.push(callbackFrame)
+    this._transactionCallbackFrames.push(callbackFrame)
 
-    if (this._transactionsCount == 0) {
-      this.logger.debug("Start transaction")
-      await this.startTransaction()
-      transactionStarted = true
-    } else {
-      this.logger.debug("Start savepoint", savePointName)
-      await this.startSavePoint(savePointName)
-      savePointStarted = true
+    try {
+      if (this._transactionsCount == 0) {
+        this.logger.debug("Start transaction")
+        await this.startTransaction(options)
+        transactionStarted = true
+      } else {
+        this.logger.debug("Start savepoint", savePointName)
+        await this.startSavePoint(savePointName, options)
+        savePointStarted = true
+      }
+    } catch (error) {
+      this._transactionCallbackFrames.pop()
+      throw error
     }
 
     let result
 
     try {
       result = await callback()
+      await this._runBeforeCommitCallbacks(callbackFrame)
 
       if (savePointStarted) {
         this.logger.debug("Release savepoint", savePointName)
-        await this.releaseSavePoint(savePointName)
+        await this.releaseSavePoint(savePointName, options)
       }
 
       if (transactionStarted) {
         this.logger.debug("Commit transaction")
-        await this.commitTransaction()
+        await this.commitTransaction(options)
       }
-
-      await this._commitAfterCommitCallbackFrame()
     } catch (error) {
       if (error instanceof Error) {
         this.logger.debug("Transaction error", error.message)
@@ -1040,58 +1121,86 @@ export default class VelociousDatabaseDriversBase {
         this.logger.debug("Transaction error", error)
       }
 
-      let transactionRolledBack = false
-
-      if (savePointStarted) {
-        this.logger.debug("Rollback savepoint", savePointName)
-        try {
-          await this.rollbackSavePoint(savePointName)
-        } catch (savePointError) {
-          const message = savePointError instanceof Error ? savePointError.message : `${savePointError}`
-
-          // MySQL sometimes drops savepoints unexpectedly; fall back to rolling back the full transaction
-          if (message.includes("SAVEPOINT") || message.includes("ER_SP_DOES_NOT_EXIST")) {
-            this.logger.debug("Savepoint rollback failed; rolling back entire transaction instead")
-            await this.rollbackTransaction()
-            transactionRolledBack = true
-          } else {
-            throw savePointError
+      try {
+        let transactionRolledBack = false
+
+        if (savePointStarted) {
+          this.logger.debug("Rollback savepoint", savePointName)
+          try {
+            await this.rollbackSavePoint(savePointName, options)
+          } catch (savePointError) {
+            const message = savePointError instanceof Error ? savePointError.message : `${savePointError}`
+
+            // MySQL sometimes drops savepoints unexpectedly; fall back to rolling back the full transaction
+            if (message.includes("SAVEPOINT") || message.includes("ER_SP_DOES_NOT_EXIST")) {
+              this.logger.debug("Savepoint rollback failed; rolling back entire transaction instead")
+              await this.rollbackTransaction(options)
+              transactionRolledBack = true
+            } else {
+              throw savePointError
+            }
           }
         }
-      }
 
-      // Only roll back if a transaction is still open. A nested savepoint whose rollback failed
-      // falls back to rolling back the whole transaction (above), which already closed it and
-      // dropped the count to 0; rolling back again here would issue a second ROLLBACK and drive
-      // `_transactionsCount` below zero, which would then defeat the outermost deadlock-retry guard.
-      if (transactionStarted && !transactionRolledBack && this._transactionsCount > 0) {
-        this.logger.debug("Rollback transaction")
-        await this.rollbackTransaction()
+        // Only roll back if a transaction is still open. A nested savepoint whose rollback failed
+        // falls back to rolling back the whole transaction (above), which already closed it and
+        // dropped the count to 0; rolling back again here would issue a second ROLLBACK and drive
+        // `_transactionsCount` below zero, which would then defeat the outermost deadlock-retry guard.
+        if (transactionStarted && !transactionRolledBack && this._transactionsCount > 0) {
+          this.logger.debug("Rollback transaction")
+          await this.rollbackTransaction(options)
+        }
+      } finally {
+        this._transactionCallbackFrames.pop()
       }
 
-      this._afterCommitCallbackFrames.pop()
-
       throw error
     }
 
+    try {
+      await this._commitTransactionCallbackFrame()
+    } catch (error) {
+      throw new VelociousDatabaseAfterCommitCallbackError(error)
+    }
+
     return result
   }
 
+  /**
+   * Registers a guard to run after the current transaction callback succeeds and before its
+   * outer commit or nested savepoint release.
+   * @param {() => void | Promise<void>} callback - Guard callback.
+   * @param {Pick<QueryOptions, "operationOwner">} [options] - Callback ownership.
+   * @returns {Promise<void>} - Resolves when the guard has been registered.
+   */
+  async beforeCommit(callback, options = {}) {
+    await this._waitForOperationLease(options.operationOwner)
+
+    const currentFrame = this._transactionCallbackFrames[this._transactionCallbackFrames.length - 1]
+
+    if (!currentFrame) throw new Error("beforeCommit requires an active transaction")
+
+    currentFrame.beforeCommitCallbacks.push(callback)
+  }
+
   /**
    * Runs a callback after the surrounding transaction commits.
    * If no transaction is active, the callback runs immediately.
    * @param {() => void | Promise<void>} callback - Callback.
+   * @param {Pick<QueryOptions, "operationOwner">} [options] - Callback ownership.
    * @returns {Promise<void>} - Resolves when the callback has been registered or run.
    */
-  async afterCommit(callback) {
-    const currentFrame = this._afterCommitCallbackFrames[this._afterCommitCallbackFrames.length - 1]
+  async afterCommit(callback, options = {}) {
+    await this._waitForOperationLease(options.operationOwner)
+
+    const currentFrame = this._transactionCallbackFrames[this._transactionCallbackFrames.length - 1]
 
     if (!currentFrame) {
       await callback()
       return
     }
 
-    currentFrame.push(callback)
+    currentFrame.afterCommitCallbacks.push(callback)
   }
 
   /**
@@ -1102,59 +1211,90 @@ export default class VelociousDatabaseDriversBase {
 
   /**
    * Runs start transaction.
+   * @param {Pick<QueryOptions, "operationOwner">} [options] - Transaction ownership.
    * @returns {Promise<void>} - Resolves when complete.
    */
-  async startTransaction() {
-    await this._transactionsActionsMutex.sync(async () => {
-      await this._startTransactionAction()
-      this._transactionsCount++
-    })
+  async startTransaction(options = {}) {
+    while (true) {
+      /** @type {import("../operation-lease.js").default | undefined} */
+      let blockingOperationLease
+
+      await this._transactionsActionsMutex.sync(async () => {
+        const operationLease = this._operationLease
+
+        if (operationLease && options.operationOwner !== operationLease.owner) {
+          blockingOperationLease = operationLease
+          return
+        }
+
+        await this._startTransactionAction(options)
+        this._transactionsCount++
+      })
+
+      if (!blockingOperationLease) return
+
+      await blockingOperationLease.wait(options.operationOwner)
+    }
   }
 
   /**
    * Runs start transaction action.
+   * @param {Pick<QueryOptions, "operationOwner">} [options] - Transaction ownership.
    * @returns {Promise<void>} - Resolves when complete.
    */
-  async _startTransactionAction() {
-    await this.query("BEGIN TRANSACTION")
+  async _startTransactionAction(options = {}) {
+    await this.query("BEGIN TRANSACTION", options)
   }
 
   /**
    * Runs commit transaction.
+   * @param {Pick<QueryOptions, "operationOwner">} [options] - Transaction ownership.
    * @returns {Promise<void>} - Resolves when complete.
    */
-  async commitTransaction() {
+  async commitTransaction(options = {}) {
     await this._transactionsActionsMutex.sync(async () => {
-      await this._commitTransactionAction()
+      await this._commitTransactionAction(options)
       this._transactionsCount--
     })
   }
 
   /**
    * Runs commit transaction action.
+   * @param {Pick<QueryOptions, "operationOwner">} [options] - Transaction ownership.
    * @returns {Promise<void>} - Resolves when complete.
    */
-  async _commitTransactionAction() {
-    await this.query("COMMIT")
+  async _commitTransactionAction(options = {}) {
+    await this.query("COMMIT", options)
+  }
+
+  /**
+   * Runs every guard registered to the transaction frame.
+   * @param {TransactionCallbackFrame} callbackFrame - Frame whose guards are completing.
+   * @returns {Promise<void>} - Resolves when every guard accepts the commit.
+   */
+  async _runBeforeCommitCallbacks(callbackFrame) {
+    for (const callback of callbackFrame.beforeCommitCallbacks) {
+      await callback()
+    }
   }
 
   /**
    * Merges committed callbacks into the parent transaction frame or runs them when the outermost commit completes.
    * @returns {Promise<void>} - Resolves when complete.
    */
-  async _commitAfterCommitCallbackFrame() {
-    const committedCallbacks = this._afterCommitCallbackFrames.pop()
+  async _commitTransactionCallbackFrame() {
+    const committedFrame = this._transactionCallbackFrames.pop()
 
-    if (!committedCallbacks || committedCallbacks.length === 0) return
+    if (!committedFrame || committedFrame.afterCommitCallbacks.length === 0) return
 
-    const parentFrame = this._afterCommitCallbackFrames[this._afterCommitCallbackFrames.length - 1]
+    const parentFrame = this._transactionCallbackFrames[this._transactionCallbackFrames.length - 1]
 
     if (parentFrame) {
-      parentFrame.push(...committedCallbacks)
+      parentFrame.afterCommitCallbacks.push(...committedFrame.afterCommitCallbacks)
       return
     }
 
-    for (const callback of committedCallbacks) {
+    for (const callback of committedFrame.afterCommitCallbacks) {
       await callback()
     }
   }
@@ -1183,6 +1323,7 @@ export default class VelociousDatabaseDriversBase {
    * @returns {Promise<QueryResultType>} - Resolves with the query.
    */
   async query(sql, options = {}) {
+    await this._waitForOperationLease(options.operationOwner)
     this._assertWritableQuery(sql)
 
     let tries = 0
@@ -1232,16 +1373,18 @@ export default class VelociousDatabaseDriversBase {
   /**
    * Executes a mutation and returns the number of rows changed by that statement.
    * @param {string} sql - Mutation SQL string.
+   * @param {QueryOptions} [options] - Query ownership options.
    * @returns {Promise<number>} - Affected row count.
    */
-  async affectedRows(sql) {
+  async affectedRows(sql, options = {}) {
+    await this._waitForOperationLease(options.operationOwner)
     this._assertWritableQuery(sql)
-    await this.beforeQuery(sql, {})
+    await this.beforeQuery(sql, options)
 
     try {
       return await this._affectedRowsActual(sql)
     } finally {
-      await this.afterQuery(sql, {})
+      await this.afterQuery(sql, options)
     }
   }
 
@@ -1609,12 +1752,13 @@ export default class VelociousDatabaseDriversBase {
 
   /**
    * Runs rollback transaction.
+   * @param {Pick<QueryOptions, "operationOwner">} [options] - Transaction ownership.
    * @returns {Promise<void>} - Resolves when complete.
    */
-  async rollbackTransaction() {
+  async rollbackTransaction(options = {}) {
     await this._transactionsActionsMutex.sync(async () => {
       try {
-        await this._rollbackTransactionAction()
+        await this._rollbackTransactionAction(options)
       } finally {
         this._transactionsCount--
 
@@ -1630,10 +1774,11 @@ export default class VelociousDatabaseDriversBase {
 
   /**
    * Runs rollback transaction action.
+   * @param {Pick<QueryOptions, "operationOwner">} [options] - Transaction ownership.
    * @returns {Promise<void>} - Resolves when complete.
    */
-  async _rollbackTransactionAction() {
-    await this.query("ROLLBACK")
+  async _rollbackTransactionAction(options = {}) {
+    await this.query("ROLLBACK", options)
   }
 
   /**
@@ -1647,21 +1792,23 @@ export default class VelociousDatabaseDriversBase {
   /**
    * Runs start save point.
    * @param {string} savePointName - Save point name.
+   * @param {Pick<QueryOptions, "operationOwner">} [options] - Transaction ownership.
    * @returns {Promise<void>} - Resolves when complete.
    */
-  async startSavePoint(savePointName) {
+  async startSavePoint(savePointName, options = {}) {
     await this._transactionsActionsMutex.sync(async () => {
-      await this._startSavePointAction(savePointName)
+      await this._startSavePointAction(savePointName, options)
     })
   }
 
   /**
    * Runs start save point action.
    * @param {string} savePointName - Save point name.
+   * @param {Pick<QueryOptions, "operationOwner">} [options] - Transaction ownership.
    * @returns {Promise<void>} - Resolves when complete.
    */
-  async _startSavePointAction(savePointName) {
-    await this.query(`SAVEPOINT ${savePointName}`)
+  async _startSavePointAction(savePointName, options = {}) {
+    await this.query(`SAVEPOINT ${savePointName}`, options)
   }
 
   /**
@@ -1691,22 +1838,24 @@ export default class VelociousDatabaseDriversBase {
   /**
    * Runs release save point.
    * @param {string} savePointName - Save point name.
+   * @param {Pick<QueryOptions, "operationOwner">} [options] - Transaction ownership.
    * @returns {Promise<void>} - Resolves when complete.
    */
-  async releaseSavePoint(savePointName) {
+  async releaseSavePoint(savePointName, options = {}) {
     await this._transactionsActionsMutex.sync(async () => {
-      await this._releaseSavePointAction(savePointName)
+      await this._releaseSavePointAction(savePointName, options)
     })
   }
 
   /**
    * Runs release save point action.
    * @param {string} savePointName - Save point name.
+   * @param {Pick<QueryOptions, "operationOwner">} [options] - Transaction ownership.
    * @returns {Promise<void>} - Resolves when complete.
    */
-  async _releaseSavePointAction(savePointName) {
+  async _releaseSavePointAction(savePointName, options = {}) {
     try {
-      await this.query(`RELEASE SAVEPOINT ${savePointName}`)
+      await this.query(`RELEASE SAVEPOINT ${savePointName}`, options)
     } catch (error) {
       const message = error instanceof Error ? error.message : `${error}`
 
@@ -1723,21 +1872,23 @@ export default class VelociousDatabaseDriversBase {
   /**
    * Runs rollback save point.
    * @param {string} savePointName - Save point name.
+   * @param {Pick<QueryOptions, "operationOwner">} [options] - Transaction ownership.
    * @returns {Promise<void>} - Resolves when complete.
    */
-  async rollbackSavePoint(savePointName) {
+  async rollbackSavePoint(savePointName, options = {}) {
     await this._transactionsActionsMutex.sync(async () => {
-      await this._rollbackSavePointAction(savePointName)
+      await this._rollbackSavePointAction(savePointName, options)
     })
   }
 
   /**
    * Runs rollback save point action.
    * @param {string} savePointName - Save point name.
+   * @param {Pick<QueryOptions, "operationOwner">} [options] - Transaction ownership.
    * @returns {Promise<void>} - Resolves when complete.
    */
-  async _rollbackSavePointAction(savePointName) {
-    await this.query(`ROLLBACK TO SAVEPOINT ${savePointName}`)
+  async _rollbackSavePointAction(savePointName, options = {}) {
+    await this.query(`ROLLBACK TO SAVEPOINT ${savePointName}`, options)
   }
 
   /**

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

@@ -463,8 +463,8 @@ export default class VelociousDatabaseDriversMssql extends Base{
     })
   }
 
-  async lastInsertID() {
-    const result = await this.query("SELECT SCOPE_IDENTITY() AS last_insert_id")
+  async lastInsertID(options = {}) {
+    const result = await this.query("SELECT SCOPE_IDENTITY() AS last_insert_id", options)
     const lastInsertID = digg(result, 0, "last_insert_id")
 
     if (lastInsertID === null) throw new Error("Couldn't get the last inserted ID")
@@ -534,29 +534,32 @@ export default class VelociousDatabaseDriversMssql extends Base{
   /**
    * Runs start save point action.
    * @param {string} savePointName - Save point name.
+   * @param {Pick<import("../base.js").QueryOptions, "operationOwner">} [options] - Transaction ownership.
    * @returns {Promise<void>} - Resolves when complete.
    */
-  async _startSavePointAction(savePointName) {
-    await this.query(`SAVE TRANSACTION [${savePointName}]`)
+  async _startSavePointAction(savePointName, options = {}) {
+    await this.query(`SAVE TRANSACTION [${savePointName}]`, options)
   }
 
   /**
    * Runs release save point action.
    * @param {string} savePointName - Save point name.
+   * @param {Pick<import("../base.js").QueryOptions, "operationOwner">} [_options] - Transaction ownership.
    * @returns {Promise<void>} - Resolves when complete.
    */
-  async _releaseSavePointAction(savePointName) { // eslint-disable-line no-unused-vars
+  async _releaseSavePointAction(savePointName, _options = {}) {
     // Do nothing in MS-SQL.
   }
 
   /**
    * Runs rollback save point action.
    * @param {string} savePointName - Save point name.
+   * @param {Pick<import("../base.js").QueryOptions, "operationOwner">} [options] - Transaction ownership.
    * @returns {Promise<void>} - Resolves when complete.
    */
-  async _rollbackSavePointAction(savePointName) {
+  async _rollbackSavePointAction(savePointName, options = {}) {
     try {
-      await this.query(`ROLLBACK TRANSACTION [${savePointName}]`)
+      await this.query(`ROLLBACK TRANSACTION [${savePointName}]`, options)
     } catch (error) {
       const message = error instanceof Error ? error.message : `${error}`