feat: enhance plugin system to include request context in bindings

Author: 3m1n3nc3

src/core/plugins.ts

@@ -1,15 +1,31 @@
 import { BindToken, BindValue, Container } from './bindings'
+
+import type { Request as CoreRequest } from './Request'
+import type { Response as CoreResponse } from './Response'
 import type { RouterConfig } from 'types/basic'
 
 export type PluginSetupResult = void | Promise<void>
 
-export type PluginBind = <T>(token: BindToken<T>, value: BindValue<T>) => void
+export interface ClearRouterPluginRequestContext {
+    ctx: any
+    request: CoreRequest
+    response: CoreResponse
+    [key: string]: any
+}
+
+export type PluginBindFactory<T = any> = (ctx: ClearRouterPluginRequestContext) => T | Promise<T>
+export type PluginBindValue<T = any> = BindValue<T> | PluginBindFactory<T>
+export type PluginBind = <T>(token: BindToken<T>, value: PluginBindValue<T>) => void
 
 export interface ClearRouterPluginContext<Options = any> {
     container: typeof Container
     bind: PluginBind
     configure: (options: RouterConfig) => void
     configureDefaults: (options: RouterConfig) => void
+    readonly request?: CoreRequest
+    readonly response?: CoreResponse
+    getRequest: () => CoreRequest | undefined
+    getResponse: () => CoreResponse | undefined
     options: Options
 }
 

src/core/router.ts

@@ -1,6 +1,6 @@
 import { ApiResourceMiddleware, ControllerAction, HttpMethod, RouterConfig } from 'types/basic'
-import type { ClearRouterPluginContext, ClearRouterPluginInput } from './plugins'
-import { Container, getBindingMetadataFromTargets, getDesignParamTypes, getStandardMetadata } from './bindings'
+import type { ClearRouterPluginContext, ClearRouterPluginInput, ClearRouterPluginRequestContext, PluginBind } from './plugins'
+import { Container, getBindingMetadataFromTargets, getDesignParamTypes, getStandardMetadata, isClass } from './bindings'
 
 import { AsyncLocalStorage } from 'node:async_hooks'
 import { Controller } from 'src/Controller'
@@ -266,9 +266,17 @@ export abstract class CoreRouter {
         const setup = async (): Promise<void> => {
             const ctx: ClearRouterPluginContext<Options> = {
                 container: Container,
-                bind: Container.bind.bind(Container),
+                bind: this.createPluginBind(),
                 configure: this.configure.bind(this),
                 configureDefaults: this.configureDefaults.bind(this),
+                get request () {
+                    return this.getRequest()
+                },
+                get response () {
+                    return this.getResponse()
+                },
+                getRequest: () => this.getCurrentPluginRequestContext()?.request,
+                getResponse: () => this.getCurrentPluginRequestContext()?.response,
                 options: options as Options,
             }
 
@@ -307,6 +315,7 @@ export abstract class CoreRouter {
         prefix: string
         groupMiddlewares: any[]
     }>()
+    protected static pluginRequestContext = new AsyncLocalStorage<ClearRouterPluginRequestContext>()
 
     static routes: Array<Route<any, any, any>> = []
     static routesByPathMethod: Record<string, Route<any, any, any>> = {}
@@ -316,6 +325,39 @@ export abstract class CoreRouter {
     static groupMiddlewares: any[] = []
     static globalMiddlewares: any[] = []
 
+    protected static getCurrentPluginRequestContext (): ClearRouterPluginRequestContext | undefined {
+        return this.pluginRequestContext.getStore()
+    }
+
+    protected static createPluginRequestContext (ctx: any): ClearRouterPluginRequestContext {
+        const request: CoreRequest = ctx.clearRequest
+        const response: CoreResponse = ctx.clearResponse
+
+        return {
+            ...ctx,
+            ctx,
+            request,
+            response,
+            clearRequest: request,
+            clearResponse: response,
+        }
+    }
+
+    protected static createPluginBind (): PluginBind {
+        const bind: PluginBind = (token, value): void => {
+            if (typeof value === 'function' && !isClass(value)) {
+                const factory = value as (ctx: ClearRouterPluginRequestContext) => any
+                Container.bind(token, (ctx: any) => factory(this.createPluginRequestContext(ctx)))
+
+                return
+            }
+
+            Container.bind(token, value)
+        }
+
+        return bind
+    }
+
     protected static ensureState (this: any): void {
         this.bindStateAccessors()
 
@@ -818,42 +860,44 @@ export abstract class CoreRouter {
         bindingHandler?: object,
         bindingMetadata?: object
     ): Promise<any> {
-        await this.pluginsReady()
-
-        if (!this.config.container?.enabled) {
-            return handlerFunction(ctx, ctx.clearRequest)
-        }
+        return this.pluginRequestContext.run(this.createPluginRequestContext(ctx), async () => {
+            await this.pluginsReady()
 
-        const metadata = getBindingMetadataFromTargets([
-            { target: bindingTarget, propertyKey: bindingMethod },
-            { target: bindingHandler },
-            { target: bindingTarget, propertyKey: '__class__' },
-        ]) ?? getStandardMetadata(bindingMetadata, bindingMethod)
-            ?? getStandardMetadata(bindingMetadata, '__class__')
-        if (!metadata) {
-            return handlerFunction(ctx, ctx.clearRequest)
-        }
+            if (!this.config.container?.enabled) {
+                return handlerFunction(ctx, ctx.clearRequest)
+            }
 
-        const designTokens = [
-            ...(bindingTarget ? getDesignParamTypes(bindingTarget, bindingMethod) : []),
-            ...(bindingHandler ? getDesignParamTypes(bindingHandler) : []),
-        ]
-        const tokens = metadata.tokens?.length ? metadata.tokens : designTokens
-        if (!tokens.length) {
-            return handlerFunction(ctx, ctx.clearRequest)
-        }
+            const metadata = getBindingMetadataFromTargets([
+                { target: bindingTarget, propertyKey: bindingMethod },
+                { target: bindingHandler },
+                { target: bindingTarget, propertyKey: '__class__' },
+            ]) ?? getStandardMetadata(bindingMetadata, bindingMethod)
+                ?? getStandardMetadata(bindingMetadata, '__class__')
+            if (!metadata) {
+                return handlerFunction(ctx, ctx.clearRequest)
+            }
 
-        const args = []
-        for (const token of tokens) {
-            const resolved = await Container.resolve(token, ctx, Boolean(this.config.container?.autoDiscover))
-            if (typeof resolved === 'undefined') {
+            const designTokens = [
+                ...(bindingTarget ? getDesignParamTypes(bindingTarget, bindingMethod) : []),
+                ...(bindingHandler ? getDesignParamTypes(bindingHandler) : []),
+            ]
+            const tokens = metadata.tokens?.length ? metadata.tokens : designTokens
+            if (!tokens.length) {
                 return handlerFunction(ctx, ctx.clearRequest)
             }
 
-            args.push(resolved)
-        }
+            const args = []
+            for (const token of tokens) {
+                const resolved = await Container.resolve(token, ctx, Boolean(this.config.container?.autoDiscover))
+                if (typeof resolved === 'undefined') {
+                    return handlerFunction(ctx, ctx.clearRequest)
+                }
 
-        return (handlerFunction as any)(...args)
+                args.push(resolved)
+            }
+
+            return (handlerFunction as any)(...args)
+        })
     }
 
     protected static bindRequestToInstance (

tests/express.test.ts

@@ -372,6 +372,57 @@ describe('Express App (JS)', () => {
             .expect({ id: '135', audit: 'async-plugin' })
     })
 
+    it('passes the current Request instance to plugin bindings', async () => {
+        class RequestAuditService {
+            constructor(
+                readonly id: string,
+                readonly method: string,
+            ) { }
+        }
+
+        const requestAuditPlugin = definePlugin({
+            name: 'test-request-aware-plugin',
+            setup ({ bind, getRequest }) {
+                expect(getRequest()).toBeUndefined()
+
+                bind(RequestAuditService, (d: { request: ClearRouterRequest }) => {
+                    return new RequestAuditService(
+                        d.request.param('id'),
+                        d.request.method,
+                    )
+                })
+            },
+        })
+
+        class PluginUsersController {
+            @Bind(RequestAuditService)
+            show (audit: RequestAuditService) {
+                return {
+                    id: audit.id,
+                    method: audit.method,
+                }
+            }
+        }
+
+        Router.configure({
+            container: {
+                enabled: true,
+            },
+        })
+        Router.use(requestAuditPlugin)
+        Router.put('/api/request-plugin/:id', [PluginUsersController, 'show'])
+
+        await setupApp()
+
+        await request(app)
+            .put('/api/request-plugin/864')
+            .expect(200)
+            .expect({
+                id: '864',
+                method: 'PUT',
+            })
+    })
+
     it('falls back to the default handler signature when binding is disabled', async () => {
         class BoundUsersController {
             @Bind(ClearRouterRequest)