@velajs/vela 1.0.0 → 1.1.0

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

@@ -1,14 +1,4 @@
 import { MetadataRegistry } from "../registry/metadata.registry.js";
-export const RequestMethod = {
-    GET: 'GET',
-    POST: 'POST',
-    PUT: 'PUT',
-    DELETE: 'DELETE',
-    PATCH: 'PATCH',
-    OPTIONS: 'OPTIONS',
-    HEAD: 'HEAD',
-    ALL: 'ALL'
-};
 export class MiddlewareBuilder {
     definitions = [];
     apply(...middleware) {
@@ -26,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,
@@ -56,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/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[];
 }

package/dist/pipeline/reflector.js

@@ -1,7 +1,4 @@
-import { getMetadata as internalGetMetadata } from "../metadata.js";
 import { MetadataRegistry } from "../registry/metadata.registry.js";
-const SET_METADATA_KEY = 'vela:metadata';
-let _decoratorKeyCounter = 0;
 /**
  * Decorator that attaches custom metadata to a class or method.
  * Read via Reflector in guards/interceptors.
@@ -15,13 +12,10 @@ let _decoratorKeyCounter = 0;
  * class AdminController { ... }
  * ```
  */ export function SetMetadata(key, value) {
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
     return (target, propertyKey)=>{
         if (propertyKey !== undefined) {
-            // Method decorator
             MetadataRegistry.setCustomHandlerMeta(target.constructor, propertyKey, key, value);
         } else {
-            // Class decorator
             MetadataRegistry.setCustomClassMeta(target, key, value);
         }
     };
@@ -54,7 +48,7 @@ let _decoratorKeyCounter = 0;
    * // reflector.get(Roles, context) — typed as string[] | undefined
    * ```
    */ static createDecorator(options) {
-        const key = options?.key ?? `vela:custom:${_decoratorKeyCounter++}`;
+        const key = options?.key ?? `vela:custom:${crypto.randomUUID()}`;
         const decorator = (value)=>SetMetadata(key, value);
         decorator.KEY = key;
         return decorator;
@@ -67,52 +61,22 @@ let _decoratorKeyCounter = 0;
    * Handler-level metadata takes priority over class-level.
    */ get(key, context) {
         const resolvedKey = this.resolveKey(key);
-        // Check handler-level first (MetadataRegistry)
-        const handlerValue = MetadataRegistry.getCustomHandlerMeta(context.getClass(), context.getHandler(), resolvedKey);
-        if (handlerValue !== undefined) {
-            return handlerValue;
-        }
-        // Check class-level (MetadataRegistry)
-        const classValue = MetadataRegistry.getCustomClassMeta(context.getClass(), resolvedKey);
-        if (classValue !== undefined) {
-            return classValue;
-        }
-        // Fallback to WeakMap for external package compat
-        const handlerMeta = internalGetMetadata(SET_METADATA_KEY, context.getClass(), context.getHandler());
-        if (handlerMeta?.has(resolvedKey)) {
-            return handlerMeta.get(resolvedKey);
-        }
-        const classMeta = internalGetMetadata(SET_METADATA_KEY, context.getClass());
-        if (classMeta?.has(resolvedKey)) {
-            return classMeta.get(resolvedKey);
-        }
-        return undefined;
+        const ctor = context.getClass();
+        const handlerValue = MetadataRegistry.getCustomHandlerMeta(ctor, context.getHandler(), resolvedKey);
+        if (handlerValue !== undefined) return handlerValue;
+        return MetadataRegistry.getCustomClassMeta(ctor, resolvedKey);
     }
     /**
    * Get metadata only from the handler (method) level.
    */ getHandler(key, context) {
         const resolvedKey = this.resolveKey(key);
-        // MetadataRegistry first
-        const value = MetadataRegistry.getCustomHandlerMeta(context.getClass(), context.getHandler(), resolvedKey);
-        if (value !== undefined) {
-            return value;
-        }
-        // Fallback to WeakMap
-        const meta = internalGetMetadata(SET_METADATA_KEY, context.getClass(), context.getHandler());
-        return meta?.get(resolvedKey);
+        return MetadataRegistry.getCustomHandlerMeta(context.getClass(), context.getHandler(), resolvedKey);
     }
     /**
    * Get metadata only from the class level.
    */ getClass(key, context) {
         const resolvedKey = this.resolveKey(key);
-        // MetadataRegistry first
-        const value = MetadataRegistry.getCustomClassMeta(context.getClass(), resolvedKey);
-        if (value !== undefined) {
-            return value;
-        }
-        // Fallback to WeakMap
-        const meta = internalGetMetadata(SET_METADATA_KEY, context.getClass());
-        return meta?.get(resolvedKey);
+        return MetadataRegistry.getCustomClassMeta(context.getClass(), resolvedKey);
     }
     /**
    * Get all metadata values for a key from both handler and class.
@@ -127,11 +91,7 @@ let _decoratorKeyCounter = 0;
    * Returns handler value if defined, else class value, else undefined.
    * First defined value wins.
    */ getAllAndOverride(key, context) {
-        const handlerValue = this.getHandler(key, context);
-        if (handlerValue !== undefined) {
-            return handlerValue;
-        }
-        return this.getClass(key, context);
+        return this.getHandler(key, context) ?? this.getClass(key, context);
     }
     /**
    * Collects handler + class values, filters undefineds.
@@ -145,13 +105,8 @@ let _decoratorKeyCounter = 0;
         const values = [];
         if (handlerValue !== undefined) values.push(handlerValue);
         if (classValue !== undefined) values.push(classValue);
-        if (values.length === 0) {
-            return [];
-        }
-        if (values.length === 1) {
-            return values[0];
-        }
-        // Both defined — merge strategy depends on type
+        if (values.length === 0) return [];
+        if (values.length === 1) return values[0];
         if (Array.isArray(values[0]) && Array.isArray(values[1])) {
             return [
                 ...values[0],

package/dist/registry/index.d.ts

@@ -1,2 +1,2 @@
 export { MetadataRegistry } from './metadata.registry';
-export type { Type, Constructor, ComponentType, ComponentTypeMap, ComponentInstance, MiddlewareType, GuardType, PipeType, InterceptorType, FilterType, RouteDefinition, ParameterMetadata, ModuleOptions, ProviderOptions, InjectionTokenLike, } from './types';
+export type { Type, Constructor, ComponentType, ComponentTypeMap, ComponentInstance, MiddlewareType, GuardType, PipeType, InterceptorType, FilterType, RouteDefinition, ParameterMetadata, ModuleOptions, ProviderOptions, InjectionToken, } from './types';

package/dist/registry/metadata.registry.d.ts

@@ -1,7 +1,6 @@
 import type { Scope } from '../constants';
 import type { InjectMetadata } from '../container/types';
-import type { Type } from '../container/types';
-import type { ComponentType, ComponentTypeMap, Constructor, HttpHandlerMeta, ModuleOptions, ParameterMetadata, RouteDefinition } from './types';
+import type { ComponentType, ComponentTypeMap, Constructor, HttpHandlerMeta, ModuleOptions, ParameterMetadata, RouteDefinition, Type } from './types';
 export interface ControllerOptions {
     version?: number | number[];
 }
@@ -11,17 +10,17 @@ export declare class MetadataRegistry {
     private static readonly controllerOptions;
     private static readonly modules;
     private static readonly parameters;
-    private static readonly global;
-    private static readonly controller;
-    private static readonly handler;
     private static readonly injectables;
     private static readonly scopes;
     private static readonly injectTokens;
     private static readonly handlerHttpMeta;
     private static readonly catchTypes;
     private static readonly routeVersions;
-    private static readonly customClassMeta;
-    private static readonly customHandlerMeta;
+    private static readonly classMeta;
+    private static readonly handlerMeta;
+    private static readonly controllerComponents;
+    private static readonly handlerComponents;
+    private static globalComponents;
     static getRoutes(controller: Constructor): RouteDefinition[];
     static addRoute(controller: Constructor, route: RouteDefinition): void;
     static getControllerPath(controller: Constructor): string;
@@ -51,12 +50,18 @@ export declare class MetadataRegistry {
     static hasCatchTypes(filter: Constructor): boolean;
     static setRouteVersion(controller: Constructor, method: string | symbol, version: number | number[]): void;
     static getRouteVersion(controller: Constructor, method: string | symbol): number | number[] | undefined;
-    static setCustomClassMeta(target: Constructor, key: string, value: unknown): void;
-    static getCustomClassMeta(target: Constructor, key: string): unknown;
-    static getCustomClassMetaAll(target: Constructor): Map<string, unknown> | undefined;
-    static setCustomHandlerMeta(target: Constructor, handler: string | symbol, key: string, value: unknown): void;
-    static getCustomHandlerMeta(target: Constructor, handler: string | symbol, key: string): unknown;
-    static getCustomHandlerMetaAll(target: Constructor, handler: string | symbol): Map<string, unknown> | undefined;
+    static setCustomClassMeta(target: object, key: string, value: unknown): void;
+    static getCustomClassMeta(target: object, key: string): unknown;
+    static getCustomClassMetaAll(target: object): Map<string, unknown> | undefined;
+    static setCustomHandlerMeta(target: object, handler: string | symbol, key: string, value: unknown): void;
+    static getCustomHandlerMeta(target: object, handler: string | symbol, key: string): unknown;
+    static getCustomHandlerMetaAll(target: object, handler: string | symbol): Map<string, unknown> | undefined;
+    static appendCustomClassMeta<T>(target: object, key: string, item: T): void;
+    static appendCustomHandlerMeta<T>(target: object, handler: string | symbol, key: string, item: T): void;
+    static setReflectMetadata(target: object, key: string, value: unknown, propertyKey?: string | symbol): void;
+    static getReflectMetadata<T = unknown>(target: object, key: string, propertyKey?: string | symbol): T | undefined;
+    static getParamTypes(target: object, propertyKey?: string | symbol): unknown[] | undefined;
     static propagateControllerComponents(from: Constructor, to: Constructor): void;
     static clear(): void;
+    static reset(): void;
 }