feat: add support for model hooks

adonis-typings/model.ts

@@ -175,6 +175,12 @@ declare module '@ioc:Adonis/Lucid/Model' {
     'manyToMany' |
     'hasManyThrough'
 
+  /**
+   * List of events for which a model will trigger hooks
+   */
+  export type EventsList = 'save' | 'create' | 'update' | 'delete'
+  export type HooksHandler<T> = ((model: T) => Promise<void> | void) | string
+
   /**
    * Lookup map required for related method
    */
@@ -565,6 +571,24 @@ declare module '@ioc:Adonis/Lucid/Model' {
 
     $boot (): void
 
+    /**
+     * Register a before hook
+     */
+    $before<T extends ModelConstructorContract> (
+      this: T,
+      event: EventsList,
+      handler: HooksHandler<InstanceType<T>>,
+    )
+
+    /**
+     * Register an after hook
+     */
+    $after<T extends ModelConstructorContract> (
+      this: T,
+      event: EventsList,
+      handler: HooksHandler<InstanceType<T>>,
+    )
+
     /**
      * Creating model from adapter results
      */
@@ -718,18 +742,6 @@ declare module '@ioc:Adonis/Lucid/Model' {
     ): ModelQueryBuilderContract<ModelConstructorContract> & ExcutableQueryBuilderContract<ModelContract[]>
   }
 
-  /**
-   * Shape of the hooks contract used by transaction client and models
-   */
-  export interface HooksContract<Events extends string, Handler extends any> {
-    add (lifecycle: 'before' | 'after', event: Events, handler: Handler): this
-    before (event: Events, handler: Handler): this
-    after (event: Events, handler: Handler): this
-    execute (lifecycle: 'before' | 'after', event: Events, payload: any): Promise<void>
-    clear (event: Events): void
-    clearAll (): void
-  }
-
   /**
    * Shape of the preloader to preload relationships
    */

example/index.ts

@@ -9,6 +9,10 @@ class User extends BaseModel {
   public profile: Profile
 }
 
+User.$before('save', async (user) => {
+  user.username
+})
+
 const user = new User()
 user.related<'hasOne', 'profile'>('profile').save(new Profile())
 

providers/DatabaseProvider.ts

@@ -43,6 +43,7 @@ export default class DatabaseServiceProvider {
        * a different adapter.
        */
       BaseModel.$adapter = new Adapter(this.$container.use('Adonis/Lucid/Database'))
+      BaseModel.$container = this.$container
 
       return {
         BaseModel,

src/Orm/BaseModel/index.ts

@@ -11,13 +11,16 @@
 
 import pluralize from 'pluralize'
 import snakeCase from 'snake-case'
+import { IocContract } from '@adonisjs/fold'
 import { Exception } from '@poppinss/utils'
 
 import { QueryClientContract, TransactionClientContract } from '@ioc:Adonis/Lucid/Database'
 import {
   CacheNode,
+  EventsList,
   ColumnNode,
   ModelObject,
+  HooksHandler,
   ModelOptions,
   ComputedNode,
   ModelContract,
@@ -30,6 +33,7 @@ import {
   ModelConstructorContract,
 } from '@ioc:Adonis/Lucid/Model'
 
+import { Hooks } from '../Hooks'
 import { Preloader } from '../Preloader'
 import { HasOne } from '../Relations/HasOne'
 import { proxyHandler } from './proxyHandler'
@@ -49,10 +53,21 @@ function StaticImplements<T> () {
 @StaticImplements<ModelConstructorContract>()
 export class BaseModel implements ModelContract {
   /**
-   * The adapter to be used for persisting and fetching data
+   * The adapter to be used for persisting and fetching data.
+   *
+   * NOTE: Adapter is a singleton and share among all the models, unless
+   * a user wants to swap the adapter for a given model
    */
   public static $adapter: AdapterContract
 
+  /**
+   * The container required to resolve hooks
+   *
+   * NOTE: Container is a singleton and share among all the models, unless
+   * a user wants to swap the container for a given model
+   */
+  public static $container: IocContract
+
   /**
    * Primary key is required to build relationships across models
    */
@@ -115,6 +130,27 @@ export class BaseModel implements ModelContract {
     cast: Map<string, string>,
   }
 
+  /**
+   * Storing model hooks
+   */
+  private static _hooks: Hooks
+
+  /**
+   * Register before hooks
+   */
+  public static $before (event: EventsList, handler: HooksHandler<any>) {
+    this._hooks.add('before', event, handler)
+    return this
+  }
+
+  /**
+   * Register after hooks
+   */
+  public static $after (event: EventsList, handler: HooksHandler<any>) {
+    this._hooks.add('after', event, handler)
+    return this
+  }
+
   /**
    * Returns the model query instance for the given model
    */
@@ -181,15 +217,13 @@ export class BaseModel implements ModelContract {
     this.$booted = true
     this.$primaryKey = this.$primaryKey || 'id'
 
+    Object.defineProperty(this, '$refs', { value: {} })
     Object.defineProperty(this, '$columns', { value: new Map() })
     Object.defineProperty(this, '$computed', { value: new Map() })
     Object.defineProperty(this, '$relations', { value: new Map() })
-    Object.defineProperty(this, '$refs', { value: {} })
-    Object.defineProperty(this, '_mappings', {
-      value: {
-        cast: new Map(),
-      },
-    })
+
+    Object.defineProperty(this, '_hooks', { value: new Hooks(this.$container) })
+    Object.defineProperty(this, '_mappings', { value: { cast: new Map() }})
 
     this.$increments = this.$increments === undefined ? true : this.$increments
     this.$table = this.$table === undefined ? pluralize(snakeCase(this.name)) : this.$table
@@ -866,9 +900,15 @@ export class BaseModel implements ModelContract {
      * Persit the model when it's not persisted already
      */
     if (!this.$persisted) {
+      await Model._hooks.execute('before', 'create', this)
+      await Model._hooks.execute('before', 'save', this)
+
       await Model.$adapter.insert(this, this.$prepareForAdapter(this.$attributes))
       this.$hydrateOriginals()
       this.$persisted = true
+
+      await Model._hooks.execute('after', 'create', this)
+      await Model._hooks.execute('after', 'save', this)
       return
     }
 
@@ -881,12 +921,18 @@ export class BaseModel implements ModelContract {
       return
     }
 
+    await Model._hooks.execute('before', 'update', this)
+    await Model._hooks.execute('before', 'save', this)
+
     /**
      * Perform update
      */
     await Model.$adapter.update(this, this.$prepareForAdapter(dirty))
     this.$hydrateOriginals()
     this.$persisted = true
+
+    await Model._hooks.execute('after', 'update', this)
+    await Model._hooks.execute('after', 'save', this)
   }
 
   /**
@@ -895,8 +941,13 @@ export class BaseModel implements ModelContract {
   public async delete () {
     this._ensureIsntDeleted()
     const Model = this.constructor as typeof BaseModel
+
+    await Model._hooks.execute('before', 'delete', this)
+
     await Model.$adapter.delete(this)
     this.$isDeleted = true
+
+    await Model._hooks.execute('after', 'delete', this)
   }
 
   /**

src/Orm/Hooks/index.ts

@@ -0,0 +1,90 @@
+/*
+ * @adonisjs/lucid
+ *
+ * (c) Harminder Virk <virk@adonisjs.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+*/
+
+/// <reference path="../../../adonis-typings/index.ts" />
+
+import { EventsList, HooksHandler } from '@ioc:Adonis/Lucid/Model'
+import { IocContract, IocResolverContract, IocResolverLookupNode } from '@adonisjs/fold'
+
+/**
+ * A generic class to implement before and after lifecycle hooks
+ */
+export class Hooks {
+  private _hooks: {
+    [event: string]: {
+      before: Set<Exclude<HooksHandler<any>, string> | IocResolverLookupNode>,
+      after: Set<Exclude<HooksHandler<any>, string> | IocResolverLookupNode>,
+    },
+  } = {}
+
+  /**
+   * Resolver to resolve IoC container bindings
+   */
+  private _resolver: IocResolverContract
+
+  constructor (container: IocContract) {
+    this._resolver = container.getResolver(undefined, 'modelHooks', 'App/Models/Hooks')
+  }
+
+  /**
+   * Add hook for a given event and lifecycle
+   */
+  public add (lifecycle: 'before' | 'after', event: EventsList, handler: HooksHandler<any>) {
+    this._hooks[event] = this._hooks[event] || { before: new Set(), after: new Set() }
+
+    let resolvedHook
+
+    /**
+     * If hook is a string, then resolve it from the container
+     */
+    if (typeof (handler) === 'string') {
+      resolvedHook = this._resolver.resolve(handler)
+    } else {
+      resolvedHook = handler
+    }
+
+    this._hooks[event][lifecycle].add(resolvedHook)
+    return this
+  }
+
+  /**
+   * Execute hooks for a given event and lifecycle
+   */
+  public async execute (lifecycle: 'before' | 'after', event: EventsList, payload: any): Promise<void> {
+    if (!this._hooks[event]) {
+      return
+    }
+
+    for (let hook of this._hooks[event][lifecycle]) {
+      if (typeof (hook) === 'function') {
+        await hook(payload)
+      } else {
+        await this._resolver.call(hook, undefined, [payload])
+      }
+    }
+  }
+
+  /**
+   * Remove hooks for a given event
+   */
+  public clear (event: EventsList): void {
+    if (!this._hooks[event]) {
+      return
+    }
+
+    delete this._hooks[event]
+  }
+
+  /**
+   * Remove all hooks
+   */
+  public clearAll (): void {
+    this._hooks = {}
+  }
+}