@velajs/vela 0.10.0 → 1.1.0

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;
@@ -36,8 +35,8 @@ export declare class MetadataRegistry {
     static getGlobal<T extends ComponentType>(type: T): Set<ComponentTypeMap[T]>;
     static registerController<T extends ComponentType>(type: T, controller: Constructor, component: ComponentTypeMap[T]): void;
     static getController<T extends ComponentType>(type: T, controller: Constructor): ComponentTypeMap[T][];
-    static registerHandler<T extends ComponentType>(type: T, handlerKey: string, component: ComponentTypeMap[T]): void;
-    static getHandler<T extends ComponentType>(type: T, handlerKey: string): ComponentTypeMap[T][];
+    static registerHandler<T extends ComponentType>(type: T, controller: Constructor, methodName: string | symbol, component: ComponentTypeMap[T]): void;
+    static getHandler<T extends ComponentType>(type: T, controller: Constructor, methodName: string | symbol): ComponentTypeMap[T][];
     static markInjectable(target: object): void;
     static hasInjectable(target: object): boolean;
     static setScope(target: object, scope: Scope): void;
@@ -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;
 }

package/dist/registry/metadata.registry.js

@@ -1,108 +1,69 @@
+import { getOrCreate, getOrCreateArray, getOrCreateMap } from "./util.js";
+function emptyComponentStore() {
+    return {
+        middleware: new Set(),
+        guard: new Set(),
+        pipe: new Set(),
+        interceptor: new Set(),
+        filter: new Set()
+    };
+}
+function emptyComponentByOwner() {
+    return {
+        middleware: new Map(),
+        guard: new Map(),
+        pipe: new Map(),
+        interceptor: new Map(),
+        filter: new Map()
+    };
+}
 export class MetadataRegistry {
+    // Decoration metadata (set at import time, persists across clear()).
     static routes = new Map();
     static controllers = new Map();
     static controllerOptions = new Map();
     static modules = new Map();
     static parameters = new Map();
-    // 3-level component hierarchy
-    static global = new Map([
-        [
-            'middleware',
-            new Set()
-        ],
-        [
-            'guard',
-            new Set()
-        ],
-        [
-            'pipe',
-            new Set()
-        ],
-        [
-            'interceptor',
-            new Set()
-        ],
-        [
-            'filter',
-            new Set()
-        ]
-    ]);
-    static controller = new Map([
-        [
-            'middleware',
-            new Map()
-        ],
-        [
-            'guard',
-            new Map()
-        ],
-        [
-            'pipe',
-            new Map()
-        ],
-        [
-            'interceptor',
-            new Map()
-        ],
-        [
-            'filter',
-            new Map()
-        ]
-    ]);
-    static handler = new Map([
-        [
-            'middleware',
-            new Map()
-        ],
-        [
-            'guard',
-            new Map()
-        ],
-        [
-            'pipe',
-            new Map()
-        ],
-        [
-            'interceptor',
-            new Map()
-        ],
-        [
-            'filter',
-            new Map()
-        ]
-    ]);
-    // DI metadata
     static injectables = new Set();
     static scopes = new Map();
     static injectTokens = new Map();
-    // HTTP handler metadata
     static handlerHttpMeta = new Map();
-    // Exception filter types
     static catchTypes = new Map();
-    // Route versions
     static routeVersions = new Map();
-    // Custom metadata (SetMetadata)
-    static customClassMeta = new Map();
-    static customHandlerMeta = new Map();
+    // Free-form key→value class & handler meta. Backs:
+    //   - @SetMetadata (custom user keys)
+    //   - feature decorators (@Cron, @OnEvent, @ApiDoc, …)
+    //   - the SWC shim (Reflect.metadata's design:* keys)
+    //   - external Reflect.defineMetadata / Reflect.getMetadata calls.
+    static classMeta = new Map();
+    static handlerMeta = new Map();
+    // Component decoration (set by @UseGuards/@UsePipes/etc. at decoration time).
+    static controllerComponents = emptyComponentByOwner();
+    static handlerComponents = {
+        middleware: new Map(),
+        guard: new Map(),
+        pipe: new Map(),
+        interceptor: new Map(),
+        filter: new Map()
+    };
+    // Global components — app-time state (cleared by clear()).
+    static globalComponents = emptyComponentStore();
     // Routes
     static getRoutes(controller) {
-        return this.routes.get(controller) || [];
+        return this.routes.get(controller) ?? [];
     }
     static addRoute(controller, route) {
-        if (!this.routes.has(controller)) {
-            this.routes.set(controller, []);
-        }
-        this.routes.get(controller).push(route);
+        getOrCreateArray(this.routes, controller).push(route);
     }
     // Controllers
     static getControllerPath(controller) {
-        return this.controllers.get(controller) || '';
+        return this.controllers.get(controller) ?? '';
     }
     static setControllerPath(controller, path) {
         this.controllers.set(controller, path);
     }
     static getControllerOptions(controller) {
-        return this.controllerOptions.get(controller) || {};
+        return this.controllerOptions.get(controller) ?? {};
     }
     static setControllerOptions(controller, options) {
         this.controllerOptions.set(controller, options);
@@ -116,46 +77,37 @@ export class MetadataRegistry {
     }
     // Parameters
     static getParameters(controller) {
-        return this.parameters.get(controller) || new Map();
+        return this.parameters.get(controller) ?? new Map();
     }
     static addParameter(controller, methodName, param) {
-        if (!this.parameters.has(controller)) {
-            this.parameters.set(controller, new Map());
-        }
-        const methodParams = this.parameters.get(controller);
-        if (!methodParams.has(methodName)) {
-            methodParams.set(methodName, []);
-        }
-        methodParams.get(methodName).push(param);
+        const methodMap = getOrCreateMap(this.parameters, controller);
+        getOrCreateArray(methodMap, methodName).push(param);
     }
-    // Component registration — 3 levels
+    // Component registration — global
     static registerGlobal(type, component) {
-        this.global.get(type).add(component);
+        this.globalComponents[type].add(component);
     }
     static getGlobal(type) {
-        return this.global.get(type);
+        return this.globalComponents[type];
     }
+    // Component registration — controller-level
     static registerController(type, controller, component) {
-        const typeMap = this.controller.get(type);
-        if (!typeMap.has(controller)) {
-            typeMap.set(controller, []);
-        }
-        typeMap.get(controller).push(component);
+        const map = this.controllerComponents[type];
+        getOrCreateArray(map, controller).push(component);
     }
     static getController(type, controller) {
-        const typeMap = this.controller.get(type);
-        return typeMap.get(controller) || [];
+        const map = this.controllerComponents[type];
+        return map.get(controller) ?? [];
     }
-    static registerHandler(type, handlerKey, component) {
-        const typeMap = this.handler.get(type);
-        if (!typeMap.has(handlerKey)) {
-            typeMap.set(handlerKey, []);
-        }
-        typeMap.get(handlerKey).push(component);
+    // Component registration — handler-level
+    static registerHandler(type, controller, methodName, component) {
+        const map = this.handlerComponents[type];
+        const methodMap = getOrCreateMap(map, controller);
+        getOrCreateArray(methodMap, methodName).push(component);
     }
-    static getHandler(type, handlerKey) {
-        const typeMap = this.handler.get(type);
-        return typeMap.get(handlerKey) || [];
+    static getHandler(type, controller, methodName) {
+        const map = this.handlerComponents[type];
+        return map.get(controller)?.get(methodName) ?? [];
     }
     // DI metadata
     static markInjectable(target) {
@@ -178,12 +130,8 @@ export class MetadataRegistry {
     }
     // HTTP handler metadata
     static setHandlerHttpMeta(controller, method, meta) {
-        if (!this.handlerHttpMeta.has(controller)) {
-            this.handlerHttpMeta.set(controller, new Map());
-        }
-        const methodMap = this.handlerHttpMeta.get(controller);
+        const methodMap = getOrCreateMap(this.handlerHttpMeta, controller);
         const existing = methodMap.get(method) ?? {};
-        // Append-merge responseHeaders
         const merged = {
             ...existing,
             ...meta
@@ -211,79 +159,112 @@ export class MetadataRegistry {
     }
     // Route versions
     static setRouteVersion(controller, method, version) {
-        if (!this.routeVersions.has(controller)) {
-            this.routeVersions.set(controller, new Map());
-        }
-        this.routeVersions.get(controller).set(method, version);
+        getOrCreateMap(this.routeVersions, controller).set(method, version);
     }
     static getRouteVersion(controller, method) {
         return this.routeVersions.get(controller)?.get(method);
     }
-    // Custom metadata (SetMetadata)
+    // Custom class/handler metadata. One slot per (target, key) for class-level,
+    // (target, handler, key) for handler-level. The same slots back @SetMetadata,
+    // every feature decorator (@Cron, @OnEvent, @ApiDoc, …), the SWC shim, and
+    // external Reflect.defineMetadata calls — one model, one source of truth.
     static setCustomClassMeta(target, key, value) {
-        if (!this.customClassMeta.has(target)) {
-            this.customClassMeta.set(target, new Map());
-        }
-        this.customClassMeta.get(target).set(key, value);
+        getOrCreate(this.classMeta, target, ()=>new Map()).set(key, value);
     }
     static getCustomClassMeta(target, key) {
-        return this.customClassMeta.get(target)?.get(key);
+        return this.classMeta.get(target)?.get(key);
     }
     static getCustomClassMetaAll(target) {
-        return this.customClassMeta.get(target);
+        return this.classMeta.get(target);
     }
     static setCustomHandlerMeta(target, handler, key, value) {
-        if (!this.customHandlerMeta.has(target)) {
-            this.customHandlerMeta.set(target, new Map());
-        }
-        const handlerMap = this.customHandlerMeta.get(target);
-        if (!handlerMap.has(handler)) {
-            handlerMap.set(handler, new Map());
-        }
-        handlerMap.get(handler).set(key, value);
+        const byHandler = getOrCreate(this.handlerMeta, target, ()=>new Map());
+        getOrCreate(byHandler, handler, ()=>new Map()).set(key, value);
     }
     static getCustomHandlerMeta(target, handler, key) {
-        return this.customHandlerMeta.get(target)?.get(handler)?.get(key);
+        return this.handlerMeta.get(target)?.get(handler)?.get(key);
     }
     static getCustomHandlerMetaAll(target, handler) {
-        return this.customHandlerMeta.get(target)?.get(handler);
+        return this.handlerMeta.get(target)?.get(handler);
+    }
+    // Append helpers — for stackable metadata like @Cron / @Interval / @OnEvent / @ApiResponse.
+    static appendCustomClassMeta(target, key, item) {
+        const list = this.getCustomClassMeta(target, key) ?? [];
+        list.push(item);
+        this.setCustomClassMeta(target, key, list);
+    }
+    static appendCustomHandlerMeta(target, handler, key, item) {
+        const list = this.getCustomHandlerMeta(target, handler, key) ?? [];
+        list.push(item);
+        this.setCustomHandlerMeta(target, handler, key, list);
+    }
+    // Reflect-style API — same storage as the typed setters above. Lets external
+    // code (and the SWC shim's Reflect.metadata polyfill) write/read uniformly.
+    static setReflectMetadata(target, key, value, propertyKey) {
+        if (propertyKey !== undefined) {
+            this.setCustomHandlerMeta(target, propertyKey, key, value);
+        } else {
+            this.setCustomClassMeta(target, key, value);
+        }
+    }
+    static getReflectMetadata(target, key, propertyKey) {
+        if (propertyKey !== undefined) {
+            return this.getCustomHandlerMeta(target, propertyKey, key);
+        }
+        return this.getCustomClassMeta(target, key);
+    }
+    // SWC-emitted design:paramtypes — class-level for constructors, handler-level for methods.
+    static getParamTypes(target, propertyKey) {
+        return this.getReflectMetadata(target, 'design:paramtypes', propertyKey);
     }
     // Propagate all controller-level components from one class to another.
-    // Used by ModuleLoader to apply module-level decorators to every controller.
     static propagateControllerComponents(from, to) {
-        for (const [, typeMap] of this.controller.entries()){
-            const components = typeMap.get(from);
+        for (const type of [
+            'middleware',
+            'guard',
+            'pipe',
+            'interceptor',
+            'filter'
+        ]){
+            const map = this.controllerComponents[type];
+            const components = map.get(from);
             if (components && components.length > 0) {
-                if (!typeMap.has(to)) {
-                    typeMap.set(to, []);
-                }
-                typeMap.get(to).push(...components);
+                const target = getOrCreateArray(map, to);
+                target.push(...components);
             }
         }
     }
-    // Clear all (for testing)
+    // Clear app-time state. Decoration metadata persists — once a class is
+    // decorated, that fact is permanent for the lifetime of the process.
     static clear() {
+        this.globalComponents = emptyComponentStore();
+    }
+    // Full reset, including decoration metadata. Used in framework-internal scenarios.
+    static reset() {
         this.routes.clear();
         this.controllers.clear();
         this.controllerOptions.clear();
         this.modules.clear();
         this.parameters.clear();
-        for (const set of this.global.values()){
-            set.clear();
-        }
-        for (const map of this.controller.values()){
-            map.clear();
-        }
-        for (const map of this.handler.values()){
-            map.clear();
-        }
         this.injectables.clear();
         this.scopes.clear();
         this.injectTokens.clear();
         this.handlerHttpMeta.clear();
         this.catchTypes.clear();
         this.routeVersions.clear();
-        this.customClassMeta.clear();
-        this.customHandlerMeta.clear();
+        this.classMeta.clear();
+        this.handlerMeta.clear();
+        for (const type of [
+            'middleware',
+            'guard',
+            'pipe',
+            'interceptor',
+            'filter'
+        ]){
+            this.controllerComponents[type].clear();
+            this.handlerComponents[type].clear();
+        }
+        this.globalComponents = emptyComponentStore();
+    // reflectMeta is a WeakMap — entries die with their targets.
     }
 }

package/dist/registry/paths.d.ts

@@ -0,0 +1,3 @@
+export declare function normalizePath(path: string): string;
+export declare function joinPaths(prefix: string, path: string): string;
+export declare function toOpenApiPath(path: string): string;

package/dist/registry/paths.js

@@ -0,0 +1,15 @@
+// Single home for path manipulation. Used by route building, openapi docs,
+// and decorator metadata.
+export function normalizePath(path) {
+    if (!path) return path;
+    return path.startsWith('/') ? path : `/${path}`;
+}
+export function joinPaths(prefix, path) {
+    const cleanPrefix = prefix.endsWith('/') ? prefix.slice(0, -1) : prefix;
+    const cleanPath = path && !path.startsWith('/') ? `/${path}` : path;
+    return `${cleanPrefix}${cleanPath}` || '/';
+}
+// Convert ':id' Hono syntax to '{id}' OpenAPI syntax.
+export function toOpenApiPath(path) {
+    return path.replace(/:([a-zA-Z_][a-zA-Z0-9_]*)/g, '{$1}');
+}

package/dist/registry/types.d.ts

@@ -1,7 +1,7 @@
 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;
+import type { Constructor, ForwardRef, InjectionToken, ProviderOptions, Token, Type } from '../container/types';
+export type { Constructor, ForwardRef, InjectionToken, ProviderOptions, Token, Type };
 export type ComponentType = 'middleware' | 'guard' | 'pipe' | 'interceptor' | 'filter';
 export type MiddlewareType = Type<NestMiddleware> | NestMiddleware;
 export type GuardType = Type<CanActivate> | CanActivate;
@@ -37,21 +37,31 @@ export interface HttpHandlerMeta {
         statusCode: number;
     };
 }
+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 {
-    imports?: unknown[];
     providers?: Array<Type | ProviderOptions>;
     controllers?: Type[];
-    exports?: Array<Type | InjectionTokenLike>;
+    imports?: ModuleImport[];
+    exports?: Array<Type | InjectionToken>;
     isGlobal?: boolean;
 }
-export interface InjectionTokenLike {
-    toString(): string;
-}
-export interface ProviderOptions<T = unknown> {
-    token?: unknown;
-    scope?: string;
-    useValue?: T;
-    useFactory?: (...args: unknown[]) => T | Promise<T>;
-    inject?: unknown[];
-    useExisting?: unknown;
+export interface ModuleMetadata {
+    providers: Array<Type | ProviderOptions>;
+    controllers: Type[];
+    imports: ModuleImport[];
+    exports: Array<Type | InjectionToken>;
+    isGlobal: boolean;
 }

package/dist/registry/types.js

@@ -1,2 +1 @@
-// Forward-compatible with ProviderOptions
 export { };

package/dist/registry/util.d.ts

@@ -0,0 +1,3 @@
+export declare function getOrCreate<K, V>(map: Map<K, V>, key: K, factory: () => V): V;
+export declare const getOrCreateMap: <K, NK, NV>(map: Map<K, Map<NK, NV>>, key: K) => Map<NK, NV>;
+export declare const getOrCreateArray: <K, V>(map: Map<K, V[]>, key: K) => V[];

package/dist/registry/util.js

@@ -0,0 +1,8 @@
+// Single map.get + optional set. Replaces `map.has(key) || map.set(key, …); map.get(key)!` patterns.
+export function getOrCreate(map, key, factory) {
+    let v = map.get(key);
+    if (v === undefined) map.set(key, v = factory());
+    return v;
+}
+export const getOrCreateMap = (map, key)=>getOrCreate(map, key, ()=>new Map());
+export const getOrCreateArray = (map, key)=>getOrCreate(map, key, ()=>[]);