feat: allow lazy imports when registering middleware

Author: thetutlage

adonis-typings/middleware.ts

@@ -11,13 +11,22 @@ declare module '@ioc:Adonis/Core/Middleware' {
   import { IocContract } from '@adonisjs/fold'
   import { HttpContextContract } from '@ioc:Adonis/Core/HttpContext'
 
+  export type DefaultExport<T> = Promise<{ default: T }>
+
+  /**
+   * Shape of the middleware class
+   */
+  export interface MiddlewareConstructorContract {
+    new (...args: any[]): {
+      handle(ctx: HttpContextContract, next: () => void, ...options: any[]): any
+    }
+  }
+
   /**
    * Input middleware node must be function or a string pointing
    * to the IoC container
    */
-  export type MiddlewareHandler =
-    | string
-    | ((ctx: HttpContextContract, next: () => Promise<void>, args?: string[]) => Promise<void>)
+  export type MiddlewareHandler = string | (() => DefaultExport<MiddlewareConstructorContract>)
 
   /**
    * Shape of resolved middleware. This information is
@@ -26,6 +35,11 @@ declare module '@ioc:Adonis/Core/Middleware' {
   export type ResolvedMiddlewareHandler =
     | {
         type: 'function'
+        value: (ctx: HttpContextContract, next: () => void, ...options: any[]) => any
+        args: string[]
+      }
+    | {
+        type: 'lazy-import'
         value: Exclude<MiddlewareHandler, string>
         args: string[]
       }

adonis-typings/route.ts

@@ -10,7 +10,7 @@
 declare module '@ioc:Adonis/Core/Route' {
   import { MacroableConstructorContract } from 'macroable'
   import { HttpContextContract } from '@ioc:Adonis/Core/HttpContext'
-  import { MiddlewareHandler, ResolvedMiddlewareHandler } from '@ioc:Adonis/Core/Middleware'
+  import { ResolvedMiddlewareHandler } from '@ioc:Adonis/Core/Middleware'
 
   /**
    * Route.where param matcher shape
@@ -26,7 +26,14 @@ declare module '@ioc:Adonis/Core/Route' {
   /**
    * The shape of the route handler
    */
-  export type RouteHandler = ((ctx: HttpContextContract) => Promise<any>) | string
+  export type RouteHandler = ((ctx: HttpContextContract) => any) | string
+
+  /**
+   * Middleware handler attached to the route.
+   */
+  export type RouteMiddlewareHandler =
+    | string
+    | ((ctx: HttpContextContract, next: () => void, ...options: any[]) => any)
 
   /**
    * Node after resolving controller.method binding from the route
@@ -75,7 +82,7 @@ declare module '@ioc:Adonis/Core/Route' {
      * leaves the type to `any` for the consumer to decide the
      * shape of the middleware
      */
-    middleware: MiddlewareHandler[]
+    middleware: RouteMiddlewareHandler[]
 
     /**
      * Any custom runtime properties to be added to the route
@@ -212,7 +219,10 @@ declare module '@ioc:Adonis/Core/Route' {
      * is true, then middleware will be added to start of the existing
      * middleware. The option is exposed for [[RouteGroup]]
      */
-    middleware(middleware: MiddlewareHandler | MiddlewareHandler[], prepend?: boolean): this
+    middleware(
+      middleware: RouteMiddlewareHandler | RouteMiddlewareHandler[],
+      prepend?: boolean
+    ): this
 
     /**
      * Give memorizable name to the route. This is helpful, when you
@@ -274,9 +284,9 @@ declare module '@ioc:Adonis/Core/Route' {
      */
     middleware(
       middleware: {
-        [P in ResourceRouteNames]?: MiddlewareHandler | MiddlewareHandler[]
+        [P in ResourceRouteNames]?: RouteMiddlewareHandler | RouteMiddlewareHandler[]
       } & {
-        '*'?: MiddlewareHandler | MiddlewareHandler[]
+        '*'?: RouteMiddlewareHandler | RouteMiddlewareHandler[]
       }
     ): this
 
@@ -355,7 +365,7 @@ declare module '@ioc:Adonis/Core/Route' {
      * }).middleware(['auth'])
      * ```
      */
-    middleware(middleware: MiddlewareHandler | MiddlewareHandler[]): this
+    middleware(middleware: RouteMiddlewareHandler | RouteMiddlewareHandler[]): this
 
     /**
      * Define namespace for all the routes inside the group.

benchmarks/fastify.ts

@@ -1,9 +1,11 @@
 const fastify = require('fastify')()
 
-fastify.get('/', (_, reply) => {
-  reply.send({ hello: 'world' })
-})
+fastify.register(require('middie')).then(() => {
+  fastify.get('/', (_, reply) => {
+    reply.send({ hello: 'world' })
+  })
 
-fastify.listen(3000, () => {
-  console.log('listening on 3000')
+  fastify.listen(3000, () => {
+    console.log('listening on 3000')
+  })
 })

package-lock.json

@@ -60,6 +60,7 @@
     "http-status-codes": "^2.1.4",
     "husky": "^5.0.9",
     "japa": "^3.1.1",
+    "middie": "^5.2.0",
     "mrm": "^2.5.18",
     "np": "^7.3.0",
     "pem": "^1.14.4",

package.json

@@ -55,7 +55,7 @@ export class MiddlewareStore implements MiddlewareStoreContract {
    */
   private resolver: IocResolverContract<any>
 
-  constructor(container: IocContract) {
+  constructor(private container: IocContract) {
     this.resolver = container.getResolver()
   }
 
@@ -71,7 +71,7 @@ export class MiddlewareStore implements MiddlewareStoreContract {
   private resolveMiddleware(middleware: MiddlewareHandler): ResolvedMiddlewareHandler {
     return typeof middleware === 'function'
       ? {
-          type: 'function',
+          type: 'lazy-import',
           value: middleware,
           args: [],
         }
@@ -128,6 +128,16 @@ export class MiddlewareStore implements MiddlewareStoreContract {
 
     const args: any[] = [params[0], params[1]]
     args.push(middleware.args)
+
+    /**
+     * Handling the lazily imported middleware
+     */
+    if (middleware.type === 'lazy-import') {
+      const middlewareClass = await middleware.value()
+      const middlewareInstance = await this.container.makeAsync(middlewareClass.default)
+      return this.container.callAsync(middlewareInstance, 'handle', args)
+    }
+
     return this.resolver.call(middleware, undefined, args)
   }
 }

src/MiddlewareStore/index.ts

@@ -10,8 +10,11 @@
 /// <reference path="../../adonis-typings/index.ts" />
 
 import { Macroable } from 'macroable'
-import { MiddlewareHandler } from '@ioc:Adonis/Core/Middleware'
-import { RouteGroupContract, RouteParamMatcher } from '@ioc:Adonis/Core/Route'
+import {
+  RouteGroupContract,
+  RouteParamMatcher,
+  RouteMiddlewareHandler,
+} from '@ioc:Adonis/Core/Route'
 
 import { Route } from './Route'
 import { BriskRoute } from './BriskRoute'
@@ -141,7 +144,7 @@ export class RouteGroup extends Macroable implements RouteGroupContract {
    * }).middleware(['auth'])
    * ```
    */
-  public middleware(middleware: MiddlewareHandler | MiddlewareHandler[]): this {
+  public middleware(middleware: RouteMiddlewareHandler | RouteMiddlewareHandler[]): this {
     this.routes.forEach((route) => this.invoke(route, 'middleware', [middleware, true]))
     return this
   }

src/Router/Group.ts

@@ -13,12 +13,12 @@ import { singular } from 'pluralize'
 import { Macroable } from 'macroable'
 import { string } from '@poppinss/utils/build/helpers'
 
-import { MiddlewareHandler } from '@ioc:Adonis/Core/Middleware'
 import {
   RouteParamMatcher,
   ResourceRouteNames,
   RouteMatchersNode,
   RouteResourceContract,
+  RouteMiddlewareHandler,
 } from '@ioc:Adonis/Core/Route'
 
 import { Route } from './Route'
@@ -131,9 +131,9 @@ export class RouteResource extends Macroable implements RouteResourceContract {
    */
   public middleware(
     middleware: {
-      [P in ResourceRouteNames]?: MiddlewareHandler | MiddlewareHandler[]
+      [P in ResourceRouteNames]?: RouteMiddlewareHandler | RouteMiddlewareHandler[]
     } & {
-      '*'?: MiddlewareHandler | MiddlewareHandler[]
+      '*'?: RouteMiddlewareHandler | RouteMiddlewareHandler[]
     }
   ): this {
     for (let name in middleware) {

src/Router/Resource.ts

@@ -17,8 +17,8 @@ import {
   RouteHandler,
   RouteMatchersNode,
   RouteParamMatcher,
+  RouteMiddlewareHandler,
 } from '@ioc:Adonis/Core/Route'
-import { MiddlewareHandler } from '@ioc:Adonis/Core/Middleware'
 
 import { dropSlash } from '../helpers'
 
@@ -64,7 +64,7 @@ export class Route extends Macroable implements RouteContract {
   /**
    * An array of middleware. Added using `middleware` function
    */
-  private routeMiddleware: MiddlewareHandler[] = []
+  private routeMiddleware: RouteMiddlewareHandler[] = []
 
   /**
    * Storing the namespace explicitly set using `route.namespace` method
@@ -171,7 +171,10 @@ export class Route extends Macroable implements RouteContract {
    * is true, then middleware will be added to start of the existing
    * middleware. The option is exposed for [[RouteGroup]]
    */
-  public middleware(middleware: MiddlewareHandler | MiddlewareHandler[], prepend = false): this {
+  public middleware(
+    middleware: RouteMiddlewareHandler | RouteMiddlewareHandler[],
+    prepend = false
+  ): this {
     middleware = Array.isArray(middleware) ? middleware : [middleware]
     this.routeMiddleware = prepend
       ? middleware.concat(this.routeMiddleware)

src/Router/Route.ts

@@ -14,12 +14,16 @@ import { MiddlewareStore } from '../src/MiddlewareStore'
 test.group('Middleware', () => {
   test('register global middleware', (assert) => {
     const middleware = new MiddlewareStore(new Ioc())
-    async function handler() {}
+    class GlobalMiddleware {
+      public async handle() {}
+    }
+
+    const handler = () => Promise.resolve({ default: GlobalMiddleware })
 
     middleware.register([handler])
     assert.deepEqual(middleware.get(), [
       {
-        type: 'function',
+        type: 'lazy-import',
         value: handler,
         args: [],
       },
@@ -28,21 +32,29 @@ test.group('Middleware', () => {
 
   test('register named middleware', (assert) => {
     const middleware = new MiddlewareStore(new Ioc())
-    async function handler() {}
+    class GlobalMiddleware {
+      public async handle() {}
+    }
+
+    const handler = () => Promise.resolve({ default: GlobalMiddleware })
 
     middleware.registerNamed({ auth: handler })
     assert.deepEqual(middleware['named'], {
-      auth: { type: 'function', value: handler, args: [] },
+      auth: { type: 'lazy-import', value: handler, args: [] },
     })
   })
 
   test('get named middleware', (assert) => {
     const middleware = new MiddlewareStore(new Ioc())
-    async function handler() {}
+    class GlobalMiddleware {
+      public async handle() {}
+    }
+
+    const handler = () => Promise.resolve({ default: GlobalMiddleware })
 
     middleware.registerNamed({ auth: handler })
     assert.deepEqual(middleware.getNamed('auth'), {
-      type: 'function',
+      type: 'lazy-import',
       value: handler,
       args: [],
     })
@@ -55,12 +67,17 @@ test.group('Middleware', () => {
 
   test('invoke resolved middleware', async (assert) => {
     const stack: any[] = []
-    async function middlewareFn() {
-      stack.push('middlewareFn')
+
+    class GlobalMiddleware {
+      public async handle() {
+        stack.push('middlewareFn')
+      }
     }
 
+    const handler = () => Promise.resolve({ default: GlobalMiddleware })
+
     const middleware = new MiddlewareStore(new Ioc())
-    middleware.register([middlewareFn])
+    middleware.register([handler])
     await middleware.invokeMiddleware(middleware.get()[0], [] as any)
     assert.deepEqual(stack, ['middlewareFn'])
   })