@velajs/vela 0.4.3 → 0.5.1

package/dist/module/decorators.js

@@ -1,32 +1,48 @@
 import { METADATA_KEYS } from "../constants.js";
-import { getMetadata } from "../metadata.js";
+import { defineMetadata, getMetadata } from "../metadata.js";
 import { MetadataRegistry } from "../registry/metadata.registry.js";
-export function Module(options = {}) {
+export function Global() {
     // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
     return (target)=>{
+        const existing = MetadataRegistry.getModuleOptions(target);
         MetadataRegistry.setModuleOptions(target, {
+            ...existing,
+            isGlobal: true
+        });
+    };
+}
+export function Module(options = {}) {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+    return (target)=>{
+        const normalized = {
             imports: options.imports,
             providers: options.providers,
             controllers: options.controllers,
-            exports: options.exports
-        });
+            exports: options.exports,
+            isGlobal: options.isGlobal
+        };
+        // WeakMap store survives MetadataRegistry.clear() — needed for framework modules
+        // decorated at import time (e.g. HttpModule, CorsModule).
+        defineMetadata(METADATA_KEYS.MODULE_OPTIONS, normalized, target);
+        MetadataRegistry.setModuleOptions(target, normalized);
     };
 }
 export function isModule(target) {
-    return MetadataRegistry.getModuleOptions(target) !== undefined || getMetadata(METADATA_KEYS.MODULE, target) === true;
+    return MetadataRegistry.getModuleOptions(target) !== undefined || getMetadata(METADATA_KEYS.MODULE, target) === true || getMetadata(METADATA_KEYS.MODULE_OPTIONS, target) !== undefined;
 }
 export function getModuleMetadata(target) {
     if (!isModule(target)) {
         return undefined;
     }
-    const options = MetadataRegistry.getModuleOptions(target);
-    if (!options) {
+    const options = MetadataRegistry.getModuleOptions(target) ?? getMetadata(METADATA_KEYS.MODULE_OPTIONS, target);
+    if (!options || typeof options !== 'object') {
         return undefined;
     }
     return {
         providers: options.providers ?? [],
         controllers: options.controllers ?? [],
         imports: options.imports ?? [],
-        exports: options.exports ?? []
+        exports: options.exports ?? [],
+        isGlobal: options.isGlobal === true
     };
 }

package/dist/module/index.d.ts

@@ -1,3 +1,3 @@
-export { Module, isModule, getModuleMetadata } from './decorators';
+export { Global, Module, isModule, getModuleMetadata } from './decorators';
 export { ModuleLoader } from './module-loader';
-export type { ModuleOptions, ModuleMetadata, DynamicModule } from './types';
+export type { ModuleOptions, ModuleMetadata, DynamicModule, AsyncModuleOptions, ModuleImport } from './types';

package/dist/module/index.js

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

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

@@ -1,5 +1,6 @@
 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;
@@ -9,6 +10,8 @@ export declare class ModuleLoader {
     private collectedControllers;
     private registeredProviders;
     private moduleExportsCache;
+    private globalExports;
+    private consumerMiddlewareDefinitions;
     private appProviderCounter;
     private appProviderTokens;
     constructor(container: Container, router: RouteManager);
@@ -20,5 +23,6 @@ export declare class ModuleLoader {
     getControllers(): Type[];
     getRegisteredProviders(): Token[];
     getAppProviderTokens(token: Token): Token[];
-    resolveAllInstances(): unknown[];
+    getConsumerMiddlewareDefinitions(): MiddlewareRouteDefinition[];
+    resolveAllInstances(): Promise<unknown[]>;
 }

package/dist/module/module-loader.js

@@ -1,6 +1,8 @@
 import { Scope } from "../constants.js";
-import { InjectionToken } from "../container/types.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 { getModuleMetadata, isModule } from "./decorators.js";
 function isDynamicModule(value) {
     return typeof value === 'object' && value !== null && 'module' in value && typeof value.module === 'function';
@@ -13,6 +15,8 @@ export class ModuleLoader {
     collectedControllers = [];
     registeredProviders = [];
     moduleExportsCache = new Map();
+    globalExports = new Set();
+    consumerMiddlewareDefinitions = [];
     appProviderCounter = 0;
     appProviderTokens = new Map([
         [
@@ -47,12 +51,14 @@ export class ModuleLoader {
         }
     }
     processModule(moduleClassOrDynamic) {
-        // Handle dynamic modules ({ module, controllers, providers })
+        // Handle dynamic modules ({ module, imports, controllers, providers })
         let moduleClass;
+        let extraImports = [];
         let extraControllers = [];
         let extraProviders = [];
         if (isDynamicModule(moduleClassOrDynamic)) {
             moduleClass = moduleClassOrDynamic.module;
+            extraImports = moduleClassOrDynamic.imports ?? [];
             extraControllers = moduleClassOrDynamic.controllers ?? [];
             extraProviders = moduleClassOrDynamic.providers ?? [];
         } else {
@@ -83,8 +89,20 @@ export class ModuleLoader {
         }
         this.processingStack.add(moduleClass);
         try {
-            const importedProviders = new Set();
-            for (const importedModule of metadata.imports){
+            const importedProviders = new Set(this.globalExports);
+            for (const entry of [
+                ...metadata.imports,
+                ...extraImports
+            ]){
+                // Unwrap forwardRef(() => Module) — resolves lazy circular references
+                const isForwardRef = entry instanceof ForwardRef;
+                const importedModule = isForwardRef ? entry.factory() : entry;
+                const importedModuleClass = isDynamicModule(importedModule) ? importedModule.module : importedModule;
+                // If this forwardRef-wrapped import is currently being processed, skip it to
+                // break the circular chain. Non-forwardRef circular imports still throw.
+                if (isForwardRef && this.processingStack.has(importedModuleClass)) {
+                    continue;
+                }
                 const exportedTokens = this.processModule(importedModule);
                 for (const token of exportedTokens){
                     importedProviders.add(token);
@@ -108,9 +126,30 @@ export class ModuleLoader {
                     this.collectedControllers.push(controller);
                 }
             }
+            // Propagate module-level Use* decorators (@UseGuards, @UseInterceptors, etc.) to each controller
+            for (const controller of allControllers){
+                MetadataRegistry.propagateControllerComponents(moduleClass, controller);
+            }
             this.processedModules.add(moduleClass);
             const exports = this.buildExportSet(metadata.exports, allProviders, importedProviders);
             this.moduleExportsCache.set(moduleClass, exports);
+            const isGlobal = metadata.isGlobal || isDynamicModule(moduleClassOrDynamic) && moduleClassOrDynamic.global === true;
+            if (isGlobal) {
+                for (const token of exports){
+                    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
+                }
+            }
             return exports;
         } finally{
             this.processingStack.delete(moduleClass);
@@ -123,7 +162,7 @@ export class ModuleLoader {
                 this.registeredProviders.push(provider);
             }
         } else {
-            const token = provider.token;
+            const token = provider.provide;
             if (!token) {
                 this.container.register(provider);
                 return;
@@ -132,7 +171,7 @@ export class ModuleLoader {
                 const syntheticToken = new InjectionToken(`${token.toString()}:${this.appProviderCounter++}`);
                 this.container.register({
                     ...provider,
-                    token: syntheticToken
+                    provide: syntheticToken
                 });
                 this.registeredProviders.push(syntheticToken);
                 this.appProviderTokens.get(token).push(syntheticToken);
@@ -154,7 +193,7 @@ export class ModuleLoader {
                 if (typeof p === 'function') {
                     return p === exported;
                 }
-                return p.token === exported;
+                return p.provide === exported;
             });
             const isImportedProvider = importedProviders.has(exported);
             if (!isLocalProvider && !isImportedProvider) {
@@ -180,14 +219,19 @@ export class ModuleLoader {
             ...this.appProviderTokens.get(token) ?? []
         ];
     }
-    resolveAllInstances() {
+    getConsumerMiddlewareDefinitions() {
+        return [
+            ...this.consumerMiddlewareDefinitions
+        ];
+    }
+    async resolveAllInstances() {
         const instances = [];
         for (const token of this.registeredProviders){
             try {
                 if (this.container.getProviderScope(token) === Scope.REQUEST) {
                     continue;
                 }
-                const instance = this.container.resolve(token);
+                const instance = await this.container.resolveAsync(token);
                 instances.push(instance);
             } catch  {
             // Skip unresolvable tokens
@@ -198,7 +242,7 @@ export class ModuleLoader {
                 if (this.container.getProviderScope(controller) === Scope.REQUEST) {
                     continue;
                 }
-                const instance = this.container.resolve(controller);
+                const instance = await this.container.resolveAsync(controller);
                 if (!instances.includes(instance)) {
                     instances.push(instance);
                 }

package/dist/module/types.d.ts

@@ -1,19 +1,29 @@
-import type { InjectionToken, ProviderOptions, Type } from '../container/types';
+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?: Array<Type | DynamicModule>;
+    imports?: ModuleImport[];
     exports?: Array<Type | InjectionToken>;
+    isGlobal?: boolean;
 }
 export interface ModuleMetadata {
     providers: Array<Type | ProviderOptions>;
     controllers: Type[];
-    imports: Array<Type | DynamicModule>;
+    imports: ModuleImport[];
     exports: Array<Type | InjectionToken>;
+    isGlobal: boolean;
 }

package/dist/pipeline/index.d.ts

@@ -3,5 +3,6 @@ export { UseMiddleware, UseGuards, UsePipes, UseInterceptors, UseFilters, Catch,
 export { SetMetadata, Reflector } from './reflector';
 export type { ReflectableDecorator, CreateDecoratorOptions } from './reflector';
 export { APP_GUARD, APP_PIPE, APP_INTERCEPTOR, APP_FILTER, APP_MIDDLEWARE } from './tokens';
-export { ParseIntPipe, ParseFloatPipe, ParseBoolPipe, DefaultValuePipe, RequiredPipe, ZodValidationPipe, } from './pipes';
-export type { ExecutionContext, CanActivate, CallHandler, NestInterceptor, NestMiddleware, PipeTransform, ExceptionFilter, ArgumentMetadata, } from './types';
+export { ParseIntPipe, ParseFloatPipe, ParseBoolPipe, ParseUUIDPipe, ParseEnumPipe, ParseArrayPipe, DefaultValuePipe, RequiredPipe, ZodValidationPipe, } from './pipes';
+export type { ParseUUIDPipeOptions, ParseArrayPipeOptions } from './pipes';
+export type { HttpArgumentsHost, ExecutionContext, CanActivate, CallHandler, NestInterceptor, NestMiddleware, PipeTransform, ExceptionFilter, ArgumentMetadata, } from './types';

package/dist/pipeline/index.js

@@ -2,4 +2,4 @@ export { ComponentManager } from "./component.manager.js";
 export { UseMiddleware, UseGuards, UsePipes, UseInterceptors, UseFilters, Catch, getCatchTypes, shouldFilterCatch } from "./decorators.js";
 export { SetMetadata, Reflector } from "./reflector.js";
 export { APP_GUARD, APP_PIPE, APP_INTERCEPTOR, APP_FILTER, APP_MIDDLEWARE } from "./tokens.js";
-export { ParseIntPipe, ParseFloatPipe, ParseBoolPipe, DefaultValuePipe, RequiredPipe, ZodValidationPipe } from "./pipes.js";
+export { ParseIntPipe, ParseFloatPipe, ParseBoolPipe, ParseUUIDPipe, ParseEnumPipe, ParseArrayPipe, DefaultValuePipe, RequiredPipe, ZodValidationPipe } from "./pipes.js";

package/dist/pipeline/pipes.d.ts

@@ -23,3 +23,25 @@ export declare class ZodValidationPipe implements PipeTransform {
     });
     transform(value: unknown, _metadata: ArgumentMetadata): unknown;
 }
+export interface ParseUUIDPipeOptions {
+    version?: '3' | '4' | '5';
+}
+export declare class ParseUUIDPipe implements PipeTransform<string, string> {
+    private readonly options?;
+    constructor(options?: ParseUUIDPipeOptions | undefined);
+    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;
+    constructor(enumType: T);
+    transform(value: string, metadata: ArgumentMetadata): T[keyof T];
+}
+export interface ParseArrayPipeOptions {
+    separator?: string;
+    optional?: boolean;
+}
+export declare class ParseArrayPipe implements PipeTransform {
+    private readonly options?;
+    constructor(options?: ParseArrayPipeOptions | undefined);
+    transform(value: unknown, metadata: ArgumentMetadata): unknown[];
+}

package/dist/pipeline/pipes.js

@@ -50,3 +50,53 @@ export class ZodValidationPipe {
         return this.schema.parse(value);
     }
 }
+const UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const UUID_VERSION_REGEX = {
+    '3': /^[0-9a-f]{8}-[0-9a-f]{4}-3[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i,
+    '4': /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i,
+    '5': /^[0-9a-f]{8}-[0-9a-f]{4}-5[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i
+};
+export class ParseUUIDPipe {
+    options;
+    constructor(options){
+        this.options = options;
+    }
+    transform(value, metadata) {
+        const regex = this.options?.version ? UUID_VERSION_REGEX[this.options.version] : UUID_REGEX;
+        if (!regex.test(value)) {
+            throw new BadRequestException(`Validation failed (uuid${this.options?.version ? ` v${this.options.version}` : ''} expected)${metadata.data ? ` for parameter '${metadata.data}'` : ''}`);
+        }
+        return value;
+    }
+}
+export class ParseEnumPipe {
+    enumType;
+    constructor(enumType){
+        this.enumType = enumType;
+    }
+    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}'` : ''}`);
+        }
+        return value;
+    }
+}
+export class ParseArrayPipe {
+    options;
+    constructor(options){
+        this.options = options;
+    }
+    transform(value, metadata) {
+        if (value === undefined || value === null || value === '') {
+            if (this.options?.optional) return [];
+            throw new BadRequestException(`Validation failed (array expected)${metadata.data ? ` for parameter '${metadata.data}'` : ''}`);
+        }
+        if (Array.isArray(value)) return value;
+        if (typeof value === 'string') {
+            const sep = this.options?.separator ?? ',';
+            return value.split(sep).map((v)=>v.trim()).filter((v)=>v.length > 0);
+        }
+        throw new BadRequestException(`Validation failed (array expected)${metadata.data ? ` for parameter '${metadata.data}'` : ''}`);
+    }
+}

package/dist/pipeline/tokens.d.ts

@@ -8,7 +8,7 @@ import type { CanActivate, ExceptionFilter, NestInterceptor, NestMiddleware, Pip
  * @Module({
  *   providers: [
  *     AuthGuard,
- *     { token: APP_GUARD, useClass: AuthGuard },
+ *     { provide: APP_GUARD, useClass: AuthGuard },
  *   ],
  * })
  * class AppModule {}

package/dist/pipeline/tokens.js

@@ -7,7 +7,7 @@ import { InjectionToken } from "../container/types.js";
  * @Module({
  *   providers: [
  *     AuthGuard,
- *     { token: APP_GUARD, useClass: AuthGuard },
+ *     { provide: APP_GUARD, useClass: AuthGuard },
  *   ],
  * })
  * class AppModule {}

package/dist/pipeline/types.d.ts

@@ -1,10 +1,26 @@
 import type { Context } from 'hono';
 import type { Type } from '../container/types';
+/**
+ * HTTP-specific arguments host returned by `ExecutionContext.switchToHttp()`.
+ * In Vela/Hono, the `Context` object holds both request and response state.
+ *
+ * - `getRequest()` — the Web `Request` object
+ * - `getResponse()` — the Hono `Context` (use `c.header()`, `c.setCookie()`, etc.)
+ */
+export interface HttpArgumentsHost {
+    getRequest<T = Request>(): T;
+    getResponse<T = Context>(): T;
+}
 export interface ExecutionContext {
+    getType<T extends string = 'http'>(): T;
     getClass(): Type;
     getHandler(): string | symbol;
+    /** Returns the Hono `Context` directly. */
     getContext<T = Context>(): T;
+    /** Shorthand for `switchToHttp().getRequest()` — returns the Web `Request`. */
     getRequest(): Request;
+    /** Switch to the HTTP arguments host for NestJS-style `getRequest()` / `getResponse()` access. */
+    switchToHttp(): HttpArgumentsHost;
 }
 export interface CanActivate {
     canActivate(context: ExecutionContext): boolean | Promise<boolean>;

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

@@ -38,12 +38,12 @@ export declare class MetadataRegistry {
     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 markInjectable(target: Constructor): void;
-    static hasInjectable(target: Constructor): boolean;
-    static setScope(target: Constructor, scope: Scope): void;
-    static getScope(target: Constructor): Scope | undefined;
-    static setInjectTokens(target: Constructor, tokens: InjectMetadata[]): void;
-    static getInjectTokens(target: Constructor): InjectMetadata[] | undefined;
+    static markInjectable(target: object): void;
+    static hasInjectable(target: object): boolean;
+    static setScope(target: object, scope: Scope): void;
+    static getScope(target: object): Scope | undefined;
+    static setInjectTokens(target: object, tokens: InjectMetadata[]): void;
+    static getInjectTokens(target: object): InjectMetadata[] | undefined;
     static setHandlerHttpMeta(controller: Constructor, method: string | symbol, meta: HttpHandlerMeta): void;
     static getHandlerHttpMeta(controller: Constructor, method: string | symbol): HttpHandlerMeta | undefined;
     static setCatchTypes(filter: Constructor, types: Type<Error>[]): void;
@@ -57,5 +57,6 @@ export declare class MetadataRegistry {
     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 propagateControllerComponents(from: Constructor, to: Constructor): void;
     static clear(): void;
 }

package/dist/registry/metadata.registry.js

@@ -248,6 +248,19 @@ export class MetadataRegistry {
     static getCustomHandlerMetaAll(target, handler) {
         return this.customHandlerMeta.get(target)?.get(handler);
     }
+    // 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);
+            if (components && components.length > 0) {
+                if (!typeMap.has(to)) {
+                    typeMap.set(to, []);
+                }
+                typeMap.get(to).push(...components);
+            }
+        }
+    }
     // Clear all (for testing)
     static clear() {
         this.routes.clear();

package/dist/registry/types.d.ts

@@ -41,6 +41,7 @@ export interface ModuleOptions {
     providers?: Array<Type | ProviderOptions>;
     controllers?: Type[];
     exports?: Array<Type | InjectionTokenLike>;
+    isGlobal?: boolean;
 }
 export interface InjectionTokenLike {
     toString(): string;

package/dist/schedule/schedule.module.d.ts

@@ -1,5 +1,8 @@
-import type { DynamicModule } from '../module/types';
+import type { AsyncModuleOptions, DynamicModule } from '../module/types';
 import type { ScheduleModuleOptions } from './schedule.types';
 export declare class ScheduleModule {
     static forRoot(options?: ScheduleModuleOptions): DynamicModule;
+    static forRootAsync(options: AsyncModuleOptions<ScheduleModuleOptions> & {
+        enableTimers?: boolean;
+    }): DynamicModule;
 }

package/dist/schedule/schedule.module.js

@@ -4,18 +4,22 @@ import { MetadataRegistry } from "../registry/metadata.registry.js";
 import { ScheduleExecutor } from "./schedule.executor.js";
 import { ScheduleRegistry } from "./schedule.registry.js";
 import { SCHEDULE_MODULE_OPTIONS } from "./schedule.tokens.js";
+function makeScheduleModuleClass() {
+    const moduleClass = class ScheduleDynamicModule {
+    };
+    Object.defineProperty(moduleClass, 'name', {
+        value: 'ScheduleModule'
+    });
+    defineMetadata(METADATA_KEYS.MODULE, true, moduleClass);
+    return moduleClass;
+}
 export class ScheduleModule {
     static forRoot(options = {}) {
         const { enableTimers = false } = options;
-        const moduleClass = class ScheduleDynamicModule {
-        };
-        Object.defineProperty(moduleClass, 'name', {
-            value: 'ScheduleModule'
-        });
-        defineMetadata(METADATA_KEYS.MODULE, true, moduleClass);
+        const moduleClass = makeScheduleModuleClass();
         const providers = [
             {
-                token: SCHEDULE_MODULE_OPTIONS,
+                provide: SCHEDULE_MODULE_OPTIONS,
                 useValue: options
             },
             ScheduleRegistry
@@ -36,4 +40,32 @@ export class ScheduleModule {
             providers
         };
     }
+    static forRootAsync(options) {
+        const { enableTimers = false } = options;
+        const moduleClass = makeScheduleModuleClass();
+        const providers = [
+            {
+                provide: SCHEDULE_MODULE_OPTIONS,
+                useFactory: options.useFactory,
+                inject: options.inject ?? []
+            },
+            ScheduleRegistry
+        ];
+        const exports = [
+            SCHEDULE_MODULE_OPTIONS,
+            ScheduleRegistry
+        ];
+        if (enableTimers) {
+            providers.push(ScheduleExecutor);
+            exports.push(ScheduleExecutor);
+        }
+        MetadataRegistry.setModuleOptions(moduleClass, {
+            imports: options.imports ?? [],
+            exports
+        });
+        return {
+            module: moduleClass,
+            providers
+        };
+    }
 }

package/dist/testing/testing.builder.js

@@ -19,7 +19,7 @@ export class OverrideBy {
         this.builder['addOverride']({
             token: this.token,
             provider: {
-                token: this.token,
+                provide: this.token,
                 useValue: value
             }
         });
@@ -29,7 +29,7 @@ export class OverrideBy {
         this.builder['addOverride']({
             token: this.token,
             provider: {
-                token: this.token,
+                provide: this.token,
                 useClass: cls
             }
         });
@@ -39,7 +39,7 @@ export class OverrideBy {
         this.builder['addOverride']({
             token: this.token,
             provider: {
-                token: this.token,
+                provide: this.token,
                 useFactory: options.factory,
                 inject: options.inject
             }
@@ -91,7 +91,7 @@ export class TestingModuleBuilder {
         // Bootstrap (mirrors VelaFactory.create)
         const container = new Container();
         container.register({
-            token: Container,
+            provide: Container,
             useValue: container
         });
         // Register overrides BEFORE module loading so ModuleLoader skips originals
@@ -133,7 +133,7 @@ export class TestingModuleBuilder {
             routeManager.useGlobalMiddlewareTokens(APP_MIDDLEWARE);
         }
         const app = new VelaApplication(container, routeManager);
-        const instances = loader.resolveAllInstances();
+        const instances = await loader.resolveAllInstances();
         app.setInstances(instances);
         await app.callOnModuleInit();
         await app.callOnApplicationBootstrap();

package/dist/throttler/throttler.module.d.ts

@@ -1,5 +1,6 @@
-import type { DynamicModule } from '../module/types';
+import type { AsyncModuleOptions, DynamicModule } from '../module/types';
 import type { ThrottlerModuleOptions } from './throttler.types';
 export declare class ThrottlerModule {
     static forRoot(options: ThrottlerModuleOptions): DynamicModule;
+    static forRootAsync(options: AsyncModuleOptions<ThrottlerModuleOptions>): DynamicModule;
 }