fix: adjust with/whereHas options leak

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@athenna/database",
-  "version": "5.49.0",
+  "version": "5.50.0",
   "description": "The Athenna database handler for SQL/NoSQL.",
   "license": "MIT",
   "author": "João Lenon <lenon@athenna.io>",

src/models/builders/ModelQueryBuilder.ts

@@ -600,16 +600,25 @@ export class ModelQueryBuilder<
   ) {
     const options = this.schema.includeWhereHasRelation(relation, closure)
 
+    /**
+     * Snapshot the full options object immediately at call time, before any
+     * subsequent `with(sameRelation)` call can mutate the shared `options`
+     * object (e.g. overwriting `closure` or `withClosure`).  Because this
+     * spread happens here — outside the Knex callback — the snapshot is
+     * frozen regardless of what happens to `options` afterwards.
+     */
+    const snapshot = { ...options }
+
     super.whereExists(query => {
-      switch (options.type) {
+      switch (snapshot.type) {
         case 'hasOne':
-          return HasOneRelation.whereHas(this.Model, query, options)
+          return HasOneRelation.whereHas(this.Model, query, snapshot)
         case 'hasMany':
-          return HasManyRelation.whereHas(this.Model, query, options)
+          return HasManyRelation.whereHas(this.Model, query, snapshot)
         case 'belongsTo':
-          return BelongsToRelation.whereHas(this.Model, query, options)
+          return BelongsToRelation.whereHas(this.Model, query, snapshot)
         case 'belongsToMany':
-          return BelongsToManyRelation.whereHas(this.Model, query, options)
+          return BelongsToManyRelation.whereHas(this.Model, query, snapshot)
       }
     })
 

src/models/relations/BelongsTo/BelongsToRelation.ts

@@ -40,7 +40,7 @@ export class BelongsToRelation {
       .model()
       .query()
       .where(relation.primaryKey as never, model[relation.foreignKey])
-      .when(relation.closure, relation.closure)
+      .when(relation.withClosure, relation.withClosure)
       .find()
 
     return model
@@ -60,7 +60,7 @@ export class BelongsToRelation {
       .model()
       .query()
       .whereIn(relation.primaryKey as never, foreignValues)
-      .when(relation.closure, relation.closure)
+      .when(relation.withClosure, relation.withClosure)
       .findMany()
 
     const map = new Map()

src/models/relations/BelongsToMany/BelongsToManyRelation.ts

@@ -49,7 +49,7 @@ export class BelongsToManyRelation {
       .model()
       .query()
       .whereIn(relation.relationPrimaryKey as never, relationIds)
-      .when(relation.closure, relation.closure)
+      .when(relation.withClosure, relation.withClosure)
       .findMany()
 
     return model
@@ -88,7 +88,7 @@ export class BelongsToManyRelation {
       .model()
       .query()
       .whereIn(relation.relationPrimaryKey as never, relationForeignKey)
-      .when(relation.closure, relation.closure)
+      .when(relation.withClosure, relation.withClosure)
       .findMany()
 
     const map = new Map()

src/models/relations/HasMany/HasManyRelation.ts

@@ -24,7 +24,7 @@ export class HasManyRelation {
       .model()
       .query()
       .where(relation.foreignKey as never, model[relation.primaryKey])
-      .when(relation.closure, relation.closure)
+      .when(relation.withClosure, relation.withClosure)
       .findMany()
 
     return model
@@ -42,7 +42,7 @@ export class HasManyRelation {
       .model()
       .query()
       .whereIn(relation.foreignKey as never, primaryValues)
-      .when(relation.closure, relation.closure)
+      .when(relation.withClosure, relation.withClosure)
       .findMany()
 
     const map = new Map()

src/models/relations/HasOne/HasOneRelation.ts

@@ -24,7 +24,7 @@ export class HasOneRelation {
       .model()
       .query()
       .where(relation.foreignKey as never, model[relation.primaryKey])
-      .when(relation.closure, relation.closure)
+      .when(relation.withClosure, relation.withClosure)
       .find()
 
     return model
@@ -42,7 +42,7 @@ export class HasOneRelation {
       .model()
       .query()
       .whereIn(relation.foreignKey as never, primaryValues)
-      .when(relation.closure, relation.closure)
+      .when(relation.withClosure, relation.withClosure)
       .findMany()
 
     const map = new Map()

src/models/schemas/ModelSchema.ts

@@ -364,7 +364,7 @@ export class ModelSchema<M extends BaseModel = any> extends Macroable {
     const i = this.relations.indexOf(options)
 
     options.isIncluded = true
-    options.closure = closure
+    options.withClosure = closure
 
     this.relations[i] = options
 

src/types/relations/BelongsToManyOptions.ts

@@ -28,10 +28,21 @@ export type BelongsToManyOptions<
    * The closure that should be executed while
    * querying the relation data from database.
    *
+   * Used by `whereHas()` for the WHERE EXISTS subquery.
+   *
    * @default undefined
    */
   closure?: (query: ModelQueryBuilder<R>) => any
 
+  /**
+   * The closure provided to `with()` for eager loading.
+   * Kept separate from {@link closure} so that a `whereHas()` call
+   * on the same relation never overwrites the eager-load filter.
+   *
+   * @default undefined
+   */
+  withClosure?: (query: ModelQueryBuilder<R>) => any
+
   /**
    * The property name in class of the relation.
    *

src/types/relations/BelongsToOptions.ts

@@ -27,10 +27,21 @@ export type BelongsToOptions<
    * The closure that should be executed while
    * querying the relation data from database.
    *
+   * Used by `whereHas()` for the WHERE EXISTS subquery.
+   *
    * @default undefined
    */
   closure?: (query: ModelQueryBuilder<R>) => any
 
+  /**
+   * The closure provided to `with()` for eager loading.
+   * Kept separate from {@link closure} so that a `whereHas()` call
+   * on the same relation never overwrites the eager-load filter.
+   *
+   * @default undefined
+   */
+  withClosure?: (query: ModelQueryBuilder<R>) => any
+
   /**
    * The property name in class of the relation.
    *

src/types/relations/HasManyOptions.ts

@@ -27,10 +27,21 @@ export type HasManyOptions<
    * The closure that should be executed while
    * querying the relation data from database.
    *
+   * Used by `whereHas()` for the WHERE EXISTS subquery.
+   *
    * @default undefined
    */
   closure?: (query: ModelQueryBuilder<R>) => any
 
+  /**
+   * The closure provided to `with()` for eager loading.
+   * Kept separate from {@link closure} so that a `whereHas()` call
+   * on the same relation never overwrites the eager-load filter.
+   *
+   * @default undefined
+   */
+  withClosure?: (query: ModelQueryBuilder<R>) => any
+
   /**
    * The property name in class of the relation.
    *

src/types/relations/HasOneOptions.ts

@@ -27,10 +27,21 @@ export type HasOneOptions<
    * The closure that should be executed while
    * querying the relation data from database.
    *
+   * Used by `whereHas()` for the WHERE EXISTS subquery.
+   *
    * @default undefined
    */
   closure?: (query: ModelQueryBuilder<R>) => any
 
+  /**
+   * The closure provided to `with()` for eager loading.
+   * Kept separate from {@link closure} so that a `whereHas()` call
+   * on the same relation never overwrites the eager-load filter.
+   *
+   * @default undefined
+   */
+  withClosure?: (query: ModelQueryBuilder<R>) => any
+
   /**
    * The property name in class of the relation.
    *

tests/unit/models/builders/ModelQueryBuilderTest.ts

@@ -2365,4 +2365,104 @@ export default class ModelQueryBuilderTest {
 
     assert.equal(findManyCalls, 2)
   }
+
+  @Test()
+  public async withBeforeWhereHasShouldStillEagerLoad({ assert }: Context) {
+    let findManyCalls = 0
+
+    Mock.stub(Database.driver, 'findMany').callsFake(async () => {
+      findManyCalls++
+
+      if (findManyCalls === 1) {
+        return [{ id: '1', name: 'John Doe' }]
+      }
+
+      return [{ id: 'p1', userId: '1' }]
+    })
+
+    await User.query()
+      .with('products')
+      .whereHas('products', qb => qb.where('id', 'p1'))
+      .findMany()
+
+    assert.equal(findManyCalls, 2)
+  }
+
+  @Test()
+  public async whereHasClosureShouldNotLeakIntoEagerLoad({ assert }: Context) {
+    const whereCalls: string[] = []
+
+    Mock.stub(Database.driver, 'findMany').callsFake(async () => {
+      return [{ id: '1', name: 'John Doe' }]
+    })
+
+    Mock.stub(Database.driver, 'where').callsFake((...args: any[]) => {
+      whereCalls.push(args[0])
+      return Database.driver
+    })
+
+    await User.query()
+      .with('products')
+      .whereHas('products', qb => qb.where('whereHasFilter', 'value'))
+      .findMany()
+
+    assert.isFalse(whereCalls.includes('whereHasFilter'))
+  }
+
+  @Test()
+  public async whereHasClosureShouldNotLeakIntoEagerLoadWhenWhereHasRunsFirst({ assert }: Context) {
+    const whereCalls: string[] = []
+
+    Mock.stub(Database.driver, 'findMany').callsFake(async () => {
+      return [{ id: '1', name: 'John Doe' }]
+    })
+
+    Mock.stub(Database.driver, 'where').callsFake((...args: any[]) => {
+      whereCalls.push(args[0])
+      return Database.driver
+    })
+
+    await User.query()
+      .whereHas('products', qb => qb.where('whereHasFilter', 'value'))
+      .with('products')
+      .findMany()
+
+    assert.isFalse(whereCalls.includes('whereHasFilter'))
+  }
+
+  @Test()
+  public async whereExistsIsRegisteredForWhereHasBeforeWith({ assert }: Context) {
+    let whereExistsCalled = false
+
+    Mock.stub(Database.driver, 'findMany').callsFake(async () => [])
+    Mock.stub(Database.driver, 'whereExists').callsFake(() => {
+      whereExistsCalled = true
+      return Database.driver
+    })
+
+    await User.query()
+      .whereHas('products', qb => qb.where('id', 'p1'))
+      .with('products')
+      .findMany()
+
+    assert.isTrue(whereExistsCalled)
+  }
+
+  @Test()
+  public async whereExistsIsRegisteredForWithBeforeWhereHas({ assert }: Context) {
+    let whereExistsCalled = false
+
+    Mock.stub(Database.driver, 'findMany').callsFake(async () => [])
+    Mock.stub(Database.driver, 'whereExists').callsFake(() => {
+      whereExistsCalled = true
+      return Database.driver
+    })
+
+    await User.query()
+      .with('products')
+      .whereHas('products', qb => qb.where('id', 'p1'))
+      .findMany()
+
+    assert.isTrue(whereExistsCalled)
+  }
 }