velocious 1.0.568 → 1.0.569

package/build/database/query/preloader/belongs-to.js

@@ -2,6 +2,7 @@
 
 import ensureModelClassInitialized from "./ensure-model-class-initialized.js"
 import PreloaderSelection from "./selection.js"
+import preloadQueryForModel from "./query-for-model.js"
 import restArgsError from "../../../utils/rest-args-error.js"
 
 export default class VelociousDatabaseQueryPreloaderBelongsTo {
@@ -94,7 +95,7 @@ export default class VelociousDatabaseQueryPreloaderBelongsTo {
       whereArgs[primaryKey] = [...foreignKeyValues]
 
       // Load target models to be preloaded on the given models
-      let query = targetModelClass.where(whereArgs)
+      let query = preloadQueryForModel(modelsToLoad, targetModelClass).where(whereArgs)
 
       query = this.relationship.applyScope(query)
       query = this.selection.applyToQuery({query, targetModelClass, mappingColumns: [primaryKey]})
@@ -211,7 +212,7 @@ export default class VelociousDatabaseQueryPreloaderBelongsTo {
 
       whereArgs[primaryKey] = [...foreignKeyValuesByType[targetType]]
 
-      let query = targetModelClass.where(whereArgs)
+      let query = preloadQueryForModel(this.models, targetModelClass).where(whereArgs)
 
       query = this.relationship.applyScope(query)
       query = this.selection.applyToQuery({query, targetModelClass, mappingColumns: [primaryKey]})

package/build/database/query/preloader/has-many.js

@@ -2,6 +2,7 @@
 
 import ensureModelClassInitialized from "./ensure-model-class-initialized.js"
 import PreloaderSelection from "./selection.js"
+import preloadQueryForModel from "./query-for-model.js"
 import restArgsError from "../../../utils/rest-args-error.js"
 
 /**
@@ -155,7 +156,7 @@ export default class VelociousDatabaseQueryPreloaderHasMany {
     }
 
     // Step 1: Query the through table to build parent→target ID mapping
-    const throughModels = await throughModelClass
+    const throughModels = await preloadQueryForModel(modelsToLoad, throughModelClass)
       .where({[throughForeignKey]: [...modelsPrimaryKeyValues]})
       .toArray()
 
@@ -186,7 +187,7 @@ export default class VelociousDatabaseQueryPreloaderHasMany {
     let targetModels = []
 
     if (allTargetIds.size > 0) {
-      let query = targetModelClass.where({[targetForeignKey]: [...allTargetIds]})
+      let query = preloadQueryForModel(modelsToLoad, targetModelClass).where({[targetForeignKey]: [...allTargetIds]})
 
       query = this.relationship.applyScope(query)
       query = this.selection.applyToQuery({query, targetModelClass, mappingColumns: [targetForeignKey]})
@@ -299,7 +300,7 @@ export default class VelociousDatabaseQueryPreloaderHasMany {
 
     await ensureModelClassInitialized(targetModelClass, this.relationship.getConfiguration())
 
-    let query = targetModelClass.where(whereArgs)
+    let query = preloadQueryForModel(modelsToLoad, targetModelClass).where(whereArgs)
 
     query = this.relationship.applyScope(query)
     query = this.selection.applyToQuery({query, targetModelClass, mappingColumns: [foreignKey]})

package/build/database/query/preloader/has-one.js

@@ -2,6 +2,7 @@
 
 import ensureModelClassInitialized from "./ensure-model-class-initialized.js"
 import PreloaderSelection from "./selection.js"
+import preloadQueryForModel from "./query-for-model.js"
 import restArgsError from "../../../utils/rest-args-error.js"
 
 export default class VelociousDatabaseQueryPreloaderHasOne {
@@ -87,7 +88,7 @@ export default class VelociousDatabaseQueryPreloaderHasOne {
     await ensureModelClassInitialized(targetModelClass, this.relationship.getConfiguration())
 
     // Load target models to be preloaded on the given models
-    let query = targetModelClass.where(whereArgs)
+    let query = preloadQueryForModel(this.models, targetModelClass).where(whereArgs)
 
     query = this.relationship.applyScope(query)
     query = this.selection.applyToQuery({query, targetModelClass, mappingColumns: [foreignKey]})

package/build/database/query/preloader/query-for-model.js

@@ -0,0 +1,17 @@
+// @ts-check
+
+/**
+ * Builds a target query preserving the explicit database operation owned by
+ * the source records.
+ * @template {typeof import("../../record/index.js").default} MC
+ * @param {import("../../record/index.js").default[]} models - Source records.
+ * @param {MC} ModelClass - Target model class.
+ * @returns {import("../model-class-query.js").default<MC>} - Target query.
+ */
+export default function preloadQueryForModel(models, ModelClass) {
+  const sourceModel = models[0]
+
+  if (!sourceModel) throw new Error("Cannot build a preload query without source records")
+
+  return sourceModel.queryForModel(ModelClass)
+}

package/build/database/query/query-data.js

@@ -190,7 +190,15 @@ export async function runQueryData({rootModelClass, rootModels, entries}) {
 
   const primaryKey = rootModelClass.primaryKey()
   const rootIds = rootModels.map((model) => /** @type {string | number} */ (model.readColumn(primaryKey)))
-  const preparedEntries = entries.map((entry, entryIndex) => prepareEntry({entry, entryIndex, primaryKey, rootIds, rootModelClass}))
+  const sourceModel = rootModels[0]
+  const preparedEntries = entries.map((entry, entryIndex) => prepareEntry({
+    entry,
+    entryIndex,
+    primaryKey,
+    rootIds,
+    rootModelClass,
+    sourceModel
+  }))
   /**
    * Compatible query groups.
    * @type {Array<{aliases: Set<string>, query: import("./model-class-query.js").default, signature: string}>} */
@@ -231,9 +239,10 @@ export async function runQueryData({rootModelClass, rootModels, entries}) {
  * @param {string} args.primaryKey - Root model primary key column.
  * @param {Array<string | number>} args.rootIds - Root primary-key values.
  * @param {typeof import("../record/index.js").default} args.rootModelClass - Root model class.
+ * @param {import("../record/index.js").default} args.sourceModel - Loaded operation owner.
  * @returns {{aliases: string[], query: import("./model-class-query.js").default, signature: string}} - Prepared entry.
  */
-function prepareEntry({entry, entryIndex, primaryKey, rootIds, rootModelClass}) {
+function prepareEntry({entry, entryIndex, primaryKey, rootIds, rootModelClass, sourceModel}) {
   const targetModelClass = resolveTargetModelClass(rootModelClass, entry.chain)
   const fn = targetModelClass.getQueryDataByName(entry.fnName)
 
@@ -242,7 +251,7 @@ function prepareEntry({entry, entryIndex, primaryKey, rootIds, rootModelClass})
       `Declare it with ${targetModelClass.name}.queryData(${JSON.stringify(entry.fnName)}, ({query, tableName}) => query.select(...))`)
   }
 
-  const query = rootModelClass._newQuery()
+  const query = sourceModel.queryForModel(rootModelClass)
 
   // Empty out any defaults the query factory added — queryData runs
   // a bare aggregate, not a full model load.

package/build/database/query/with-count.js

@@ -111,10 +111,11 @@ export async function runWithCount({models, modelClass, entries}) {
 
   const primaryKey = modelClass.primaryKey()
   const parentIds = models.map((model) => /** @type {string | number} */ (model.readColumn(primaryKey)))
+  const sourceModel = models[0]
   const queryGroups = new Map()
 
   for (const entry of entries) {
-    const countQuery = queryForEntry({entry, modelClass, parentIds})
+    const countQuery = queryForEntry({entry, modelClass, parentIds, sourceModel})
     const sql = countQuery.toSql()
     const existingGroup = queryGroups.get(sql)
 
@@ -138,9 +139,10 @@ export async function runWithCount({models, modelClass, entries}) {
  * @param {WithCountEntry} args.entry - Entry being evaluated.
  * @param {typeof import("../record/index.js").default} args.modelClass - Parent model class.
  * @param {Array<string | number>} args.parentIds - Primary keys of the loaded parents.
+ * @param {import("../record/index.js").default} args.sourceModel - Loaded operation owner.
  * @returns {import("./model-class-query.js").default} - Prepared count query.
  */
-function queryForEntry({entry, modelClass, parentIds}) {
+function queryForEntry({entry, modelClass, parentIds, sourceModel}) {
   const relationship = modelClass.getRelationshipByName(entry.relationshipName)
 
   if (!relationship) {
@@ -172,7 +174,7 @@ function queryForEntry({entry, modelClass, parentIds}) {
     Object.assign(whereConditions, entry.where)
   }
 
-  const baseQuery = targetModelClass._newQuery()
+  const baseQuery = sourceModel.queryForModel(targetModelClass)
   baseQuery._forceQualifyBaseTable = true
   baseQuery.where(whereConditions)
 

package/build/database/record/acts-as-list.js

@@ -173,7 +173,7 @@ function assertPositivePosition({position, positionColumn, persisted = false}) {
  */
 async function placeMovedRecord({record, positionColumn, scope, scopeValue, position}) {
   const modelClass = /** @type {typeof import("./index.js").default} */ (record.constructor)
-  const connection = modelClass.connection()
+  const connection = record.connection()
   const tableSql = connection.quoteTable(modelClass._getTable().getName())
   const scopeCol = modelClass.getColumnNameForAttributeName(scope)
   const posCol = modelClass.getColumnNameForAttributeName(positionColumn)
@@ -224,7 +224,7 @@ function clearBelongsToChangeForScope(record) {
  */
 async function shiftPositionsUp({record, positionColumn, scope, fromPosition, toPosition, scopeValue, excludeRecordId}) {
   const modelClass = /** @type {typeof import("./index.js").default} */ (record.constructor)
-  const connection = modelClass.connection()
+  const connection = record.connection()
   const tableName = modelClass._getTable().getName()
   const resolvedScopeValue = scopeValue != null ? scopeValue : resolveScopeValue(record, scope)
   const scopeColumnName = modelClass.getColumnNameForAttributeName(scope)
@@ -239,7 +239,8 @@ async function shiftPositionsUp({record, positionColumn, scope, fromPosition, to
   const quotedScope = connection.quote(resolvedScopeValue)
 
   // Load rows in descending order so we bump the highest first
-  let query = modelClass
+  let query = record
+    .queryForModel(modelClass)
     .select(modelClass.primaryKey())
     .select(positionColumn)
     .where({[scopeColumnName]: resolvedScopeValue})
@@ -289,7 +290,7 @@ async function shiftPositionsUp({record, positionColumn, scope, fromPosition, to
  */
 async function shiftPositionsDown({record, positionColumn, scope, fromPosition, toPosition, scopeValue}) {
   const modelClass = /** @type {typeof import("./index.js").default} */ (record.constructor)
-  const connection = modelClass.connection()
+  const connection = record.connection()
   const tableName = modelClass._getTable().getName()
   const resolvedScopeValue = scopeValue != null ? scopeValue : resolveScopeValue(record, scope)
   const scopeColumnName = modelClass.getColumnNameForAttributeName(scope)
@@ -304,7 +305,8 @@ async function shiftPositionsDown({record, positionColumn, scope, fromPosition,
   const quotedScope = connection.quote(resolvedScopeValue)
 
   // Load rows in ascending order so we shift the lowest gap first
-  let query = modelClass
+  let query = record
+    .queryForModel(modelClass)
     .select(modelClass.primaryKey())
     .select(positionColumn)
     .where({[scopeColumnName]: resolvedScopeValue})
@@ -345,7 +347,7 @@ async function shiftPositionsDown({record, positionColumn, scope, fromPosition,
  */
 async function highestPositionInScope({record, positionColumn, scope, scopeValue}) {
   const modelClass = /** @type {typeof import("./index.js").default} */ (record.constructor)
-  const connection = modelClass.connection()
+  const connection = record.connection()
   const scopeColumnName = modelClass.getColumnNameForAttributeName(scope)
   const positionColumnName = modelClass.getColumnNameForAttributeName(positionColumn)
   const positionColumnSql = connection.quoteColumn(positionColumnName)
@@ -353,7 +355,8 @@ async function highestPositionInScope({record, positionColumn, scope, scopeValue
 
   if (resolvedScopeValue == null) return 0
 
-  const rows = await modelClass
+  const rows = await record
+    .queryForModel(modelClass)
     .select(positionColumn)
     .where({[scopeColumnName]: resolvedScopeValue})
     .order(`${positionColumnSql} DESC`)
@@ -415,7 +418,7 @@ function resolveScopeValue(record, scope) {
  */
 async function moveOutOfWay({record, positionColumn, scope, scopeValue}) {
   const modelClass = /** @type {typeof import("./index.js").default} */ (record.constructor)
-  const connection = modelClass.connection()
+  const connection = record.connection()
   const tableName = modelClass._getTable().getName()
   const resolvedScopeValue = scopeValue != null ? scopeValue : resolveScopeValue(record, scope)
 

package/build/database/record/attachments/store.js

@@ -88,9 +88,10 @@ export default class RecordAttachmentsStore {
 
   /**
    * Runs ensure ready.
+   * @param {import("../index.js").default} [model] - Operation-owning model.
    * @returns {Promise<void>} - Resolves when schema is ready.
    */
-  async ensureReady() {
+  async ensureReady(model) {
     if (this._readyPromise) {
       await this._readyPromise
       return
@@ -124,7 +125,7 @@ export default class RecordAttachmentsStore {
         await db.createTable(table)
         this._driverColumnsAvailable = true
         this._contentBase64Nullable = true
-      })
+      }, model)
     })()
 
     try {
@@ -144,7 +145,7 @@ export default class RecordAttachmentsStore {
    * @returns {Promise<void>} - Resolves when complete.
    */
   async attach({input, model, name, replace}) {
-    await this.ensureReady()
+    await this.ensureReady(model)
     const attachmentsConfiguration = this.configuration.getAttachmentsConfiguration?.() || {}
     const allowPathInput = attachmentsConfiguration.allowPathInput === true
     const allowedPathPrefixes = Array.isArray(attachmentsConfiguration.allowedPathPrefixes)
@@ -298,7 +299,7 @@ export default class RecordAttachmentsStore {
         })
 
         rowPersisted = true
-      })
+      }, model)
     } catch (error) {
       if (!rowPersisted && storageKey && typeof attachmentDriver.delete === "function") {
         try {
@@ -435,7 +436,7 @@ export default class RecordAttachmentsStore {
    * @returns {Promise<Record<string, ?> | null>} - Attachment row.
    */
   async findOne({id, model, name}) {
-    await this.ensureReady()
+    await this.ensureReady(model)
 
     return await this._withDb(async (db) => {
       const recordType = model.getModelClass().getModelName()
@@ -455,7 +456,7 @@ export default class RecordAttachmentsStore {
       const rows = await query.results()
 
       return rows[0] || null
-    })
+    }, model)
   }
 
   /**
@@ -466,7 +467,7 @@ export default class RecordAttachmentsStore {
    * @returns {Promise<Array<Record<string, ?>>>} - Attachment rows.
    */
   async findMany({model, name}) {
-    await this.ensureReady()
+    await this.ensureReady(model)
 
     return await this._withDb(async (db) => {
       const recordType = model.getModelClass().getModelName()
@@ -479,7 +480,7 @@ export default class RecordAttachmentsStore {
         .order("created_at_ms ASC")
 
       return await query.results()
-    })
+    }, model)
   }
 
   /**
@@ -517,7 +518,7 @@ export default class RecordAttachmentsStore {
    * @returns {Promise<number>} - Number of attachments purged.
    */
   async purgeAll({model, name}) {
-    await this.ensureReady()
+    await this.ensureReady(model)
 
     return await this._withDb(async (db) => {
       const recordType = model.getModelClass().getModelName()
@@ -549,7 +550,7 @@ export default class RecordAttachmentsStore {
       }
 
       return rows.length
-    })
+    }, model)
   }
 
   /**
@@ -732,9 +733,12 @@ export default class RecordAttachmentsStore {
    * Runs with db.
    * @template T
    * @param {(db: import("../../../database/drivers/base.js").default) => Promise<T>} callback - Callback.
+   * @param {import("../index.js").default} [model] - Operation-owning model.
    * @returns {Promise<T>} - Callback result.
    */
-  async _withDb(callback) {
+  async _withDb(callback, model) {
+    if (model && model.databaseOperation()) return await callback(model.connection())
+
     const pool = this.configuration.getDatabasePool(this.databaseIdentifier)
     /**
      * Defines result.

package/build/database/record/auditing.js

@@ -148,18 +148,20 @@ function dedicatedAuditTableName(modelClass) {
  * Resolves audit table data for a model class. Cached per model.
  * Called lazily on first createAudit / withoutAudit / relationship usage.
  * @param {AuditedModelClass} modelClass - Audited model class.
+ * @param {import("../drivers/base.js").default} [connection] - Explicit record-owned connection.
  * @returns {Promise<AuditTableData>} Resolved audit table metadata.
  */
-async function resolveAuditTableData(modelClass) {
+async function resolveAuditTableData(modelClass, connection) {
   if (modelClass._auditTableResolved && modelClass._auditTableData) {
     return modelClass._auditTableData
   }
 
-  const tableData = await buildAuditTableData(modelClass)
+  const resolvedConnection = connection || modelClass.connection()
+  const tableData = await buildAuditTableData(modelClass, resolvedConnection)
   const configuration = modelClass._getConfiguration()
 
   tableData.auditClass.registerRecordClass({configuration})
-  await tableData.auditClass.initializeRecord({configuration})
+  await tableData.auditClass.initializeRecord({configuration, connection: resolvedConnection})
 
   modelClass._auditTableData = tableData
   modelClass._auditTableResolved = true
@@ -174,11 +176,12 @@ async function resolveAuditTableData(modelClass) {
  * registered Audit model for shared tables; falls back to a framework-owned
  * dynamic class.
  * @param {AuditedModelClass} modelClass - Audited model class.
+ * @param {import("../drivers/base.js").default} connection - Explicit record-owned connection.
  * @returns {Promise<AuditTableData>} Audit table metadata.
  */
-async function buildAuditTableData(modelClass) {
+async function buildAuditTableData(modelClass, connection) {
   const dedicatedTable = dedicatedAuditTableName(modelClass)
-  const dedicatedExists = await dedicatedTableExistsForConnection(modelClass, dedicatedTable)
+  const dedicatedExists = await dedicatedTableExistsForConnection(modelClass, dedicatedTable, connection)
 
   if (dedicatedExists) {
     const auditClass = dedicatedAuditClass(modelClass, dedicatedTable)
@@ -217,9 +220,10 @@ async function buildAuditTableData(modelClass) {
  * Checks whether a dedicated audit table exists for a model's connection.
  * @param {AuditedModelClass} modelClass - Audited model class.
  * @param {string} tableName - Dedicated audit table name to check.
+ * @param {import("../drivers/base.js").default} connection - Explicit record-owned connection.
  * @returns {Promise<boolean>} Whether the table exists.
  */
-async function dedicatedTableExistsForConnection(modelClass, tableName) {
+async function dedicatedTableExistsForConnection(modelClass, tableName, connection) {
   const databaseIdentifier = modelClass.getDatabaseIdentifier()
   const cacheKey = `${databaseIdentifier}:${tableName}`
   const cached = dedicatedTableCache.get(cacheKey)
@@ -228,7 +232,6 @@ async function dedicatedTableExistsForConnection(modelClass, tableName) {
     return cached
   }
 
-  const connection = modelClass.connection()
   const table = await connection.getTableByName(tableName, {throwError: false})
   const exists = Boolean(table)
 
@@ -546,11 +549,11 @@ async function createAudit(record, args) {
 async function createAuditWithCurrentConnection(record, args, modelClass) {
   if (!record.isPersisted()) throw new Error(`Cannot audit unpersisted ${modelClass.getModelName()} record`)
 
-  const tableData = await resolveAuditTableData(modelClass)
+  const db = record.connection()
+  const tableData = await resolveAuditTableData(modelClass, db)
   const action = normalizeAction(args.action)
   const auditedChanges = args.auditedChanges === undefined ? null : args.auditedChanges
   const params = args.params === undefined ? null : args.params
-  const db = modelClass.connection()
   const currentDate = new Date()
 
   const auditActionId = await findOrCreateLookupId({

package/build/database/record/counter-cache-magnitude.js

@@ -204,9 +204,11 @@ async function incrementParentCounter(record, definition, parentId, amount) {
     throw new Error(`magnitudeCounterCache on ${modelClass.getModelName()} could not resolve the "${definition.belongsTo}" parent model class`)
   }
 
-  // Update through the PARENT model's connection: the row being modified belongs
-  // to the parent, which may live on a different database/tenant than the child.
-  const db = parentModelClass.connection()
+  // Resolve through the record so an operation both owns the parent write and
+  // rejects a relationship whose parent routes to another database.
+  const db = record
+    .queryForModel(parentModelClass)
+    .driver
   const counterColumnSql = db.quoteColumn(definition.counterColumn)
   const truncatedAmount = Math.trunc(amount)
 

package/build/database/record/index.js

@@ -444,6 +444,11 @@ class VelociousDatabaseRecord {
    * @type {import("../drivers/base.js").default | undefined} */
   __connection = undefined
 
+  /**
+   * Explicit operation owning this record's database work.
+   * @type {import("../operation.js").default | undefined} */
+  _databaseOperation = undefined
+
   /**
    * Instance relationships.
    * @type {Record<string, import("./instance-relationships/base.js").default>} */
@@ -863,9 +868,10 @@ class VelociousDatabaseRecord {
      * single UPDATE ... SET col = (SELECT COUNT(*)) so concurrent
      * creates/destroys cannot race into a stale count.
      * @param {number | string | null} parentId - Parent primary-key value.
+     * @param {VelociousDatabaseRecord} record - Child record owning the connection.
      * @returns {Promise<void>} - Resolves when the counter cache has been synced.
      */
-    async function syncCounter(parentId) {
+    async function syncCounter(parentId, record) {
       if (!parentId) return
 
       const relationship = ChildModel.getRelationshipByName(relationshipName)
@@ -880,7 +886,9 @@ class VelociousDatabaseRecord {
       const parentTable = ParentModel.tableName()
       const childTable = ChildModel.tableName()
       const pkColumn = inflection.underscore(primaryKey)
-      const connection = ParentModel.connection()
+      const connection = record
+        .queryForModel(ParentModel)
+        .driver
       const quoted = connection.quote(parentId)
 
       const sql = `UPDATE ${connection.quoteTable(parentTable)} SET ${connection.quoteColumn(counterColumn)} = (SELECT COUNT(*) FROM ${connection.quoteTable(childTable)} WHERE ${connection.quoteColumn(fk)} = ${quoted}) WHERE ${connection.quoteColumn(pkColumn)} = ${quoted}`
@@ -901,11 +909,11 @@ class VelociousDatabaseRecord {
     }
 
     ChildModel.afterCreate(async (record) => {
-      await syncCounter(readFkAttribute(record))
+      await syncCounter(readFkAttribute(record), record)
     })
 
     ChildModel.afterDestroy(async (record) => {
-      await syncCounter(readFkAttribute(record))
+      await syncCounter(readFkAttribute(record), record)
     })
 
     ChildModel.beforeSave(async (record) => {
@@ -932,8 +940,8 @@ class VelociousDatabaseRecord {
 
       if (previousParentId !== undefined) {
         delete model[prevKey]
-        await syncCounter(previousParentId)
-        await syncCounter(readFkAttribute(model))
+        await syncCounter(previousParentId, record)
+        await syncCounter(readFkAttribute(model), record)
       }
     })
   }
@@ -1452,15 +1460,16 @@ class VelociousDatabaseRecord {
    * Runs initialize record.
    * @param {object} args - Options object.
    * @param {import("../../configuration.js").default} args.configuration - Configuration instance.
+   * @param {import("../drivers/base.js").default} [args.connection] - Explicit metadata connection.
    * @returns {Promise<void>} - Resolves when complete.
    */
-  static async initializeRecord({configuration, ...restArgs}) {
+  static async initializeRecord({configuration, connection: explicitConnection, ...restArgs}) {
     restArgsError(restArgs)
 
     if (!configuration) throw new Error(`No configuration given for ${this.name}`)
 
     this.registerRecordClass({configuration})
-    const connection = this.connection({enforceTenantDatabaseScope: false})
+    const connection = explicitConnection || this.connection({enforceTenantDatabaseScope: false})
 
     this._databaseType = connection.getType()
 
@@ -2427,7 +2436,7 @@ class VelociousDatabaseRecord {
       await this._runLifecycleCallbacks("beforeValidation")
       await this._runValidations()
 
-      await this.getModelClass().transaction(async () => {
+      const saveInTransaction = async () => {
         await this._runLifecycleCallbacks("beforeSave")
 
         // If any belongs-to-relationships was saved, then updated-at should still be set on this record.
@@ -2454,7 +2463,13 @@ class VelociousDatabaseRecord {
         await this._autoSaveAttachments()
         await this._runLifecycleCallbacks("afterSave")
         await this._emitRecordChangeAfterCommit(isNewRecord ? "create" : "update")
-      })
+      }
+
+      if (this._databaseOperation) {
+        await this._databaseOperation.transaction(saveInTransaction)
+      } else {
+        await this.getModelClass().transaction(saveInTransaction)
+      }
     })
 
     this._assignedAttributeNames = undefined
@@ -2481,6 +2496,7 @@ class VelociousDatabaseRecord {
       if (model) {
         if (model instanceof VelociousDatabaseRecord) {
           if (model.isChanged()) {
+            this.bindRelatedRecord(model)
             await model.save()
 
             const foreignKey = this._relationshipForeignKeyAttribute(instanceRelationship)
@@ -2539,6 +2555,7 @@ class VelociousDatabaseRecord {
 
       if (loaded) {
         for (const model of loaded) {
+          this.bindRelatedRecord(model)
           const foreignKey = model._relationshipForeignKeyAttribute(instanceRelationship)
 
           model.setAttribute(foreignKey, this.id())
@@ -2592,6 +2609,7 @@ class VelociousDatabaseRecord {
       }
 
       for (const model of loaded) {
+        this.bindRelatedRecord(model)
         const foreignKey = model._relationshipForeignKeyAttribute(instanceRelationship)
 
         model.setAttribute(foreignKey, this.id())
@@ -3021,15 +3039,18 @@ class VelociousDatabaseRecord {
    * Runs new query.
    * @template {typeof VelociousDatabaseRecord} MC
    * @this {MC}
+   * @param {{driver?: import("../drivers/base.js").default | (() => import("../drivers/base.js").default), operation?: import("../operation.js").default}} [args] - Explicit query ownership.
    * @returns {ModelClassQuery<MC>} - The new query.
    */
-  static _newQuery() {
+  static _newQuery({driver = () => this.connection(), operation, ...restArgs} = {}) {
+    restArgsError(restArgs)
     this._assertHasBeenInitialized()
     const handler = new Handler()
     const query = new ModelClassQuery({
-      driver: () => this.connection(),
+      driver,
       handler,
-      modelClass: this
+      modelClass: this,
+      operation
     })
 
     return query.from(new FromTable(this.tableName()))
@@ -3416,6 +3437,53 @@ class VelociousDatabaseRecord {
     }
   }
 
+  /**
+   * Binds future query, lifecycle, relationship, and persistence work to an operation.
+   * @param {import("../operation.js").default} operation - Owning operation.
+   * @returns {this} - Bound record.
+   */
+  bindDatabaseOperation(operation) {
+    if (this._databaseOperation && this._databaseOperation !== operation) {
+      throw new Error("Record is already bound to another database operation")
+    }
+
+    this._databaseOperation = operation
+
+    return this
+  }
+
+  /**
+   * Returns the explicit operation owning this record, if any.
+   * @returns {import("../operation.js").default | undefined} - Owning operation.
+   */
+  databaseOperation() {
+    return this._databaseOperation
+  }
+
+  /**
+   * Binds a related record to the same operation as this record.
+   * @template {VelociousDatabaseRecord} Model
+   * @param {Model} record - Related record.
+   * @returns {Model} - Related record.
+   */
+  bindRelatedRecord(record) {
+    if (this._databaseOperation) this._databaseOperation.bindRecord(record)
+
+    return record
+  }
+
+  /**
+   * Builds a model query preserving this record's operation ownership.
+   * @template {typeof VelociousDatabaseRecord} MC
+   * @param {MC} ModelClass - Target model class.
+   * @returns {ModelClassQuery<MC>} - Target query.
+   */
+  queryForModel(ModelClass) {
+    if (this._databaseOperation) return this._databaseOperation.forModel(ModelClass)
+
+    return ModelClass._newQuery()
+  }
+
   /**
    * Runs load existing record.
    * @param {object} attributes - Attributes.
@@ -3473,11 +3541,20 @@ class VelociousDatabaseRecord {
    * @returns {import("../drivers/base.js").default} - The connection.
    */
   _connection() {
+    if (this._databaseOperation) return this._databaseOperation.connection()
     if (this.__connection) return this.__connection
 
     return this.getModelClass().connection()
   }
 
+  /**
+   * Returns the connection that owns this record's database work.
+   * @returns {import("../drivers/base.js").default} - Connection.
+   */
+  connection() {
+    return this._connection()
+  }
+
   /**
    * Counts dependent records for a `dependent: "restrict"` relationship.
    * @param {RestrictInstanceRelationship} instanceRelationship - Relationship instance to count.
@@ -4374,7 +4451,11 @@ class VelociousDatabaseRecord {
 
     whereObject[primaryKey] = id
 
-    const query = /** @type {import("../query/model-class-query.js").default<MC>} */ (this.getModelClass().where(whereObject))
+    const query = /** @type {import("../query/model-class-query.js").default<MC>} */ (
+      this
+        .queryForModel(this.getModelClass())
+        .where(whereObject)
+    )
     const reloadedModel = await query.first()
 
     if (!reloadedModel) throw new Error(`${this.constructor.name}#${id} couldn't be reloaded - record didn't exist`)