velocious 1.0.567 → 1.0.569

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)
@@ -156,65 +157,181 @@ export default class RecordAttachmentsStore {
       allowedPathPrefixes,
       environmentHandler: this.configuration.getEnvironmentHandler()
     })
+    /**
+     * Attachment persistence error.
+     * This stays opaque so any JavaScript thrown value is preserved exactly.
+     * @type {unknown} */
+    let persistenceError = null
+    let persistenceFailed = false
+
+    try {
+      const persistenceInput = await this.persistenceInputFor(normalizedInput)
+
+      await this.persistNormalizedAttachment({
+        model,
+        name,
+        normalizedInput: persistenceInput,
+        replace
+      })
+    } catch (error) {
+      persistenceFailed = true
+      persistenceError = error
+    }
+
+    if (normalizedInput.pathSource) {
+      try {
+        await normalizedInput.pathSource.close()
+      } catch (closeError) {
+        if (persistenceFailed) {
+          throw new AggregateError(
+            [persistenceError, closeError],
+            `Attachment persistence and path-source close both failed for ${model.getModelClass().getModelName()}#${String(model.id())} (${name})`,
+            {cause: closeError}
+          )
+        }
+
+        throw closeError
+      }
+    }
+
+    if (persistenceFailed) throw persistenceError
+  }
+
+  /**
+   * Materializes path content once when a legacy schema requires Base64.
+   * @param {import("./normalize-input.js").NormalizedAttachmentInput} normalizedInput - Normalized attachment input.
+   * @returns {Promise<import("./normalize-input.js").NormalizedAttachmentInput>} - Input used by the driver and database.
+   */
+  async persistenceInputFor(normalizedInput) {
+    if (this._contentBase64Nullable || !normalizedInput.pathSource) return normalizedInput
+
+    const contentBuffer = await normalizedInput.pathSource.readBuffer()
+
+    return {
+      ...normalizedInput,
+      contentBase64: contentBuffer.toString("base64"),
+      contentBuffer,
+      pathSource: null
+    }
+  }
+
+  /**
+   * Persists one normalized attachment while its path source remains open.
+   * @param {object} args - Options.
+   * @param {import("../index.js").default} args.model - Model instance.
+   * @param {string} args.name - Attachment name.
+   * @param {import("./normalize-input.js").NormalizedAttachmentInput} args.normalizedInput - Normalized attachment.
+   * @param {boolean} args.replace - Whether to replace existing attachments.
+   * @returns {Promise<void>} - Resolves after persistence.
+   */
+  async persistNormalizedAttachment({model, name, normalizedInput, replace}) {
     const attachmentDriver = await this.resolveAttachmentDriver({model, name})
     const attachmentDriverName = this._attachmentDriverNameFor({model, name})
     const now = Date.now()
     const recordType = model.getModelClass().getModelName()
     const recordId = String(model.id())
     const attachmentId = generateUUID()
-    const {storageKey} = await attachmentDriver.write({
-      attachmentId,
-      input: normalizedInput,
-      model,
-      name
-    })
+    /**
+     * Written storage key.
+     * @type {string | null} */
+    let storageKey = null
+    let rowPersisted = false
+
+    try {
+      const writeResult = await attachmentDriver.write({
+        attachmentId,
+        input: normalizedInput,
+        model,
+        name
+      })
 
-    await this._withDb(async (db) => {
-      if (replace) {
-        const existingRows = await db
-          .newQuery()
-          .from(ATTACHMENTS_TABLE)
-          .where({name, record_id: recordId, record_type: recordType})
-          .results()
+      storageKey = writeResult.storageKey
 
-        for (const existingRow of existingRows) {
-          await this.deleteAttachmentRowStorage({model, name, row: existingRow})
+      // Current schemas keep content_base64 nullable and avoid duplicating
+      // driver-backed content. Legacy path input was materialized once before
+      // the driver write so this value describes those exact persisted bytes.
+      const databaseContentBase64 = await this.databaseContentBase64For(normalizedInput)
+
+      await this._withDb(async (db) => {
+        if (replace) {
+          const existingRows = await db
+            .newQuery()
+            .from(ATTACHMENTS_TABLE)
+            .where({name, record_id: recordId, record_type: recordType})
+            .results()
+
+          for (const existingRow of existingRows) {
+            await this.deleteAttachmentRowStorage({model, name, row: existingRow})
+          }
+
+          await db.delete({
+            conditions: {name, record_id: recordId, record_type: recordType},
+            tableName: ATTACHMENTS_TABLE
+          })
+        }
+
+        const position = replace ? 0 : await this._nextPosition({db, name, recordId, recordType})
+        /**
+         * Insert data.
+         * @type {Record<string, ?>} */
+        const insertData = {
+          byte_size: normalizedInput.byteSize,
+          content_base64: databaseContentBase64,
+          content_type: normalizedInput.contentType,
+          created_at_ms: now,
+          filename: normalizedInput.filename,
+          id: attachmentId,
+          name,
+          position,
+          record_id: recordId,
+          record_type: recordType,
+          updated_at_ms: now
         }
 
-        await db.delete({
-          conditions: {name, record_id: recordId, record_type: recordType},
+        if (this._driverColumnsAvailable) {
+          insertData.driver = attachmentDriverName
+          insertData.storage_key = storageKey
+        }
+
+        await db.insert({
+          data: insertData,
           tableName: ATTACHMENTS_TABLE
         })
-      }
 
-      const position = replace ? 0 : await this._nextPosition({db, name, recordId, recordType})
-      /**
-       * Insert data.
-       * @type {Record<string, ?>} */
-      const insertData = {
-        byte_size: normalizedInput.byteSize,
-        content_base64: this._contentBase64Nullable ? null : normalizedInput.contentBase64,
-        content_type: normalizedInput.contentType,
-        created_at_ms: now,
-        filename: normalizedInput.filename,
-        id: attachmentId,
-        name,
-        position,
-        record_id: recordId,
-        record_type: recordType,
-        updated_at_ms: now
+        rowPersisted = true
+      }, model)
+    } catch (error) {
+      if (!rowPersisted && storageKey && typeof attachmentDriver.delete === "function") {
+        try {
+          await attachmentDriver.delete({
+            model,
+            name,
+            row: {id: attachmentId, storage_key: storageKey},
+            storageKey
+          })
+        } catch (cleanupError) {
+          throw new AggregateError(
+            [error, cleanupError],
+            `Attachment write finalization and new-storage cleanup both failed for ${recordType}#${recordId} (${name})`,
+            {cause: cleanupError}
+          )
+        }
       }
 
-      if (this._driverColumnsAvailable) {
-        insertData.driver = attachmentDriverName
-        insertData.storage_key = storageKey
-      }
+      throw error
+    }
+  }
 
-      await db.insert({
-        data: insertData,
-        tableName: ATTACHMENTS_TABLE
-      })
-    })
+  /**
+   * Resolves the database content_base64 value for current and legacy schemas.
+   * @param {import("./normalize-input.js").NormalizedAttachmentInput} normalizedInput - Normalized attachment input.
+   * @returns {Promise<string | null>} - Nullable or legacy Base64 database value.
+   */
+  async databaseContentBase64For(normalizedInput) {
+    if (this._contentBase64Nullable) return null
+    if (normalizedInput.contentBase64 !== null) return normalizedInput.contentBase64
+
+    throw new Error("Legacy attachment schema requires materialized content bytes")
   }
 
   /**
@@ -319,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()
@@ -339,7 +456,7 @@ export default class RecordAttachmentsStore {
       const rows = await query.results()
 
       return rows[0] || null
-    })
+    }, model)
   }
 
   /**
@@ -350,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()
@@ -363,7 +480,7 @@ export default class RecordAttachmentsStore {
         .order("created_at_ms ASC")
 
       return await query.results()
-    })
+    }, model)
   }
 
   /**
@@ -401,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()
@@ -433,7 +550,7 @@ export default class RecordAttachmentsStore {
       }
 
       return rows.length
-    })
+    }, model)
   }
 
   /**
@@ -616,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`)

package/build/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()