@velajs/vela 0.4.2 → 0.5.0

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,8 +29,8 @@ export class OverrideBy {
         this.builder['addOverride']({
             token: this.token,
             provider: {
-                token: this.token,
-                useFactory: ()=>new cls()
+                provide: this.token,
+                useClass: cls
             }
         });
         return this.builder;
@@ -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
@@ -102,24 +102,38 @@ export class TestingModuleBuilder {
         ComponentManager.init(container);
         const loader = new ModuleLoader(container, routeManager);
         loader.load(TestRootModule);
-        // Resolve APP_* tokens
-        if (container.has(APP_GUARD)) {
-            routeManager.useGlobalGuards(container.resolve(APP_GUARD));
+        const appGuards = loader.getAppProviderTokens(APP_GUARD);
+        if (appGuards.length > 0) {
+            routeManager.useGlobalGuardTokens(...appGuards);
+        } else if (container.has(APP_GUARD)) {
+            routeManager.useGlobalGuardTokens(APP_GUARD);
         }
-        if (container.has(APP_PIPE)) {
-            routeManager.useGlobalPipes(container.resolve(APP_PIPE));
+        const appPipes = loader.getAppProviderTokens(APP_PIPE);
+        if (appPipes.length > 0) {
+            routeManager.useGlobalPipeTokens(...appPipes);
+        } else if (container.has(APP_PIPE)) {
+            routeManager.useGlobalPipeTokens(APP_PIPE);
         }
-        if (container.has(APP_INTERCEPTOR)) {
-            routeManager.useGlobalInterceptors(container.resolve(APP_INTERCEPTOR));
+        const appInterceptors = loader.getAppProviderTokens(APP_INTERCEPTOR);
+        if (appInterceptors.length > 0) {
+            routeManager.useGlobalInterceptorTokens(...appInterceptors);
+        } else if (container.has(APP_INTERCEPTOR)) {
+            routeManager.useGlobalInterceptorTokens(APP_INTERCEPTOR);
         }
-        if (container.has(APP_FILTER)) {
-            routeManager.useGlobalFilters(container.resolve(APP_FILTER));
+        const appFilters = loader.getAppProviderTokens(APP_FILTER);
+        if (appFilters.length > 0) {
+            routeManager.useGlobalFilterTokens(...appFilters);
+        } else if (container.has(APP_FILTER)) {
+            routeManager.useGlobalFilterTokens(APP_FILTER);
         }
-        if (container.has(APP_MIDDLEWARE)) {
-            routeManager.useGlobalMiddleware(container.resolve(APP_MIDDLEWARE));
+        const appMiddleware = loader.getAppProviderTokens(APP_MIDDLEWARE);
+        if (appMiddleware.length > 0) {
+            routeManager.useGlobalMiddlewareTokens(...appMiddleware);
+        } else if (container.has(APP_MIDDLEWARE)) {
+            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.2",
+  "version": "0.5.0",
   "description": "NestJS-compatible framework for edge runtimes, powered by Hono",
   "type": "module",
   "main": "./dist/index.js",