@carno.js/core 0.2.11 → 1.0.2

package/src/validation/ValidatorAdapter.ts

@@ -0,0 +1,69 @@
+/**
+ * Validation result type.
+ */
+export interface ValidationResult<T = any> {
+    success: boolean;
+    data?: T;
+    errors?: ValidationError[];
+}
+
+export interface ValidationError {
+    path: string;
+    message: string;
+}
+
+/**
+ * Base interface for validation adapters.
+ * Adapters provide validation capabilities for different libraries.
+ */
+export interface ValidatorAdapter {
+    /**
+     * Validator name for debugging.
+     */
+    readonly name: string;
+
+    /**
+     * Check if a target has validation schema.
+     */
+    hasValidation(target: any): boolean;
+
+    /**
+     * Validate and transform a value.
+     * Returns result object instead of throwing for better performance.
+     */
+    validate<T>(target: any, value: unknown): ValidationResult<T>;
+
+    /**
+     * Validate and transform, throwing on error.
+     * Used when you want to short-circuit on failure.
+     */
+    validateOrThrow<T>(target: any, value: unknown): T;
+}
+
+/**
+ * Validation configuration for Turbo.
+ */
+export interface ValidationConfig {
+    adapter: ValidatorAdapter;
+}
+
+/**
+ * Symbol for storing validation schema on DTOs.
+ */
+export const VALIDATION_SCHEMA = Symbol('turbo:validation');
+
+/**
+ * Decorator to attach a validation schema to a DTO class.
+ */
+export function Schema(schema: any): ClassDecorator {
+    return (target) => {
+        Reflect.defineMetadata(VALIDATION_SCHEMA, schema, target);
+    };
+}
+
+/**
+ * Get the validation schema from a DTO class.
+ */
+export function getSchema(target: any): any | undefined {
+    return Reflect.getMetadata(VALIDATION_SCHEMA, target);
+}

package/src/validation/ZodAdapter.ts

@@ -0,0 +1,102 @@
+import type { ValidatorAdapter, ValidationResult, ValidationError } from './ValidatorAdapter';
+import { VALIDATION_SCHEMA, getSchema } from './ValidatorAdapter';
+
+/**
+ * Zod Adapter - Default validation adapter for Turbo.
+ * 
+ * Usage:
+ * ```typescript
+ * import { z } from 'zod';
+ * 
+ * @Schema(z.object({
+ *   name: z.string().min(1),
+ *   email: z.string().email()
+ * }))
+ * class CreateUserDto {
+ *   name: string;
+ *   email: string;
+ * }
+ * ```
+ */
+export class ZodAdapter implements ValidatorAdapter {
+    readonly name = 'ZodAdapter';
+
+    // Cache parsed schemas for performance
+    private schemaCache = new Map<any, any>();
+
+    hasValidation(target: any): boolean {
+        return getSchema(target) !== undefined;
+    }
+
+    validate<T>(target: any, value: unknown): ValidationResult<T> {
+        const schema = this.getOrCacheSchema(target);
+
+        if (!schema) {
+            return { success: true, data: value as T };
+        }
+
+        const result = schema.safeParse(value);
+
+        if (result.success) {
+            return { success: true, data: result.data };
+        }
+
+        return {
+            success: false,
+            errors: this.formatErrors(result.error)
+        };
+    }
+
+    validateOrThrow<T>(target: any, value: unknown): T {
+        const schema = this.getOrCacheSchema(target);
+
+        if (!schema) {
+            return value as T;
+        }
+
+        const result = schema.safeParse(value);
+
+        if (result.success) {
+            return result.data;
+        }
+
+        const errors = this.formatErrors(result.error);
+        throw new ValidationException(errors);
+    }
+
+    private getOrCacheSchema(target: any): any {
+        let schema = this.schemaCache.get(target);
+
+        if (schema === undefined) {
+            schema = getSchema(target) ?? null;
+            this.schemaCache.set(target, schema);
+        }
+
+        return schema;
+    }
+
+    private formatErrors(zodError: any): ValidationError[] {
+        return zodError.issues.map((issue: any) => ({
+            path: issue.path.join('.'),
+            message: issue.message
+        }));
+    }
+}
+
+/**
+ * Validation exception thrown when validation fails.
+ */
+export class ValidationException extends Error {
+    constructor(public readonly errors: ValidationError[]) {
+        super(`Validation failed: ${errors.map(e => `${e.path}: ${e.message}`).join(', ')}`);
+        this.name = 'ValidationException';
+    }
+
+    toResponse(): Response {
+        return Response.json({
+            statusCode: 400,
+            message: 'Validation failed',
+            errors: this.errors
+        }, { status: 400 });
+    }
+}

package/dist/Carno.d.ts

@@ -1,75 +0,0 @@
-import { Server } from "bun";
-import * as pino from "pino";
-import type { ValidationConfig, ValidatorAdapterConstructor } from "./validation/ValidatorAdapter";
-import { TokenRouteWithProvider } from "./container/ContainerConfiguration";
-import { CorsConfig } from "./domain/cors-config";
-import Memoirist from "./route/memoirist";
-import { type CompiledRoute } from "./route/CompiledRoute";
-export interface ApplicationConfig<TAdapter extends ValidatorAdapterConstructor = ValidatorAdapterConstructor> {
-    validation?: ValidationConfig<TAdapter>;
-    logger?: pino.LoggerOptions;
-    exports?: any[];
-    providers?: any[];
-    cors?: CorsConfig;
-    globalMiddlewares?: any[];
-    disableStartupLog?: boolean;
-}
-export declare class Carno<TAdapter extends ValidatorAdapterConstructor = ValidatorAdapterConstructor> {
-    config: ApplicationConfig<TAdapter>;
-    router: Memoirist<CompiledRoute | TokenRouteWithProvider>;
-    private injector;
-    private corsCache?;
-    private readonly emptyLocals;
-    private validatorAdapter;
-    private corsEnabled;
-    private hasOnRequestHook;
-    private fetch;
-    private server;
-    constructor(config?: ApplicationConfig<TAdapter>);
-    private resolveValidatorAdapter;
-    /**
-     * Use the Carno plugin.
-     *
-     * @param plugin
-     */
-    use(plugin: Carno): this;
-    private findProviderInConfig;
-    private getProviderToken;
-    private shouldCloneProvider;
-    private cloneProvider;
-    /**
-     * Set the custom logger provider.
-     * The provider must be a class with the @Service() decorator.
-     * The provider must extend the LoggerService class.
-     *
-     * @param provider
-     */
-    useLogger(provider: any): this;
-    private loadProvidersAndControllers;
-    private registerControllers;
-    private registerMetadataProviders;
-    private registerConfigProviders;
-    private normalizeProvider;
-    init(): Promise<void>;
-    listen(port?: number): Promise<void>;
-    private registerShutdownHandlers;
-    getHttpServer(): Server<any>;
-    getInjector(): import("./container").InjectorService;
-    private createHttpServer;
-    private fetcherAsync;
-    private catcher;
-    private bootstrapApplication;
-    private handleShutdownHook;
-    private closeHttpServer;
-    private exitProcess;
-    private reportHookFailure;
-    private resolveLogger;
-    private isCorsEnabled;
-    private errorResponse;
-    private handlePreflightRequest;
-    private applyCorsHeaders;
-    close(closeActiveConnections?: boolean): void;
-    private resolveLocalsContainer;
-    private buildLocalsContainer;
-    private discoverRoutePath;
-}

package/dist/cache/bento-cache.driver.d.ts

@@ -1,13 +0,0 @@
-import { LoggerService } from '../services/logger.service';
-import { CacheService } from './cache.service';
-export declare class BentoCacheDriver extends CacheService {
-    private readonly logger;
-    private cache;
-    constructor(logger: LoggerService);
-    set(key: string, value: any, ttl?: number): Promise<boolean>;
-    get(key: string): Promise<any>;
-    del(key: string): Promise<boolean>;
-    has(key: string): Promise<boolean>;
-    clear(): Promise<void>;
-    getOrSet(key: string, cb: () => Promise<any>, ttl?: number): Promise<any>;
-}

package/dist/cache/bento-cache.driver.js

@@ -1,55 +0,0 @@
-"use strict";
-var __decorate = (this && this.__decorate) || function (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;
-};
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BentoCacheDriver = void 0;
-const service_decorator_1 = require("../commons/decorators/service.decorator");
-const logger_service_1 = require("../services/logger.service");
-const cache_service_1 = require("./cache.service");
-const bentocache_1 = require("bentocache");
-// @ts-ignore
-const memory_1 = require("bentocache/drivers/memory");
-let BentoCacheDriver = class BentoCacheDriver extends cache_service_1.CacheService {
-    constructor(logger) {
-        super();
-        this.logger = logger;
-        this.cache = new bentocache_1.BentoCache({
-            //@ts-ignore
-            logger: this.logger.getLogger(),
-            default: 'defaultCache',
-            stores: {
-                defaultCache: (0, bentocache_1.bentostore)().useL1Layer(((0, memory_1.memoryDriver)({ maxSize: 10_000 }))), // TODO: Not default, custom with properties.
-            }
-        });
-    }
-    set(key, value, ttl) {
-        return this.cache.set({ key, value, ttl: ttl ?? '1h' });
-    }
-    get(key) {
-        return this.cache.get({ key });
-    }
-    del(key) {
-        return this.cache.delete({ key });
-    }
-    has(key) {
-        return this.cache.has({ key });
-    }
-    clear() {
-        return this.cache.clear();
-    }
-    getOrSet(key, cb, ttl) {
-        return this.cache.getOrSet({ key, factory: cb, ttl: ttl ?? '1h' });
-    }
-};
-exports.BentoCacheDriver = BentoCacheDriver;
-exports.BentoCacheDriver = BentoCacheDriver = __decorate([
-    (0, service_decorator_1.Service)({ provide: cache_service_1.CacheService }),
-    __metadata("design:paramtypes", [logger_service_1.LoggerService])
-], BentoCacheDriver);

package/dist/cache/cache.service.d.ts

@@ -1,8 +0,0 @@
-export declare abstract class CacheService {
-    abstract set(key: string, value: any, ttl?: number): Promise<boolean>;
-    abstract get(key: string): Promise<any>;
-    abstract del(key: string): Promise<boolean>;
-    abstract has(key: string): Promise<boolean>;
-    abstract clear(): Promise<void>;
-    abstract getOrSet<T>(key: string, cb: () => Promise<T>, ttl?: number): Promise<T>;
-}

package/dist/cache/cache.service.js

@@ -1,6 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CacheService = void 0;
-class CacheService {
-}
-exports.CacheService = CacheService;

package/dist/commons/decorators/Injectable.decorator.d.ts

@@ -1,20 +0,0 @@
-import { Provider } from "../../domain/provider";
-/**
- * The decorators `@Injectable()` declare a new service can be injected in other service, controller, interceptor, etc.. on there `constructor`.
- * All classes annotated with `@Injectable()` are built one time, excepted if you change the default provider configuration.
- *
- * ::: tip
- * `@Injectable()` use the `reflect-metadata` to collect and inject the built provided to other services.
- * :::
- *
- * ### Options
- *
- * - type (@@ProviderType@@  or `string`): Kind of provider. (Default: `ProviderType.PROVIDER`)
- * - scope (@@ProviderScope@@): Kind of provider. (Default: `ProviderScope.SINGLETON`)
- * - provide (@@TokenProvider@@): An injection token (Note: This option override default metadata generated by Typescript).
- * - deps (`Type<any>`): List of class or provider which will be injected to the constructor (Note: This options override default metadata generated by Typescript).
- *
- * @returns {Function}
- * @decorator
- */
-export declare function Injectable(options?: Partial<Provider>): ClassDecorator;

package/dist/commons/decorators/Injectable.decorator.js

@@ -1,33 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Injectable = Injectable;
-const Metadata_1 = require("../../domain/Metadata");
-const constants_1 = require("../../constants");
-/**
- * The decorators `@Injectable()` declare a new service can be injected in other service, controller, interceptor, etc.. on there `constructor`.
- * All classes annotated with `@Injectable()` are built one time, excepted if you change the default provider configuration.
- *
- * ::: tip
- * `@Injectable()` use the `reflect-metadata` to collect and inject the built provided to other services.
- * :::
- *
- * ### Options
- *
- * - type (@@ProviderType@@  or `string`): Kind of provider. (Default: `ProviderType.PROVIDER`)
- * - scope (@@ProviderScope@@): Kind of provider. (Default: `ProviderScope.SINGLETON`)
- * - provide (@@TokenProvider@@): An injection token (Note: This option override default metadata generated by Typescript).
- * - deps (`Type<any>`): List of class or provider which will be injected to the constructor (Note: This options override default metadata generated by Typescript).
- *
- * @returns {Function}
- * @decorator
- */
-function Injectable(options = {}) {
-    return (target) => {
-        const providers = Metadata_1.Metadata.get(constants_1.PROVIDER, Reflect) || [];
-        providers.push({
-            ...options,
-            ...(options.provide ? { useClass: target } : { provide: target }),
-        });
-        Metadata_1.Metadata.set(constants_1.PROVIDER, providers, Reflect);
-    };
-}

package/dist/commons/decorators/controller.decorator.d.ts

@@ -1,8 +0,0 @@
-import { ProviderScope } from "../../domain/provider-scope";
-type ControllerOptions = {
-    path?: string;
-    scope?: ProviderScope;
-    children?: any[];
-};
-export declare function Controller(pathOrOptions?: string | ControllerOptions): ClassDecorator;
-export {};

package/dist/commons/decorators/controller.decorator.js

@@ -1,22 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Controller = Controller;
-const constants_1 = require("../../constants");
-const Metadata_1 = require("../../domain/Metadata");
-function normalizeOptions(pathOrOptions) {
-    if (!pathOrOptions) {
-        return {};
-    }
-    if (typeof pathOrOptions === 'string') {
-        return { path: pathOrOptions };
-    }
-    return pathOrOptions;
-}
-function Controller(pathOrOptions) {
-    return (target) => {
-        const options = normalizeOptions(pathOrOptions);
-        const controllers = Metadata_1.Metadata.get(constants_1.CONTROLLER, Reflect) || [];
-        controllers.push({ provide: target, ...options });
-        Metadata_1.Metadata.set(constants_1.CONTROLLER, controllers, Reflect);
-    };
-}

package/dist/commons/decorators/http.decorators.d.ts

@@ -1,13 +0,0 @@
-import { Context } from "../../domain/Context";
-export declare function createParamDecorator(func: (context: Context, data?: any) => any): (data?: any) => ParameterDecorator;
-export declare const Body: (data?: any) => ParameterDecorator;
-export declare const Query: (data?: any) => ParameterDecorator;
-export declare const Param: (data?: any) => ParameterDecorator;
-export declare const Req: (data?: any) => ParameterDecorator;
-export declare const Headers: (data?: any) => ParameterDecorator;
-export declare const Locals: (data?: any) => ParameterDecorator;
-export declare const Get: (path?: string) => MethodDecorator;
-export declare const Post: (path?: string) => MethodDecorator;
-export declare const Put: (path?: string) => MethodDecorator;
-export declare const Delete: (path?: string) => MethodDecorator;
-export declare const Patch: (path?: string) => MethodDecorator;

package/dist/commons/decorators/http.decorators.js

@@ -1,63 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Patch = exports.Delete = exports.Put = exports.Post = exports.Get = exports.Locals = exports.Headers = exports.Req = exports.Param = exports.Query = exports.Body = void 0;
-exports.createParamDecorator = createParamDecorator;
-const Metadata_1 = require("../../domain/Metadata");
-const constants_1 = require("../../constants");
-const PARAM_TYPE_KEY = "__carnoParamType";
-const markParamType = (func, paramType) => {
-    func[PARAM_TYPE_KEY] = paramType;
-    return func;
-};
-const createMethodDecorator = (methodType) => {
-    return (path = "") => {
-        return (target, propertyKey) => {
-            const routes = [];
-            if (!path.startsWith("/")) {
-                path = `/${path}`;
-            }
-            if (Metadata_1.Metadata.has(constants_1.CONTROLLER_ROUTES, target)) {
-                routes.push(...Metadata_1.Metadata.get(constants_1.CONTROLLER_ROUTES, target));
-            }
-            routes.push({
-                method: methodType,
-                path,
-                methodName: propertyKey.toString(),
-                middlewares: [],
-            });
-            Metadata_1.Metadata.set(constants_1.CONTROLLER_ROUTES, routes, target);
-        };
-    };
-};
-function createParamDecorator(func) {
-    return (data) => (target, propertyKey, parameterIndex) => {
-        const existingArgs = Metadata_1.Metadata.get(constants_1.ROUTE_PARAM, target.constructor, propertyKey) || {};
-        existingArgs[parameterIndex] = {
-            fun: func,
-            param: data,
-            type: func[PARAM_TYPE_KEY],
-        };
-        Metadata_1.Metadata.set(constants_1.ROUTE_PARAM, existingArgs, target.constructor, propertyKey);
-    };
-}
-const bodyResolver = markParamType((context, data) => data ? context.body[data] : context.body || {}, "body");
-const queryResolver = markParamType((context, data) => data ? context.query[data] : context.query || {}, "query");
-const paramResolver = markParamType((context, data) => data ? context.param[data] : null, "param");
-const reqResolver = markParamType((context) => context.req, "req");
-const headersResolver = markParamType((context, data) => data
-    ? context.headers.has(data)
-        ? context.headers.get(data)
-        : undefined
-    : context.headers || {}, "headers");
-const localsResolver = markParamType((context) => context.locals || {}, "locals");
-exports.Body = createParamDecorator(bodyResolver);
-exports.Query = createParamDecorator(queryResolver);
-exports.Param = createParamDecorator(paramResolver);
-exports.Req = createParamDecorator(reqResolver);
-exports.Headers = createParamDecorator(headersResolver);
-exports.Locals = createParamDecorator(localsResolver);
-exports.Get = createMethodDecorator("GET");
-exports.Post = createMethodDecorator("POST");
-exports.Put = createMethodDecorator("PUT");
-exports.Delete = createMethodDecorator("DELETE");
-exports.Patch = createMethodDecorator("PATCH");

package/dist/commons/decorators/index.d.ts

@@ -1,6 +0,0 @@
-export * from './controller.decorator';
-export * from './http.decorators';
-export * from './service.decorator';
-export * from './middleware.decorator';
-export * from './Injectable.decorator';
-export * from './validation.decorator';

package/dist/commons/decorators/index.js

@@ -1,22 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./controller.decorator"), exports);
-__exportStar(require("./http.decorators"), exports);
-__exportStar(require("./service.decorator"), exports);
-__exportStar(require("./middleware.decorator"), exports);
-__exportStar(require("./Injectable.decorator"), exports);
-__exportStar(require("./validation.decorator"), exports);

package/dist/commons/decorators/inject.decorator.d.ts

@@ -1 +0,0 @@
-export declare const Inject: (data?: any) => ParameterDecorator;

package/dist/commons/decorators/inject.decorator.js

@@ -1,5 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Inject = void 0;
-const http_decorators_1 = require("./http.decorators");
-exports.Inject = (0, http_decorators_1.createParamDecorator)(() => { });

package/dist/commons/decorators/middleware.decorator.d.ts

@@ -1,2 +0,0 @@
-import { CarnoMiddleware } from "../../domain/CarnoMiddleware";
-export declare function Middleware(...middlewares: (new (...args: any[]) => CarnoMiddleware)[]): ClassDecorator & MethodDecorator;

package/dist/commons/decorators/middleware.decorator.js

@@ -1,30 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Middleware = Middleware;
-const constants_1 = require("../../constants");
-function Middleware(...middlewares) {
-    return (target, propertyKey) => {
-        let definedMiddlewares;
-        if (propertyKey)
-            definedMiddlewares = getMethodMiddlewares(target, propertyKey.toString());
-        else
-            definedMiddlewares = getControllerMiddlewares(target);
-        definedMiddlewares.push(...middlewares);
-        if (propertyKey)
-            setMethodMiddlewares(target, propertyKey.toString(), definedMiddlewares);
-        else
-            setControllerMiddlewares(target, definedMiddlewares);
-    };
-}
-function getControllerMiddlewares(target) {
-    return Reflect.getMetadata(constants_1.CONTROLLER_MIDDLEWARES, target) || [];
-}
-function setControllerMiddlewares(target, middlewares) {
-    Reflect.defineMetadata(constants_1.CONTROLLER_MIDDLEWARES, middlewares, target);
-}
-function getMethodMiddlewares(target, methodName) {
-    return Reflect.getMetadata(constants_1.ROUTE_MIDDLEWARES, target.constructor, methodName) || [];
-}
-function setMethodMiddlewares(target, methodName, middlewares) {
-    Reflect.defineMetadata(constants_1.ROUTE_MIDDLEWARES, middlewares, target.constructor, methodName);
-}

package/dist/commons/decorators/service.decorator.d.ts

@@ -1,2 +0,0 @@
-import { Provider } from '../../domain/provider';
-export declare function Service(options?: Partial<Provider>): ClassDecorator;

package/dist/commons/decorators/service.decorator.js

@@ -1,7 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Service = Service;
-const Injectable_decorator_1 = require("./Injectable.decorator");
-function Service(options = {}) {
-    return (0, Injectable_decorator_1.Injectable)(options);
-}

package/dist/commons/decorators/validation.decorator.d.ts

@@ -1,32 +0,0 @@
-import { z } from "zod";
-/**
- * Decorator to attach a Zod schema to a DTO class
- * The schema will be used for validation when the DTO is used in route handlers
- *
- * @example
- * ```typescript
- * const CreateUserSchema = z.object({
- *   name: z.string().min(3),
- *   email: z.string().email()
- * });
- *
- * @ZodSchema(CreateUserSchema)
- * class CreateUserDto {
- *   name: string;
- *   email: string;
- * }
- *
- * @Controller('/users')
- * class UserController {
- *   @Post()
- *   create(@Body() dto: CreateUserDto) {
- *     // dto is validated and typed
- *     return dto;
- *   }
- * }
- * ```
- *
- * @param schema - The Zod schema to use for validation
- * @returns Class decorator
- */
-export declare function ZodSchema<T extends z.ZodType>(schema: T): ClassDecorator;

package/dist/commons/decorators/validation.decorator.js

@@ -1,40 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ZodSchema = ZodSchema;
-const Metadata_1 = require("../../domain/Metadata");
-const constants_1 = require("../../constants");
-/**
- * Decorator to attach a Zod schema to a DTO class
- * The schema will be used for validation when the DTO is used in route handlers
- *
- * @example
- * ```typescript
- * const CreateUserSchema = z.object({
- *   name: z.string().min(3),
- *   email: z.string().email()
- * });
- *
- * @ZodSchema(CreateUserSchema)
- * class CreateUserDto {
- *   name: string;
- *   email: string;
- * }
- *
- * @Controller('/users')
- * class UserController {
- *   @Post()
- *   create(@Body() dto: CreateUserDto) {
- *     // dto is validated and typed
- *     return dto;
- *   }
- * }
- * ```
- *
- * @param schema - The Zod schema to use for validation
- * @returns Class decorator
- */
-function ZodSchema(schema) {
-    return (target) => {
-        Metadata_1.Metadata.set(constants_1.VALIDATION_ZOD_SCHEMA, schema, target);
-    };
-}