velocious 1.0.567 → 1.0.569

package/README.md

@@ -34,9 +34,11 @@
 * In-process driver schema metadata caching (see [docs/schema-metadata-cache.md](docs/schema-metadata-cache.md))
 * Planned local-first shared-resource sync architecture (see [docs/offline-sync.md](docs/offline-sync.md))
 * Selective named database connection checkouts, bounded pool waits, and debugging held connections (see [docs/database-connections.md](docs/database-connections.md))
+* Explicit singular-database operation transactions whose model scopes preserve ownership through records, relationships, lifecycle work, nested savepoints, and commit callbacks (see [docs/operation-scoped-transactions.md](docs/operation-scoped-transactions.md))
 * AbortSignal-driven MySQL/MariaDB query cancellation for raw, model, and cross-tenant aggregate queries (see [docs/database-query-cancellation.md](docs/database-query-cancellation.md))
 * Optional built-in debug endpoint for inspecting server and database connection state (see [docs/debug-endpoint.md](docs/debug-endpoint.md))
 * Optional built-in API manifest endpoint describing every registered frontend-model resource as human- and machine-readable JSON (see [docs/api-manifest-endpoint.md](docs/api-manifest-endpoint.md))
+* Backend record attachments with filesystem, S3, native callback, and bounded Node path-input persistence (see [docs/attachments.md](docs/attachments.md))
 
 # Setup
 
@@ -50,6 +52,25 @@ npx velocious init
 
 By default, Velocious looks for your configuration in `src/config/configuration.js`. If you keep the configuration elsewhere, make sure your app imports it early and calls `configuration.setCurrent()`.
 
+# Operation-scoped transactions
+
+Use `configuration.withTransaction` for an atomic unit of model work on one database:
+
+```js
+await configuration.withTransaction({databaseIdentifier: "default", name: "accept ticket"}, async (operation) => {
+  const ticket = await operation.forModel(Ticket).find(ticketId)
+
+  ticket.setAccepted(true)
+  await ticket.save()
+
+  await operation.afterCommit(async () => {
+    await publishAcceptedTicket(ticket.id())
+  })
+})
+```
+
+Use operation-bound model scopes and their loaded records throughout the callback. `operation.transaction` adds a nested savepoint, and `operation.connection()` is the deliberate escape hatch for owned raw SQL. Cross-database models, same-identifier tenant switches to another physical database, and operation handles used after the callback are rejected. On shared SQLite/SQL.js pools, unrelated work waits for the operation lease, while admission during an already-open ordinary transaction is rejected. See [operation-scoped transactions](docs/operation-scoped-transactions.md) for pool behavior, after-commit failure semantics, and migration guidance.
+
 # Development
 
 When working on Velocious itself, npm scripts are cross-platform (Windows `cmd`/PowerShell and POSIX shells):
@@ -521,6 +542,9 @@ Task.hasOneAttachment("descriptionFile")
 Task.hasOneAttachment("archivedPdf", {driver: "s3"})
 ```
 
+See [Backend record attachments](docs/attachments.md) for the complete input,
+storage-driver, lifecycle, and path-security contracts.
+
 You can also pass a driver class or instance directly on the attachment:
 
 ```js
@@ -538,6 +562,10 @@ await task.descriptionFile().attach({
   content: "my file content",
   filename: "file.doc"
 })
+await task.archivedPdf().attach({
+  path: "/var/app/uploads/archive.pdf",
+  contentType: "application/pdf"
+})
 const descriptionFileUrl = await task.descriptionFile().url()
 await task.update({
   descriptionFile: {
@@ -605,7 +633,25 @@ new Configuration({
 ```
 
 Then `{path: "..."}`
-inputs are only accepted when the file resolves inside one of the allowed prefixes.
+inputs are only accepted when the path resolves inside one of the allowed
+prefixes and the once-opened handle identifies a regular file. Its exact byte
+size comes from that handle's stat snapshot. The filesystem driver copies it
+with a bounded, backpressured stream and the S3 driver sends a Node `Readable`;
+on current nullable schemas neither driver first materializes the whole file as
+a Buffer or Base64 value. Legacy schemas with a non-null `content_base64`
+column instead materialize the opened snapshot once before driver persistence
+and reuse those exact bytes for storage and the database Base64. Path
+replacement cannot switch the opened source, truncation is rejected, later
+appends are ignored, and the source is closed after persistence.
+
+The native driver's documented `write({contentBase64, ...})` callback remains
+source-compatible. For path input only, that driver reads and Base64-encodes the
+opened source after driver selection on current schemas; legacy path input
+arrives pre-materialized with the same Base64 written to the database. Existing
+Buffer, string, browser, and `UploadedFile` inputs keep their in-memory
+behavior. See
+[docs/attachments.md](docs/attachments.md#normalized-storage-driver-input) for
+the normalized input passed to custom drivers.
 
 For frontend models, configure `resourceConfig().attachments` and use:
 
@@ -1148,6 +1194,8 @@ export default class CreateEvents extends Migration {
 }
 ```
 
+To reverse an `addReference("tasks", "project", {foreignKey: true, type: "uuid"})` migration, use `await this.removeReference("tasks", "project")` in `down()`. It removes the generated foreign key, index, and column; see [removing references and foreign keys](docs/database-migrations.md#removing-references-and-foreign-keys) for custom-column and foreign-key-only cases.
+
 Migrations that must be rerunnable can guard changes with `tableExists(...)`, `columnExists(table, column)` and `indexExists(table, index)` — a missing table yields `false` rather than throwing. See [docs/database-migrations.md](docs/database-migrations.md#guarding-schema-changes-in-rerunnable-migrations).
 
 ## Run migrations from the command line

package/build/configuration.js

@@ -16,6 +16,7 @@ import {digg} from "diggerize"
 import gettextConfig from "gettext-universal/build/src/config.js"
 import translate from "gettext-universal/build/src/translate.js"
 import Ability from "./authorization/ability.js"
+import DatabaseOperation from "./database/operation.js"
 import {initializeAuditedModelRelationships} from "./database/record/auditing.js"
 import EventEmitter from "./utils/event-emitter.js"
 import VelociousWebsocketChannelSubscribers from "./http-server/websocket-channel-subscribers.js"
@@ -2896,6 +2897,41 @@ export default class VelociousConfiguration {
     })
   }
 
+  /**
+   * Runs explicit model work in a transaction pinned to one database connection.
+   * @template T
+   * @param {{databaseIdentifier: string, name?: string}} options - Operation options.
+   * @param {(operation: DatabaseOperation) => Promise<T>} callback - Operation callback.
+   * @returns {Promise<T>} - Resolves with the callback result.
+   */
+  async withTransaction({databaseIdentifier, name = "Configuration.withTransaction", ...restArgs}, callback) {
+    restArgsError(restArgs)
+
+    if (!databaseIdentifier) throw new Error("Configuration.withTransaction requires a databaseIdentifier")
+    if (typeof callback != "function") throw new Error("Configuration.withTransaction requires a callback")
+    if (!this.getDatabaseIdentifiers().includes(databaseIdentifier)) {
+      throw new Error(`Unknown or inactive database identifier: ${databaseIdentifier}`)
+    }
+
+    const pool = this.getDatabasePool(databaseIdentifier)
+
+    return await pool.withOperationConnection({name}, async (connection, owner) => {
+      const operation = new DatabaseOperation({
+        configuration: this,
+        configurationReuseKey: pool.getConnectionConfigurationReuseKey(connection),
+        connection,
+        databaseIdentifier,
+        owner
+      })
+
+      try {
+        return await operation.transaction(async () => await callback(operation))
+      } finally {
+        operation.complete()
+      }
+    })
+  }
+
   /**
    * Runs callback with database connections for the requested identifiers.
    * @template T

package/build/database/drivers/base-table.js

@@ -104,13 +104,15 @@ export default class VelociousDatabaseDriversBaseTable {
     }
 
     for (const foreignKey of await this.getForeignKeys()) {
-      tableData.addForeignKey(foreignKey.getTableDataForeignKey())
+      const tableDataForeignKey = foreignKey.getTableDataForeignKey()
+
+      tableData.addForeignKey(tableDataForeignKey)
 
       const tableDataColumn = tableDataColumns.find((tableDataColumn) => tableDataColumn.getName() == foreignKey.getColumnName())
 
       if (!tableDataColumn) throw new Error(`Couldn't find table data column for foreign key: ${foreignKey.getColumnName()}`)
 
-      tableDataColumn.setForeignKey(foreignKey)
+      tableDataColumn.setForeignKey(tableDataForeignKey)
     }
 
     for (const index of await this.getIndexes()) {
@@ -153,4 +155,3 @@ export default class VelociousDatabaseDriversBaseTable {
     return await this.getDriver().query(sql)
   }
 }
-

package/build/database/drivers/base.js

@@ -61,6 +61,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 +128,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.
@@ -175,6 +191,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.
@@ -224,6 +245,34 @@ export default class VelociousDatabaseDriversBase {
     }
   }
 
+  /**
+   * Runs remove foreign key.
+   * @param {string} tableName - Table name.
+   * @param {import("./base-foreign-key.js").default} foreignKeyMetadata - Foreign key metadata.
+   * @returns {Promise<void>} - Resolves when complete.
+   */
+  async removeForeignKey(tableName, foreignKeyMetadata) {
+    this._assertNotReadOnly()
+
+    const tableForeignKey = new TableForeignKey({
+      columnName: foreignKeyMetadata.getColumnName(),
+      dropForeignKey: true,
+      name: foreignKeyMetadata.getName(),
+      referencedColumnName: foreignKeyMetadata.getReferencedColumnName(),
+      referencedTableName: foreignKeyMetadata.getReferencedTableName(),
+      tableName
+    })
+    const tableData = new TableData(tableName)
+
+    tableData.addForeignKey(tableForeignKey)
+
+    const alterTableSQLs = await this.alterTableSQLs(tableData)
+
+    for (const alterTableSQL of alterTableSQLs) {
+      await this.query(alterTableSQL)
+    }
+  }
+
   /**
    * Runs alter table sqls.
    * @abstract
@@ -460,6 +509,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.
@@ -711,9 +800,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`)
   }
 
@@ -904,12 +994,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()
@@ -922,8 +1016,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) {
@@ -965,10 +1061,12 @@ 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.
@@ -979,14 +1077,19 @@ export default class VelociousDatabaseDriversBase {
 
     this._afterCommitCallbackFrames.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._afterCommitCallbackFrames.pop()
+      throw error
     }
 
     let result
@@ -996,15 +1099,13 @@ export default class VelociousDatabaseDriversBase {
 
       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)
@@ -1017,14 +1118,14 @@ export default class VelociousDatabaseDriversBase {
       if (savePointStarted) {
         this.logger.debug("Rollback savepoint", savePointName)
         try {
-          await this.rollbackSavePoint(savePointName)
+          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()
+            await this.rollbackTransaction(options)
             transactionRolledBack = true
           } else {
             throw savePointError
@@ -1038,7 +1139,7 @@ export default class VelociousDatabaseDriversBase {
       // `_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()
+        await this.rollbackTransaction(options)
       }
 
       this._afterCommitCallbackFrames.pop()
@@ -1046,6 +1147,12 @@ export default class VelociousDatabaseDriversBase {
       throw error
     }
 
+    try {
+      await this._commitAfterCommitCallbackFrame()
+    } catch (error) {
+      throw new VelociousDatabaseAfterCommitCallbackError(error)
+    }
+
     return result
   }
 
@@ -1053,9 +1160,12 @@ export default class VelociousDatabaseDriversBase {
    * 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) {
+  async afterCommit(callback, options = {}) {
+    await this._waitForOperationLease(options.operationOwner)
+
     const currentFrame = this._afterCommitCallbackFrames[this._afterCommitCallbackFrames.length - 1]
 
     if (!currentFrame) {
@@ -1074,40 +1184,60 @@ 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)
   }
 
   /**
@@ -1155,6 +1285,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
@@ -1204,16 +1335,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)
     }
   }
 
@@ -1581,12 +1714,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--
 
@@ -1602,10 +1736,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)
   }
 
   /**
@@ -1619,21 +1754,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)
   }
 
   /**
@@ -1663,22 +1800,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}`
 
@@ -1695,21 +1834,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)
   }
 
   /**