@velajs/vela 0.10.0 → 1.1.0

package/dist/module/graph.js

@@ -0,0 +1,35 @@
+import { ForwardRef } from "../container/types.js";
+import { getModuleMetadata } from "./decorators.js";
+function isDynamicModuleLike(value) {
+    return !!value && typeof value === 'object' && 'module' in value && typeof value.module === 'function';
+}
+/**
+ * Walks the module dependency graph from a root, unwrapping ForwardRef and
+ * dynamic-module imports along the way, and returns every controller
+ * reachable from it. Pure metadata read — no Container, no side effects.
+ *
+ * Used by createOpenApiDocument and any other consumer that needs a
+ * controller list without bootstrapping the application.
+ */ export function collectControllers(rootModule) {
+    const visited = new Set();
+    const controllers = new Set();
+    const visit = (entry)=>{
+        const unwrapped = entry instanceof ForwardRef ? entry.factory() : entry;
+        const moduleClass = isDynamicModuleLike(unwrapped) ? unwrapped.module : unwrapped;
+        const extraControllers = isDynamicModuleLike(unwrapped) ? unwrapped.controllers ?? [] : [];
+        const extraImports = isDynamicModuleLike(unwrapped) ? unwrapped.imports ?? [] : [];
+        if (typeof moduleClass !== 'function' || visited.has(moduleClass)) return;
+        visited.add(moduleClass);
+        const metadata = getModuleMetadata(moduleClass);
+        if (metadata) {
+            for (const controller of metadata.controllers)controllers.add(controller);
+            for (const imp of metadata.imports)visit(imp);
+        }
+        for (const controller of extraControllers)controllers.add(controller);
+        for (const imp of extraImports)visit(imp);
+    };
+    visit(rootModule);
+    return [
+        ...controllers
+    ];
+}

package/dist/module/index.d.ts

@@ -1,3 +1,5 @@
 export { Global, Module, isModule, getModuleMetadata, createModuleRef } from './decorators';
 export { ModuleLoader } from './module-loader';
+export { MiddlewareBuilder } from './middleware';
+export type { MiddlewareConsumer, MiddlewareConfigProxy, MiddlewareRouteDefinition, NestModule, RouteInfo, } from './middleware';
 export type { ModuleOptions, ModuleMetadata, DynamicModule, AsyncModuleOptions, ModuleImport } from './types';

package/dist/module/index.js

@@ -1,2 +1,3 @@
 export { Global, Module, isModule, getModuleMetadata, createModuleRef } from "./decorators.js";
 export { ModuleLoader } from "./module-loader.js";
+export { MiddlewareBuilder } from "./middleware.js";

package/dist/{http/middleware-consumer.d.ts → module/middleware.d.ts}

@@ -1,18 +1,9 @@
+import { HttpMethod } from '../constants';
 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"
-}
+import type { Constructor, Type } from '../registry/types';
 export interface RouteInfo {
     path: string;
-    method?: RequestMethod;
+    method?: HttpMethod;
 }
 export interface MiddlewareRouteDefinition {
     middleware: Array<Type<NestMiddleware> | NestMiddleware>;
@@ -24,7 +15,7 @@ export interface MiddlewareRouteDefinition {
 export interface MiddlewareConfigProxy {
     exclude(...routes: Array<string | RouteInfo>): MiddlewareConfigProxy;
     withPriority(priority: number): MiddlewareConfigProxy;
-    forRoutes(...routes: Array<string | Function | RouteInfo>): MiddlewareConsumer;
+    forRoutes(...routes: Array<string | Constructor | RouteInfo>): MiddlewareConsumer;
 }
 export interface MiddlewareConsumer {
     apply(...middleware: Array<Type<NestMiddleware> | NestMiddleware>): MiddlewareConfigProxy;

package/dist/{http/middleware-consumer.js → module/middleware.js}

@@ -1,15 +1,4 @@
 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) {
@@ -27,7 +16,6 @@ export class MiddlewareBuilder {
                 currentPriority = priority;
                 return proxy;
             },
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
             forRoutes: (...routes)=>{
                 this.definitions.push({
                     middleware: currentMiddleware,
@@ -57,7 +45,6 @@ function normalizeRouteArg(route) {
         path: route
     } : route;
 }
-// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
 function resolveRouteArg(route) {
     if (typeof route === 'string') {
         return [

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 { MiddlewareRouteDefinition } from "./middleware";
 export declare class ModuleLoader {
     private container;
     private router;

package/dist/module/module-loader.js

@@ -1,7 +1,10 @@
 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";
+import { MetadataRegistry } from "../registry/metadata.registry.js";
+import { getOrCreateArray } from "../registry/util.js";
+import { getModuleMetadata, isModule } from "./decorators.js";
+import { MiddlewareBuilder } from "./middleware.js";
 const APP_TOKENS = new Set([
     APP_GUARD,
     APP_PIPE,
@@ -9,11 +12,12 @@ const APP_TOKENS = new Set([
     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";
 }
+function implementsNestModule(cls) {
+    return typeof cls.prototype?.configure === "function";
+}
 export class ModuleLoader {
     container;
     router;
@@ -152,16 +156,16 @@ export class ModuleLoader {
                     this.globalExports.add(token);
                 }
             }
-            // Call configure() if the module implements NestModule
-            if (typeof moduleClass.prototype?.configure === "function") {
-                try {
-                    const instance = new moduleClass();
-                    const builder = new MiddlewareBuilder();
-                    instance.configure(builder);
-                    this.consumerMiddlewareDefinitions.push(...builder.getDefinitions());
-                } catch  {
-                // Module has constructor dependencies — configure() skipped
+            // Call configure() if the module implements NestModule. The module is
+            // resolved through the container so it can have its own DI dependencies.
+            if (implementsNestModule(moduleClass)) {
+                if (!this.container.has(moduleClass)) {
+                    this.container.register(moduleClass);
                 }
+                const instance = this.container.resolve(moduleClass);
+                const builder = new MiddlewareBuilder();
+                instance.configure(builder);
+                this.consumerMiddlewareDefinitions.push(...builder.getDefinitions());
             }
             return exports;
         } finally{
@@ -187,7 +191,7 @@ export class ModuleLoader {
                     provide: syntheticToken
                 });
                 this.registeredProviders.push(syntheticToken);
-                this.appProviderTokens.get(token).push(syntheticToken);
+                getOrCreateArray(this.appProviderTokens, token).push(syntheticToken);
                 return;
             }
             if (!this.container.has(token)) {

package/dist/module/types.d.ts

@@ -1,29 +1 @@
-import type { ForwardRef, InjectionToken, ProviderOptions, Token, Type } from '../container/types';
-export type ModuleImport = Type | DynamicModule | ForwardRef;
-export interface AsyncModuleOptions<T = unknown> {
-    imports?: ModuleImport[];
-    useFactory: (...args: any[]) => T | Promise<T>;
-    inject?: Token[];
-}
-export interface DynamicModule {
-    module: Type;
-    imports?: ModuleImport[];
-    providers?: Array<Type | ProviderOptions>;
-    controllers?: Type[];
-    exports?: Array<Type | InjectionToken>;
-    global?: boolean;
-}
-export interface ModuleOptions {
-    providers?: Array<Type | ProviderOptions>;
-    controllers?: Type[];
-    imports?: ModuleImport[];
-    exports?: Array<Type | InjectionToken>;
-    isGlobal?: boolean;
-}
-export interface ModuleMetadata {
-    providers: Array<Type | ProviderOptions>;
-    controllers: Type[];
-    imports: ModuleImport[];
-    exports: Array<Type | InjectionToken>;
-    isGlobal: boolean;
-}
+export type { AsyncModuleOptions, DynamicModule, ModuleImport, ModuleMetadata, ModuleOptions, } from '../registry/types';

package/dist/openapi/decorators.js

@@ -1,3 +1,4 @@
+import { MetadataRegistry } from "../registry/metadata.registry.js";
 export const API_DOC_METADATA = 'vela:openapi:doc';
 export const API_TAGS_METADATA = 'vela:openapi:tags';
 export const API_RESPONSES_METADATA = 'vela:openapi:responses';
@@ -12,9 +13,9 @@ export const API_RESPONSES_METADATA = 'vela:openapi:responses';
  */ export function ApiDoc(metadata) {
     return (target, propertyKey)=>{
         if (propertyKey !== undefined) {
-            Reflect.defineMetadata(API_DOC_METADATA, metadata, target, propertyKey);
+            MetadataRegistry.setCustomHandlerMeta(target.constructor, propertyKey, API_DOC_METADATA, metadata);
         } else {
-            Reflect.defineMetadata(API_DOC_METADATA, metadata, target);
+            MetadataRegistry.setCustomClassMeta(target, API_DOC_METADATA, metadata);
         }
     };
 }
@@ -24,17 +25,23 @@ export const API_RESPONSES_METADATA = 'vela:openapi:responses';
  */ export function ApiTags(...tags) {
     return (target, propertyKey)=>{
         if (propertyKey !== undefined) {
-            Reflect.defineMetadata(API_TAGS_METADATA, tags, target, propertyKey);
+            MetadataRegistry.setCustomHandlerMeta(target.constructor, propertyKey, API_TAGS_METADATA, tags);
         } else {
-            Reflect.defineMetadata(API_TAGS_METADATA, tags, target);
+            MetadataRegistry.setCustomClassMeta(target, API_TAGS_METADATA, tags);
         }
     };
 }
 export function getApiDoc(target, propertyKey) {
-    return propertyKey !== undefined ? Reflect.getMetadata(API_DOC_METADATA, target, propertyKey) : Reflect.getMetadata(API_DOC_METADATA, target);
+    if (propertyKey !== undefined) {
+        return MetadataRegistry.getCustomHandlerMeta(target, propertyKey, API_DOC_METADATA);
+    }
+    return MetadataRegistry.getCustomClassMeta(target, API_DOC_METADATA);
 }
 export function getApiTags(target, propertyKey) {
-    return propertyKey !== undefined ? Reflect.getMetadata(API_TAGS_METADATA, target, propertyKey) : Reflect.getMetadata(API_TAGS_METADATA, target);
+    if (propertyKey !== undefined) {
+        return MetadataRegistry.getCustomHandlerMeta(target, propertyKey, API_TAGS_METADATA);
+    }
+    return MetadataRegistry.getCustomClassMeta(target, API_TAGS_METADATA);
 }
 /**
  * Document a response for a given status code. Stackable: apply multiple
@@ -48,14 +55,12 @@ export function getApiTags(target, propertyKey) {
  * ```
  */ export function ApiResponse(status, options) {
     return (target, propertyKey)=>{
-        const existing = Reflect.getMetadata(API_RESPONSES_METADATA, target, propertyKey) ?? [];
-        existing.push({
+        MetadataRegistry.appendCustomHandlerMeta(target.constructor, propertyKey, API_RESPONSES_METADATA, {
             status,
             ...options
         });
-        Reflect.defineMetadata(API_RESPONSES_METADATA, existing, target, propertyKey);
     };
 }
 export function getApiResponses(target, propertyKey) {
-    return Reflect.getMetadata(API_RESPONSES_METADATA, target, propertyKey);
+    return MetadataRegistry.getCustomHandlerMeta(target, propertyKey, API_RESPONSES_METADATA);
 }

package/dist/openapi/document.js

@@ -1,44 +1,9 @@
-import { getModuleMetadata } from "../module/decorators.js";
-import { ForwardRef } from "../container/types.js";
+import { collectControllers } from "../module/graph.js";
 import { MetadataRegistry } from "../registry/metadata.registry.js";
+import { joinPaths, toOpenApiPath } from "../registry/paths.js";
 import { ParamType } from "../constants.js";
 import { getApiDoc, getApiResponses, getApiTags } from "./decorators.js";
 import { isOptional, zodToJsonSchema } from "./zod-to-json-schema.js";
-function isDynamicModuleLike(v) {
-    return !!v && typeof v === 'object' && 'module' in v && typeof v.module === 'function';
-}
-function collectControllers(rootModule) {
-    const visited = new Set();
-    const controllers = new Set();
-    function visit(entry) {
-        const unwrapped = entry instanceof ForwardRef ? entry.factory() : entry;
-        const moduleClass = isDynamicModuleLike(unwrapped) ? unwrapped.module : unwrapped;
-        const extraControllers = isDynamicModuleLike(unwrapped) ? unwrapped.controllers ?? [] : [];
-        const extraImports = isDynamicModuleLike(unwrapped) ? unwrapped.imports ?? [] : [];
-        if (typeof moduleClass !== 'function' || visited.has(moduleClass)) return;
-        visited.add(moduleClass);
-        const metadata = getModuleMetadata(moduleClass);
-        if (metadata) {
-            for (const controller of metadata.controllers)controllers.add(controller);
-            for (const imp of metadata.imports)visit(imp);
-        }
-        for (const controller of extraControllers)controllers.add(controller);
-        for (const imp of extraImports)visit(imp);
-    }
-    visit(rootModule);
-    return [
-        ...controllers
-    ];
-}
-function normalizePath(path) {
-    return path.replace(/:([a-zA-Z_][a-zA-Z0-9_]*)/g, '{$1}');
-}
-function joinPath(a, b) {
-    const left = a.endsWith('/') ? a.slice(0, -1) : a;
-    const right = b && !b.startsWith('/') ? `/${b}` : b;
-    const joined = `${left}${right}`;
-    return joined || '/';
-}
 /**
  * Tracks DTO classes referenced during document generation and registers
  * each under `components.schemas`. Handles name collisions by suffixing.
@@ -176,9 +141,9 @@ function buildOperation(controller, route, pathString, registry) {
             });
         }
     }
-    const docMeta = getApiDoc(controller.prototype, handlerName);
+    const docMeta = getApiDoc(controller, handlerName);
     const controllerTags = getApiTags(controller) ?? [];
-    const handlerTags = getApiTags(controller.prototype, handlerName) ?? [];
+    const handlerTags = getApiTags(controller, handlerName) ?? [];
     const docTags = docMeta?.tags ?? [];
     const mergedTags = [
         ...new Set([
@@ -192,7 +157,7 @@ function buildOperation(controller, route, pathString, registry) {
             description: 'OK'
         }
     };
-    const apiResponses = getApiResponses(controller.prototype, handlerName) ?? [];
+    const apiResponses = getApiResponses(controller, handlerName) ?? [];
     for (const entry of apiResponses){
         const key = String(entry.status);
         const resolved = {
@@ -239,8 +204,8 @@ export function createOpenApiDocument(rootModule, options = {}) {
         for (const route of routes){
             const method = route.method.toLowerCase();
             if (!VERB_WHITELIST.has(method)) continue;
-            const rawPath = joinPath(joinPath(globalPrefix, controllerPath), route.path);
-            const pathString = normalizePath(rawPath);
+            const rawPath = joinPaths(joinPaths(globalPrefix, controllerPath), route.path);
+            const pathString = toOpenApiPath(rawPath);
             const operation = buildOperation(controller, route, pathString, registry);
             const pathItem = paths[pathString] ?? {};
             pathItem[method] = operation;

package/dist/pipeline/app-providers.d.ts

@@ -0,0 +1,10 @@
+import type { Container } from '../container/container';
+import type { RouteManager } from '../http/route.manager';
+import type { ModuleLoader } from '../module/module-loader';
+/**
+ * Bind every APP_* provider registered in the container as a global
+ * component on the RouteManager. The single source of truth for app-level
+ * pipeline configuration — used by both VelaFactory.create and
+ * @velajs/testing's TestingModuleBuilder.compile.
+ */
+export declare function bindAppProviders(routeManager: RouteManager, container: Container, loader: ModuleLoader): void;

package/dist/pipeline/app-providers.js

@@ -0,0 +1,43 @@
+import { APP_FILTER, APP_GUARD, APP_INTERCEPTOR, APP_MIDDLEWARE, APP_PIPE } from "./tokens.js";
+// NestJS-style "APP_*" provider convention: each slot maps a well-known DI
+// token to the RouteManager method that installs providers under it as a
+// global component. Module-level @Provide(APP_*) entries expand into
+// synthetic tokens (collected by ModuleLoader); a single @Inject(APP_*)
+// provider falls back to the bare token.
+const SLOTS = [
+    {
+        token: APP_GUARD,
+        bind: (rm)=>rm.useGlobalGuardTokens.bind(rm)
+    },
+    {
+        token: APP_PIPE,
+        bind: (rm)=>rm.useGlobalPipeTokens.bind(rm)
+    },
+    {
+        token: APP_INTERCEPTOR,
+        bind: (rm)=>rm.useGlobalInterceptorTokens.bind(rm)
+    },
+    {
+        token: APP_FILTER,
+        bind: (rm)=>rm.useGlobalFilterTokens.bind(rm)
+    },
+    {
+        token: APP_MIDDLEWARE,
+        bind: (rm)=>rm.useGlobalMiddlewareTokens.bind(rm)
+    }
+];
+/**
+ * Bind every APP_* provider registered in the container as a global
+ * component on the RouteManager. The single source of truth for app-level
+ * pipeline configuration — used by both VelaFactory.create and
+ * @velajs/testing's TestingModuleBuilder.compile.
+ */ export function bindAppProviders(routeManager, container, loader) {
+    for (const { token, bind } of SLOTS){
+        const collected = loader.getAppProviderTokens(token);
+        if (collected.length > 0) {
+            bind(routeManager)(...collected);
+        } else if (container.has(token)) {
+            bind(routeManager)(token);
+        }
+    }
+}

package/dist/pipeline/component.manager.d.ts

@@ -8,6 +8,7 @@ export declare class ComponentManager {
     static registerController<T extends ComponentType>(type: T, controller: Constructor, ...components: ComponentTypeMap[T][]): void;
     static registerHandler<T extends ComponentType>(type: T, controller: Constructor, handlerName: string | symbol, ...components: ComponentTypeMap[T][]): void;
     static getComponents<T extends ComponentType>(type: T, controller: Constructor, handlerName: string | symbol): ComponentTypeMap[T][];
+    private static resolveAll;
     static resolveMiddleware(items: MiddlewareType[]): NestMiddleware[];
     static resolveGuards(items: GuardType[]): CanActivate[];
     static resolvePipes(items: PipeType[]): PipeTransform[];

package/dist/pipeline/component.manager.js

@@ -19,16 +19,14 @@ export class ComponentManager {
         }
     }
     static registerHandler(type, controller, handlerName, ...components) {
-        const handlerKey = `${controller.name}:${String(handlerName)}`;
         for (const component of components){
-            MetadataRegistry.registerHandler(type, handlerKey, component);
+            MetadataRegistry.registerHandler(type, controller, handlerName, component);
         }
     }
     // 3-level resolution: global → controller → handler
     static getComponents(type, controller, handlerName) {
-        const handlerKey = `${controller.name}:${String(handlerName)}`;
         const controllerComponents = MetadataRegistry.getController(type, controller);
-        const handlerComponents = MetadataRegistry.getHandler(type, handlerKey);
+        const handlerComponents = MetadataRegistry.getHandler(type, controller, handlerName);
         return [
             ...MetadataRegistry.getGlobal(type),
             ...controllerComponents,
@@ -36,45 +34,23 @@ export class ComponentManager {
         ];
     }
     // Type-specific resolvers
+    static resolveAll(items, methodKey) {
+        return items.map((item)=>isObject(item) && methodKey in item ? item : this.container.resolve(item));
+    }
     static resolveMiddleware(items) {
-        return items.map((item)=>{
-            if (isObject(item) && 'use' in item) {
-                return item;
-            }
-            return this.container.resolve(item);
-        });
+        return this.resolveAll(items, 'use');
     }
     static resolveGuards(items) {
-        return items.map((item)=>{
-            if (isObject(item) && 'canActivate' in item) {
-                return item;
-            }
-            return this.container.resolve(item);
-        });
+        return this.resolveAll(items, 'canActivate');
     }
     static resolvePipes(items) {
-        return items.map((item)=>{
-            if (isObject(item) && 'transform' in item) {
-                return item;
-            }
-            return this.container.resolve(item);
-        });
+        return this.resolveAll(items, 'transform');
     }
     static resolveInterceptors(items) {
-        return items.map((item)=>{
-            if (isObject(item) && 'intercept' in item) {
-                return item;
-            }
-            return this.container.resolve(item);
-        });
+        return this.resolveAll(items, 'intercept');
     }
     static resolveFilters(items) {
-        return items.map((item)=>{
-            if (isObject(item) && 'catch' in item) {
-                return item;
-            }
-            return this.container.resolve(item);
-        });
+        return this.resolveAll(items, 'catch');
     }
     // Pipe execution
     static async executePipes(value, metadata, pipes) {

package/dist/pipeline/decorators.d.ts

@@ -1,10 +1,10 @@
 import type { Type } from '../container/types';
 import type { ComponentTypeMap } from '../registry/types';
-export declare function UseMiddleware(...middleware: ComponentTypeMap['middleware'][]): (target: Function | object, propertyKey?: string | symbol) => void;
-export declare function UseGuards(...guards: ComponentTypeMap['guard'][]): (target: Function | object, propertyKey?: string | symbol) => void;
-export declare function UsePipes(...pipes: ComponentTypeMap['pipe'][]): (target: Function | object, propertyKey?: string | symbol) => void;
-export declare function UseInterceptors(...interceptors: ComponentTypeMap['interceptor'][]): (target: Function | object, propertyKey?: string | symbol) => void;
-export declare function UseFilters(...filters: ComponentTypeMap['filter'][]): (target: Function | object, propertyKey?: string | symbol) => void;
+export declare function UseMiddleware(...middleware: ComponentTypeMap['middleware'][]): (target: object, propertyKey?: string | symbol) => void;
+export declare function UseGuards(...guards: ComponentTypeMap['guard'][]): (target: object, propertyKey?: string | symbol) => void;
+export declare function UsePipes(...pipes: ComponentTypeMap['pipe'][]): (target: object, propertyKey?: string | symbol) => void;
+export declare function UseInterceptors(...interceptors: ComponentTypeMap['interceptor'][]): (target: object, propertyKey?: string | symbol) => void;
+export declare function UseFilters(...filters: ComponentTypeMap['filter'][]): (target: object, propertyKey?: string | symbol) => void;
 export declare function Catch(...exceptions: Type<Error>[]): ClassDecorator;
 export declare function getCatchTypes(filter: unknown): Type<Error>[];
 export declare function shouldFilterCatch(filter: unknown, exception: unknown): boolean;

package/dist/pipeline/decorators.js

@@ -1,15 +1,10 @@
-import { METADATA_KEYS } from "../constants.js";
-import { getMetadata } from "../metadata.js";
 import { ComponentManager } from "./component.manager.js";
 import { MetadataRegistry } from "../registry/metadata.registry.js";
 function UseComponent(type, ...components) {
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
     return (target, propertyKey)=>{
         if (propertyKey !== undefined) {
-            // Method decorator — target is prototype, target.constructor is the class
             ComponentManager.registerHandler(type, target.constructor, propertyKey, ...components);
         } else {
-            // Class decorator — target is the class itself
             ComponentManager.registerController(type, target, ...components);
         }
     };
@@ -36,10 +31,7 @@ export function Catch(...exceptions) {
 }
 export function getCatchTypes(filter) {
     const filterClass = typeof filter === 'function' ? filter : filter.constructor;
-    if (MetadataRegistry.hasCatchTypes(filterClass)) {
-        return MetadataRegistry.getCatchTypes(filterClass) ?? [];
-    }
-    return getMetadata(METADATA_KEYS.CATCH, filterClass) ?? [];
+    return MetadataRegistry.getCatchTypes(filterClass) ?? [];
 }
 export function shouldFilterCatch(filter, exception) {
     const catchTypes = getCatchTypes(filter);

package/dist/pipeline/reflector.d.ts

@@ -1,3 +1,4 @@
+import type { ExecutionContext } from './types';
 export interface CreateDecoratorOptions {
     key?: string;
 }
@@ -18,7 +19,7 @@ export interface ReflectableDecorator<TParam> {
  * class AdminController { ... }
  * ```
  */
-export declare function SetMetadata<V = unknown>(key: string, value: V): (target: Function | object, propertyKey?: string | symbol) => void;
+export declare function SetMetadata<V = unknown>(key: string, value: V): (target: object, propertyKey?: string | symbol) => void;
 /**
  * Reads custom metadata set by @SetMetadata().
  * Use in guards/interceptors via ExecutionContext.
@@ -54,39 +55,25 @@ export declare class Reflector {
      * Get metadata value from handler first, then class.
      * Handler-level metadata takes priority over class-level.
      */
-    get<T = unknown>(key: string | ReflectableDecorator<T>, context: {
-        getClass(): Function;
-        getHandler(): string | symbol;
-    }): T | undefined;
+    get<T = unknown>(key: string | ReflectableDecorator<T>, context: ExecutionContext): T | undefined;
     /**
      * Get metadata only from the handler (method) level.
      */
-    getHandler<T = unknown>(key: string | ReflectableDecorator<T>, context: {
-        getClass(): Function;
-        getHandler(): string | symbol;
-    }): T | undefined;
+    getHandler<T = unknown>(key: string | ReflectableDecorator<T>, context: ExecutionContext): T | undefined;
     /**
      * Get metadata only from the class level.
      */
-    getClass<T = unknown>(key: string | ReflectableDecorator<T>, context: {
-        getClass(): Function;
-    }): T | undefined;
+    getClass<T = unknown>(key: string | ReflectableDecorator<T>, context: Pick<ExecutionContext, "getClass">): T | undefined;
     /**
      * Get all metadata values for a key from both handler and class.
      * Returns [handlerValue, classValue] (either may be undefined).
      */
-    getAll<T = unknown>(key: string | ReflectableDecorator<T>, context: {
-        getClass(): Function;
-        getHandler(): string | symbol;
-    }): [T | undefined, T | undefined];
+    getAll<T = unknown>(key: string | ReflectableDecorator<T>, context: ExecutionContext): [T | undefined, T | undefined];
     /**
      * Returns handler value if defined, else class value, else undefined.
      * First defined value wins.
      */
-    getAllAndOverride<T = unknown>(key: string | ReflectableDecorator<T>, context: {
-        getClass(): Function;
-        getHandler(): string | symbol;
-    }): T | undefined;
+    getAllAndOverride<T = unknown>(key: string | ReflectableDecorator<T>, context: ExecutionContext): T | undefined;
     /**
      * Collects handler + class values, filters undefineds.
      * - 0 values → []
@@ -95,8 +82,5 @@ export declare class Reflector {
      * - Objects → Object.assign({}, ...values)
      * - Otherwise → wrap in array
      */
-    getAllAndMerge<T = unknown>(key: string | ReflectableDecorator<T>, context: {
-        getClass(): Function;
-        getHandler(): string | symbol;
-    }): T | T[];
+    getAllAndMerge<T = unknown>(key: string | ReflectableDecorator<T>, context: ExecutionContext): T | T[];
 }