feat(query): add primary closure support for the where clause

Author: kiaking

src/model/attributes/relations/BelongsTo.ts

@@ -62,7 +62,7 @@ export class BelongsTo extends Relation {
    * Set the constraints for an eager load of the relation.
    */
   addEagerConstraints(query: Query, models: Collection): void {
-    query.whereIn(this.ownerKey, this.getEagerModelKeys(models))
+    query.whereIn(this.ownerKey as any, this.getEagerModelKeys(models))
   }
 
   /**

src/model/attributes/relations/HasMany.ts

@@ -58,7 +58,7 @@ export class HasMany extends Relation {
    * Set the constraints for an eager load of the relation.
    */
   addEagerConstraints(query: Query, models: Collection): void {
-    query.whereIn(this.foreignKey, this.getKeys(models, this.localKey))
+    query.whereIn(this.foreignKey as any, this.getKeys(models, this.localKey))
   }
 
   /**

src/model/attributes/relations/HasOne.ts

@@ -52,7 +52,7 @@ export class HasOne extends Relation {
    * Set the constraints for an eager load of the relation.
    */
   addEagerConstraints(query: Query, models: Collection): void {
-    query.whereIn(this.foreignKey, this.getKeys(models, this.localKey))
+    query.whereIn(this.foreignKey as any, this.getKeys(models, this.localKey))
   }
 
   /**

src/query/Options.ts

@@ -1,16 +1,18 @@
 import { Model } from '../model/Model'
 import { Query } from './Query'
 
-export type WhereSecondaryClosure<M extends Model, K extends keyof M> = (
-  value: M[K]
-) => boolean
-
 export interface Where<M extends Model, T extends keyof M> {
-  field: T
+  field: WherePrimaryClosure<M> | T
   value: WhereSecondaryClosure<M, T> | M[T] | M[T][]
   boolean: 'and' | 'or'
 }
 
+export type WherePrimaryClosure<M extends Model> = (model: M) => boolean
+
+export type WhereSecondaryClosure<M extends Model, K extends keyof M> = (
+  value: M[K]
+) => boolean
+
 export interface WhereGroup<M extends Model, T extends keyof M> {
   and?: Where<M, T>[]
   or?: Where<M, T>[]

src/query/Query.ts

@@ -12,6 +12,7 @@ import { Model } from '../model/Model'
 import { Connection } from '../connection/Connection'
 import {
   Where,
+  WherePrimaryClosure,
   WhereSecondaryClosure,
   Order,
   OrderDirection,
@@ -80,9 +81,10 @@ export class Query<M extends Model = Model> {
   /**
    * Add a basic where clause to the query.
    */
-  where<T extends keyof M>(field: T, value: WhereSecondaryClosure<M, T>): this
-  where<T extends keyof M>(field: T, value: M[T] | M[T][]): this
-  where(field: any, value: any): any {
+  where<T extends keyof M>(
+    field: WherePrimaryClosure<M> | T,
+    value?: WhereSecondaryClosure<M, T> | M[T] | M[T][]
+  ): this {
     this.wheres.push({ field, value, boolean: 'and' })
 
     return this
@@ -107,9 +109,10 @@ export class Query<M extends Model = Model> {
   /**
    * Add an "or where" clause to the query.
    */
-  orWhere<T extends keyof M>(field: T, value: WhereSecondaryClosure<M, T>): this
-  orWhere<T extends keyof M>(field: T, value: M[T] | M[T][]): this
-  orWhere(field: any, value: any): any {
+  orWhere<T extends keyof M>(
+    field: WherePrimaryClosure<M> | T,
+    value?: WhereSecondaryClosure<M, T> | M[T] | M[T][]
+  ): this {
     this.wheres.push({ field, value, boolean: 'or' })
 
     return this
@@ -273,6 +276,10 @@ export class Query<M extends Model = Model> {
    * The function to compare where clause to the given model.
    */
   protected whereComparator(model: M, where: Where<M, any>): boolean {
+    if (isFunction(where.field)) {
+      return where.field(model)
+    }
+
     if (isArray(where.value)) {
       return where.value.includes(model[where.field])
     }

src/repository/Repository.ts

@@ -11,7 +11,11 @@ import {
 import { Model } from '../model/Model'
 import { Interpreter } from '../interpreter/Interpreter'
 import { Query } from '../query/Query'
-import { WhereSecondaryClosure, OrderDirection } from '../query/Options'
+import {
+  WherePrimaryClosure,
+  WhereSecondaryClosure,
+  OrderDirection
+} from '../query/Options'
 
 export type PersistMethod = 'insert' | 'merge'
 
@@ -67,11 +71,9 @@ export class Repository<M extends Model> {
    * Add a basic where clause to the query.
    */
   where<T extends keyof M>(
-    field: T,
-    value: WhereSecondaryClosure<M, T>
-  ): Query<M>
-  where<T extends keyof M>(field: T, value: M[T] | M[T][]): Query<M>
-  where(field: any, value: any): any {
+    field: WherePrimaryClosure<M> | T,
+    value?: WhereSecondaryClosure<M, T> | M[T] | M[T][]
+  ): Query<M> {
     return this.query().where(field, value)
   }
 
@@ -82,7 +84,9 @@ export class Repository<M extends Model> {
     field: T,
     value: WhereSecondaryClosure<M, T>
   ): Query<M>
+
   orWhere<T extends keyof M>(field: T, value: M[T] | M[T][]): Query<M>
+
   orWhere(field: any, value: any): any {
     return this.query().orWhere(field, value)
   }

test/feature/repository/retrieves_where.spec.ts

@@ -87,4 +87,30 @@ describe('feature/repository/retrieves_where', () => {
     assertInstanceOf(users, User)
     assertModels(users, expected)
   })
+
+  it('can filter records by passing closure as a field', () => {
+    const store = createStore([User])
+
+    fillState(store, {
+      users: {
+        1: { id: 1, name: 'John Doe', age: 30 },
+        2: { id: 2, name: 'Jane Doe', age: 30 },
+        3: { id: 3, name: 'Johnny Doe', age: 20 }
+      }
+    })
+
+    const users = store
+      .$repo(User)
+      .where((user) => user.age === 30)
+      .get()
+
+    const expected = [
+      { id: 1, name: 'John Doe', age: 30 },
+      { id: 2, name: 'Jane Doe', age: 30 }
+    ]
+
+    expect(users.length).toBe(2)
+    assertInstanceOf(users, User)
+    assertModels(users, expected)
+  })
 })