@velajs/vela 0.4.3 → 0.5.0

package/dist/factory.js

@@ -1,5 +1,6 @@
 import { VelaApplication } from "./application.js";
 import { Container } from "./container/container.js";
+import { ModuleRef } from "./container/module-ref.js";
 import { RouteManager } from "./http/route.manager.js";
 import { ModuleLoader } from "./module/module-loader.js";
 import { ComponentManager } from "./pipeline/component.manager.js";
@@ -8,9 +9,16 @@ export const VelaFactory = {
     async create (rootModule) {
         const container = new Container();
         container.register({
-            token: Container,
+            provide: Container,
             useValue: container
         });
+        container.register({
+            provide: ModuleRef,
+            useFactory: (c)=>new ModuleRef(c),
+            inject: [
+                Container
+            ]
+        });
         const routeManager = new RouteManager(container);
         ComponentManager.init(container);
         const loader = new ModuleLoader(container, routeManager);
@@ -45,8 +53,9 @@ export const VelaFactory = {
         } else if (container.has(APP_MIDDLEWARE)) {
             routeManager.useGlobalMiddlewareTokens(APP_MIDDLEWARE);
         }
+        routeManager.registerConsumerMiddleware(loader.getConsumerMiddlewareDefinitions());
         const app = new VelaApplication(container, routeManager);
-        const instances = loader.resolveAllInstances();
+        const instances = await loader.resolveAllInstances();
         app.setInstances(instances);
         await app.callOnModuleInit();
         await app.callOnApplicationBootstrap();

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

@@ -0,0 +1,6 @@
+import type { AsyncModuleOptions, DynamicModule } from '../module/types';
+import type { HttpModuleOptions } from './fetch.types';
+export declare class HttpModule {
+    static register(options?: HttpModuleOptions): DynamicModule;
+    static registerAsync(options: AsyncModuleOptions<HttpModuleOptions>): DynamicModule;
+}

package/dist/fetch/fetch.module.js

@@ -0,0 +1,77 @@
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+import { METADATA_KEYS } from "../constants.js";
+import { defineMetadata } from "../metadata.js";
+import { MetadataRegistry } from "../registry/metadata.registry.js";
+import { Module } from "../module/decorators.js";
+import { HttpService, HTTP_MODULE_OPTIONS } from "./fetch.service.js";
+export class HttpModule {
+    static register(options = {}) {
+        const moduleClass = class HttpDynamicModule {
+        };
+        Object.defineProperty(moduleClass, 'name', {
+            value: 'HttpModule'
+        });
+        defineMetadata(METADATA_KEYS.MODULE, true, moduleClass);
+        MetadataRegistry.setModuleOptions(moduleClass, {
+            exports: [
+                HttpService,
+                HTTP_MODULE_OPTIONS
+            ]
+        });
+        return {
+            module: moduleClass,
+            providers: [
+                {
+                    provide: HTTP_MODULE_OPTIONS,
+                    useValue: options
+                },
+                HttpService
+            ]
+        };
+    }
+    static registerAsync(options) {
+        const moduleClass = class HttpAsyncDynamicModule {
+        };
+        Object.defineProperty(moduleClass, 'name', {
+            value: 'HttpModule'
+        });
+        defineMetadata(METADATA_KEYS.MODULE, true, moduleClass);
+        MetadataRegistry.setModuleOptions(moduleClass, {
+            imports: options.imports ?? [],
+            exports: [
+                HttpService,
+                HTTP_MODULE_OPTIONS
+            ]
+        });
+        return {
+            module: moduleClass,
+            providers: [
+                {
+                    provide: HTTP_MODULE_OPTIONS,
+                    useFactory: options.useFactory,
+                    inject: options.inject ?? []
+                },
+                HttpService
+            ]
+        };
+    }
+}
+HttpModule = _ts_decorate([
+    Module({
+        providers: [
+            {
+                provide: HTTP_MODULE_OPTIONS,
+                useValue: {}
+            },
+            HttpService
+        ],
+        exports: [
+            HttpService
+        ]
+    })
+], HttpModule);

package/dist/fetch/fetch.service.d.ts

@@ -0,0 +1,24 @@
+import { InjectionToken } from '../container/index';
+import type { HttpModuleOptions, HttpRequestConfig, HttpResponse, RequestConfig } from './fetch.types';
+export declare const HTTP_MODULE_OPTIONS: InjectionToken<HttpModuleOptions>;
+export declare class HttpRequestException extends Error {
+    readonly status: number;
+    readonly statusText: string;
+    readonly response: Response;
+    constructor(status: number, statusText: string, response: Response);
+}
+export declare class HttpService {
+    private readonly baseURL;
+    private readonly defaultHeaders;
+    private readonly defaultTimeout;
+    constructor(options: HttpModuleOptions);
+    get<T = unknown>(url: string, config?: RequestConfig): Promise<HttpResponse<T>>;
+    post<T = unknown>(url: string, body?: unknown, config?: RequestConfig): Promise<HttpResponse<T>>;
+    put<T = unknown>(url: string, body?: unknown, config?: RequestConfig): Promise<HttpResponse<T>>;
+    patch<T = unknown>(url: string, body?: unknown, config?: RequestConfig): Promise<HttpResponse<T>>;
+    delete<T = unknown>(url: string, config?: RequestConfig): Promise<HttpResponse<T>>;
+    head(url: string, config?: RequestConfig): Promise<HttpResponse<void>>;
+    request<T = unknown>(config: HttpRequestConfig): Promise<HttpResponse<T>>;
+    private buildUrl;
+    private parseBody;
+}

package/dist/fetch/fetch.service.js

@@ -0,0 +1,145 @@
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function _ts_metadata(k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+function _ts_param(paramIndex, decorator) {
+    return function(target, key) {
+        decorator(target, key, paramIndex);
+    };
+}
+import { Inject, Injectable, InjectionToken, Optional } from "../container/index.js";
+export const HTTP_MODULE_OPTIONS = new InjectionToken('HTTP_MODULE_OPTIONS');
+export class HttpRequestException extends Error {
+    status;
+    statusText;
+    response;
+    constructor(status, statusText, response){
+        super(`HTTP ${status} ${statusText}`), this.status = status, this.statusText = statusText, this.response = response;
+        this.name = 'HttpRequestException';
+    }
+}
+export class HttpService {
+    baseURL;
+    defaultHeaders;
+    defaultTimeout;
+    constructor(options){
+        const opts = options ?? {};
+        this.baseURL = opts.baseURL ?? '';
+        this.defaultHeaders = opts.headers ?? {};
+        this.defaultTimeout = opts.timeout;
+    }
+    get(url, config) {
+        return this.request({
+            method: 'GET',
+            url,
+            ...config
+        });
+    }
+    post(url, body, config) {
+        return this.request({
+            method: 'POST',
+            url,
+            body,
+            ...config
+        });
+    }
+    put(url, body, config) {
+        return this.request({
+            method: 'PUT',
+            url,
+            body,
+            ...config
+        });
+    }
+    patch(url, body, config) {
+        return this.request({
+            method: 'PATCH',
+            url,
+            body,
+            ...config
+        });
+    }
+    delete(url, config) {
+        return this.request({
+            method: 'DELETE',
+            url,
+            ...config
+        });
+    }
+    head(url, config) {
+        return this.request({
+            method: 'HEAD',
+            url,
+            ...config
+        });
+    }
+    async request(config) {
+        const fullUrl = this.buildUrl(config.url, config.params);
+        const headers = {
+            ...this.defaultHeaders,
+            ...config.headers
+        };
+        const init = {
+            method: config.method,
+            headers
+        };
+        if (config.body !== undefined) {
+            if (typeof config.body === 'string' || config.body instanceof FormData) {
+                init.body = config.body;
+            } else {
+                init.body = JSON.stringify(config.body);
+                if (!headers['Content-Type'] && !headers['content-type']) {
+                    headers['Content-Type'] = 'application/json';
+                }
+            }
+        }
+        const timeout = config.timeout ?? this.defaultTimeout;
+        if (timeout !== undefined) {
+            init.signal = AbortSignal.timeout(timeout);
+        }
+        const response = await fetch(fullUrl, init);
+        if (!response.ok) {
+            throw new HttpRequestException(response.status, response.statusText, response);
+        }
+        const data = await this.parseBody(response);
+        return {
+            data,
+            status: response.status,
+            statusText: response.statusText,
+            headers: response.headers
+        };
+    }
+    buildUrl(url, params) {
+        const base = this.baseURL ? `${this.baseURL}${url}` : url;
+        if (!params || Object.keys(params).length === 0) return base;
+        const searchParams = new URLSearchParams(Object.entries(params).map(([k, v])=>[
+                k,
+                String(v)
+            ]));
+        return `${base}?${searchParams.toString()}`;
+    }
+    async parseBody(response) {
+        if (response.status === 204 || response.headers.get('content-length') === '0') {
+            return undefined;
+        }
+        const contentType = response.headers.get('content-type') ?? '';
+        if (contentType.includes('application/json')) {
+            return response.json();
+        }
+        return response.text();
+    }
+}
+HttpService = _ts_decorate([
+    Injectable(),
+    _ts_param(0, Optional()),
+    _ts_param(0, Inject(HTTP_MODULE_OPTIONS)),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof HttpModuleOptions === "undefined" ? Object : HttpModuleOptions
+    ])
+], HttpService);

package/dist/fetch/fetch.types.d.ts

@@ -0,0 +1,24 @@
+export interface HttpModuleOptions {
+    /** Base URL prepended to all requests. */
+    baseURL?: string;
+    /** Default headers sent with every request. */
+    headers?: Record<string, string>;
+    /** Default timeout in milliseconds (uses AbortSignal.timeout). */
+    timeout?: number;
+}
+export interface RequestConfig {
+    headers?: Record<string, string>;
+    params?: Record<string, string | number | boolean>;
+    timeout?: number;
+}
+export interface HttpRequestConfig extends RequestConfig {
+    method: string;
+    url: string;
+    body?: unknown;
+}
+export interface HttpResponse<T = unknown> {
+    data: T;
+    status: number;
+    statusText: string;
+    headers: Headers;
+}

package/dist/fetch/fetch.types.js

@@ -0,0 +1 @@
+export { };

package/dist/fetch/index.d.ts

@@ -0,0 +1,3 @@
+export { HttpModule } from './fetch.module';
+export { HttpService, HTTP_MODULE_OPTIONS, HttpRequestException } from './fetch.service';
+export type { HttpModuleOptions, HttpRequestConfig, HttpResponse, RequestConfig } from './fetch.types';

package/dist/fetch/index.js

@@ -0,0 +1,2 @@
+export { HttpModule } from "./fetch.module.js";
+export { HttpService, HTTP_MODULE_OPTIONS, HttpRequestException } from "./fetch.service.js";

package/dist/http/decorators.d.ts

@@ -44,6 +44,53 @@ export declare const Query: (nameOrPipe?: string | PipeType, ...pipes: PipeType[
 export declare const Body: (nameOrPipe?: string | PipeType, ...pipes: PipeType[]) => ParameterDecorator;
 export declare const Headers: (nameOrPipe?: string | PipeType, ...pipes: PipeType[]) => ParameterDecorator;
 export declare const Req: (nameOrPipe?: string | PipeType, ...pipes: PipeType[]) => ParameterDecorator;
+/**
+ * Injects the Hono `Context` as the response handle.
+ * In Hono, request and response state are unified in the `Context` object,
+ * so `@Res()` and `@Req()` both return it.
+ *
+ * Use `c.header()`, `c.setCookie()`, `c.redirect()`, etc. for response control.
+ *
+ * @example
+ * ```ts
+ * @Get('/set-cookie')
+ * handle(@Res() c: Context) {
+ *   c.setCookie('session', 'abc123', { httpOnly: true });
+ *   return { ok: true };
+ * }
+ * ```
+ */
+export declare const Res: (nameOrPipe?: string | PipeType, ...pipes: PipeType[]) => ParameterDecorator;
+export declare const Ip: (nameOrPipe?: string | PipeType, ...pipes: PipeType[]) => ParameterDecorator;
+export declare const Cookie: (nameOrPipe?: string | PipeType, ...pipes: PipeType[]) => ParameterDecorator;
+/**
+ * Injects all cookies as a `Record<string, string>`, or a single cookie value by name.
+ *
+ * - `@Cookie()` — all cookies as an object
+ * - `@Cookie('token')` — the value of the `token` cookie
+ *
+ * @example
+ * ```ts
+ * @Get('/me')
+ * handle(@Cookie('session') session: string) { ... }
+ * ```
+ */
+export declare const Cookies: (nameOrPipe?: string | PipeType, ...pipes: PipeType[]) => ParameterDecorator;
+/**
+ * Injects the raw request body as a `Uint8Array`.
+ * Useful for webhook HMAC verification (Stripe, GitHub, etc.) where you
+ * need the raw bytes before any JSON parsing.
+ *
+ * @example
+ * ```ts
+ * @Post('/webhook')
+ * async handle(@RawBody() body: Uint8Array) {
+ *   const sig = new TextDecoder().decode(body);
+ *   // verify HMAC...
+ * }
+ * ```
+ */
+export declare function RawBody(): ParameterDecorator;
 /**
  * Factory for creating custom parameter decorators.
  *
@@ -120,4 +167,21 @@ export declare function getRedirect(target: Constructor, method: string | symbol
     url: string;
     statusCode: number;
 } | undefined;
+/**
+ * Composes multiple decorators into one. Applies them in order (top to bottom),
+ * matching how stacked decorators behave when written separately.
+ *
+ * @example
+ * ```ts
+ * const Auth = (...roles: string[]) => applyDecorators(
+ *   UseGuards(JwtGuard, RolesGuard),
+ *   SetMetadata('roles', roles),
+ * );
+ *
+ * @Auth('admin')
+ * @Get('/admin')
+ * handle() { ... }
+ * ```
+ */
+export declare function applyDecorators(...decorators: Array<ClassDecorator | MethodDecorator | PropertyDecorator | ParameterDecorator>): ClassDecorator & MethodDecorator & PropertyDecorator;
 export declare function isController(target: Constructor): boolean;

package/dist/http/decorators.js

@@ -136,6 +136,60 @@ export const Query = createBuiltinParamDecorator(ParamType.QUERY);
 export const Body = createBuiltinParamDecorator(ParamType.BODY);
 export const Headers = createBuiltinParamDecorator(ParamType.HEADERS);
 export const Req = createBuiltinParamDecorator(ParamType.REQUEST);
+/**
+ * Injects the Hono `Context` as the response handle.
+ * In Hono, request and response state are unified in the `Context` object,
+ * so `@Res()` and `@Req()` both return it.
+ *
+ * Use `c.header()`, `c.setCookie()`, `c.redirect()`, etc. for response control.
+ *
+ * @example
+ * ```ts
+ * @Get('/set-cookie')
+ * handle(@Res() c: Context) {
+ *   c.setCookie('session', 'abc123', { httpOnly: true });
+ *   return { ok: true };
+ * }
+ * ```
+ */ export const Res = createBuiltinParamDecorator(ParamType.RESPONSE);
+export const Ip = createBuiltinParamDecorator(ParamType.IP);
+export const Cookie = createBuiltinParamDecorator(ParamType.COOKIE);
+/**
+ * Injects all cookies as a `Record<string, string>`, or a single cookie value by name.
+ *
+ * - `@Cookie()` — all cookies as an object
+ * - `@Cookie('token')` — the value of the `token` cookie
+ *
+ * @example
+ * ```ts
+ * @Get('/me')
+ * handle(@Cookie('session') session: string) { ... }
+ * ```
+ */ export const Cookies = Cookie;
+/**
+ * Injects the raw request body as a `Uint8Array`.
+ * Useful for webhook HMAC verification (Stripe, GitHub, etc.) where you
+ * need the raw bytes before any JSON parsing.
+ *
+ * @example
+ * ```ts
+ * @Post('/webhook')
+ * async handle(@RawBody() body: Uint8Array) {
+ *   const sig = new TextDecoder().decode(body);
+ *   // verify HMAC...
+ * }
+ * ```
+ */ export function RawBody() {
+    return (target, propertyKey, parameterIndex)=>{
+        if (propertyKey === undefined) {
+            throw new Error('Parameter decorators can only be used on method parameters');
+        }
+        MetadataRegistry.addParameter(target.constructor, propertyKey, {
+            index: parameterIndex,
+            type: ParamType.RAW_BODY
+        });
+    };
+}
 /**
  * Factory for creating custom parameter decorators.
  *
@@ -175,10 +229,15 @@ export const Req = createBuiltinParamDecorator(ParamType.REQUEST);
                 factory: (_unused, ctx)=>{
                     const honoCtx = ctx;
                     const execCtx = {
+                        getType: ()=>'http',
                         getClass: ()=>target.constructor,
                         getHandler: ()=>propertyKey,
                         getContext: ()=>honoCtx,
-                        getRequest: ()=>honoCtx.req.raw
+                        getRequest: ()=>honoCtx.req.raw,
+                        switchToHttp: ()=>({
+                                getRequest: ()=>honoCtx.req.raw,
+                                getResponse: ()=>honoCtx
+                            })
                     };
                     return factory(data, execCtx);
                 },
@@ -271,6 +330,35 @@ export function getRedirect(target, method) {
     if (meta?.redirect) return meta.redirect;
     return getMetadata(METADATA_KEYS.REDIRECT, target, method);
 }
+/**
+ * Composes multiple decorators into one. Applies them in order (top to bottom),
+ * matching how stacked decorators behave when written separately.
+ *
+ * @example
+ * ```ts
+ * const Auth = (...roles: string[]) => applyDecorators(
+ *   UseGuards(JwtGuard, RolesGuard),
+ *   SetMetadata('roles', roles),
+ * );
+ *
+ * @Auth('admin')
+ * @Get('/admin')
+ * handle() { ... }
+ * ```
+ */ export function applyDecorators(...decorators) {
+    const composed = (target, propertyKey, descriptor)=>{
+        for (const decorator of decorators){
+            if (propertyKey === undefined && typeof descriptor !== 'number') {
+                decorator(target);
+            } else if (typeof descriptor === 'number') {
+                decorator(target, propertyKey, descriptor);
+            } else {
+                decorator(target, propertyKey, descriptor);
+            }
+        }
+    };
+    return composed;
+}
 // Helpers
 export function isController(target) {
     return MetadataRegistry.getControllerPath(target) !== '' || MetadataRegistry.getRoutes(target).length > 0;

package/dist/http/index.d.ts

@@ -1,3 +1,5 @@
 export { RouteManager } from './route.manager';
-export { Controller, Version, Get, Post, Put, Patch, Delete, Options, Head, Sse, Param, Query, Body, Headers, Req, HttpCode, Header, Redirect, createParamDecorator, isController, } from './decorators';
+export { MiddlewareBuilder, RequestMethod } from './middleware-consumer';
+export type { MiddlewareConsumer, MiddlewareConfigProxy, RouteInfo, NestModule, MiddlewareRouteDefinition } from './middleware-consumer';
+export { Controller, Version, Get, Post, Put, Patch, Delete, Options, Head, Sse, Param, Query, Body, Headers, Req, Res, Ip, Cookie, Cookies, RawBody, HttpCode, Header, Redirect, createParamDecorator, applyDecorators, isController, } from './decorators';
 export type { RouteMetadata, ControllerMetadata, ControllerOptions, ParamMetadata, ControllerRegistration, } from './types';

package/dist/http/index.js

@@ -1,2 +1,3 @@
 export { RouteManager } from "./route.manager.js";
-export { Controller, Version, Get, Post, Put, Patch, Delete, Options, Head, Sse, Param, Query, Body, Headers, Req, HttpCode, Header, Redirect, createParamDecorator, isController } from "./decorators.js";
+export { MiddlewareBuilder, RequestMethod } from "./middleware-consumer.js";
+export { Controller, Version, Get, Post, Put, Patch, Delete, Options, Head, Sse, Param, Query, Body, Headers, Req, Res, Ip, Cookie, Cookies, RawBody, HttpCode, Header, Redirect, createParamDecorator, applyDecorators, isController } from "./decorators.js";

package/dist/http/middleware-consumer.d.ts

@@ -0,0 +1,36 @@
+import type { NestMiddleware } from '../pipeline/types';
+import type { Type } from '../registry/types';
+export declare enum RequestMethod {
+    GET = "GET",
+    POST = "POST",
+    PUT = "PUT",
+    DELETE = "DELETE",
+    PATCH = "PATCH",
+    OPTIONS = "OPTIONS",
+    HEAD = "HEAD",
+    ALL = "ALL"
+}
+export interface RouteInfo {
+    path: string;
+    method?: RequestMethod;
+}
+export interface MiddlewareRouteDefinition {
+    middleware: Array<Type<NestMiddleware> | NestMiddleware>;
+    routes: RouteInfo[];
+    excludes: RouteInfo[];
+}
+export interface MiddlewareConfigProxy {
+    exclude(...routes: Array<string | RouteInfo>): MiddlewareConfigProxy;
+    forRoutes(...routes: Array<string | Function | RouteInfo>): MiddlewareConsumer;
+}
+export interface MiddlewareConsumer {
+    apply(...middleware: Array<Type<NestMiddleware> | NestMiddleware>): MiddlewareConfigProxy;
+}
+export interface NestModule {
+    configure(consumer: MiddlewareConsumer): void;
+}
+export declare class MiddlewareBuilder implements MiddlewareConsumer {
+    private definitions;
+    apply(...middleware: Array<Type<NestMiddleware> | NestMiddleware>): MiddlewareConfigProxy;
+    getDefinitions(): MiddlewareRouteDefinition[];
+}

package/dist/http/middleware-consumer.js

@@ -0,0 +1,71 @@
+import { MetadataRegistry } from "../registry/metadata.registry.js";
+export var RequestMethod = /*#__PURE__*/ function(RequestMethod) {
+    RequestMethod["GET"] = "GET";
+    RequestMethod["POST"] = "POST";
+    RequestMethod["PUT"] = "PUT";
+    RequestMethod["DELETE"] = "DELETE";
+    RequestMethod["PATCH"] = "PATCH";
+    RequestMethod["OPTIONS"] = "OPTIONS";
+    RequestMethod["HEAD"] = "HEAD";
+    RequestMethod["ALL"] = "ALL";
+    return RequestMethod;
+}({});
+export class MiddlewareBuilder {
+    definitions = [];
+    apply(...middleware) {
+        const currentMiddleware = [
+            ...middleware
+        ];
+        let currentExcludes = [];
+        const proxy = {
+            exclude: (...routes)=>{
+                currentExcludes = routes.map(normalizeRouteArg);
+                return proxy;
+            },
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+            forRoutes: (...routes)=>{
+                this.definitions.push({
+                    middleware: currentMiddleware,
+                    routes: routes.flatMap(resolveRouteArg),
+                    excludes: [
+                        ...currentExcludes
+                    ]
+                });
+                currentExcludes = [];
+                return this;
+            }
+        };
+        return proxy;
+    }
+    getDefinitions() {
+        return [
+            ...this.definitions
+        ];
+    }
+}
+function normalizeRouteArg(route) {
+    return typeof route === 'string' ? {
+        path: route
+    } : route;
+}
+// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+function resolveRouteArg(route) {
+    if (typeof route === 'string') {
+        return [
+            {
+                path: route
+            }
+        ];
+    }
+    if (typeof route === 'function') {
+        const prefix = MetadataRegistry.getControllerPath(route);
+        return [
+            {
+                path: prefix || '/'
+            }
+        ];
+    }
+    return [
+        route
+    ];
+}

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

@@ -1,6 +1,7 @@
 import { Hono } from 'hono';
 import type { Container } from '../container/container';
 import type { Token, Type } from '../container/types';
+import type { MiddlewareRouteDefinition } from './middleware-consumer';
 import type { CanActivate, ExceptionFilter, NestInterceptor, NestMiddleware, PipeTransform } from '../pipeline/types';
 import type { FilterType, GuardType, InterceptorType, MiddlewareType, PipeType } from '../registry/types';
 import type { ControllerRegistration } from './types';
@@ -13,7 +14,9 @@ export declare class RouteManager {
     private globalInterceptors;
     private globalFilters;
     private globalPrefix;
+    private consumerMiddlewareDefinitions;
     constructor(container: Container);
+    registerConsumerMiddleware(definitions: MiddlewareRouteDefinition[]): this;
     setGlobalPrefix(prefix: string): this;
     useGlobalMiddleware(...middleware: MiddlewareType[]): this;
     useGlobalMiddlewareTokens(...middlewareTokens: Array<Token<NestMiddleware>>): this;
@@ -38,5 +41,6 @@ export declare class RouteManager {
     private registerRoute;
     private buildVersionedPaths;
     private joinPaths;
+    private matchesConsumerPath;
     getControllers(): ControllerRegistration[];
 }