feat: add order by feature

Author: kiaking

src/query/Options.ts

@@ -11,6 +11,13 @@ export interface WhereGroup {
   or?: Where[]
 }
 
+export interface Order {
+  field: string
+  direction: OrderDirection
+}
+
+export type OrderDirection = 'asc' | 'desc'
+
 export interface EagerLoad {
   [name: string]: EagerLoadConstraint
 }

src/query/Query.ts

@@ -1,10 +1,16 @@
 import { Store } from 'vuex'
-import { isArray, isEmpty, groupBy } from '../support/Utils'
+import { isArray, isEmpty, orderBy, groupBy } from '../support/Utils'
 import { Element, Item, Collection } from '../data/Data'
 import { Relation } from '../model/attributes/relations/Relation'
 import { Model } from '../model/Model'
 import { Connection } from '../connection/Connection'
-import { Where, EagerLoad, EagerLoadConstraint } from './Options'
+import {
+  Where,
+  Order,
+  OrderDirection,
+  EagerLoad,
+  EagerLoadConstraint
+} from './Options'
 
 export class Query<M extends Model = Model> {
   /**
@@ -22,6 +28,11 @@ export class Query<M extends Model = Model> {
    */
   protected wheres: Where[] = []
 
+  /**
+   * The orderings for the query.
+   */
+  protected orders: Order[] = []
+
   /**
    * The maximum number of records to return.
    */
@@ -93,6 +104,15 @@ export class Query<M extends Model = Model> {
     return this
   }
 
+  /**
+   * Add an "order by" clause to the query.
+   */
+  orderBy(field: string, direction: OrderDirection = 'asc'): Query<M> {
+    this.orders.push({ field, direction })
+
+    return this
+  }
+
   /**
    * Set the "take" value of the query.
    */
@@ -203,6 +223,7 @@ export class Query<M extends Model = Model> {
     let models = this.getModels()
 
     models = this.filterWhere(models)
+    models = this.filterOrder(models)
     models = this.filterLimit(models)
 
     return models
@@ -248,6 +269,20 @@ export class Query<M extends Model = Model> {
     return model[where.field] === where.value
   }
 
+  /**
+   * Filter the given collection by the registered order conditions.
+   */
+  protected filterOrder(models: Collection<M>): Collection<M> {
+    if (this.orders.length === 0) {
+      return models
+    }
+
+    const fields = this.orders.map((order) => order.field)
+    const directions = this.orders.map((order) => order.direction)
+
+    return orderBy(models, fields, directions)
+  }
+
   /**
    * Filter the given collection by the registered limit and offset values.
    */

src/repository/Repository.ts

@@ -11,6 +11,7 @@ import {
 import { Model } from '../model/Model'
 import { Interpretation } from '../interpretation/Interpretation'
 import { Query } from '../query/Query'
+import { OrderDirection } from '../query/Options'
 
 export type PersistMethod = 'insert' | 'merge'
 
@@ -76,6 +77,13 @@ export class Repository<M extends Model> {
     return this.query().orWhere(field, value)
   }
 
+  /**
+   * Add an "order by" clause to the query.
+   */
+  orderBy(field: string, direction?: OrderDirection): Query<M> {
+    return this.query().orderBy(field, direction)
+  }
+
   /**
    * Set the relationships that should be eager loaded.
    */

test/feature/repository/retrieves_order_by.spec.ts

@@ -0,0 +1,93 @@
+import {
+  createStore,
+  fillState,
+  assertInstanceOf,
+  assertModels
+} from 'test/Helpers'
+import { Model, Attr, Str, Num } from '@/index'
+
+describe('feature/repository/retrieves_order_by', () => {
+  class User extends Model {
+    static entity = 'users'
+
+    @Attr() id!: any
+    @Str('') name!: string
+    @Num(0) age!: number
+  }
+
+  it('can sort the records by the `order by` clause', () => {
+    const store = createStore([User])
+
+    fillState(store, {
+      users: {
+        1: { id: 1, name: 'James', age: 40 },
+        2: { id: 2, name: 'Andy', age: 30 },
+        3: { id: 3, name: 'David', age: 20 }
+      }
+    })
+
+    const users = store.$repo(User).orderBy('name').get()
+
+    const expected = [
+      { id: 2, name: 'Andy', age: 30 },
+      { id: 3, name: 'David', age: 20 },
+      { id: 1, name: 'James', age: 40 }
+    ]
+
+    expect(users.length).toBe(3)
+    assertInstanceOf(users, User)
+    assertModels(users, expected)
+  })
+
+  it('can sort the records by "desc" order', () => {
+    const store = createStore([User])
+
+    fillState(store, {
+      users: {
+        1: { id: 1, name: 'James', age: 40 },
+        2: { id: 2, name: 'Andy', age: 30 },
+        3: { id: 3, name: 'David', age: 20 }
+      }
+    })
+
+    const users = store.$repo(User).orderBy('name', 'desc').get()
+
+    const expected = [
+      { id: 1, name: 'James', age: 40 },
+      { id: 3, name: 'David', age: 20 },
+      { id: 2, name: 'Andy', age: 30 }
+    ]
+
+    expect(users.length).toBe(3)
+    assertInstanceOf(users, User)
+    assertModels(users, expected)
+  })
+
+  it('can combine multiple orders', () => {
+    const store = createStore([User])
+
+    fillState(store, {
+      users: {
+        1: { id: 1, name: 'James', age: 40 },
+        2: { id: 2, name: 'Andy', age: 30 },
+        3: { id: 3, name: 'Andy', age: 20 },
+        4: { id: 4, name: 'David', age: 20 },
+        5: { id: 5, name: 'David', age: 50 }
+      }
+    })
+
+    const users = store.$repo(User).orderBy('name', 'desc').orderBy('age').get()
+
+    const expected = [
+      { id: 1, name: 'James', age: 40 },
+      { id: 4, name: 'David', age: 20 },
+      { id: 5, name: 'David', age: 50 },
+      { id: 3, name: 'Andy', age: 20 },
+      { id: 2, name: 'Andy', age: 30 }
+    ]
+
+    expect(users.length).toBe(5)
+    assertInstanceOf(users, User)
+    assertModels(users, expected)
+  })
+})