@velajs/vela 0.4.2 → 0.5.0

package/dist/module/module-loader.js

@@ -1,3 +1,8 @@
+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 { getModuleMetadata, isModule } from "./decorators.js";
 function isDynamicModule(value) {
     return typeof value === 'object' && value !== null && 'module' in value && typeof value.module === 'function';
@@ -10,6 +15,31 @@ export class ModuleLoader {
     collectedControllers = [];
     registeredProviders = [];
     moduleExportsCache = new Map();
+    globalExports = new Set();
+    consumerMiddlewareDefinitions = [];
+    appProviderCounter = 0;
+    appProviderTokens = new Map([
+        [
+            APP_GUARD,
+            []
+        ],
+        [
+            APP_PIPE,
+            []
+        ],
+        [
+            APP_INTERCEPTOR,
+            []
+        ],
+        [
+            APP_FILTER,
+            []
+        ],
+        [
+            APP_MIDDLEWARE,
+            []
+        ]
+    ]);
     constructor(container, router){
         this.container = container;
         this.router = router;
@@ -21,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 {
@@ -57,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);
@@ -82,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);
@@ -97,15 +162,30 @@ export class ModuleLoader {
                 this.registeredProviders.push(provider);
             }
         } else {
-            const token = provider.token;
-            if (token && !this.container.has(token)) {
+            const token = provider.provide;
+            if (!token) {
                 this.container.register(provider);
-                this.registeredProviders.push(token);
-            } else if (!token) {
+                return;
+            }
+            if (this.isAppToken(token)) {
+                const syntheticToken = new InjectionToken(`${token.toString()}:${this.appProviderCounter++}`);
+                this.container.register({
+                    ...provider,
+                    provide: syntheticToken
+                });
+                this.registeredProviders.push(syntheticToken);
+                this.appProviderTokens.get(token).push(syntheticToken);
+                return;
+            }
+            if (!this.container.has(token)) {
                 this.container.register(provider);
+                this.registeredProviders.push(token);
             }
         }
     }
+    isAppToken(token) {
+        return token === APP_GUARD || token === APP_PIPE || token === APP_INTERCEPTOR || token === APP_FILTER || token === APP_MIDDLEWARE;
+    }
     buildExportSet(exports, providers, importedProviders) {
         const exportSet = new Set();
         for (const exported of exports){
@@ -113,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) {
@@ -134,11 +214,24 @@ export class ModuleLoader {
             ...this.registeredProviders
         ];
     }
-    resolveAllInstances() {
+    getAppProviderTokens(token) {
+        return [
+            ...this.appProviderTokens.get(token) ?? []
+        ];
+    }
+    getConsumerMiddlewareDefinitions() {
+        return [
+            ...this.consumerMiddlewareDefinitions
+        ];
+    }
+    async resolveAllInstances() {
         const instances = [];
         for (const token of this.registeredProviders){
             try {
-                const instance = this.container.resolve(token);
+                if (this.container.getProviderScope(token) === Scope.REQUEST) {
+                    continue;
+                }
+                const instance = await this.container.resolveAsync(token);
                 instances.push(instance);
             } catch  {
             // Skip unresolvable tokens
@@ -146,7 +239,10 @@ export class ModuleLoader {
         }
         for (const controller of this.collectedControllers){
             try {
-                const instance = this.container.resolve(controller);
+                if (this.container.getProviderScope(controller) === Scope.REQUEST) {
+                    continue;
+                }
+                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.executor.d.ts

@@ -2,10 +2,19 @@ import type { OnApplicationBootstrap, OnModuleDestroy } from '../lifecycle/index
 import { ScheduleRegistry } from './schedule.registry';
 export declare class ScheduleExecutor implements OnApplicationBootstrap, OnModuleDestroy {
     private registry;
-    private timers;
+    private intervalTimers;
+    private cronTimers;
+    private cronMatcherCache;
+    private lastCronMinute;
     private running;
     constructor(registry: ScheduleRegistry);
     onApplicationBootstrap(): void;
-    private scheduleNext;
+    private scheduleInterval;
+    private scheduleCron;
+    private invoke;
+    private getCronMatcher;
+    private parseField;
+    private parseRange;
+    private parseCronNumber;
     onModuleDestroy(): void;
 }

package/dist/schedule/schedule.executor.js

@@ -11,38 +11,153 @@ import { Injectable } from "../container/index.js";
 import { ScheduleRegistry } from "./schedule.registry.js";
 export class ScheduleExecutor {
     registry;
-    timers = [];
+    intervalTimers = [];
+    cronTimers = [];
+    cronMatcherCache = new Map();
+    lastCronMinute = new Map();
     running = true;
     constructor(registry){
         this.registry = registry;
     }
     onApplicationBootstrap() {
-        const jobs = this.registry.getIntervalJobs();
-        for (const job of jobs){
-            this.scheduleNext(job.instance, job.methodName, job.ms);
+        const intervalJobs = this.registry.getIntervalJobs();
+        const cronJobs = this.registry.getCronJobs();
+        for (const job of intervalJobs){
+            this.scheduleInterval(job.instance, job.methodName, job.ms);
+        }
+        for(let i = 0; i < cronJobs.length; i++){
+            const job = cronJobs[i];
+            this.scheduleCron(job.instance, job.methodName, job.expression, i);
         }
     }
-    scheduleNext(instance, methodName, ms) {
+    scheduleInterval(instance, methodName, ms) {
         if (!this.running) return;
-        const timer = setTimeout(async ()=>{
-            try {
-                const method = instance[methodName];
-                if (typeof method === 'function') {
-                    await method.call(instance);
-                }
-            } catch  {
-            // Swallow errors to keep the loop alive
-            }
-            this.scheduleNext(instance, methodName, ms);
+        const timer = setInterval(()=>{
+            void this.invoke(instance, methodName);
         }, ms);
-        this.timers.push(timer);
+        this.intervalTimers.push(timer);
+    }
+    scheduleCron(instance, methodName, expression, index) {
+        if (!this.running) return;
+        const matcher = this.getCronMatcher(expression);
+        if (!matcher) {
+            return;
+        }
+        const jobKey = `${index}:${methodName}:${expression}`;
+        const timer = setInterval(()=>{
+            const now = new Date();
+            const minuteKey = Math.floor(now.getTime() / 60_000);
+            if (this.lastCronMinute.get(jobKey) === minuteKey) {
+                return;
+            }
+            if (!matcher(now)) {
+                return;
+            }
+            this.lastCronMinute.set(jobKey, minuteKey);
+            void this.invoke(instance, methodName);
+        }, 1000);
+        this.cronTimers.push(timer);
+    }
+    async invoke(instance, methodName) {
+        try {
+            const method = instance[methodName];
+            if (typeof method === 'function') {
+                await method.call(instance);
+            }
+        } catch  {
+        // Swallow errors to keep the scheduler alive
+        }
+    }
+    getCronMatcher(expression) {
+        if (this.cronMatcherCache.has(expression)) {
+            return this.cronMatcherCache.get(expression) ?? null;
+        }
+        const fields = expression.trim().split(/\s+/);
+        if (fields.length !== 5) {
+            this.cronMatcherCache.set(expression, null);
+            return null;
+        }
+        const [minuteField, hourField, dayField, monthField, weekdayField] = fields;
+        const minuteMatcher = this.parseField(minuteField, 0, 59);
+        const hourMatcher = this.parseField(hourField, 0, 23);
+        const dayMatcher = this.parseField(dayField, 1, 31);
+        const monthMatcher = this.parseField(monthField, 1, 12);
+        const weekdayMatcher = this.parseField(weekdayField, 0, 7);
+        if (!minuteMatcher || !hourMatcher || !dayMatcher || !monthMatcher || !weekdayMatcher) {
+            this.cronMatcherCache.set(expression, null);
+            return null;
+        }
+        const matcher = (date)=>{
+            const weekday = date.getDay();
+            return minuteMatcher(date.getMinutes()) && hourMatcher(date.getHours()) && dayMatcher(date.getDate()) && monthMatcher(date.getMonth() + 1) && weekdayMatcher(weekday);
+        };
+        this.cronMatcherCache.set(expression, matcher);
+        return matcher;
+    }
+    parseField(field, min, max) {
+        const segments = field.split(',');
+        const predicates = [];
+        for (const rawSegment of segments){
+            const segment = rawSegment.trim();
+            if (!segment) return null;
+            const stepParts = segment.split('/');
+            if (stepParts.length > 2) return null;
+            const baseSegment = stepParts[0];
+            const step = stepParts.length === 2 ? Number(stepParts[1]) : 1;
+            if (!Number.isInteger(step) || step <= 0) return null;
+            const range = this.parseRange(baseSegment, min, max);
+            if (!range) return null;
+            predicates.push((value)=>{
+                if (value < range.start || value > range.end) return false;
+                return (value - range.start) % step === 0;
+            });
+        }
+        return (value)=>predicates.some((predicate)=>predicate(value));
+    }
+    parseRange(segment, min, max) {
+        if (segment === '*') {
+            return {
+                start: min,
+                end: max
+            };
+        }
+        const bounds = segment.split('-');
+        if (bounds.length === 1) {
+            const value = this.parseCronNumber(bounds[0], min, max);
+            if (value === null) return null;
+            return {
+                start: value,
+                end: value
+            };
+        }
+        if (bounds.length !== 2) return null;
+        const start = this.parseCronNumber(bounds[0], min, max);
+        const end = this.parseCronNumber(bounds[1], min, max);
+        if (start === null || end === null || start > end) return null;
+        return {
+            start,
+            end
+        };
+    }
+    parseCronNumber(raw, min, max) {
+        const value = Number(raw);
+        if (!Number.isInteger(value)) return null;
+        // Cron allows both 0 and 7 for Sunday.
+        const normalized = max === 7 && value === 7 ? 0 : value;
+        if (normalized < min || normalized > max) return null;
+        return normalized;
     }
     onModuleDestroy() {
         this.running = false;
-        for (const timer of this.timers){
-            clearTimeout(timer);
+        for (const timer of this.intervalTimers){
+            clearInterval(timer);
+        }
+        for (const timer of this.cronTimers){
+            clearInterval(timer);
         }
-        this.timers = [];
+        this.intervalTimers = [];
+        this.cronTimers = [];
+        this.lastCronMinute.clear();
     }
 }
 ScheduleExecutor = _ts_decorate([

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