@velajs/vela 0.4.0 → 0.4.2

package/dist/health/health.http.d.ts

@@ -0,0 +1,14 @@
+import { HealthIndicatorService } from './health.indicator';
+import type { HealthIndicatorResult, ResponseCheckCallback } from './health.types';
+export interface HttpPingOptions {
+    method?: string;
+    headers?: Record<string, string>;
+    timeout?: number;
+    expectedStatus?: number;
+}
+export declare class HttpHealthIndicator {
+    private indicator;
+    constructor(indicator: HealthIndicatorService);
+    pingCheck(key: string, url: string, options?: HttpPingOptions): Promise<HealthIndicatorResult>;
+    responseCheck(key: string, url: string, callback: ResponseCheckCallback, options?: HttpPingOptions): Promise<HealthIndicatorResult>;
+}

package/dist/health/health.http.js

@@ -0,0 +1,75 @@
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function _ts_metadata(k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+import { Injectable } from "../container/index.js";
+import { HealthIndicatorService } from "./health.indicator.js";
+export class HttpHealthIndicator {
+    indicator;
+    constructor(indicator){
+        this.indicator = indicator;
+    }
+    async pingCheck(key, url, options) {
+        const { method = 'GET', headers, timeout = 5000, expectedStatus } = options ?? {};
+        try {
+            const response = await fetch(url, {
+                method,
+                headers,
+                signal: AbortSignal.timeout(timeout)
+            });
+            const statusCode = response.status;
+            const isHealthy = expectedStatus !== undefined ? statusCode === expectedStatus : statusCode >= 200 && statusCode < 300;
+            if (isHealthy) {
+                return this.indicator.check(key).up({
+                    statusCode
+                });
+            }
+            return this.indicator.check(key).down({
+                statusCode,
+                message: response.statusText
+            });
+        } catch (error) {
+            const message = error instanceof Error ? error.message : 'Unknown error';
+            return this.indicator.check(key).down({
+                message
+            });
+        }
+    }
+    async responseCheck(key, url, callback, options) {
+        const { method = 'GET', headers, timeout = 5000 } = options ?? {};
+        try {
+            const response = await fetch(url, {
+                method,
+                headers,
+                signal: AbortSignal.timeout(timeout)
+            });
+            const statusCode = response.status;
+            const isHealthy = await callback(response);
+            if (isHealthy) {
+                return this.indicator.check(key).up({
+                    statusCode
+                });
+            }
+            return this.indicator.check(key).down({
+                statusCode
+            });
+        } catch (error) {
+            const message = error instanceof Error ? error.message : 'Unknown error';
+            return this.indicator.check(key).down({
+                message
+            });
+        }
+    }
+}
+HttpHealthIndicator = _ts_decorate([
+    Injectable(),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof HealthIndicatorService === "undefined" ? Object : HealthIndicatorService
+    ])
+], HttpHealthIndicator);

package/dist/health/health.indicator.d.ts

@@ -0,0 +1,9 @@
+import type { HealthIndicatorResult } from './health.types';
+interface HealthIndicatorBuilder {
+    up(data?: Record<string, unknown>): HealthIndicatorResult;
+    down(data?: Record<string, unknown>): HealthIndicatorResult;
+}
+export declare class HealthIndicatorService {
+    check(key: string): HealthIndicatorBuilder;
+}
+export {};

package/dist/health/health.indicator.js

@@ -0,0 +1,32 @@
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+import { Injectable } from "../container/index.js";
+export class HealthIndicatorService {
+    check(key) {
+        return {
+            up (data) {
+                return {
+                    [key]: {
+                        status: 'up',
+                        ...data
+                    }
+                };
+            },
+            down (data) {
+                return {
+                    [key]: {
+                        status: 'down',
+                        ...data
+                    }
+                };
+            }
+        };
+    }
+}
+HealthIndicatorService = _ts_decorate([
+    Injectable()
+], HealthIndicatorService);

package/dist/health/health.module.d.ts

@@ -0,0 +1,2 @@
+export declare class HealthModule {
+}

package/dist/health/health.module.js

@@ -0,0 +1,26 @@
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+import { Module } from "../module/index.js";
+import { HealthCheckService } from "./health.service.js";
+import { HealthIndicatorService } from "./health.indicator.js";
+import { HttpHealthIndicator } from "./health.http.js";
+export class HealthModule {
+}
+HealthModule = _ts_decorate([
+    Module({
+        providers: [
+            HealthCheckService,
+            HealthIndicatorService,
+            HttpHealthIndicator
+        ],
+        exports: [
+            HealthCheckService,
+            HealthIndicatorService,
+            HttpHealthIndicator
+        ]
+    })
+], HealthModule);

package/dist/health/health.service.d.ts

@@ -0,0 +1,7 @@
+import type { BeforeApplicationShutdown } from '../lifecycle/index';
+import type { HealthCheckResult, HealthIndicatorFunction } from './health.types';
+export declare class HealthCheckService implements BeforeApplicationShutdown {
+    private isShuttingDown;
+    beforeApplicationShutdown(): void;
+    check(indicators: HealthIndicatorFunction[]): Promise<HealthCheckResult>;
+}

package/dist/health/health.service.js

@@ -0,0 +1,65 @@
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+import { Injectable } from "../container/index.js";
+import { ServiceUnavailableException } from "../errors/http-exception.js";
+export class HealthCheckService {
+    isShuttingDown = false;
+    beforeApplicationShutdown() {
+        this.isShuttingDown = true;
+    }
+    async check(indicators) {
+        if (this.isShuttingDown) {
+            const result = {
+                status: 'shutting_down',
+                info: {},
+                error: {},
+                details: {}
+            };
+            throw new ServiceUnavailableException('Service Unavailable', result);
+        }
+        const results = await Promise.allSettled(indicators.map((fn)=>fn()));
+        const info = {};
+        const error = {};
+        const details = {};
+        for (const result of results){
+            if (result.status === 'fulfilled') {
+                const indicatorResult = result.value;
+                for (const [key, value] of Object.entries(indicatorResult)){
+                    details[key] = value;
+                    if (value.status === 'up') {
+                        info[key] = value;
+                    } else {
+                        error[key] = value;
+                    }
+                }
+            } else {
+                const message = result.reason instanceof Error ? result.reason.message : 'Health check failed';
+                const key = 'unknown';
+                const value = {
+                    status: 'down',
+                    message
+                };
+                details[key] = value;
+                error[key] = value;
+            }
+        }
+        const status = Object.keys(error).length > 0 ? 'error' : 'ok';
+        const checkResult = {
+            status,
+            info,
+            error,
+            details
+        };
+        if (status === 'error') {
+            throw new ServiceUnavailableException('Service Unavailable', checkResult);
+        }
+        return checkResult;
+    }
+}
+HealthCheckService = _ts_decorate([
+    Injectable()
+], HealthCheckService);

package/dist/health/health.types.d.ts

@@ -0,0 +1,15 @@
+export type HealthCheckStatus = 'ok' | 'error' | 'shutting_down';
+export interface HealthIndicatorResult {
+    [key: string]: {
+        status: 'up' | 'down';
+        [key: string]: unknown;
+    };
+}
+export interface HealthCheckResult {
+    status: HealthCheckStatus;
+    info: HealthIndicatorResult;
+    error: HealthIndicatorResult;
+    details: HealthIndicatorResult;
+}
+export type HealthIndicatorFunction = () => Promise<HealthIndicatorResult>;
+export type ResponseCheckCallback = (response: Response) => boolean | Promise<boolean>;

package/dist/health/health.types.js

@@ -0,0 +1 @@
+export { };

package/dist/health/index.d.ts

@@ -0,0 +1,6 @@
+export { HealthModule } from './health.module';
+export { HealthCheckService } from './health.service';
+export { HealthIndicatorService } from './health.indicator';
+export { HttpHealthIndicator } from './health.http';
+export type { HealthCheckResult, HealthCheckStatus, HealthIndicatorResult, HealthIndicatorFunction, ResponseCheckCallback, } from './health.types';
+export type { HttpPingOptions } from './health.http';

package/dist/health/index.js

@@ -0,0 +1,4 @@
+export { HealthModule } from "./health.module.js";
+export { HealthCheckService } from "./health.service.js";
+export { HealthIndicatorService } from "./health.indicator.js";
+export { HttpHealthIndicator } from "./health.http.js";

package/dist/http/route.manager.js

@@ -148,6 +148,8 @@ export class RouteManager {
     }
     createHandler(instance, route, controller, allParamMetadata) {
         const paramMetadata = (allParamMetadata.get(route.handlerName) || []).sort((a, b)=>a.index - b.index);
+        // Read param types once at build time for metatype population
+        const paramTypes = Reflect.getMetadata('design:paramtypes', instance.constructor.prototype, route.handlerName);
         // Pre-resolve controller + method level components at build time
         const methodGuards = ComponentManager.getComponents('guard', controller, route.handlerName);
         const methodPipes = ComponentManager.getComponents('pipe', controller, route.handlerName);
@@ -188,7 +190,7 @@ export class RouteManager {
             const executionContext = this.createExecutionContext(c, controller, route);
             try {
                 // 1. Extract args + run pipes
-                const args = await this.extractArguments(c, paramMetadata, pipes);
+                const args = await this.extractArguments(c, paramMetadata, pipes, paramTypes);
                 // 2. Guards (fail-fast)
                 for (const guard of guards){
                     const canActivate = await guard.canActivate(executionContext);
@@ -245,7 +247,7 @@ export class RouteManager {
             }
         };
     }
-    async extractArguments(c, paramMetadata, pipes) {
+    async extractArguments(c, paramMetadata, pipes, paramTypes) {
         if (paramMetadata.length === 0) {
             return [
                 c
@@ -258,7 +260,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){

package/dist/index.d.ts

@@ -18,6 +18,8 @@ export { EventEmitterModule, EventEmitter, EventEmitterSubscriber, OnEvent, ON_E
 export type { EventHandler, OnEventMetadata } from './event-emitter/index';
 export { ScheduleModule, ScheduleRegistry, ScheduleExecutor, Cron, Interval, SCHEDULE_MODULE_OPTIONS, CRON_METADATA, INTERVAL_METADATA, } from './schedule/index';
 export type { RegisteredCronJob, RegisteredIntervalJob, CronMetadata, IntervalMetadata, ScheduleModuleOptions, } from './schedule/index';
+export { HealthModule, HealthCheckService, HealthIndicatorService, HttpHealthIndicator, } from './health/index';
+export type { HealthCheckResult, HealthCheckStatus, HealthIndicatorResult, HealthIndicatorFunction, ResponseCheckCallback, HttpPingOptions, } from './health/index';
 export { ThrottlerModule, ThrottlerGuard, ThrottlerStorage, Throttle, SkipThrottle, THROTTLER_OPTIONS, THROTTLER_STORAGE, THROTTLE_METADATA, SKIP_THROTTLE_METADATA, } from './throttler/index';
 export type { ThrottlerModuleOptions, ThrottleConfig, ThrottlerStore, ThrottlerStorageRecord, RateLimitInfo, } from './throttler/index';
 export { Module } from './module/index';
@@ -32,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

@@ -21,6 +21,8 @@ export { CacheModule, CacheService, CacheInterceptor, MemoryCacheStore, CacheKey
 export { EventEmitterModule, EventEmitter, EventEmitterSubscriber, OnEvent, ON_EVENT_METADATA } from "./event-emitter/index.js";
 // Schedule
 export { ScheduleModule, ScheduleRegistry, ScheduleExecutor, Cron, Interval, SCHEDULE_MODULE_OPTIONS, CRON_METADATA, INTERVAL_METADATA } from "./schedule/index.js";
+// Health
+export { HealthModule, HealthCheckService, HealthIndicatorService, HttpHealthIndicator } from "./health/index.js";
 // Throttler
 export { ThrottlerModule, ThrottlerGuard, ThrottlerStorage, Throttle, SkipThrottle, THROTTLER_OPTIONS, THROTTLER_STORAGE, THROTTLE_METADATA, SKIP_THROTTLE_METADATA } from "./throttler/index.js";
 // Module
@@ -38,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/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,134 @@
+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,
+                useFactory: ()=>new 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);
+        // Resolve APP_* tokens
+        if (container.has(APP_GUARD)) {
+            routeManager.useGlobalGuards(container.resolve(APP_GUARD));
+        }
+        if (container.has(APP_PIPE)) {
+            routeManager.useGlobalPipes(container.resolve(APP_PIPE));
+        }
+        if (container.has(APP_INTERCEPTOR)) {
+            routeManager.useGlobalInterceptors(container.resolve(APP_INTERCEPTOR));
+        }
+        if (container.has(APP_FILTER)) {
+            routeManager.useGlobalFilters(container.resolve(APP_FILTER));
+        }
+        if (container.has(APP_MIDDLEWARE)) {
+            routeManager.useGlobalMiddleware(container.resolve(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.0",
+  "version": "0.4.2",
   "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",