@velajs/vela 1.9.0 → 1.12.0

package/dist/factory/adapter.d.ts

@@ -0,0 +1,36 @@
+import type { MiddlewareHandler } from 'hono';
+import type { VelaApplication } from '../application';
+import type { Container } from '../container/container';
+import type { DiscoveryService } from '../discovery/discovery.service';
+import type { RouteManager } from '../http/route.manager';
+/** The framework's resolved world, handed to adapter hooks. */
+export interface AdapterContext {
+    app: VelaApplication;
+    container: Container;
+    routeManager: RouteManager;
+    discovery: DiscoveryService;
+}
+/**
+ * The contract a runtime binding implements to plug a platform into a Vela
+ * app — what `@velajs/cloudflare` (bindings + Durable Object WebSocket) and
+ * the Node/Bun WebSocket transport do, made first-class:
+ *
+ * ```ts
+ * const app = await VelaFactory.create(AppModule, {
+ *   adapters: [cloudflareAdapter({ bindings })],
+ * });
+ * ```
+ *
+ * - `requestMiddleware` is prepended to the global middleware chain (runs
+ *   before consumer middleware — e.g. capture `c.env` for binding services).
+ * - `onBootstrap` runs after DI + lifecycle hooks, with `app.entrypoints`
+ *   available, BEFORE routes are built — register platform services here.
+ * - `onRoutesBuilt` runs after the Hono app exists — mount platform routes
+ *   (WebSocket upgrades, health endpoints) here via `ctx.app.getHonoApp()`.
+ */
+export interface RuntimeAdapter {
+    name: string;
+    requestMiddleware?: MiddlewareHandler[];
+    onBootstrap?(ctx: AdapterContext): void | Promise<void>;
+    onRoutesBuilt?(ctx: AdapterContext): void | Promise<void>;
+}

package/dist/factory/adapter.js

@@ -0,0 +1,18 @@
+/**
+ * The contract a runtime binding implements to plug a platform into a Vela
+ * app — what `@velajs/cloudflare` (bindings + Durable Object WebSocket) and
+ * the Node/Bun WebSocket transport do, made first-class:
+ *
+ * ```ts
+ * const app = await VelaFactory.create(AppModule, {
+ *   adapters: [cloudflareAdapter({ bindings })],
+ * });
+ * ```
+ *
+ * - `requestMiddleware` is prepended to the global middleware chain (runs
+ *   before consumer middleware — e.g. capture `c.env` for binding services).
+ * - `onBootstrap` runs after DI + lifecycle hooks, with `app.entrypoints`
+ *   available, BEFORE routes are built — register platform services here.
+ * - `onRoutesBuilt` runs after the Hono app exists — mount platform routes
+ *   (WebSocket upgrades, health endpoints) here via `ctx.app.getHonoApp()`.
+ */ export { };

package/dist/factory/bootstrap.js

@@ -1,11 +1,11 @@
 import { Scope } from "../constants.js";
 import { Container } from "../container/container.js";
 import { ModuleRef } from "../container/module-ref.js";
+import { DiscoveryService } from "../discovery/discovery.service.js";
 import { REQUEST_CONTEXT } from "../http/request-context.js";
 import { RouteManager } from "../http/route.manager.js";
 import { ModuleLoader } from "../module/module-loader.js";
 import { bindAppProviders } from "../pipeline/app-providers.js";
-import { ComponentManager } from "../pipeline/component.manager.js";
 import { APP_FILTER, APP_GUARD, APP_INTERCEPTOR, APP_MIDDLEWARE, APP_PIPE } from "../pipeline/tokens.js";
 /**
  * Wire the DI graph for `rootModule` and prepare the route manager — without
@@ -32,6 +32,15 @@ import { APP_FILTER, APP_GUARD, APP_INTERCEPTOR, APP_MIDDLEWARE, APP_PIPE } from
         ]
     });
     container.markGlobalToken(ModuleRef);
+    // Decorator-driven discovery — global so any provider can inject it.
+    container.register({
+        provide: DiscoveryService,
+        useFactory: (c)=>new DiscoveryService(c),
+        inject: [
+            Container
+        ]
+    });
+    container.markGlobalToken(DiscoveryService);
     for (const t of [
         APP_GUARD,
         APP_PIPE,
@@ -54,7 +63,13 @@ import { APP_FILTER, APP_GUARD, APP_INTERCEPTOR, APP_MIDDLEWARE, APP_PIPE } from
     });
     container.markGlobalToken(REQUEST_CONTEXT);
     const routeManager = new RouteManager(container, options);
-    ComponentManager.init(container);
+    // Resolvable so non-HTTP transports (the WebSocket dispatcher) can read the
+    // same global-tier components (APP_* + app.useGlobalX()).
+    container.register({
+        provide: RouteManager,
+        useValue: routeManager
+    });
+    container.markGlobalToken(RouteManager);
     const loader = new ModuleLoader(container, routeManager);
     loader.load(rootModule);
     bindAppProviders(routeManager, container, loader);
@@ -68,6 +83,9 @@ import { APP_FILTER, APP_GUARD, APP_INTERCEPTOR, APP_MIDDLEWARE, APP_PIPE } from
         };
         routeManager.useGlobalMiddleware(mw);
     }
+    // All providers are registered — compute request-scope bubbling so effective
+    // scopes are known before eager instantiation and request resolution.
+    container.computeEffectiveScopes();
     return {
         container,
         routeManager,

package/dist/factory.d.ts

@@ -1,6 +1,16 @@
 import { VelaApplication } from './application';
 import type { Type } from './container/types';
+import type { RuntimeAdapter } from './factory/adapter';
 import type { BootstrapOptions } from './factory/bootstrap';
+export interface VelaCreateOptions extends BootstrapOptions {
+    /**
+     * Runtime adapters binding this app to a platform (Cloudflare bindings,
+     * WebSocket transports, …). Their `requestMiddleware` is prepended to the
+     * global middleware chain; `onBootstrap`/`onRoutesBuilt` hooks run around
+     * route building. See {@link RuntimeAdapter}.
+     */
+    adapters?: RuntimeAdapter[];
+}
 export declare const VelaFactory: {
-    create(rootModule: Type, options?: BootstrapOptions): Promise<VelaApplication>;
+    create(rootModule: Type, options?: VelaCreateOptions): Promise<VelaApplication>;
 };

package/dist/factory.js

@@ -1,15 +1,36 @@
 import { VelaApplication } from "./application.js";
+import { DiscoveryService } from "./discovery/discovery.service.js";
 import { bootstrap } from "./factory/bootstrap.js";
 export const VelaFactory = {
     async create (rootModule, options = {}) {
-        const { container, routeManager, loader } = await bootstrap(rootModule, options);
+        const { adapters = [], ...bootstrapOptions } = options;
+        const adapterMiddleware = adapters.flatMap((a)=>a.requestMiddleware ?? []);
+        if (adapterMiddleware.length > 0) {
+            bootstrapOptions.middleware = [
+                ...adapterMiddleware,
+                ...bootstrapOptions.middleware ?? []
+            ];
+        }
+        const { container, routeManager, loader } = await bootstrap(rootModule, bootstrapOptions);
         const app = new VelaApplication(container, routeManager);
         const instances = await loader.resolveAllInstances();
         app.setInstances(instances);
         await app.callOnModuleInit();
         await app.callOnApplicationBootstrap();
-        // Build routes (async — supports CRUD integration with dynamic imports)
+        const adapterContext = {
+            app,
+            container,
+            routeManager,
+            discovery: container.resolve(DiscoveryService)
+        };
+        for (const adapter of adapters){
+            await adapter.onBootstrap?.(adapterContext);
+        }
+        // Build routes (async — supports route-contributor integration)
         await app.initRoutes();
+        for (const adapter of adapters){
+            await adapter.onRoutesBuilt?.(adapterContext);
+        }
         return app;
     }
 };

package/dist/fetch/fetch.module.d.ts

@@ -1,8 +1,7 @@
-import type { AsyncModuleOptions, DynamicModule } from '../module/types';
 import type { HttpModuleOptions } from './fetch.types';
-export declare class HttpModule {
-    static forRoot(options?: HttpModuleOptions): DynamicModule;
-    static forRootAsync(options: AsyncModuleOptions<HttpModuleOptions> & {
-        key?: string;
-    }): DynamicModule;
+declare const ConfigurableModuleClass: import("..").ConfigurableModuleClassType<HttpModuleOptions, "forRoot", "create", {
+    isGlobal?: boolean;
+}>;
+export declare class HttpModule extends ConfigurableModuleClass {
 }
+export {};

package/dist/fetch/fetch.module.js

@@ -5,52 +5,18 @@ function _ts_decorate(decorators, target, key, desc) {
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
 import { Module } from "../module/decorators.js";
-import { stableHash } from "../module/stable-hash.js";
+import { ConfigurableModuleBuilder } from "../module/configurable-module.builder.js";
 import { HttpService, HTTP_MODULE_OPTIONS } from "./fetch.service.js";
-export class HttpModule {
-    static forRoot(options = {}) {
-        return {
-            module: HttpModule,
-            key: stableHash(options),
-            providers: [
-                {
-                    provide: HTTP_MODULE_OPTIONS,
-                    useValue: options
-                },
-                HttpService
-            ],
-            exports: [
-                HttpService,
-                HTTP_MODULE_OPTIONS
-            ]
-        };
-    }
-    static forRootAsync(options) {
-        return {
-            module: HttpModule,
-            key: options.key ?? stableHash({
-                inject: options.inject,
-                useFactory: options.useFactory
-            }),
-            imports: options.imports ?? [],
-            providers: [
-                {
-                    provide: HTTP_MODULE_OPTIONS,
-                    useFactory: options.useFactory,
-                    inject: options.inject ?? []
-                },
-                HttpService
-            ],
-            exports: [
-                HttpService,
-                HTTP_MODULE_OPTIONS
-            ]
-        };
-    }
+const { ConfigurableModuleClass } = new ConfigurableModuleBuilder({
+    moduleName: 'Http',
+    optionsInjectionToken: HTTP_MODULE_OPTIONS
+}).build();
+export class HttpModule extends ConfigurableModuleClass {
 }
 HttpModule = _ts_decorate([
     Module({
         providers: [
+            // Default for bare `imports: [HttpModule]`; forRoot(options) overrides via merge.
             {
                 provide: HTTP_MODULE_OPTIONS,
                 useValue: {}
@@ -58,7 +24,8 @@ HttpModule = _ts_decorate([
             HttpService
         ],
         exports: [
-            HttpService
+            HttpService,
+            HTTP_MODULE_OPTIONS
         ]
     })
 ], HttpModule);

package/dist/http/ambient.d.ts

@@ -0,0 +1,17 @@
+import type { MiddlewareHandler } from 'hono';
+import type { Container } from '../container/container';
+import { type RequestContext } from './request-context';
+/**
+ * Returns Hono's `contextStorage()` middleware. Register it as the FIRST global
+ * middleware so `getCurrentContainer()` works everywhere downstream. When using
+ * `VelaFactory.create(module, { ambientContainer: true })` this is wired
+ * automatically — call this only for manual/raw Hono setups.
+ */
+export declare function enableAmbientContainer(): MiddlewareHandler;
+/**
+ * The current request's DI container. Throws with actionable guidance if
+ * ambient access isn't enabled or this runs outside a request.
+ */
+export declare function getCurrentContainer(): Container;
+/** The current request's {@link RequestContext} (via the ambient container). */
+export declare function getCurrentRequestContext(): RequestContext;

package/dist/http/ambient.js

@@ -0,0 +1,44 @@
+import { contextStorage, getContext } from "hono/context-storage";
+import { REQUEST_CONTEXT } from "./request-context.js";
+// Opt-in ambient access to the per-request DI container / RequestContext,
+// for deep code that lacks the Hono `Context` (services, standalone helpers).
+//
+// Portable across vela's target runtimes because the `node:async_hooks`
+// dependency lives inside Hono's `contextStorage()` middleware — vela's own
+// source never imports `node:*`. Uses only the workerd-safe ALS subset
+// (`run()`/`getStore()`); no `enterWith`, no cross-thenable propagation.
+//
+// Default path is unchanged: request scope is still carried by the per-request
+// child container (see RouteManager.getRequestContainer). This is a second
+// READ path, active only when enabled.
+/**
+ * Returns Hono's `contextStorage()` middleware. Register it as the FIRST global
+ * middleware so `getCurrentContainer()` works everywhere downstream. When using
+ * `VelaFactory.create(module, { ambientContainer: true })` this is wired
+ * automatically — call this only for manual/raw Hono setups.
+ */ export function enableAmbientContainer() {
+    return contextStorage();
+}
+function tryGetContext() {
+    try {
+        return getContext();
+    } catch  {
+        // Thrown when called outside the contextStorage() middleware (i.e. ambient
+        // access not enabled, or outside a request).
+        return undefined;
+    }
+}
+/**
+ * The current request's DI container. Throws with actionable guidance if
+ * ambient access isn't enabled or this runs outside a request.
+ */ export function getCurrentContainer() {
+    const context = tryGetContext();
+    const container = context?.get('container');
+    if (!container) {
+        throw new Error('getCurrentContainer() is unavailable: enable ambient access via ' + "VelaFactory.create(module, { ambientContainer: true }) (or app.use(enableAmbientContainer())) " + 'and only call it within a request.');
+    }
+    return container;
+}
+/** The current request's {@link RequestContext} (via the ambient container). */ export function getCurrentRequestContext() {
+    return getCurrentContainer().resolve(REQUEST_CONTEXT);
+}

package/dist/http/execution-context.js

@@ -10,7 +10,10 @@ export function buildExecutionContext(c, controller, handlerName) {
         switchToHttp: ()=>({
                 getRequest: ()=>c.req.raw,
                 getResponse: ()=>c
-            })
+            }),
+        switchToWs: ()=>{
+            throw new Error('switchToWs() called on an HTTP ExecutionContext. This handler runs over HTTP, not a WebSocket gateway.');
+        }
     };
 }
 // Sentinel marker exposed via `ExecutionContext.getClass()` when the host is a

package/dist/http/handler-executor.js

@@ -1,6 +1,7 @@
-import { ForbiddenException, HttpException } from "../errors/http-exception.js";
+import { HttpException } from "../errors/http-exception.js";
 import { ComponentManager } from "../pipeline/component.manager.js";
 import { shouldFilterCatch } from "../pipeline/decorators.js";
+import { PipelineRunner } from "../pipeline/pipeline-runner.js";
 import { getHttpCode, getRedirect, getResponseHeaders } from "./decorators.js";
 import { buildExecutionContext } from "./execution-context.js";
 import { instantiateMany } from "./instantiate.js";
@@ -25,12 +26,12 @@ export class HandlerExecutor {
         // Routed via Reflect so the polyfill funnels both src-level and dist-level
         // consumers to the same registry (matters in tests that import from dist).
         const paramTypes = Reflect.getMetadata('design:paramtypes', controller.prototype, route.handlerName);
-        const methodGuards = ComponentManager.getComponents('guard', controller, route.handlerName);
-        const methodPipes = ComponentManager.getComponents('pipe', controller, route.handlerName);
-        const methodInterceptors = ComponentManager.getComponents('interceptor', controller, route.handlerName);
+        const methodGuards = ComponentManager.getScopedComponents('guard', controller, route.handlerName);
+        const methodPipes = ComponentManager.getScopedComponents('pipe', controller, route.handlerName);
+        const methodInterceptors = ComponentManager.getScopedComponents('interceptor', controller, route.handlerName);
         // Filters: reverse order (handler → controller → global) — closest to handler runs first
         const methodFilters = [
-            ...ComponentManager.getComponents('filter', controller, route.handlerName)
+            ...ComponentManager.getScopedComponents('filter', controller, route.handlerName)
         ].reverse();
         const httpCode = getHttpCode(controller, route.handlerName);
         const responseHeaders = getResponseHeaders(controller, route.handlerName);
@@ -58,24 +59,20 @@ export class HandlerExecutor {
             const executionContext = buildExecutionContext(c, controller, route.handlerName);
             try {
                 const instance = requestContainer.resolve(controller);
-                // 1. Extract args + run pipes (vela order: args before guards).
-                const args = await this.argumentResolver.extract(c, paramMetadata, pipes, requestContainer, paramTypes);
-                // 2. Guards (fail-fast).
-                for (const guard of guards){
-                    const canActivate = await guard.canActivate(executionContext);
-                    if (!canActivate) {
-                        throw new ForbiddenException();
-                    }
-                }
-                // 3. Get handler method.
                 const method = Reflect.get(instance, route.handlerName);
                 if (typeof method !== 'function') {
                     throw new Error(`Method ${String(route.handlerName)} not found on controller`);
                 }
-                // 4. Build core handler.
-                const coreHandler = async ()=>Reflect.apply(method, instance, args);
-                // 5. Run interceptor chain.
-                const result = await ComponentManager.runInterceptorChain(interceptors, executionContext, coreHandler);
+                // Args + pipes → guards → interceptor chain → handler, via the shared
+                // runner. `argsBeforeGuards` preserves the deliberate vela HTTP order.
+                const result = await PipelineRunner.run({
+                    context: executionContext,
+                    guards,
+                    interceptors,
+                    argsBeforeGuards: true,
+                    resolveArgs: ()=>this.argumentResolver.extract(c, paramMetadata, pipes, requestContainer, paramTypes),
+                    invoke: async (args)=>Reflect.apply(method, instance, args)
+                });
                 if (redirect) {
                     return mapRedirect(c, result, redirect);
                 }
@@ -98,6 +95,12 @@ export class HandlerExecutor {
                     const status = error.getStatus();
                     return c.json(response, status);
                 }
+                // An unknown error reaching here means no filter claimed it — never
+                // swallow it silently: the response is a generic 500, but the cause
+                // must land in the logs (diagnostics 'silent' opts out).
+                if (requestContainer.getDiagnostics() !== 'silent') {
+                    console.error(`[vela] unhandled error in ${controller.name}.${String(route.handlerName)}:`, error);
+                }
                 return c.json({
                     statusCode: 500,
                     message: 'Internal Server Error'

package/dist/http/index.d.ts

@@ -4,4 +4,5 @@ export { MiddlewareBuilder } from '../module/middleware';
 export type { MiddlewareConsumer, MiddlewareConfigProxy, RouteInfo, NestModule, MiddlewareRouteDefinition } from '../module/middleware';
 export { Controller, Version, Get, Post, Put, Patch, Delete, Options, Head, All, Sse, Param, Query, Body, Headers, Req, Res, Ip, Cookie, Cookies, RawBody, HttpCode, Header, Redirect, createParamDecorator, applyDecorators, isController, } from './decorators';
 export { createLazyParamDecorator } from './lazy-param.decorator';
+export { enableAmbientContainer, getCurrentContainer, getCurrentRequestContext, } from './ambient';
 export type { RouteMetadata, ControllerMetadata, ControllerOptions, ParamMetadata, ControllerRegistration, } from './types';

package/dist/http/index.js

@@ -2,3 +2,4 @@ export { RouteManager } from "./route.manager.js";
 export { MiddlewareBuilder } from "../module/middleware.js";
 export { Controller, Version, Get, Post, Put, Patch, Delete, Options, Head, All, Sse, Param, Query, Body, Headers, Req, Res, Ip, Cookie, Cookies, RawBody, HttpCode, Header, Redirect, createParamDecorator, applyDecorators, isController } from "./decorators.js";
 export { createLazyParamDecorator } from "./lazy-param.decorator.js";
+export { enableAmbientContainer, getCurrentContainer, getCurrentRequestContext } from "./ambient.js";

package/dist/http/route-contributor.d.ts

@@ -0,0 +1,68 @@
+import type { Hono } from 'hono';
+import type { Container } from '../container/container';
+import type { Type } from '../container/types';
+import type { OpenApiPathItem } from '../openapi/types';
+import type { CanActivate } from '../pipeline/types';
+/**
+ * Context passed to {@link RouteContributor.buildRoutes} for each controller
+ * the contributor claims. The contributor receives the framework's resolved
+ * view of the world so generated routes behave identically to hand-written
+ * ones: same global prefix, same global guard instances, same path joining.
+ */
+export interface RouteContributorContext {
+    /** The claimed controller class. */
+    controller: Type;
+    /** Controller-level prefix as registered with `@Controller(...)`. */
+    controllerPrefix: string;
+    /** The metadata value (under `claimsMetaKey`) that claimed this controller. */
+    meta: unknown;
+    /** Application-wide path prefix (e.g. `/api`), already normalized. */
+    globalPrefix: string;
+    /** Global guard instances, pre-resolved from the root container. */
+    globalGuards: CanActivate[];
+    /** The app's root container — resolve controller/services from here. */
+    container: Container;
+    /** Path joiner used by the framework — handles slash normalization. */
+    joinPaths: (...parts: string[]) => string;
+}
+/** Context for {@link RouteContributor.buildOpenApiPaths}. */
+export interface RouteContributorOpenApiContext {
+    controller: Type;
+    meta: unknown;
+    /** Application-wide path prefix (e.g. `/api`), already normalized. */
+    globalPrefix: string;
+    /** Controller-level prefix as registered with `@Controller(...)`. */
+    controllerPrefix: string;
+}
+/**
+ * A route generator that claims controllers by class-level metadata and
+ * mounts routes for them — the public extension point behind `@Crud()` (and
+ * any future metadata-driven route generator: storage HTTP surfaces, admin
+ * panels, RPC bridges).
+ *
+ * Register once at import time (`registerRouteContributor`); the framework
+ * consults contributors during `RouteManager.build` — AFTER all explicit
+ * `@Get`/`@Post` routes, so generated `/:id` catch-alls never shadow custom
+ * routes — and during OpenAPI document generation.
+ *
+ * This contract exists instead of dynamic `import()` because esbuild leaves
+ * `await import(variable)` as a runtime import Cloudflare Workers cannot
+ * resolve.
+ */
+export interface RouteContributor {
+    /** Stable identifier; re-registering the same id overwrites (HMR-friendly). */
+    id: string;
+    /** Class-level metadata key whose presence claims a controller. */
+    claimsMetaKey: string;
+    buildRoutes(app: Hono, ctx: RouteContributorContext): void | Promise<void>;
+    buildOpenApiPaths?(ctx: RouteContributorOpenApiContext): Record<string, OpenApiPathItem>;
+}
+/** Register a contributor. Last registration per `id` wins. */
+export declare function registerRouteContributor(contributor: RouteContributor): void;
+/** All registered contributors (registration order). */
+export declare function getRouteContributors(): RouteContributor[];
+/**
+ * Reset all contributor registrations. Test-only.
+ * @internal
+ */
+export declare function _resetRouteContributors(): void;

package/dist/http/route-contributor.js

@@ -0,0 +1,22 @@
+// Contributors register at import time (package side effect), so the store is
+// anchored on `globalThis` like MetadataRegistry state: a Vite HMR re-eval
+// reuses the same store instead of minting an empty one.
+const STORE_KEY = Symbol.for('vela:route-contributors:v1');
+function store() {
+    const g = globalThis;
+    return g[STORE_KEY] ??= new Map();
+}
+/** Register a contributor. Last registration per `id` wins. */ export function registerRouteContributor(contributor) {
+    store().set(contributor.id, contributor);
+}
+/** All registered contributors (registration order). */ export function getRouteContributors() {
+    return [
+        ...store().values()
+    ];
+}
+/**
+ * Reset all contributor registrations. Test-only.
+ * @internal
+ */ export function _resetRouteContributors() {
+    store().clear();
+}

package/dist/http/route.manager.d.ts

@@ -9,6 +9,12 @@ export interface RouteManagerOptions {
     getClientIp?: (c: Context) => string | null;
     middleware?: MiddlewareHandler[];
     globalPrefix?: string;
+    /**
+     * Opt into ambient request-container access (`getCurrentContainer()` /
+     * `getCurrentRequestContext()`). Registers Hono's `contextStorage()` as the
+     * first middleware. Off by default — the explicit child container is unchanged.
+     */
+    ambientContainer?: boolean;
 }
 export declare class RouteManager {
     private container;
@@ -22,7 +28,20 @@ export declare class RouteManager {
     private globalPrefix;
     private consumerMiddlewareDefinitions;
     private readonly handlerExecutor;
+    private readonly ambientContainer;
     constructor(container: Container, options?: RouteManagerOptions);
+    /**
+     * The global-tier components (`APP_*` provider tokens + imperative
+     * `app.useGlobalX()` instances). Exposed so non-HTTP transports (the
+     * WebSocket dispatcher) can apply the same app-wide guards/pipes/interceptors/
+     * filters as HTTP routes, read live so late registrations propagate.
+     */
+    getGlobalComponents(): {
+        guards: Array<GuardType | Token<CanActivate>>;
+        pipes: Array<PipeType | Token<PipeTransform>>;
+        interceptors: Array<InterceptorType | Token<NestInterceptor>>;
+        filters: Array<FilterType | Token<ExceptionFilter>>;
+    };
     registerConsumerMiddleware(definitions: MiddlewareRouteDefinition[]): this;
     setGlobalPrefix(prefix: string): this;
     useGlobalMiddleware(...middleware: MiddlewareType[]): this;