refactor: cleanup how named middleware are created and used

Author: thetutlage

index.ts

@@ -22,4 +22,3 @@ export { HttpException } from './src/exceptions/http_exception.js'
 export { AbortException } from './src/exceptions/abort_exception.js'
 export { RouteNotFoundException } from './src/exceptions/route_not_found.js'
 export { CannotLookupRouteException } from './src/exceptions/cannot_lookup_route.js'
-export { defineMiddleware, defineNamedMiddleware } from './src/define_middleware.js'

src/define_middleware.ts

@@ -7,23 +7,55 @@
  * file that was distributed with this source code.
  */
 
-import type { LazyImport } from './types/base.js'
-import type { MiddlewareAsClass } from './types/middleware.js'
+import { moduleImporter } from '@adonisjs/fold'
+import type { LazyImport, UnWrapLazyImport } from './types/base.js'
+import type {
+  GetMiddlewareArgs,
+  MiddlewareAsClass,
+  ParsedGlobalMiddleware,
+} from './types/middleware.js'
 
 /**
- * Define an array of midldeware to be used either by the server
- * or the router
+ * Converts a middleware name and its lazy import to a factory function. The function
+ * can than later be used to reference the middleware with different arguments
+ * every time.
  */
-export function defineMiddleware(list: LazyImport<MiddlewareAsClass>[]) {
-  return list
+function middlewareReferenceBuilder(
+  name: string | number | symbol,
+  middleware: LazyImport<MiddlewareAsClass>
+) {
+  const handler = moduleImporter(middleware, 'handle').toHandleMethod()
+  return function (...args: any[]) {
+    return {
+      name,
+      args: args[0],
+      ...handler,
+    }
+  }
 }
 
 /**
- * Define an collection of named middleware. The name can be later be
- * referenced on the routes
+ * Define an collection of named middleware. The collection gets converted
+ * into a collection of factory functions. Calling the function returns
+ * a reference to the executable middleware.
  */
 export function defineNamedMiddleware<
-  NamedMiddleware extends Record<string, LazyImport<MiddlewareAsClass>>
+  NamedMiddleware extends Record<string | number | symbol, LazyImport<MiddlewareAsClass>>
 >(collection: NamedMiddleware) {
-  return collection
+  return Object.keys(collection).reduce(
+    (result, key: keyof NamedMiddleware) => {
+      result[key] = middlewareReferenceBuilder(key, collection[key])
+      return result
+    },
+    {} as {
+      [K in keyof NamedMiddleware]: <
+        Args extends GetMiddlewareArgs<UnWrapLazyImport<NamedMiddleware[K]>>
+      >(
+        ...args: Args
+      ) => {
+        name: K
+        args: Args[0]
+      } & ParsedGlobalMiddleware
+    }
+  )
 }

src/middleware/store.ts

@@ -11,9 +11,7 @@ import { Macroable } from '@poppinss/macroable'
 import type { Application } from '@adonisjs/application'
 
 import { Route } from './route.js'
-import type { LazyImport } from '../types/base.js'
-import type { MiddlewareStore } from '../middleware/store.js'
-import type { MiddlewareAsClass } from '../types/middleware.js'
+import type { ParsedGlobalMiddleware } from '../types/middleware.js'
 import type { MakeUrlOptions, RouteFn, RouteMatchers } from '../types/route.js'
 
 /**
@@ -25,9 +23,7 @@ import type { MakeUrlOptions, RouteFn, RouteMatchers } from '../types/route.js'
  *
  * Brisk routes are always registered under the `GET` HTTP method.
  */
-export class BriskRoute<
-  NamedMiddleware extends Record<string, LazyImport<MiddlewareAsClass>> = any
-> extends Macroable {
+export class BriskRoute extends Macroable {
   /**
    * Route pattern
    */
@@ -44,26 +40,26 @@ export class BriskRoute<
   #app: Application<any, any>
 
   /**
-   * Middleware store to resolve middleware
+   * Middleware registered on the router
    */
-  #middlewareStore: MiddlewareStore<NamedMiddleware>
+  #routerMiddleware: ParsedGlobalMiddleware[]
 
   /**
    * Reference to route instance. Set after `setHandler` is called
    */
-  route: null | Route<NamedMiddleware> = null
+  route: null | Route = null
 
   constructor(
     app: Application<any, any>,
-    middlewareStore: MiddlewareStore<NamedMiddleware>,
+    routerMiddleware: ParsedGlobalMiddleware[],
     options: {
       pattern: string
       globalMatchers: RouteMatchers
     }
   ) {
     super()
     this.#app = app
-    this.#middlewareStore = middlewareStore
+    this.#routerMiddleware = routerMiddleware
     this.#pattern = options.pattern
     this.#globalMatchers = options.globalMatchers
   }
@@ -72,7 +68,7 @@ export class BriskRoute<
    * Set handler for the brisk route
    */
   setHandler(handler: RouteFn): Route {
-    this.route = new Route(this.#app, this.#middlewareStore, {
+    this.route = new Route(this.#app, this.#routerMiddleware, {
       pattern: this.#pattern,
       globalMatchers: this.#globalMatchers,
       methods: ['GET', 'HEAD'],

src/router/brisk.ts

@@ -8,10 +8,8 @@
  */
 
 import { Macroable } from '@poppinss/macroable'
-import type { MiddlewareStore } from '../middleware/store.js'
-import type { LazyImport, UnWrapLazyImport } from '../types/base.js'
 import type { RouteMatcher, StoreRouteMiddleware } from '../types/route.js'
-import type { GetMiddlewareArgs, MiddlewareAsClass, MiddlewareFn } from '../types/middleware.js'
+import type { MiddlewareFn, ParsedNamedMiddleware } from '../types/middleware.js'
 
 import { Route } from './route.js'
 import { BriskRoute } from './brisk.js'
@@ -21,25 +19,14 @@ import { RouteResource } from './resource.js'
  * Group class exposes the API to take action on a group of routes.
  * The group routes must be pre-defined using the constructor.
  */
-export class RouteGroup<
-  NamedMiddleware extends Record<string, LazyImport<MiddlewareAsClass>> = any
-> extends Macroable {
+export class RouteGroup extends Macroable {
   /**
    * Array of middleware registered on the group.
    */
   #middleware: StoreRouteMiddleware[] = []
 
-  /**
-   * Middleware store to resolve middleware
-   */
-  #middlewareStore: MiddlewareStore<NamedMiddleware>
-
-  constructor(
-    public routes: (Route | RouteGroup | RouteResource | BriskRoute)[],
-    middlewareStore: MiddlewareStore<NamedMiddleware>
-  ) {
+  constructor(public routes: (Route | RouteGroup | RouteResource | BriskRoute)[]) {
     super()
-    this.#middlewareStore = middlewareStore
   }
 
   /**
@@ -226,12 +213,7 @@ export class RouteGroup<
    * }).middleware(['auth'])
    * ```
    */
-  middleware<Name extends keyof NamedMiddleware>(
-    middleware: Name,
-    ...args: GetMiddlewareArgs<UnWrapLazyImport<NamedMiddleware[Name]>>
-  ): this
-  middleware(middleware: MiddlewareFn): this
-  middleware(middleware: keyof NamedMiddleware | MiddlewareFn, args?: any): this {
+  middleware(middleware: MiddlewareFn | ParsedNamedMiddleware): this {
     /**
      * Register middleware with children. We share the group middleware
      * array by reference, therefore have to register it only for the
@@ -241,21 +223,7 @@ export class RouteGroup<
       this.routes.forEach((route) => this.#shareMiddlewareStackWithRoutes(route))
     }
 
-    /**
-     * Resolve string based middleware
-     */
-    if (typeof middleware === 'string') {
-      this.#middleware.push(this.#middlewareStore.get(middleware, args))
-      return this
-    }
-
-    /**
-     * Register function
-     */
-    if (typeof middleware === 'function') {
-      this.#middleware.push(middleware)
-    }
-
+    this.#middleware.push(middleware)
     return this
   }
 }