@velajs/vela 0.4.3 → 0.5.0

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;
 }

package/dist/throttler/throttler.module.js

@@ -5,14 +5,18 @@ import { APP_GUARD } from "../pipeline/tokens.js";
 import { ThrottlerGuard } from "./throttler.guard.js";
 import { ThrottlerStorage } from "./throttler.storage.js";
 import { THROTTLER_OPTIONS, THROTTLER_STORAGE } from "./throttler.tokens.js";
+function makeThrottlerModuleClass() {
+    const moduleClass = class ThrottlerDynamicModule {
+    };
+    Object.defineProperty(moduleClass, 'name', {
+        value: 'ThrottlerModule'
+    });
+    defineMetadata(METADATA_KEYS.MODULE, true, moduleClass);
+    return moduleClass;
+}
 export class ThrottlerModule {
     static forRoot(options) {
-        const moduleClass = class ThrottlerDynamicModule {
-        };
-        Object.defineProperty(moduleClass, 'name', {
-            value: 'ThrottlerModule'
-        });
-        defineMetadata(METADATA_KEYS.MODULE, true, moduleClass);
+        const moduleClass = makeThrottlerModuleClass();
         MetadataRegistry.setModuleOptions(moduleClass, {
             exports: [
                 THROTTLER_OPTIONS,
@@ -22,16 +26,50 @@ export class ThrottlerModule {
         });
         const providers = [
             {
-                token: THROTTLER_OPTIONS,
+                provide: THROTTLER_OPTIONS,
                 useValue: options
             },
             {
-                token: THROTTLER_STORAGE,
+                provide: THROTTLER_STORAGE,
                 useValue: options.storage ?? new ThrottlerStorage()
             },
             ThrottlerGuard,
             {
-                token: APP_GUARD,
+                provide: APP_GUARD,
+                useExisting: ThrottlerGuard
+            }
+        ];
+        return {
+            module: moduleClass,
+            providers
+        };
+    }
+    static forRootAsync(options) {
+        const moduleClass = makeThrottlerModuleClass();
+        MetadataRegistry.setModuleOptions(moduleClass, {
+            imports: options.imports ?? [],
+            exports: [
+                THROTTLER_OPTIONS,
+                THROTTLER_STORAGE,
+                ThrottlerGuard
+            ]
+        });
+        const providers = [
+            {
+                provide: THROTTLER_OPTIONS,
+                useFactory: options.useFactory,
+                inject: options.inject ?? []
+            },
+            {
+                provide: THROTTLER_STORAGE,
+                useFactory: (opts)=>opts.storage ?? new ThrottlerStorage(),
+                inject: [
+                    THROTTLER_OPTIONS
+                ]
+            },
+            ThrottlerGuard,
+            {
+                provide: APP_GUARD,
                 useExisting: ThrottlerGuard
             }
         ];

package/package.json

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