@velajs/vela 0.4.1 → 0.4.3

package/dist/container/container.d.ts

@@ -1,3 +1,4 @@
+import { Scope } from '../constants';
 import type { ProviderOptions, Token, Type } from './types';
 export declare class Container {
     private providers;
@@ -9,6 +10,7 @@ export declare class Container {
     private registerOptions;
     resolve<T>(token: Token<T>): T;
     has(token: Token): boolean;
+    getProviderScope(token: Token): Scope | undefined;
     getTokens(): Token[];
     /**
      * Create a child container for request-scoped resolution.

package/dist/container/container.js

@@ -40,6 +40,8 @@ export class Container {
         } else if (options.useFactory) {
             registration.useFactory = options.useFactory;
             registration.inject = options.inject;
+        } else if (options.useClass) {
+            registration.useClass = options.useClass;
         } else if (options.useExisting) {
             registration.useExisting = options.useExisting;
         } else if (typeof token === 'function') {
@@ -68,6 +70,9 @@ export class Container {
     has(token) {
         return this.providers.has(token);
     }
+    getProviderScope(token) {
+        return this.providers.get(token)?.scope;
+    }
     getTokens() {
         return Array.from(this.providers.keys());
     }

package/dist/container/types.d.ts

@@ -22,6 +22,7 @@ export interface ProviderOptions<T = unknown> {
     scope?: Scope;
     useValue?: T;
     useFactory?: (...args: any[]) => T | Promise<T>;
+    useClass?: Type<T>;
     inject?: Token[];
     useExisting?: Token<T>;
 }

package/dist/factory.js

@@ -15,21 +15,35 @@ export const VelaFactory = {
         ComponentManager.init(container);
         const loader = new ModuleLoader(container, routeManager);
         loader.load(rootModule);
-        // Resolve APP_* tokens registered via module providers
-        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();

package/dist/http/route.manager.d.ts

@@ -1,6 +1,7 @@
 import { Hono } from 'hono';
 import type { Container } from '../container/container';
-import type { Type } from '../container/types';
+import type { Token, Type } from '../container/types';
+import type { CanActivate, ExceptionFilter, NestInterceptor, NestMiddleware, PipeTransform } from '../pipeline/types';
 import type { FilterType, GuardType, InterceptorType, MiddlewareType, PipeType } from '../registry/types';
 import type { ControllerRegistration } from './types';
 export declare class RouteManager {
@@ -15,11 +16,18 @@ export declare class RouteManager {
     constructor(container: Container);
     setGlobalPrefix(prefix: string): this;
     useGlobalMiddleware(...middleware: MiddlewareType[]): this;
+    useGlobalMiddlewareTokens(...middlewareTokens: Array<Token<NestMiddleware>>): this;
     useGlobalPipes(...pipes: PipeType[]): this;
+    useGlobalPipeTokens(...pipeTokens: Array<Token<PipeTransform>>): this;
     useGlobalGuards(...guards: GuardType[]): this;
+    useGlobalGuardTokens(...guardTokens: Array<Token<CanActivate>>): this;
     useGlobalInterceptors(...interceptors: InterceptorType[]): this;
+    useGlobalInterceptorTokens(...interceptorTokens: Array<Token<NestInterceptor>>): this;
     useGlobalFilters(...filters: FilterType[]): this;
+    useGlobalFilterTokens(...filterTokens: Array<Token<ExceptionFilter>>): this;
     private instantiate;
+    private instantiateMany;
+    private getRequestContainer;
     registerController(controller: Type): this;
     build(): Promise<Hono>;
     private createExecutionContext;

package/dist/http/route.manager.js

@@ -35,43 +35,68 @@ export class RouteManager {
         return this;
     }
     useGlobalMiddleware(...middleware) {
-        for (const mw of middleware){
-            this.globalMiddleware.push(this.instantiate(mw));
-        }
+        this.globalMiddleware.push(...middleware);
+        return this;
+    }
+    useGlobalMiddlewareTokens(...middlewareTokens) {
+        this.globalMiddleware.push(...middlewareTokens);
         return this;
     }
     useGlobalPipes(...pipes) {
-        for (const pipe of pipes){
-            this.globalPipes.push(this.instantiate(pipe));
-        }
+        this.globalPipes.push(...pipes);
+        return this;
+    }
+    useGlobalPipeTokens(...pipeTokens) {
+        this.globalPipes.push(...pipeTokens);
         return this;
     }
     useGlobalGuards(...guards) {
-        for (const guard of guards){
-            this.globalGuards.push(this.instantiate(guard));
-        }
+        this.globalGuards.push(...guards);
+        return this;
+    }
+    useGlobalGuardTokens(...guardTokens) {
+        this.globalGuards.push(...guardTokens);
         return this;
     }
     useGlobalInterceptors(...interceptors) {
-        for (const interceptor of interceptors){
-            this.globalInterceptors.push(this.instantiate(interceptor));
-        }
+        this.globalInterceptors.push(...interceptors);
+        return this;
+    }
+    useGlobalInterceptorTokens(...interceptorTokens) {
+        this.globalInterceptors.push(...interceptorTokens);
         return this;
     }
     useGlobalFilters(...filters) {
-        for (const filter of filters){
-            this.globalFilters.push(this.instantiate(filter));
-        }
+        this.globalFilters.push(...filters);
+        return this;
+    }
+    useGlobalFilterTokens(...filterTokens) {
+        this.globalFilters.push(...filterTokens);
         return this;
     }
-    instantiate(classOrInstance) {
-        if (typeof classOrInstance !== 'function') {
-            return classOrInstance;
+    instantiate(classOrInstance, container) {
+        if (typeof classOrInstance === 'function') {
+            if (container.has(classOrInstance)) {
+                return container.resolve(classOrInstance);
+            }
+            return new classOrInstance();
+        }
+        if (container.has(classOrInstance)) {
+            return container.resolve(classOrInstance);
         }
-        if (this.container.has(classOrInstance)) {
-            return this.container.resolve(classOrInstance);
+        return classOrInstance;
+    }
+    instantiateMany(items, container) {
+        return items.map((item)=>this.instantiate(item, container));
+    }
+    getRequestContainer(c) {
+        const existing = c.get('container');
+        if (existing) {
+            return existing;
         }
-        return new classOrInstance();
+        const child = this.container.createChild();
+        c.set('container', child);
+        return child;
     }
     registerController(controller) {
         const prefix = MetadataRegistry.getControllerPath(controller);
@@ -94,12 +119,15 @@ export class RouteManager {
         const app = new Hono();
         // Register global middleware on the Hono app
         for (const mw of this.globalMiddleware){
-            app.use('*', (c, next)=>mw.use(c, next));
+            app.use('*', (c, next)=>{
+                const requestContainer = this.getRequestContainer(c);
+                const resolved = this.instantiate(mw, requestContainer);
+                return resolved.use(c, next);
+            });
         }
         // First pass: register all custom routes (must come before CRUD /:id routes)
         for (const { controller, metadata, routes } of this.controllers){
             if (routes.length > 0) {
-                const instance = this.container.resolve(controller);
                 const allParamMetadata = MetadataRegistry.getParameters(controller);
                 for (const route of routes){
                     // Determine effective version: route-level overrides controller-level
@@ -108,11 +136,14 @@ export class RouteManager {
                     const versionedPaths = this.buildVersionedPaths(this.globalPrefix, metadata.prefix, route.path, effectiveVersion);
                     // Register per-route middleware as Hono middleware before the handler
                     const middlewareItems = ComponentManager.getComponents('middleware', controller, route.handlerName);
-                    const resolvedMw = ComponentManager.resolveMiddleware(middlewareItems);
-                    const handler = this.createHandler(instance, route, controller, allParamMetadata);
+                    const handler = this.createHandler(route, controller, allParamMetadata);
                     for (const fullPath of versionedPaths){
-                        for (const mw of resolvedMw){
-                            app.use(fullPath, (c, next)=>mw.use(c, next));
+                        for (const middlewareItem of middlewareItems){
+                            app.use(fullPath, (c, next)=>{
+                                const requestContainer = this.getRequestContainer(c);
+                                const resolved = this.instantiate(middlewareItem, requestContainer);
+                                return resolved.use(c, next);
+                            });
                         }
                         this.registerRoute(app, route.method, fullPath, handler);
                     }
@@ -128,7 +159,7 @@ export class RouteManager {
                     const { buildCrudRoutes } = await import(pkg);
                     await buildCrudRoutes(app, controller, metadata.prefix, crudConfig, {
                         globalPrefix: this.globalPrefix,
-                        globalGuards: this.globalGuards,
+                        globalGuards: this.instantiateMany(this.globalGuards, this.container),
                         joinPaths: this.joinPaths.bind(this)
                     });
                 } catch  {
@@ -146,49 +177,46 @@ export class RouteManager {
             getRequest: ()=>c.req.raw
         };
     }
-    createHandler(instance, route, controller, allParamMetadata) {
+    createHandler(route, controller, allParamMetadata) {
         const paramMetadata = (allParamMetadata.get(route.handlerName) || []).sort((a, b)=>a.index - b.index);
-        // Pre-resolve controller + method level components at build time
+        // Read param types once at build time for metatype population
+        const paramTypes = Reflect.getMetadata('design:paramtypes', controller.prototype, route.handlerName);
+        // Collect controller + method level components at build time
         const methodGuards = ComponentManager.getComponents('guard', controller, route.handlerName);
         const methodPipes = ComponentManager.getComponents('pipe', controller, route.handlerName);
         const methodInterceptors = ComponentManager.getComponents('interceptor', controller, route.handlerName);
-        const methodFilters = ComponentManager.getComponents('filter', controller, route.handlerName);
-        const resolvedMethodGuards = ComponentManager.resolveGuards(methodGuards);
-        const resolvedMethodPipes = ComponentManager.resolvePipes(methodPipes);
-        const resolvedMethodInterceptors = ComponentManager.resolveInterceptors(methodInterceptors);
         // Filters: reverse order (handler → controller → global) — closest to handler runs first
-        const resolvedMethodFilters = ComponentManager.resolveFilters([
-            ...methodFilters
-        ].reverse());
+        const methodFilters = [
+            ...ComponentManager.getComponents('filter', controller, route.handlerName)
+        ].reverse();
         // Read response decorators at build time
         const httpCode = getHttpCode(controller, route.handlerName);
         const responseHeaders = getResponseHeaders(controller, route.handlerName);
         const redirect = getRedirect(controller, route.handlerName);
         return async (c)=>{
-            // Create a child container for request-scoped providers
-            const requestContainer = this.container.createChild();
-            c.set('container', requestContainer);
             // Combine global + method at request time (allows post-create registration)
+            const requestContainer = this.getRequestContainer(c);
             const guards = [
-                ...this.globalGuards,
-                ...resolvedMethodGuards
+                ...this.instantiateMany(this.globalGuards, requestContainer),
+                ...this.instantiateMany(methodGuards, requestContainer)
             ];
             const pipes = [
-                ...this.globalPipes,
-                ...resolvedMethodPipes
+                ...this.instantiateMany(this.globalPipes, requestContainer),
+                ...this.instantiateMany(methodPipes, requestContainer)
             ];
             const interceptors = [
-                ...this.globalInterceptors,
-                ...resolvedMethodInterceptors
+                ...this.instantiateMany(this.globalInterceptors, requestContainer),
+                ...this.instantiateMany(methodInterceptors, requestContainer)
             ];
             const filters = [
-                ...resolvedMethodFilters,
-                ...this.globalFilters
+                ...this.instantiateMany(methodFilters, requestContainer),
+                ...this.instantiateMany(this.globalFilters, requestContainer)
             ];
             const executionContext = this.createExecutionContext(c, controller, route);
             try {
+                const instance = requestContainer.resolve(controller);
                 // 1. Extract args + run pipes
-                const args = await this.extractArguments(c, paramMetadata, pipes);
+                const args = await this.extractArguments(c, paramMetadata, pipes, requestContainer, paramTypes);
                 // 2. Guards (fail-fast)
                 for (const guard of guards){
                     const canActivate = await guard.canActivate(executionContext);
@@ -245,7 +273,7 @@ export class RouteManager {
             }
         };
     }
-    async extractArguments(c, paramMetadata, pipes) {
+    async extractArguments(c, paramMetadata, pipes, requestContainer, paramTypes) {
         if (paramMetadata.length === 0) {
             return [
                 c
@@ -258,7 +286,7 @@ export class RouteManager {
             const metadata = {
                 type: param.type,
                 data: param.name,
-                metatype: undefined
+                metatype: paramTypes?.[param.index]
             };
             // Run shared pipes (global + controller + method)
             for (const pipe of pipes){
@@ -267,7 +295,7 @@ export class RouteManager {
             // Run param-level pipes
             if (param.pipes && param.pipes.length > 0) {
                 for (const paramPipe of param.pipes){
-                    const pipeInstance = this.instantiate(paramPipe);
+                    const pipeInstance = this.instantiate(paramPipe, requestContainer);
                     value = await pipeInstance.transform(value, metadata);
                 }
             }

package/dist/index.d.ts

@@ -34,3 +34,6 @@ export { MetadataRegistry } from './registry/index';
 export { RouteManager } from './http/index';
 export { ModuleLoader } from './module/index';
 export { ComponentManager } from './pipeline/index';
+export { createZodDto, ValidationPipe } from './validation/index';
+export { Serialize, SerializerInterceptor, SERIALIZE_METADATA } from './serialization/index';
+export { Test, TestingModule, TestingModuleBuilder } from './testing/index';

package/dist/index.js

@@ -40,3 +40,9 @@ export { RouteManager } from "./http/index.js";
 export { ModuleLoader } from "./module/index.js";
 // Component Manager (for advanced usage)
 export { ComponentManager } from "./pipeline/index.js";
+// Validation
+export { createZodDto, ValidationPipe } from "./validation/index.js";
+// Serialization
+export { Serialize, SerializerInterceptor, SERIALIZE_METADATA } from "./serialization/index.js";
+// Testing
+export { Test, TestingModule, TestingModuleBuilder } from "./testing/index.js";

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

@@ -9,12 +9,16 @@ export declare class ModuleLoader {
     private collectedControllers;
     private registeredProviders;
     private moduleExportsCache;
+    private appProviderCounter;
+    private appProviderTokens;
     constructor(container: Container, router: RouteManager);
     load(rootModule: Type): void;
     private processModule;
     private registerProvider;
+    private isAppToken;
     private buildExportSet;
     getControllers(): Type[];
     getRegisteredProviders(): Token[];
+    getAppProviderTokens(token: Token): Token[];
     resolveAllInstances(): unknown[];
 }

package/dist/module/module-loader.js

@@ -1,3 +1,6 @@
+import { Scope } from "../constants.js";
+import { InjectionToken } from "../container/types.js";
+import { APP_FILTER, APP_GUARD, APP_INTERCEPTOR, APP_MIDDLEWARE, APP_PIPE } from "../pipeline/tokens.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 +13,29 @@ export class ModuleLoader {
     collectedControllers = [];
     registeredProviders = [];
     moduleExportsCache = new Map();
+    appProviderCounter = 0;
+    appProviderTokens = new Map([
+        [
+            APP_GUARD,
+            []
+        ],
+        [
+            APP_PIPE,
+            []
+        ],
+        [
+            APP_INTERCEPTOR,
+            []
+        ],
+        [
+            APP_FILTER,
+            []
+        ],
+        [
+            APP_MIDDLEWARE,
+            []
+        ]
+    ]);
     constructor(container, router){
         this.container = container;
         this.router = router;
@@ -98,14 +124,29 @@ export class ModuleLoader {
             }
         } else {
             const token = provider.token;
-            if (token && !this.container.has(token)) {
+            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,
+                    token: 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){
@@ -134,10 +175,18 @@ export class ModuleLoader {
             ...this.registeredProviders
         ];
     }
+    getAppProviderTokens(token) {
+        return [
+            ...this.appProviderTokens.get(token) ?? []
+        ];
+    }
     resolveAllInstances() {
         const instances = [];
         for (const token of this.registeredProviders){
             try {
+                if (this.container.getProviderScope(token) === Scope.REQUEST) {
+                    continue;
+                }
                 const instance = this.container.resolve(token);
                 instances.push(instance);
             } catch  {
@@ -146,6 +195,9 @@ export class ModuleLoader {
         }
         for (const controller of this.collectedControllers){
             try {
+                if (this.container.getProviderScope(controller) === Scope.REQUEST) {
+                    continue;
+                }
                 const instance = this.container.resolve(controller);
                 if (!instances.includes(instance)) {
                     instances.push(instance);

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/serialization/index.d.ts

@@ -0,0 +1,2 @@
+export { Serialize, SERIALIZE_METADATA } from './serialize.decorator';
+export { SerializerInterceptor } from './serializer.interceptor';

package/dist/serialization/index.js

@@ -0,0 +1,2 @@
+export { Serialize, SERIALIZE_METADATA } from "./serialize.decorator.js";
+export { SerializerInterceptor } from "./serializer.interceptor.js";

package/dist/serialization/serialize.decorator.d.ts

@@ -0,0 +1,6 @@
+export declare const SERIALIZE_METADATA = "vela:serialize";
+export declare function Serialize(dto: {
+    schema: {
+        parse(data: unknown): unknown;
+    };
+}): MethodDecorator;

package/dist/serialization/serialize.decorator.js

@@ -0,0 +1,7 @@
+import { MetadataRegistry } from "../registry/metadata.registry.js";
+export const SERIALIZE_METADATA = 'vela:serialize';
+export function Serialize(dto) {
+    return (target, propertyKey)=>{
+        MetadataRegistry.setCustomHandlerMeta(target.constructor, propertyKey, SERIALIZE_METADATA, dto);
+    };
+}

package/dist/serialization/serializer.interceptor.d.ts

@@ -0,0 +1,4 @@
+import type { CallHandler, ExecutionContext, NestInterceptor } from '../pipeline/types';
+export declare class SerializerInterceptor implements NestInterceptor {
+    intercept(context: ExecutionContext, next: CallHandler): Promise<unknown>;
+}

package/dist/serialization/serializer.interceptor.js

@@ -0,0 +1,16 @@
+import { MetadataRegistry } from "../registry/metadata.registry.js";
+import { SERIALIZE_METADATA } from "./serialize.decorator.js";
+export class SerializerInterceptor {
+    async intercept(context, next) {
+        const result = await next.handle();
+        const controller = context.getClass();
+        const handler = context.getHandler();
+        const dto = MetadataRegistry.getCustomHandlerMeta(controller, handler, SERIALIZE_METADATA);
+        const schema = dto?.schema;
+        if (!schema?.parse) return result;
+        if (Array.isArray(result)) {
+            return result.map((item)=>schema.parse(item));
+        }
+        return schema.parse(result);
+    }
+}

package/dist/testing/index.d.ts

@@ -0,0 +1,2 @@
+export { Test, TestingModuleBuilder, OverrideBy } from './testing.builder';
+export { TestingModule } from './testing.module';

package/dist/testing/index.js

@@ -0,0 +1,2 @@
+export { Test, TestingModuleBuilder, OverrideBy } from "./testing.builder.js";
+export { TestingModule } from "./testing.module.js";

package/dist/testing/testing.builder.d.ts

@@ -0,0 +1,29 @@
+import type { Token, Type } from '../container/types';
+import type { ModuleOptions } from '../module/types';
+import { TestingModule } from './testing.module';
+export declare class OverrideBy {
+    private readonly builder;
+    private readonly token;
+    constructor(builder: TestingModuleBuilder, token: Token);
+    useValue(value: unknown): TestingModuleBuilder;
+    useClass(cls: Type): TestingModuleBuilder;
+    useFactory(options: {
+        factory: (...args: unknown[]) => unknown;
+        inject?: Token[];
+    }): TestingModuleBuilder;
+}
+export declare class TestingModuleBuilder {
+    private readonly metadata;
+    private overrides;
+    constructor(metadata: ModuleOptions);
+    overrideProvider(token: Token): OverrideBy;
+    overrideGuard(guard: Type): OverrideBy;
+    overridePipe(pipe: Type): OverrideBy;
+    overrideInterceptor(interceptor: Type): OverrideBy;
+    overrideFilter(filter: Type): OverrideBy;
+    private addOverride;
+    compile(): Promise<TestingModule>;
+}
+export declare class Test {
+    static createTestingModule(metadata: ModuleOptions): TestingModuleBuilder;
+}

package/dist/testing/testing.builder.js

@@ -0,0 +1,148 @@
+import { VelaApplication } from "../application.js";
+import { METADATA_KEYS } from "../constants.js";
+import { Container } from "../container/container.js";
+import { RouteManager } from "../http/route.manager.js";
+import { defineMetadata } from "../metadata.js";
+import { ModuleLoader } from "../module/module-loader.js";
+import { ComponentManager } from "../pipeline/component.manager.js";
+import { APP_FILTER, APP_GUARD, APP_INTERCEPTOR, APP_MIDDLEWARE, APP_PIPE } from "../pipeline/tokens.js";
+import { MetadataRegistry } from "../registry/metadata.registry.js";
+import { TestingModule } from "./testing.module.js";
+export class OverrideBy {
+    builder;
+    token;
+    constructor(builder, token){
+        this.builder = builder;
+        this.token = token;
+    }
+    useValue(value) {
+        this.builder['addOverride']({
+            token: this.token,
+            provider: {
+                token: this.token,
+                useValue: value
+            }
+        });
+        return this.builder;
+    }
+    useClass(cls) {
+        this.builder['addOverride']({
+            token: this.token,
+            provider: {
+                token: this.token,
+                useClass: cls
+            }
+        });
+        return this.builder;
+    }
+    useFactory(options) {
+        this.builder['addOverride']({
+            token: this.token,
+            provider: {
+                token: this.token,
+                useFactory: options.factory,
+                inject: options.inject
+            }
+        });
+        return this.builder;
+    }
+}
+export class TestingModuleBuilder {
+    metadata;
+    overrides = [];
+    constructor(metadata){
+        this.metadata = metadata;
+    }
+    overrideProvider(token) {
+        return new OverrideBy(this, token);
+    }
+    overrideGuard(guard) {
+        return new OverrideBy(this, guard);
+    }
+    overridePipe(pipe) {
+        return new OverrideBy(this, pipe);
+    }
+    overrideInterceptor(interceptor) {
+        return new OverrideBy(this, interceptor);
+    }
+    overrideFilter(filter) {
+        return new OverrideBy(this, filter);
+    }
+    addOverride(entry) {
+        // Replace existing override for same token if any
+        const idx = this.overrides.findIndex((o)=>o.token === entry.token);
+        if (idx !== -1) {
+            this.overrides[idx] = entry;
+        } else {
+            this.overrides.push(entry);
+        }
+    }
+    async compile() {
+        // Create a temporary module class with the provided metadata
+        let TestRootModule = class TestRootModule {
+        };
+        MetadataRegistry.setModuleOptions(TestRootModule, {
+            imports: this.metadata.imports,
+            providers: this.metadata.providers,
+            controllers: this.metadata.controllers,
+            exports: this.metadata.exports
+        });
+        defineMetadata(METADATA_KEYS.MODULE, true, TestRootModule);
+        // Bootstrap (mirrors VelaFactory.create)
+        const container = new Container();
+        container.register({
+            token: Container,
+            useValue: container
+        });
+        // Register overrides BEFORE module loading so ModuleLoader skips originals
+        for (const override of this.overrides){
+            container.register(override.provider);
+        }
+        const routeManager = new RouteManager(container);
+        ComponentManager.init(container);
+        const loader = new ModuleLoader(container, routeManager);
+        loader.load(TestRootModule);
+        const appGuards = loader.getAppProviderTokens(APP_GUARD);
+        if (appGuards.length > 0) {
+            routeManager.useGlobalGuardTokens(...appGuards);
+        } else if (container.has(APP_GUARD)) {
+            routeManager.useGlobalGuardTokens(APP_GUARD);
+        }
+        const appPipes = loader.getAppProviderTokens(APP_PIPE);
+        if (appPipes.length > 0) {
+            routeManager.useGlobalPipeTokens(...appPipes);
+        } else if (container.has(APP_PIPE)) {
+            routeManager.useGlobalPipeTokens(APP_PIPE);
+        }
+        const appInterceptors = loader.getAppProviderTokens(APP_INTERCEPTOR);
+        if (appInterceptors.length > 0) {
+            routeManager.useGlobalInterceptorTokens(...appInterceptors);
+        } else if (container.has(APP_INTERCEPTOR)) {
+            routeManager.useGlobalInterceptorTokens(APP_INTERCEPTOR);
+        }
+        const appFilters = loader.getAppProviderTokens(APP_FILTER);
+        if (appFilters.length > 0) {
+            routeManager.useGlobalFilterTokens(...appFilters);
+        } else if (container.has(APP_FILTER)) {
+            routeManager.useGlobalFilterTokens(APP_FILTER);
+        }
+        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();
+        app.setInstances(instances);
+        await app.callOnModuleInit();
+        await app.callOnApplicationBootstrap();
+        await app.initRoutes();
+        return new TestingModule(app);
+    }
+}
+export class Test {
+    static createTestingModule(metadata) {
+        return new TestingModuleBuilder(metadata);
+    }
+}

package/dist/testing/testing.module.d.ts

@@ -0,0 +1,9 @@
+import type { VelaApplication } from '../application';
+import type { Token } from '../container/types';
+export declare class TestingModule {
+    private readonly app;
+    constructor(app: VelaApplication);
+    get<T>(token: Token<T>): T;
+    close(signal?: string): Promise<void>;
+    createNestApplication(): VelaApplication;
+}

package/dist/testing/testing.module.js

@@ -0,0 +1,15 @@
+export class TestingModule {
+    app;
+    constructor(app){
+        this.app = app;
+    }
+    get(token) {
+        return this.app.get(token);
+    }
+    async close(signal) {
+        await this.app.close(signal);
+    }
+    createNestApplication() {
+        return this.app;
+    }
+}

package/dist/validation/create-zod-dto.d.ts

@@ -0,0 +1,8 @@
+interface ZodSchema {
+    parse(data: unknown): unknown;
+}
+export declare function createZodDto<T extends ZodSchema>(schema: T): {
+    new (): unknown;
+    schema: T;
+};
+export {};

package/dist/validation/create-zod-dto.js

@@ -0,0 +1,6 @@
+export function createZodDto(schema) {
+    let ZodDto = class ZodDto {
+        static schema = schema;
+    };
+    return ZodDto;
+}

package/dist/validation/index.d.ts

@@ -0,0 +1,2 @@
+export { createZodDto } from './create-zod-dto';
+export { ValidationPipe } from './validation.pipe';

package/dist/validation/index.js

@@ -0,0 +1,2 @@
+export { createZodDto } from "./create-zod-dto.js";
+export { ValidationPipe } from "./validation.pipe.js";

package/dist/validation/validation.pipe.d.ts

@@ -0,0 +1,4 @@
+import type { ArgumentMetadata, PipeTransform } from '../pipeline/types';
+export declare class ValidationPipe implements PipeTransform {
+    transform(value: unknown, metadata: ArgumentMetadata): unknown;
+}

package/dist/validation/validation.pipe.js

@@ -0,0 +1,19 @@
+import { BadRequestException } from "../errors/http-exception.js";
+export class ValidationPipe {
+    transform(value, metadata) {
+        const metatype = metadata.metatype;
+        if (!metatype?.schema?.parse) return value;
+        try {
+            return metatype.schema.parse(value);
+        } catch (error) {
+            if (error && typeof error === 'object' && 'issues' in error && Array.isArray(error.issues)) {
+                throw new BadRequestException('Validation failed', {
+                    statusCode: 400,
+                    message: 'Validation failed',
+                    errors: error.issues
+                });
+            }
+            throw error;
+        }
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@velajs/vela",
-  "version": "0.4.1",
+  "version": "0.4.3",
   "description": "NestJS-compatible framework for edge runtimes, powered by Hono",
   "type": "module",
   "main": "./dist/index.js",
@@ -66,7 +66,8 @@
     "@types/bun": "latest",
     "typescript": "^5",
     "unplugin-swc": "^1.5.9",
-    "vitest": "^4.0.18"
+    "vitest": "^4.0.18",
+    "zod": "^4.3.6"
   },
   "scripts": {
     "build": "rm -rf dist && swc src -d dist --strip-leading-paths && tsc --emitDeclarationOnly",