@velajs/vela 0.5.2 → 0.6.1

package/dist/application.d.ts

@@ -1,45 +1,27 @@
 import type { Hono } from 'hono';
 import type { Container } from './container/container';
 import type { Token } from './container/types';
-import type { CorsOptions } from './cors/cors.types';
 import type { RouteManager } from './http/route.manager';
-import type { FilterType, GuardType, InterceptorType, MiddlewareType, PipeType } from './registry/types';
+import type { FilterType, GuardType, InterceptorType, PipeType } from './registry/types';
 export declare class VelaApplication {
     private readonly container;
     private readonly routeManager;
     private instances;
     private honoApp;
-    private routesBuilt;
     constructor(container: Container, routeManager: RouteManager);
     /** Pre-build routes (handles async CRUD imports). Called by VelaFactory. */
     initRoutes(): Promise<void>;
-    /**
-     * Rebuild routes. Call after registering global middleware/guards/etc.
-     * Not needed if you don't use useGlobalMiddleware() post-create.
-     */
-    rebuild(): Promise<void>;
     private getApp;
     get fetch(): Hono['fetch'];
     getInstances(): unknown[];
     getContainer(): Container;
     setInstances(instances: unknown[]): void;
-    /**
-     * Set a global prefix for all routes (e.g. '/api').
-     * Must be called before getHonoApp()/fetch, or call rebuild() after.
-     */
-    setGlobalPrefix(prefix: string): this;
-    /**
-     * Register global middleware. Call rebuild() after if called post-create.
-     * Controller/method-level @UseMiddleware works without rebuild.
-     */
-    useGlobalMiddleware(...middleware: MiddlewareType[]): this;
+    get<T>(token: Token<T>): T;
+    getHonoApp(): Hono;
     useGlobalPipes(...pipes: PipeType[]): this;
     useGlobalGuards(...guards: GuardType[]): this;
     useGlobalInterceptors(...interceptors: InterceptorType[]): this;
     useGlobalFilters(...filters: FilterType[]): this;
-    enableCors(options?: CorsOptions): this;
-    get<T>(token: Token<T>): T;
-    getHonoApp(): Hono;
     callOnModuleInit(): Promise<void>;
     callOnApplicationBootstrap(): Promise<void>;
     close(signal?: string): Promise<void>;

package/dist/application.js

@@ -1,25 +1,15 @@
-import { cors } from "hono/cors";
 import { hasBeforeApplicationShutdown, hasOnApplicationBootstrap, hasOnApplicationShutdown, hasOnModuleDestroy, hasOnModuleInit } from "./lifecycle/index.js";
 export class VelaApplication {
     container;
     routeManager;
     instances = [];
     honoApp = null;
-    routesBuilt = false;
     constructor(container, routeManager){
         this.container = container;
         this.routeManager = routeManager;
     }
     /** Pre-build routes (handles async CRUD imports). Called by VelaFactory. */ async initRoutes() {
         this.honoApp = await this.routeManager.build();
-        this.routesBuilt = true;
-    }
-    /**
-   * Rebuild routes. Call after registering global middleware/guards/etc.
-   * Not needed if you don't use useGlobalMiddleware() post-create.
-   */ async rebuild() {
-        this.honoApp = await this.routeManager.build();
-        this.routesBuilt = true;
     }
     getApp() {
         if (!this.honoApp) {
@@ -39,20 +29,13 @@ export class VelaApplication {
     setInstances(instances) {
         this.instances = instances;
     }
-    /**
-   * Set a global prefix for all routes (e.g. '/api').
-   * Must be called before getHonoApp()/fetch, or call rebuild() after.
-   */ setGlobalPrefix(prefix) {
-        this.routeManager.setGlobalPrefix(prefix);
-        return this;
+    get(token) {
+        return this.container.resolve(token);
     }
-    /**
-   * Register global middleware. Call rebuild() after if called post-create.
-   * Controller/method-level @UseMiddleware works without rebuild.
-   */ useGlobalMiddleware(...middleware) {
-        this.routeManager.useGlobalMiddleware(...middleware);
-        return this;
+    getHonoApp() {
+        return this.getApp();
     }
+    // Pipeline components — applied at request time, no rebuild needed
     useGlobalPipes(...pipes) {
         this.routeManager.useGlobalPipes(...pipes);
         return this;
@@ -69,27 +52,6 @@ export class VelaApplication {
         this.routeManager.useGlobalFilters(...filters);
         return this;
     }
-    enableCors(options = {}) {
-        const corsMiddleware = cors({
-            origin: options.origin ?? '*',
-            allowMethods: options.allowMethods,
-            allowHeaders: options.allowHeaders,
-            exposeHeaders: options.exposeHeaders,
-            credentials: options.credentials,
-            maxAge: options.maxAge
-        });
-        const mw = {
-            use: (c, next)=>corsMiddleware(c, next)
-        };
-        this.routeManager.useGlobalMiddleware(mw);
-        return this;
-    }
-    get(token) {
-        return this.container.resolve(token);
-    }
-    getHonoApp() {
-        return this.getApp();
-    }
     // Lifecycle hooks
     async callOnModuleInit() {
         for (const instance of this.instances){

package/dist/event-emitter/event-emitter.service.d.ts

@@ -1,13 +1,13 @@
 import type { EventHandler } from './event-emitter.types';
 export declare class EventEmitter {
-    private listeners;
-    private onceListeners;
+    private exactListeners;
+    private exactOnceListeners;
+    private wildcardListeners;
     on(event: string, handler: EventHandler): this;
     once(event: string, handler: EventHandler): this;
     off(event: string, handler: EventHandler): this;
     emit(event: string, ...args: unknown[]): Promise<void>;
     removeAllListeners(event?: string): this;
     listenerCount(event: string): number;
-    private getMatchingHandlers;
-    private matchPattern;
+    private getOrCreateWildcard;
 }

package/dist/event-emitter/event-emitter.service.js

@@ -5,86 +5,121 @@ function _ts_decorate(decorators, target, key, desc) {
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
 import { Injectable } from "../container/index.js";
+function isWildcard(pattern) {
+    return pattern.includes('*');
+}
+function compilePattern(pattern) {
+    const regexStr = pattern.split('.').map((segment)=>{
+        if (segment === '**') return '.*';
+        if (segment === '*') return '[^.]+';
+        return segment.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    }).join('\\.');
+    return new RegExp(`^${regexStr}$`);
+}
 export class EventEmitter {
-    listeners = new Map();
-    onceListeners = new Set();
+    exactListeners = new Map();
+    exactOnceListeners = new Map();
+    wildcardListeners = new Map();
     on(event, handler) {
-        const handlers = this.listeners.get(event) ?? [];
-        handlers.push(handler);
-        this.listeners.set(event, handlers);
+        if (isWildcard(event)) {
+            this.getOrCreateWildcard(event).handlers.add(handler);
+        } else {
+            const handlers = this.exactListeners.get(event) ?? new Set();
+            handlers.add(handler);
+            this.exactListeners.set(event, handlers);
+        }
         return this;
     }
     once(event, handler) {
-        this.onceListeners.add(handler);
-        return this.on(event, handler);
+        this.on(event, handler);
+        if (isWildcard(event)) {
+            this.getOrCreateWildcard(event).onceHandlers.add(handler);
+        } else {
+            const onceSet = this.exactOnceListeners.get(event) ?? new Set();
+            onceSet.add(handler);
+            this.exactOnceListeners.set(event, onceSet);
+        }
+        return this;
     }
     off(event, handler) {
-        const handlers = this.listeners.get(event);
-        if (handlers) {
-            const index = handlers.indexOf(handler);
-            if (index !== -1) handlers.splice(index, 1);
-            if (handlers.length === 0) this.listeners.delete(event);
+        if (isWildcard(event)) {
+            const entry = this.wildcardListeners.get(event);
+            if (entry) {
+                entry.handlers.delete(handler);
+                entry.onceHandlers.delete(handler);
+                if (entry.handlers.size === 0) this.wildcardListeners.delete(event);
+            }
+        } else {
+            const handlers = this.exactListeners.get(event);
+            if (handlers) {
+                handlers.delete(handler);
+                this.exactOnceListeners.get(event)?.delete(handler);
+                if (handlers.size === 0) this.exactListeners.delete(event);
+            }
         }
-        this.onceListeners.delete(handler);
         return this;
     }
     async emit(event, ...args) {
-        const handlers = this.getMatchingHandlers(event);
         const toRemove = [];
-        await Promise.all(handlers.map(async ({ event: registeredEvent, handler })=>{
-            await handler(...args);
-            if (this.onceListeners.has(handler)) {
-                toRemove.push({
-                    event: registeredEvent,
-                    handler
-                });
-            }
-        }));
-        for (const { event: registeredEvent, handler } of toRemove){
-            this.off(registeredEvent, handler);
+        // Exact match
+        const exactHandlers = this.exactListeners.get(event);
+        if (exactHandlers) {
+            const onceSet = this.exactOnceListeners.get(event);
+            await Promise.all([
+                ...exactHandlers
+            ].map(async (handler)=>{
+                await handler(...args);
+                if (onceSet?.has(handler)) {
+                    toRemove.push(()=>this.off(event, handler));
+                }
+            }));
+        }
+        // Wildcard match (regex pre-compiled at registration)
+        for (const [pattern, entry] of this.wildcardListeners){
+            if (!entry.regex.test(event)) continue;
+            await Promise.all([
+                ...entry.handlers
+            ].map(async (handler)=>{
+                await handler(...args);
+                if (entry.onceHandlers.has(handler)) {
+                    toRemove.push(()=>this.off(pattern, handler));
+                }
+            }));
         }
+        for (const remove of toRemove)remove();
     }
     removeAllListeners(event) {
         if (event) {
-            const handlers = this.listeners.get(event);
-            if (handlers) {
-                for (const h of handlers)this.onceListeners.delete(h);
+            if (isWildcard(event)) {
+                this.wildcardListeners.delete(event);
+            } else {
+                this.exactListeners.delete(event);
+                this.exactOnceListeners.delete(event);
             }
-            this.listeners.delete(event);
         } else {
-            this.listeners.clear();
-            this.onceListeners.clear();
+            this.exactListeners.clear();
+            this.exactOnceListeners.clear();
+            this.wildcardListeners.clear();
         }
         return this;
     }
     listenerCount(event) {
-        return this.getMatchingHandlers(event).length;
-    }
-    getMatchingHandlers(event) {
-        const result = [];
-        for (const [pattern, handlers] of this.listeners){
-            if (this.matchPattern(pattern, event)) {
-                for (const handler of handlers){
-                    result.push({
-                        event: pattern,
-                        handler
-                    });
-                }
-            }
+        let count = this.exactListeners.get(event)?.size ?? 0;
+        for (const entry of this.wildcardListeners.values()){
+            if (entry.regex.test(event)) count += entry.handlers.size;
         }
-        return result;
+        return count;
     }
-    matchPattern(pattern, event) {
-        if (pattern === event) return true;
-        // Convert glob pattern to regex
-        // ** matches any depth (any number of segments)
-        // * matches single segment (no dots)
-        const regexStr = pattern.split('.').map((segment)=>{
-            if (segment === '**') return '.*';
-            if (segment === '*') return '[^.]+';
-            return segment.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-        }).join('\\.');
-        return new RegExp(`^${regexStr}$`).test(event);
+    getOrCreateWildcard(pattern) {
+        const existing = this.wildcardListeners.get(pattern);
+        if (existing) return existing;
+        const entry = {
+            regex: compilePattern(pattern),
+            handlers: new Set(),
+            onceHandlers: new Set()
+        };
+        this.wildcardListeners.set(pattern, entry);
+        return entry;
     }
 }
 EventEmitter = _ts_decorate([

package/dist/factory.d.ts

@@ -1,5 +1,6 @@
 import { VelaApplication } from './application';
 import type { Type } from './container/types';
+import type { RouteManagerOptions } from './http/route.manager';
 export declare const VelaFactory: {
-    create(rootModule: Type): Promise<VelaApplication>;
+    create(rootModule: Type, options?: RouteManagerOptions): Promise<VelaApplication>;
 };

package/dist/factory.js

@@ -6,7 +6,7 @@ import { ModuleLoader } from "./module/module-loader.js";
 import { ComponentManager } from "./pipeline/component.manager.js";
 import { APP_GUARD, APP_PIPE, APP_INTERCEPTOR, APP_FILTER, APP_MIDDLEWARE } from "./pipeline/tokens.js";
 export const VelaFactory = {
-    async create (rootModule) {
+    async create (rootModule, options = {}) {
         const container = new Container();
         container.register({
             provide: Container,
@@ -19,7 +19,7 @@ export const VelaFactory = {
                 Container
             ]
         });
-        const routeManager = new RouteManager(container);
+        const routeManager = new RouteManager(container, options);
         ComponentManager.init(container);
         const loader = new ModuleLoader(container, routeManager);
         loader.load(rootModule);
@@ -54,6 +54,15 @@ export const VelaFactory = {
             routeManager.useGlobalMiddlewareTokens(APP_MIDDLEWARE);
         }
         routeManager.registerConsumerMiddleware(loader.getConsumerMiddlewareDefinitions());
+        if (options.globalPrefix) {
+            routeManager.setGlobalPrefix(options.globalPrefix);
+        }
+        for (const handler of options.middleware ?? []){
+            const mw = {
+                use: handler
+            };
+            routeManager.useGlobalMiddleware(mw);
+        }
         const app = new VelaApplication(container, routeManager);
         const instances = await loader.resolveAllInstances();
         app.setInstances(instances);

package/dist/http/index.d.ts

@@ -1,4 +1,5 @@
 export { RouteManager } from './route.manager';
+export type { RouteManagerOptions } from './route.manager';
 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, All, Sse, Param, Query, Body, Headers, Req, Res, Ip, Cookie, Cookies, RawBody, HttpCode, Header, Redirect, createParamDecorator, applyDecorators, isController, } from './decorators';

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

@@ -1,12 +1,19 @@
-import { Hono } from 'hono';
+import { type Context, type MiddlewareHandler, 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';
+export interface RouteManagerOptions {
+    getClientIp?: (c: Context) => string | null;
+    middleware?: MiddlewareHandler[];
+    globalPrefix?: string;
+}
 export declare class RouteManager {
     private container;
+    private static readonly METHOD_REGISTRAR;
+    private static readonly PARAM_EXTRACTORS;
     private controllers;
     private globalMiddleware;
     private globalPipes;
@@ -15,7 +22,8 @@ export declare class RouteManager {
     private globalFilters;
     private globalPrefix;
     private consumerMiddlewareDefinitions;
-    constructor(container: Container);
+    private readonly ipExtractor;
+    constructor(container: Container, options?: RouteManagerOptions);
     registerConsumerMiddleware(definitions: MiddlewareRouteDefinition[]): this;
     setGlobalPrefix(prefix: string): this;
     useGlobalMiddleware(...middleware: MiddlewareType[]): this;
@@ -41,6 +49,7 @@ export declare class RouteManager {
     private registerRoute;
     private buildVersionedPaths;
     private joinPaths;
-    private matchesConsumerPath;
+    private compilePathMatcher;
+    private compileRouteMatcher;
     getControllers(): ControllerRegistration[];
 }

package/dist/http/route.manager.js

@@ -1,4 +1,5 @@
 import { Hono } from "hono";
+import { getCookie } from "hono/cookie";
 import { HttpMethod, ParamType } from "../constants.js";
 import { getMetadata } from "../metadata.js";
 import { RequestMethod } from "./middleware-consumer.js";
@@ -7,6 +8,7 @@ import { ComponentManager } from "../pipeline/component.manager.js";
 import { shouldFilterCatch } from "../pipeline/decorators.js";
 import { MetadataRegistry } from "../registry/metadata.registry.js";
 import { getHttpCode, getRedirect, getResponseHeaders } from "./decorators.js";
+const defaultGetClientIp = (c)=>c.req.raw.headers.get('x-forwarded-for')?.split(',')[0]?.trim() ?? c.req.raw.headers.get('x-real-ip') ?? null;
 function parseRedirectResult(result) {
     if (typeof result !== 'object' || result === null) return undefined;
     if (!('url' in result)) return undefined;
@@ -21,6 +23,82 @@ function parseRedirectResult(result) {
 }
 export class RouteManager {
     container;
+    static METHOD_REGISTRAR = new Map([
+        [
+            HttpMethod.GET,
+            (app, p, h)=>app.get(p, h)
+        ],
+        [
+            HttpMethod.POST,
+            (app, p, h)=>app.post(p, h)
+        ],
+        [
+            HttpMethod.PUT,
+            (app, p, h)=>app.put(p, h)
+        ],
+        [
+            HttpMethod.PATCH,
+            (app, p, h)=>app.patch(p, h)
+        ],
+        [
+            HttpMethod.DELETE,
+            (app, p, h)=>app.delete(p, h)
+        ],
+        [
+            HttpMethod.OPTIONS,
+            (app, p, h)=>app.options(p, h)
+        ],
+        [
+            HttpMethod.HEAD,
+            (app, p, h)=>app.get(p, h)
+        ],
+        [
+            HttpMethod.ALL,
+            (app, p, h)=>app.all(p, h)
+        ]
+    ]);
+    static PARAM_EXTRACTORS = new Map([
+        [
+            ParamType.PARAM,
+            (c, p)=>p.name ? c.req.param(p.name) : c.req.param()
+        ],
+        [
+            ParamType.QUERY,
+            (c, p)=>p.name ? c.req.query(p.name) : c.req.query()
+        ],
+        [
+            ParamType.BODY,
+            async (c, p)=>{
+                let body;
+                try {
+                    body = await c.req.json();
+                } catch  {
+                    return undefined;
+                }
+                return p.name && body !== null && typeof body === 'object' ? body[p.name] : body;
+            }
+        ],
+        [
+            ParamType.HEADERS,
+            (c, p)=>p.name ? c.req.header(p.name) : c.req.header()
+        ],
+        [
+            ParamType.REQUEST,
+            (c)=>c
+        ],
+        [
+            ParamType.RESPONSE,
+            (c)=>c
+        ],
+        [
+            ParamType.COOKIE,
+            (c, p)=>p.name ? getCookie(c, p.name) : getCookie(c)
+        ],
+        [
+            ParamType.RAW_BODY,
+            async (c)=>new Uint8Array(await c.req.arrayBuffer())
+        ]
+    ]);
     controllers = [];
     globalMiddleware = [];
     globalPipes = [];
@@ -29,8 +107,10 @@ export class RouteManager {
     globalFilters = [];
     globalPrefix = '';
     consumerMiddlewareDefinitions = [];
-    constructor(container){
+    ipExtractor;
+    constructor(container, options = {}){
         this.container = container;
+        this.ipExtractor = options.getClientIp ?? defaultGetClientIp;
     }
     registerConsumerMiddleware(definitions) {
         this.consumerMiddlewareDefinitions.push(...definitions);
@@ -133,25 +213,12 @@ export class RouteManager {
         }
         // Register MiddlewareConsumer-configured middleware
         for (const def of this.consumerMiddlewareDefinitions){
+            const matchRoute = this.compileRouteMatcher(def.routes);
+            const matchExclude = this.compileRouteMatcher(def.excludes);
             app.use('*', (c, next)=>{
-                const reqPath = c.req.path;
-                const reqMethod = c.req.method;
-                const matches = def.routes.some((route)=>{
-                    if (!this.matchesConsumerPath(reqPath, route.path)) return false;
-                    if (route.method && route.method !== RequestMethod.ALL) {
-                        if (reqMethod !== route.method) return false;
-                    }
-                    return true;
-                });
-                if (!matches) return next();
-                const excluded = def.excludes.some((exclude)=>{
-                    if (!this.matchesConsumerPath(reqPath, exclude.path)) return false;
-                    if (exclude.method && exclude.method !== RequestMethod.ALL) {
-                        if (reqMethod !== exclude.method) return false;
-                    }
-                    return true;
-                });
-                if (excluded) return next();
+                const path = c.req.path;
+                const method = c.req.method;
+                if (!matchRoute(path, method) || matchExclude(path, method)) return next();
                 const requestContainer = this.getRequestContainer(c);
                 const runChain = (index)=>{
                     if (index >= def.middleware.length) return next();
@@ -321,7 +388,7 @@ export class RouteManager {
                 c
             ];
         }
-        const maxIndex = Math.max(...paramMetadata.map((p)=>p.index));
+        const maxIndex = paramMetadata.at(-1).index;
         const args = new Array(maxIndex + 1).fill(undefined);
         for (const param of paramMetadata){
             let value = await this.extractParam(c, param);
@@ -345,65 +412,11 @@ export class RouteManager {
         }
         return args;
     }
-    async extractParam(c, param) {
-        switch(param.type){
-            case ParamType.PARAM:
-                return param.name ? c.req.param(param.name) : c.req.param();
-            case ParamType.QUERY:
-                return param.name ? c.req.query(param.name) : c.req.query();
-            case ParamType.BODY:
-                {
-                    let body;
-                    try {
-                        body = await c.req.json();
-                    } catch  {
-                        return undefined;
-                    }
-                    if (param.name && body !== null && typeof body === 'object') {
-                        return body[param.name];
-                    }
-                    return body;
-                }
-            case ParamType.HEADERS:
-                if (param.name) {
-                    return c.req.header(param.name);
-                }
-                const headers = {};
-                c.req.raw.headers.forEach((value, key)=>{
-                    headers[key] = value;
-                });
-                return headers;
-            case ParamType.REQUEST:
-                return c;
-            case ParamType.RESPONSE:
-                return c;
-            case ParamType.IP:
-                return c.req.raw.headers.get('x-forwarded-for')?.split(',')[0]?.trim() ?? c.req.raw.headers.get('x-real-ip') ?? null;
-            case ParamType.COOKIE:
-                {
-                    const cookieHeader = c.req.raw.headers.get('cookie') ?? '';
-                    const cookies = {};
-                    for (const pair of cookieHeader.split(';')){
-                        const eqIdx = pair.indexOf('=');
-                        if (eqIdx === -1) continue;
-                        const name = pair.slice(0, eqIdx).trim();
-                        const value = pair.slice(eqIdx + 1).trim();
-                        if (name) cookies[name] = decodeURIComponent(value);
-                    }
-                    return param.name ? cookies[param.name] ?? undefined : cookies;
-                }
-            case ParamType.RAW_BODY:
-                {
-                    const buffer = await c.req.arrayBuffer();
-                    return new Uint8Array(buffer);
-                }
-            default:
-                // Custom param decorator — use factory if available
-                if (param.factory) {
-                    return param.factory(param.name, c);
-                }
-                return undefined;
-        }
+    extractParam(c, param) {
+        if (param.type === ParamType.IP) return this.ipExtractor(c);
+        const extractor = RouteManager.PARAM_EXTRACTORS.get(param.type);
+        if (extractor) return extractor(c, param);
+        return param.factory ? param.factory(param.name, c) : undefined;
     }
     createResponse(c, result, statusCode) {
         if (result instanceof Response) {
@@ -419,35 +432,8 @@ export class RouteManager {
     }
     registerRoute(app, method, path, handler) {
         const normalizedPath = path || '/';
-        switch(method){
-            case HttpMethod.GET:
-                app.get(normalizedPath, handler);
-                break;
-            case HttpMethod.POST:
-                app.post(normalizedPath, handler);
-                break;
-            case HttpMethod.PUT:
-                app.put(normalizedPath, handler);
-                break;
-            case HttpMethod.PATCH:
-                app.patch(normalizedPath, handler);
-                break;
-            case HttpMethod.DELETE:
-                app.delete(normalizedPath, handler);
-                break;
-            case HttpMethod.OPTIONS:
-                app.options(normalizedPath, handler);
-                break;
-            case HttpMethod.HEAD:
-                // Hono converts HEAD to GET internally, so register as GET
-                app.get(normalizedPath, handler);
-                break;
-            case HttpMethod.ALL:
-                app.all(normalizedPath, handler);
-                break;
-            default:
-                app.on(method.toUpperCase(), normalizedPath, handler);
-        }
+        const registrar = RouteManager.METHOD_REGISTRAR.get(method);
+        registrar ? registrar(app, normalizedPath, handler) : app.on(method.toUpperCase(), normalizedPath, handler);
     }
     buildVersionedPaths(globalPrefix, controllerPrefix, routePath, version) {
         if (version === undefined) {
@@ -468,15 +454,27 @@ export class RouteManager {
         const cleanPath = path && !path.startsWith('/') ? `/${path}` : path;
         return `${cleanPrefix}${cleanPath}` || '/';
     }
-    matchesConsumerPath(reqPath, routePath) {
-        if (routePath === '*') return true;
-        const normalized = routePath.startsWith('/') ? routePath : `/${routePath}`;
-        if (reqPath === normalized) return true;
-        if (reqPath.startsWith(`${normalized}/`)) return true;
-        if (normalized.endsWith('*')) {
-            return reqPath.startsWith(normalized.slice(0, -1));
+    compilePathMatcher(routePath) {
+        if (routePath === '*') return ()=>true;
+        const norm = routePath.startsWith('/') ? routePath : `/${routePath}`;
+        if (norm.endsWith('*')) {
+            const prefix = norm.slice(0, -1);
+            return (p)=>p.startsWith(prefix);
         }
-        return false;
+        return (p)=>p === norm || p.startsWith(`${norm}/`);
+    }
+    compileRouteMatcher(routes) {
+        const matchers = routes.map((route)=>{
+            const matchPath = this.compilePathMatcher(route.path);
+            return (path, method)=>{
+                if (!matchPath(path)) return false;
+                if (route.method && route.method !== RequestMethod.ALL) return method === route.method;
+                return true;
+            };
+        });
+        if (matchers.length === 0) return ()=>false;
+        if (matchers.length === 1) return matchers[0];
+        return (path, method)=>matchers.some((m)=>m(path, method));
     }
     getControllers() {
         return [

package/dist/index.d.ts

@@ -37,8 +37,10 @@ export { HttpException, BadRequestException, UnauthorizedException, ForbiddenExc
 export type { OnModuleInit, OnApplicationBootstrap, OnModuleDestroy, OnApplicationShutdown, BeforeApplicationShutdown, } from './lifecycle/index';
 export { MetadataRegistry } from './registry/index';
 export { RouteManager } from './http/index';
+export type { RouteManagerOptions } from './http/index';
 export { ModuleLoader } from './module/index';
 export { ComponentManager } from './pipeline/index';
 export { createZodDto, ValidationPipe } from './validation/index';
 export { Serialize, SerializerInterceptor, SERIALIZE_METADATA } from './serialization/index';
 export { Test, TestingModule, TestingModuleBuilder } from './testing/index';
+export { getRuntimeKey, env } from 'hono/adapter';

package/dist/index.js

@@ -49,3 +49,5 @@ export { createZodDto, ValidationPipe } from "./validation/index.js";
 export { Serialize, SerializerInterceptor, SERIALIZE_METADATA } from "./serialization/index.js";
 // Testing
 export { Test, TestingModule, TestingModuleBuilder } from "./testing/index.js";
+// Hono Adapter Utilities
+export { getRuntimeKey, env } from "hono/adapter";

package/dist/module/module-loader.d.ts

@@ -1,7 +1,7 @@
-import type { Container } from '../container/container';
-import type { Token, Type } from '../container/types';
-import type { MiddlewareRouteDefinition } from '../http/middleware-consumer';
-import type { RouteManager } from '../http/route.manager';
+import type { Container } from "../container/container";
+import type { Token, Type } from "../container/types";
+import type { MiddlewareRouteDefinition } from "../http/middleware-consumer";
+import type { RouteManager } from "../http/route.manager";
 export declare class ModuleLoader {
     private container;
     private router;

package/dist/module/module-loader.js

@@ -2,17 +2,24 @@ import { Scope } from "../constants.js";
 import { ForwardRef, InjectionToken } from "../container/types.js";
 import { MiddlewareBuilder } from "../http/middleware-consumer.js";
 import { APP_FILTER, APP_GUARD, APP_INTERCEPTOR, APP_MIDDLEWARE, APP_PIPE } from "../pipeline/tokens.js";
+const APP_TOKENS = new Set([
+    APP_GUARD,
+    APP_PIPE,
+    APP_INTERCEPTOR,
+    APP_FILTER,
+    APP_MIDDLEWARE
+]);
 import { MetadataRegistry } from "../registry/metadata.registry.js";
 import { getModuleMetadata, isModule } from "./decorators.js";
 function isDynamicModule(value) {
-    return typeof value === 'object' && value !== null && 'module' in value && typeof value.module === 'function';
+    return typeof value === "object" && value !== null && "module" in value && typeof value.module === "function";
 }
 export class ModuleLoader {
     container;
     router;
     processedModules = new Set();
     processingStack = new Set();
-    collectedControllers = [];
+    collectedControllers = new Set();
     registeredProviders = [];
     moduleExportsCache = new Map();
     globalExports = new Set();
@@ -67,9 +74,7 @@ export class ModuleLoader {
         if (this.processedModules.has(moduleClass)) {
             // Even if already processed, still collect extra controllers from dynamic module
             for (const controller of extraControllers){
-                if (!this.collectedControllers.includes(controller)) {
-                    this.collectedControllers.push(controller);
-                }
+                this.collectedControllers.add(controller);
             }
             return this.moduleExportsCache.get(moduleClass) ?? new Set();
         }
@@ -77,7 +82,7 @@ export class ModuleLoader {
             const chain = [
                 ...this.processingStack,
                 moduleClass
-            ].map((m)=>m.name).join(' -> ');
+            ].map((m)=>m.name).join(" -> ");
             throw new Error(`Circular module dependency detected: ${chain}`);
         }
         if (!isModule(moduleClass)) {
@@ -122,9 +127,7 @@ export class ModuleLoader {
                 ...extraControllers
             ];
             for (const controller of allControllers){
-                if (!this.collectedControllers.includes(controller)) {
-                    this.collectedControllers.push(controller);
-                }
+                this.collectedControllers.add(controller);
             }
             // Propagate module-level Use* decorators (@UseGuards, @UseInterceptors, etc.) to each controller
             for (const controller of allControllers){
@@ -140,7 +143,7 @@ export class ModuleLoader {
                 }
             }
             // Call configure() if the module implements NestModule
-            if (typeof moduleClass.prototype?.configure === 'function') {
+            if (typeof moduleClass.prototype?.configure === "function") {
                 try {
                     const instance = new moduleClass();
                     const builder = new MiddlewareBuilder();
@@ -156,7 +159,7 @@ export class ModuleLoader {
         }
     }
     registerProvider(provider) {
-        if (typeof provider === 'function') {
+        if (typeof provider === "function") {
             if (!this.container.has(provider)) {
                 this.container.register(provider);
                 this.registeredProviders.push(provider);
@@ -184,17 +187,17 @@ export class ModuleLoader {
         }
     }
     isAppToken(token) {
-        return token === APP_GUARD || token === APP_PIPE || token === APP_INTERCEPTOR || token === APP_FILTER || token === APP_MIDDLEWARE;
+        return APP_TOKENS.has(token);
     }
     buildExportSet(exports, providers, importedProviders) {
         const exportSet = new Set();
+        const providerTokens = new Set();
+        for (const p of providers){
+            const token = typeof p === "function" ? p : p.provide;
+            if (token !== undefined) providerTokens.add(token);
+        }
         for (const exported of exports){
-            const isLocalProvider = providers.some((p)=>{
-                if (typeof p === 'function') {
-                    return p === exported;
-                }
-                return p.provide === exported;
-            });
+            const isLocalProvider = providerTokens.has(exported);
             const isImportedProvider = importedProviders.has(exported);
             if (!isLocalProvider && !isImportedProvider) {
                 const name = exported.name ?? String(exported);
@@ -225,14 +228,14 @@ export class ModuleLoader {
         ];
     }
     async resolveAllInstances() {
-        const instances = [];
+        const instanceSet = new Set();
         for (const token of this.registeredProviders){
             try {
                 if (this.container.getProviderScope(token) === Scope.REQUEST) {
                     continue;
                 }
                 const instance = await this.container.resolveAsync(token);
-                instances.push(instance);
+                instanceSet.add(instance);
             } catch  {
             // Skip unresolvable tokens
             }
@@ -243,13 +246,13 @@ export class ModuleLoader {
                     continue;
                 }
                 const instance = await this.container.resolveAsync(controller);
-                if (!instances.includes(instance)) {
-                    instances.push(instance);
-                }
+                instanceSet.add(instance);
             } catch  {
             // Skip unresolvable controllers
             }
         }
-        return instances;
+        return [
+            ...instanceSet
+        ];
     }
 }

package/dist/pipeline/component.manager.js

@@ -27,11 +27,10 @@ export class ComponentManager {
     // 3-level resolution: global → controller → handler
     static getComponents(type, controller, handlerName) {
         const handlerKey = `${controller.name}:${String(handlerName)}`;
-        const globalComponents = Array.from(MetadataRegistry.getGlobal(type));
         const controllerComponents = MetadataRegistry.getController(type, controller);
         const handlerComponents = MetadataRegistry.getHandler(type, handlerKey);
         return [
-            ...globalComponents,
+            ...MetadataRegistry.getGlobal(type),
             ...controllerComponents,
             ...handlerComponents
         ];

package/dist/pipeline/pipes.d.ts

@@ -32,7 +32,8 @@ export declare class ParseUUIDPipe implements PipeTransform<string, string> {
     transform(value: string, metadata: ArgumentMetadata): string;
 }
 export declare class ParseEnumPipe<T extends Record<string, string | number>> implements PipeTransform<string, T[keyof T]> {
-    private readonly enumType;
+    private readonly allowedValues;
+    private readonly valuesLabel;
     constructor(enumType: T);
     transform(value: string, metadata: ArgumentMetadata): T[keyof T];
 }

package/dist/pipeline/pipes.js

@@ -70,14 +70,16 @@ export class ParseUUIDPipe {
     }
 }
 export class ParseEnumPipe {
-    enumType;
+    allowedValues;
+    valuesLabel;
     constructor(enumType){
-        this.enumType = enumType;
+        const values = Object.values(enumType);
+        this.allowedValues = new Set(values);
+        this.valuesLabel = values.join(', ');
     }
     transform(value, metadata) {
-        const enumValues = Object.values(this.enumType);
-        if (!enumValues.includes(value)) {
-            throw new BadRequestException(`Validation failed (${enumValues.join(', ')} expected)${metadata.data ? ` for parameter '${metadata.data}'` : ''}`);
+        if (!this.allowedValues.has(value)) {
+            throw new BadRequestException(`Validation failed (${this.valuesLabel} expected)${metadata.data ? ` for parameter '${metadata.data}'` : ''}`);
         }
         return value;
     }

package/dist/registry/types.d.ts

@@ -1,3 +1,4 @@
+import type { Context } from 'hono';
 import type { CanActivate, ExceptionFilter, NestInterceptor, NestMiddleware, PipeTransform } from '../pipeline/types';
 export type Type<T = any> = new (...args: any[]) => T;
 export type Constructor = Function;
@@ -26,7 +27,7 @@ export interface ParameterMetadata {
     type: string;
     name?: string;
     pipes?: PipeType[];
-    factory?: (data: unknown, ctx: unknown) => unknown;
+    factory?: (data: unknown, ctx: Context) => unknown;
 }
 export interface HttpHandlerMeta {
     httpCode?: number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@velajs/vela",
-  "version": "0.5.2",
+  "version": "0.6.1",
   "description": "NestJS-compatible framework for edge runtimes, powered by Hono",
   "type": "module",
   "main": "./dist/index.js",