feat(model): implement update,delete and counter methods to model que…

…ry builder

adonis-typings/model.ts

@@ -9,7 +9,14 @@
 
 declare module '@ioc:Adonis/Lucid/Model' {
   import { ProfilerContract, ProfilerRowContract } from '@ioc:Adonis/Core/Profiler'
-  import { ChainableContract, StrictValues, QueryCallback } from '@ioc:Adonis/Lucid/DatabaseQueryBuilder'
+  import {
+    Update,
+    Counter,
+    StrictValues,
+    QueryCallback,
+    ChainableContract,
+  } from '@ioc:Adonis/Lucid/DatabaseQueryBuilder'
+
   import {
     QueryClientContract,
     TransactionClientContract,
@@ -368,9 +375,9 @@ declare module '@ioc:Adonis/Lucid/Model' {
   /**
    * Model query builder will have extras methods on top of Database query builder
    */
-  export interface ModelQueryBuilderContract<
-    Model extends ModelConstructorContract
-  > extends ChainableContract {
+  export interface ModelQueryBuilderContract<Model extends ModelConstructorContract>
+    extends ChainableContract
+  {
     model: Model
 
     /**
@@ -405,6 +412,14 @@ declare module '@ioc:Adonis/Lucid/Model' {
      */
     firstOrFail (): Promise<InstanceType<Model>>
 
+    /**
+     * Mutations (update and increment can be one query aswell)
+     */
+    update: Update<ModelQueryBuilderContract<Model> & ExcutableQueryBuilderContract<number[]>>
+    increment: Counter<ModelQueryBuilderContract<Model> & ExcutableQueryBuilderContract<number[]>>
+    decrement: Counter<ModelQueryBuilderContract<Model> & ExcutableQueryBuilderContract<number[]>>
+    del (): ModelQueryBuilderContract<Model> & ExcutableQueryBuilderContract<number[]>
+
     /**
      * Define relationships to be preloaded
      */

adonis-typings/querybuilder.ts

@@ -602,8 +602,6 @@ declare module '@ioc:Adonis/Lucid/DatabaseQueryBuilder' {
   export interface DatabaseQueryBuilderContract <
     Result extends any = Dictionary<any, string>,
   > extends ChainableContract {
-    del (): this
-
     client: QueryClientContract,
 
     /**
@@ -616,8 +614,10 @@ declare module '@ioc:Adonis/Lucid/DatabaseQueryBuilder' {
      */
     first (): Promise<Result | null>
 
+    del (): this
+
     /**
-     * Mutations
+     * Mutations (update and increment can be one query aswell)
      */
     update: Update<this>
     increment: Counter<this>

src/Database/QueryBuilder/Chainable.ts

@@ -1095,22 +1095,4 @@ export abstract class Chainable implements ChainableContract {
     this.$knexBuilder.sum(this._normalizeAggregateColumns(columns, alias))
     return this
   }
-
-  /**
-   * Perform update by incrementing value for a given column. Increments
-   * can be clubbed with `update` as well
-   */
-  public increment (column: any, counter?: any): this {
-    this.$knexBuilder.increment(column, counter)
-    return this
-  }
-
-  /**
-   * Perform update by decrementing value for a given column. Decrements
-   * can be clubbed with `update` as well
-   */
-  public decrement (column: any, counter?: any): this {
-    this.$knexBuilder.decrement(column, counter)
-    return this
-  }
 }

src/Database/QueryBuilder/Database.ts

@@ -89,6 +89,24 @@ export class DatabaseQueryBuilder extends Chainable implements DatabaseQueryBuil
     return this
   }
 
+  /**
+   * Perform update by incrementing value for a given column. Increments
+   * can be clubbed with `update` as well
+   */
+  public increment (column: any, counter?: any): this {
+    this.$knexBuilder.increment(column, counter)
+    return this
+  }
+
+  /**
+   * Perform update by decrementing value for a given column. Decrements
+   * can be clubbed with `update` as well
+   */
+  public decrement (column: any, counter?: any): this {
+    this.$knexBuilder.decrement(column, counter)
+    return this
+  }
+
   /**
    * Perform update
    */

src/Orm/QueryBuilder/index.ts

@@ -35,6 +35,13 @@ import { Executable, ExecutableConstructor } from '../../Traits/Executable'
 @trait<ExecutableConstructor>(Executable)
 export class ModelQueryBuilder extends Chainable implements ModelQueryBuilderContract<ModelConstructorContract
 > {
+  /**
+   * A flag to know, if the query being executed is a select query
+   * or not, since we don't transform return types of non-select
+   * queries
+   */
+  private _isSelectQuery: boolean = true
+
   /**
    * Sideloaded attributes that will be passed to the model instances
    */
@@ -67,6 +74,16 @@ export class ModelQueryBuilder extends Chainable implements ModelQueryBuilderCon
     builder.table(model.$table)
   }
 
+  /**
+   * Ensures that we are not executing `update` or `del` when using read only
+   * client
+   */
+  private _ensureCanPerformWrites () {
+    if (this.client && this.client.mode === 'read') {
+      throw new Exception('Updates and deletes cannot be performed in read mode')
+    }
+  }
+
   /**
    * Process preloads for a single model instance
    */
@@ -85,11 +102,24 @@ export class ModelQueryBuilder extends Chainable implements ModelQueryBuilderCon
     return modelInstances
   }
 
+  /**
+   * Checks to see that the executed query is update or delete
+   */
+  public async beforeExecute () {
+    if (['update', 'del'].includes(this.$knexBuilder['_method'])) {
+      this._isSelectQuery = false
+    }
+  }
+
   /**
    * Wraps the query result to model instances. This method is invoked by the
    * Executable trait.
    */
   public async afterExecute (rows: any[]): Promise<any[]> {
+    if (!this._isSelectQuery) {
+      return Array.isArray(rows) ? rows : [rows]
+    }
+
     const modelInstances = this.model.$createMultipleFromAdapterResult(
       rows,
       this.$sideloaded,
@@ -149,6 +179,14 @@ export class ModelQueryBuilder extends Chainable implements ModelQueryBuilderCon
    * to running the query
    */
   public getQueryClient () {
+    /**
+     * Use write client for updates and deletes
+     */
+    if (['update', 'del'].includes(this.$knexBuilder['_method'])) {
+      this._ensureCanPerformWrites()
+      return this.client!.getWriteClient().client
+    }
+
     return this.client!.getReadClient().client
   }
 
@@ -166,4 +204,41 @@ export class ModelQueryBuilder extends Chainable implements ModelQueryBuilderCon
       model: this.model.name,
     }))
   }
+  /**
+   * Perform update by incrementing value for a given column. Increments
+   * can be clubbed with `update` as well
+   */
+  public increment (column: any, counter?: any): any {
+    this._ensureCanPerformWrites()
+    this.$knexBuilder.increment(column, counter)
+    return this
+  }
+
+  /**
+   * Perform update by decrementing value for a given column. Decrements
+   * can be clubbed with `update` as well
+   */
+  public decrement (column: any, counter?: any): any {
+    this._ensureCanPerformWrites()
+    this.$knexBuilder.decrement(column, counter)
+    return this
+  }
+
+  /**
+   * Perform update
+   */
+  public update (columns: any): any {
+    this._ensureCanPerformWrites()
+    this.$knexBuilder.update(columns)
+    return this
+  }
+
+  /**
+   * Delete rows under the current query
+   */
+  public del (): any {
+    this._ensureCanPerformWrites()
+    this.$knexBuilder.del()
+    return this
+  }
 }

src/Orm/Relations/Base/QueryBuilder.ts

@@ -59,7 +59,7 @@ export abstract class BaseRelationQueryBuilder
   /**
    * Adds neccessary where clause to the query to perform the select
    */
-  public beforeExecute () {
+  public async beforeExecute () {
     this.applyConstraints()
   }
 

test-helpers/index.ts

@@ -109,6 +109,7 @@ export async function setup () {
       table.integer('country_id')
       table.string('username').unique()
       table.string('email')
+      table.integer('points').defaultTo(0)
       table.timestamps()
     })
   }

test/orm/model-query-builder.spec.ts

@@ -146,4 +146,84 @@ test.group('Model query builder', (group) => {
     assert.deepEqual(users[0].$attributes, { id: 1, username: 'virk' })
     assert.deepEqual(users[0].$options!.profiler, profiler)
   })
+
+  test('perform update using model query builder', async (assert) => {
+    class User extends BaseModel {
+      @column({ primary: true })
+      public id: number
+
+      @column()
+      public username: string
+    }
+
+    User.$boot()
+    await db.insertQuery().table('users').insert([{ username: 'virk' }, { username: 'nikk' }])
+
+    const rows = await User.query().where('username', 'virk').update({ username: 'hvirk' })
+    assert.lengthOf(rows, 1)
+    assert.deepEqual(rows, [1])
+
+    const user = await db.from('users').where('username', 'hvirk').first()
+    assert.equal(user!.username, 'hvirk')
+  })
+
+  test('perform increment using model query builder', async (assert) => {
+    class User extends BaseModel {
+      @column({ primary: true })
+      public id: number
+
+      @column()
+      public username: string
+    }
+
+    User.$boot()
+    await db.insertQuery().table('users').insert([{ username: 'virk', points: 1 }])
+
+    const rows = await User.query().where('username', 'virk').increment('points', 1)
+    assert.lengthOf(rows, 1)
+    assert.deepEqual(rows, [1])
+
+    const user = await db.from('users').where('username', 'virk').first()
+    assert.equal(user!.points, 2)
+  })
+
+  test('perform decrement using model query builder', async (assert) => {
+    class User extends BaseModel {
+      @column({ primary: true })
+      public id: number
+
+      @column()
+      public username: string
+    }
+
+    User.$boot()
+    await db.insertQuery().table('users').insert([{ username: 'virk', points: 3 }])
+
+    const rows = await User.query().where('username', 'virk').decrement('points', 1)
+    assert.lengthOf(rows, 1)
+    assert.deepEqual(rows, [1])
+
+    const user = await db.from('users').where('username', 'virk').first()
+    assert.equal(user!.points, 2)
+  })
+
+  test('delete in bulk', async (assert) => {
+    class User extends BaseModel {
+      @column({ primary: true })
+      public id: number
+
+      @column()
+      public username: string
+    }
+
+    User.$boot()
+    await db.insertQuery().table('users').insert([{ username: 'virk' }, { username: 'nikk' }])
+
+    const rows = await User.query().where('username', 'virk').del()
+    assert.lengthOf(rows, 1)
+    assert.deepEqual(rows, [1])
+
+    const user = await db.from('users').where('username', 'virk').first()
+    assert.isNull(user)
+  })
 })