velocious 1.0.568 → 1.0.570

package/src/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`)

package/src/database/record/instance-relationships/belongs-to.js

@@ -27,7 +27,9 @@ export default class VelociousDatabaseRecordBelongsToInstanceRelationship extend
 
     if (!TargetModelClass) throw new Error("Can't build a new record without a target model")
 
-    const newInstance = /** @type {InstanceType<TMC>} */ (new TargetModelClass(data))
+    const newInstance = this.getModel().bindRelatedRecord(
+      /** @type {InstanceType<TMC>} */ (new TargetModelClass(data))
+    )
 
     this._loaded = newInstance
 
@@ -85,7 +87,7 @@ export default class VelociousDatabaseRecordBelongsToInstanceRelationship extend
 
     whereArgs[primaryKey] = foreignModelID
 
-    const query = this.applyScope(TargetModelClass.where(whereArgs))
+    const query = this.applyScope(this.getModel().queryForModel(TargetModelClass).where(whereArgs))
 
     const foreignModel = await query.first()
 

package/src/database/record/instance-relationships/has-many.js

@@ -29,8 +29,9 @@ export default class VelociousDatabaseRecordHasManyInstanceRelationship extends
 
     if (!targetModelClass) throw new Error("Can't build a new record without a taget model class")
 
-    const newInstance = /** @type {InstanceType<TMC>} */ (new targetModelClass(data))
-
+    const newInstance = this.getModel().bindRelatedRecord(
+      /** @type {InstanceType<TMC>} */ (new targetModelClass(data))
+    )
 
     // Add it to the loaded models of this relationship
     if (this._loaded === undefined) {
@@ -196,13 +197,14 @@ export default class VelociousDatabaseRecordHasManyInstanceRelationship extends
       )
       const targetTable = TargetModelClass.tableName()
       const throughTable = throughModelClass.tableName()
-      const driver = TargetModelClass.connection()
+      const baseQuery = this.getModel().queryForModel(TargetModelClass)
+      const driver = baseQuery.driver
       const parentPrimaryKey = this.getPrimaryKey()
       const parentId = /** @type {string | number} */ (this.getModel().readColumn(parentPrimaryKey))
       const joinSql = `LEFT JOIN ${driver.quoteTable(throughTable)} ON ${driver.quoteTable(throughTable)}.${driver.quoteColumn(throughPrimaryKey)} = ${driver.quoteTable(targetTable)}.${driver.quoteColumn(targetForeignKey)}`
       const whereSql = `${driver.quoteTable(throughTable)}.${driver.quoteColumn(throughForeignKey)} = ${driver.options().quote(parentId)}`
 
-      const query = TargetModelClass.joins(joinSql).where(whereSql)
+      const query = baseQuery.joins(joinSql).where(whereSql)
 
       return this.applyScope(query)
     }
@@ -224,7 +226,7 @@ export default class VelociousDatabaseRecordHasManyInstanceRelationship extends
       whereArgs[typeColumn] = this.getModel().getModelClass().getModelName()
     }
 
-    const query = TargetModelClass.where(whereArgs)
+    const query = this.getModel().queryForModel(TargetModelClass).where(whereArgs)
 
     return this.applyScope(query)
   }

package/src/database/record/instance-relationships/has-one.js

@@ -32,7 +32,9 @@ export default class VelociousDatabaseRecordHasOneInstanceRelationship extends B
 
     if (!TargetModelClass) throw new Error("Can't build a new record without a target model class")
 
-    const newInstance = /** @type {InstanceType<TMC>} */ (new TargetModelClass(data))
+    const newInstance = this.getModel().bindRelatedRecord(
+      /** @type {InstanceType<TMC>} */ (new TargetModelClass(data))
+    )
 
     this._loaded = newInstance
 
@@ -64,7 +66,7 @@ export default class VelociousDatabaseRecordHasOneInstanceRelationship extends B
 
     whereArgs[foreignKey] = primaryModelID
 
-    let query = TargetModelClass.where(whereArgs)
+    let query = this.getModel().queryForModel(TargetModelClass).where(whereArgs)
 
     query = this.applyScope(query)
 

package/src/database/record/validators/uniqueness.js

@@ -15,7 +15,7 @@ export default class VelociousDatabaseRecordValidatorsUniqueness extends Base {
   async validate({model, attributeName}) {
     const modelClass = /** @type {typeof import("../index.js").default} */ (model.constructor)
 
-    const connection = modelClass.connection()
+    const connection = model.connection()
     const tableName = modelClass._getTable().getName()
     const attributeValue = /** @type {string | number} */ (model.readAttribute(attributeName))
     const attributeNameUnderscore = inflection.underscore(attributeName)
@@ -49,7 +49,8 @@ export default class VelociousDatabaseRecordValidatorsUniqueness extends Base {
       whereArgs[scopeUnderscore] = /** @type {string | number} */ (scopeValue)
     }
 
-    let existingRecordQuery = modelClass
+    let existingRecordQuery = model
+      .queryForModel(modelClass)
       .select(modelClass.primaryKey())
       .where(whereArgs)
 

package/src/frontend-models/websocket-publishers.js

@@ -145,7 +145,7 @@ export async function ensureFrontendModelWebsocketPublishersRegistered(configura
 
       if (action !== "create" && action !== "update") return
 
-      void model.getModelClass().connection().afterCommit(async () => {
+      void model.connection().afterCommit(async () => {
         broadcastFrontendModelEvent(model._getConfiguration(), modelName, {
           action,
           id: model.id(),
@@ -156,7 +156,7 @@ export async function ensureFrontendModelWebsocketPublishersRegistered(configura
     })
 
     modelClass.afterDestroy((model) => {
-      void model.getModelClass().connection().afterCommit(async () => {
+      void model.connection().afterCommit(async () => {
         broadcastFrontendModelEvent(model._getConfiguration(), modelName, {
           action: "destroy",
           id: model.id()

package/src/sync/server-sequence-allocator.js

@@ -49,23 +49,52 @@ export default class ServerSequenceAllocator {
    * parallel `next()` calls - including calls from other allocator instances
    * sharing the same table and connection - cannot interleave their insert
    * and last-insert-id reads and hand out duplicate sequences.
+   * @param {{connection?: import("../database/drivers/base.js").default}} [options] - Explicit record-owned connection.
    * @returns {Promise<number>} Next sequence value.
    */
-  async next() {
+  async next({connection} = {}) {
     const queueKey = `${this.databaseIdentifier}::${this.tableName}`
     const previousAllocation = allocationQueues.get(queueKey) ?? Promise.resolve()
-    const allocation = previousAllocation.then(() => this._allocateNext())
+    const allocation = previousAllocation.then(() => this._allocateNext(connection))
 
     allocationQueues.set(queueKey, allocation.then(() => undefined, () => undefined))
 
     return await allocation
   }
 
+  /**
+   * Allocates for a record while preserving allocator routing and operation ownership.
+   * @param {import("../database/record/index.js").default} record - Record receiving the sequence.
+   * @returns {Promise<number>} Next sequence value.
+   */
+  async _nextForRecord(record) {
+    const operation = record.databaseOperation()
+
+    if (!operation) return await this.next()
+
+    const ModelClass = record.getModelClass()
+
+    if (this._getConfiguration() !== ModelClass._getConfiguration()) {
+      throw new Error("Server sequence allocator belongs to another Velocious configuration")
+    }
+
+    const modelDatabaseIdentifier = ModelClass.getDatabaseIdentifier()
+
+    if (this.databaseIdentifier !== modelDatabaseIdentifier) {
+      throw new Error(`Server sequence allocator uses database ${JSON.stringify(this.databaseIdentifier)}, not operation model database ${JSON.stringify(modelDatabaseIdentifier)}`)
+    }
+
+    const operationScope = operation.forModel(ModelClass)
+
+    return await this.next({connection: operationScope.driver})
+  }
+
   /**
    * Ensures the backing table exists.
+   * @param {import("../database/drivers/base.js").default} [connection] - Explicit record-owned connection.
    * @returns {Promise<void>} Resolves when ready.
    */
-  async ensureReady() {
+  async ensureReady(connection) {
     if (this._isReady) return
 
     if (this._usesMemoryStorage()) {
@@ -85,7 +114,7 @@ export default class ServerSequenceAllocator {
       // cache readiness when the table was not created inside an active
       // transaction; otherwise the next allocation re-verifies the table.
       if (!created || !db.insideTransaction()) this._isReady = true
-    })
+    }, connection)
 
     try {
       await this._readyPromise
@@ -96,10 +125,11 @@ export default class ServerSequenceAllocator {
 
   /**
    * Allocates one sequence value after queueing.
+   * @param {import("../database/drivers/base.js").default} [connection] - Explicit record-owned connection.
    * @returns {Promise<number>} Allocated sequence value.
    */
-  async _allocateNext() {
-    await this.ensureReady()
+  async _allocateNext(connection) {
+    await this.ensureReady(connection)
 
     if (this._usesMemoryStorage()) {
       return ++this._memorySequence
@@ -123,7 +153,7 @@ export default class ServerSequenceAllocator {
       if (insertedId !== undefined && insertedId !== null) return Number(insertedId)
 
       return Number(await db.lastInsertID())
-    })
+    }, connection)
   }
 
   /**
@@ -158,9 +188,12 @@ export default class ServerSequenceAllocator {
    * Runs a callback with a database connection.
    * @template Result
    * @param {(db: import("../database/drivers/base.js").default) => Promise<Result>} callback - Database callback.
+   * @param {import("../database/drivers/base.js").default} [connection] - Explicit record-owned connection.
    * @returns {Promise<Result>} Callback result.
    */
-  async _withDb(callback) {
+  async _withDb(callback, connection) {
+    if (connection) return await callback(connection)
+
     return await this._getConfiguration().ensureConnections({databaseIdentifiers: [this.databaseIdentifier], name: "Server sequence allocator"}, async (dbs) => {
       const db = dbs[this.databaseIdentifier]
 
@@ -225,11 +258,11 @@ export function withServerSequence(ModelClass, {allocator, column = "serverSeque
   if (typeof prototype[advanceMethodName] != "function") {
     /**
      * Assigns the next server-side sequence.
-     * @this {Record<string, ?>}
+     * @this {import("../database/record/index.js").default & Record<string, ?>}
      * @returns {Promise<void>}
      */
     prototype[advanceMethodName] = async function advanceServerSequenceThroughAllocator() {
-      this[setterMethodName](await allocator.next())
+      this[setterMethodName](await allocator._nextForRecord(this))
     }
   }
 

package/src/sync/sync-client.js

@@ -220,13 +220,17 @@ export default class SyncClient {
         resource: record
       })
       const syncType = this.defaultSyncType({operation, record, resourceConfig})
+      const databaseOperation = record.databaseOperation()
+      const operationScope = databaseOperation
+        ? databaseOperation.forModel(this.config.syncModel)
+        : this.config.syncModel
 
-      await resourceConfig.modelClass.connection().afterCommit(async () => {
+      await record.connection().afterCommit(async () => {
         try {
           await SyncApiClient.queueLocalSync({
             data,
             resource: record,
-            syncModel: this.config.syncModel,
+            syncModel: operationScope,
             syncType
           })
         } catch (error) {

package/src/sync/sync-publisher.js

@@ -203,10 +203,14 @@ export default class SyncPublisher {
         sync_type: syncType,
         ...scopeValues.columns
       }
+      const databaseOperation = record.databaseOperation()
+      const operationScope = databaseOperation
+        ? databaseOperation.forModel(this.config.syncModel)
+        : this.config.syncModel
 
-      await resourceConfig.modelClass.connection().afterCommit(async () => {
+      await record.connection().afterCommit(async () => {
         try {
-          const syncRow = await this.upsertPublishedSyncRow(attributes)
+          const syncRow = await this.upsertPublishedSyncRow(attributes, operationScope)
 
           await this.broadcaster()({
             body: {
@@ -273,10 +277,11 @@ export default class SyncPublisher {
    * change back to), so repeated server changes to one resource reuse and
    * re-sequence one feed row.
    * @param {Record<string, ?>} attributes - Snapshotted sync row attributes.
+   * @param {?} syncModel - Operation-bound or static Sync model interface.
    * @returns {Promise<?>} Upserted sync row.
    */
-  async upsertPublishedSyncRow(attributes) {
-    const existingSync = await this.config.syncModel
+  async upsertPublishedSyncRow(attributes, syncModel = this.config.syncModel) {
+    const existingSync = await syncModel
       .where({
         [this.config.actorForeignKeyColumn]: null,
         resource_id: attributes.resource_id,
@@ -284,7 +289,7 @@ export default class SyncPublisher {
       })
       .first()
 
-    return await upsertSyncRow({attributes, existingSync, syncModel: this.config.syncModel})
+    return await upsertSyncRow({attributes, existingSync, syncModel})
   }
 
   /**