@carno.js/core 0.2.8 → 0.2.9

package/dist/Carno.d.ts

@@ -1,27 +1,29 @@
 import { Server } from "bun";
-import { ValidatorOptions } from "class-validator";
 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 {
-    validation?: ValidatorOptions;
+export interface ApplicationConfig<TAdapter extends ValidatorAdapterConstructor = ValidatorAdapterConstructor> {
+    validation?: ValidationConfig<TAdapter>;
     logger?: pino.LoggerOptions;
     exports?: any[];
     providers?: any[];
     cors?: CorsConfig;
     globalMiddlewares?: any[];
 }
-export declare class Carno {
-    config: ApplicationConfig;
+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 fetch;
     private server;
-    constructor(config?: ApplicationConfig);
+    constructor(config?: ApplicationConfig<TAdapter>);
+    private resolveValidatorAdapter;
     /**
      * Use the Carno plugin.
      *
@@ -49,7 +51,7 @@ export declare class Carno {
     listen(port?: number): Promise<void>;
     private registerShutdownHandlers;
     getHttpServer(): Server<any>;
-    getInjector(): import(".").InjectorService;
+    getInjector(): import("./container").InjectorService;
     private createHttpServer;
     private fetcher;
     private catcher;

package/dist/Carno.js

@@ -5,6 +5,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Carno = void 0;
 const node_process_1 = __importDefault(require("node:process"));
+const ZodAdapter_1 = require("./validation/adapters/ZodAdapter");
+const ValidationCache_1 = require("./utils/ValidationCache");
 const index_1 = require("./commons/index");
 const constants_1 = require("./constants");
 const createContainer_1 = require("./container/createContainer");
@@ -56,11 +58,21 @@ class Carno {
             console.error("Unhandled error:", error);
             return new Response("Internal Server Error", { status: 500 });
         };
+        this.validatorAdapter = this.resolveValidatorAdapter();
         if (config.cors) {
             this.corsCache = new cors_headers_cache_1.CorsHeadersCache(config.cors);
         }
         void this.bootstrapApplication();
     }
+    resolveValidatorAdapter() {
+        const config = this.config.validation;
+        if (!config?.adapter) {
+            return new ZodAdapter_1.ZodAdapter();
+        }
+        const AdapterClass = config.adapter;
+        const options = config.options || {};
+        return new AdapterClass(options);
+    }
     /**
      * Use the Carno plugin.
      *
@@ -148,8 +160,9 @@ class Carno {
         };
     }
     async init() {
+        (0, ValidationCache_1.setValidatorAdapter)(this.validatorAdapter);
         this.loadProvidersAndControllers();
-        await this.injector.loadModule((0, createContainer_1.createContainer)(), this.config, this.router);
+        await this.injector.loadModule((0, createContainer_1.createContainer)(), this.config, this.router, this.validatorAdapter);
     }
     async listen(port = 3000) {
         this.registerShutdownHandlers();

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

@@ -3,3 +3,4 @@ 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

@@ -19,3 +19,4 @@ __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/validation.decorator.d.ts

@@ -0,0 +1,32 @@
+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

@@ -0,0 +1,40 @@
+"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);
+    };
+}

package/dist/constants.d.ts

@@ -5,3 +5,4 @@ export declare const CONTROLLER_EVENTS = "carno:controller:events";
 export declare const ROUTE_PARAM = "carno:route:param";
 export declare const ROUTE_MIDDLEWARES = "carno:route:middlewares";
 export declare const PROVIDER = "carno:provider";
+export declare const VALIDATION_ZOD_SCHEMA = "carno:validation:zod";

package/dist/constants.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PROVIDER = exports.ROUTE_MIDDLEWARES = exports.ROUTE_PARAM = exports.CONTROLLER_EVENTS = exports.CONTROLLER_MIDDLEWARES = exports.CONTROLLER_ROUTES = exports.CONTROLLER = void 0;
+exports.VALIDATION_ZOD_SCHEMA = exports.PROVIDER = exports.ROUTE_MIDDLEWARES = exports.ROUTE_PARAM = exports.CONTROLLER_EVENTS = exports.CONTROLLER_MIDDLEWARES = exports.CONTROLLER_ROUTES = exports.CONTROLLER = void 0;
 exports.CONTROLLER = "carno:controller";
 exports.CONTROLLER_ROUTES = "carno:controller:routes";
 exports.CONTROLLER_MIDDLEWARES = "carno:controller:middlewares";
@@ -8,3 +8,4 @@ exports.CONTROLLER_EVENTS = "carno:controller:events";
 exports.ROUTE_PARAM = "carno:route:param";
 exports.ROUTE_MIDDLEWARES = "carno:route:middlewares";
 exports.PROVIDER = "carno:provider";
+exports.VALIDATION_ZOD_SCHEMA = "carno:validation:zod";

package/dist/container/InjectorService.d.ts

@@ -1,5 +1,6 @@
 import type { ApplicationConfig } from "../Carno";
 import { TokenProvider } from "../commons/registries/ProviderControl";
+import type { ValidatorAdapter } from "../validation/ValidatorAdapter";
 import { Context } from "../domain/Context";
 import { LocalsContainer } from "../domain/LocalsContainer";
 import { Provider } from "../domain/provider";
@@ -20,7 +21,8 @@ export declare class InjectorService {
     private routeResolver;
     private dependencyResolver;
     private methodInvoker;
-    loadModule(container: Container, applicationConfig: ApplicationConfig, router: Memoirist<any>): Promise<void>;
+    private validatorAdapter;
+    loadModule(container: Container, applicationConfig: ApplicationConfig, router: Memoirist<any>, validatorAdapter: ValidatorAdapter): Promise<void>;
     private initializeResolvers;
     private ensureProvider;
     get(token: TokenProvider): Provider | undefined;

package/dist/container/InjectorService.js

@@ -40,10 +40,11 @@ let InjectorService = InjectorService_1 = class InjectorService {
         this._hasOnResponseHook = false;
         this.controllerScopes = new Map();
     }
-    async loadModule(container, applicationConfig, router) {
+    async loadModule(container, applicationConfig, router, validatorAdapter) {
         this.container = container;
         this.router = router;
         this.applicationConfig = applicationConfig;
+        this.validatorAdapter = validatorAdapter;
         this.initializeResolvers();
         this.removeUnknownProviders();
         this.saveInjector();
@@ -57,7 +58,7 @@ let InjectorService = InjectorService_1 = class InjectorService {
     initializeResolvers() {
         this.routeResolver = new RouteResolver_1.RouteResolver(this.router, this.applicationConfig.globalMiddlewares);
         this.dependencyResolver = new DependencyResolver_1.DependencyResolver(this.container);
-        this.methodInvoker = new MethodInvoker_1.MethodInvoker(this.applicationConfig);
+        this.methodInvoker = new MethodInvoker_1.MethodInvoker(this.applicationConfig, this.validatorAdapter);
     }
     ensureProvider(token) {
         if (!this.container.has(token) && ProviderControl_1.GlobalProvider.has(token)) {
@@ -175,7 +176,7 @@ let InjectorService = InjectorService_1 = class InjectorService {
         const compiler = new RouteCompiler_1.RouteCompiler({
             container: this.container,
             controllerScopes: this.controllerScopes,
-            validationConfig: this.applicationConfig.validation,
+            validatorAdapter: this.validatorAdapter,
             hasOnRequestHook: this._hasOnRequestHook,
             hasOnResponseHook: this._hasOnResponseHook,
         });

package/dist/container/MethodInvoker.d.ts

@@ -2,10 +2,12 @@ import { ApplicationConfig } from "../Carno";
 import { TokenProvider } from "../commons/registries/ProviderControl";
 import { Context } from "../domain/Context";
 import { LocalsContainer } from "../domain/LocalsContainer";
+import type { ValidatorAdapter } from "../validation/ValidatorAdapter";
 export declare class MethodInvoker {
     private applicationConfig;
+    private validatorAdapter;
     private historyMethods;
-    constructor(applicationConfig: ApplicationConfig);
+    constructor(applicationConfig: ApplicationConfig, validatorAdapter: ValidatorAdapter);
     invoke(instance: any, methodName: string, locals: LocalsContainer, context: Context, invokeCallback: (token: TokenProvider, locals: LocalsContainer) => any): Promise<any>;
     private getMethodInfo;
     private getCachedMethod;
@@ -16,5 +18,4 @@ export declare class MethodInvoker {
     private hasBodyParam;
     private isBodyParam;
     private resolveService;
-    private validateAndTransform;
 }

package/dist/container/MethodInvoker.js

@@ -1,16 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MethodInvoker = void 0;
-const class_transformer_1 = require("class-transformer");
-const class_validator_1 = require("class-validator");
 const Metadata_1 = require("../domain/Metadata");
-const HttpException_1 = require("../exceptions/HttpException");
 const getClassOrSymbol_1 = require("../utils/getClassOrSymbol");
 const getMethodArgTypes_1 = require("../utils/getMethodArgTypes");
-const isClassValidator_1 = require("../utils/isClassValidator");
 class MethodInvoker {
-    constructor(applicationConfig) {
+    constructor(applicationConfig, validatorAdapter) {
         this.applicationConfig = applicationConfig;
+        this.validatorAdapter = validatorAdapter;
         this.historyMethods = new WeakMap();
     }
     async invoke(instance, methodName, locals, context, invokeCallback) {
@@ -78,19 +75,9 @@ class MethodInvoker {
             return invokeCallback((0, getClassOrSymbol_1.getClassOrSymbol)(token), locals);
         }
         const value = param.fun(context, param.param);
-        return (0, isClassValidator_1.isClassValidator)(token)
-            ? this.validateAndTransform(token, value)
+        return this.validatorAdapter.hasValidation(token)
+            ? this.validatorAdapter.validateAndTransform(token, value)
             : value;
     }
-    validateAndTransform(token, value) {
-        const obj = (0, class_transformer_1.plainToInstance)(token, value);
-        const errors = (0, class_validator_1.validateSync)(obj, this.applicationConfig.validation);
-        // todo: deve retornar apenas os erros e no o objeto class-validator intei
-        // ro.
-        if (errors.length > 0) {
-            throw new HttpException_1.HttpException(errors, 400);
-        }
-        return obj;
-    }
 }
 exports.MethodInvoker = MethodInvoker;

package/dist/index.d.ts

@@ -13,3 +13,4 @@ export * from "./services/logger.service";
 export * from "./cache/cache.service";
 export * from "./cache/bento-cache.driver";
 export * from "./testing";
+export * from "./validation";

package/dist/index.js

@@ -29,3 +29,4 @@ __exportStar(require("./services/logger.service"), exports);
 __exportStar(require("./cache/cache.service"), exports);
 __exportStar(require("./cache/bento-cache.driver"), exports);
 __exportStar(require("./testing"), exports);
+__exportStar(require("./validation"), exports);

package/dist/route/ParamResolverFactory.d.ts

@@ -1,6 +1,4 @@
-import { type ValidatorOptions } from 'class-validator';
 import type { Context } from '../domain/Context';
-import type { ParamResolver, AsyncParamResolver } from './CompiledRoute';
 export type ParamDecoratorType = 'body' | 'query' | 'param' | 'headers' | 'req' | 'locals';
 export interface ParamDecoratorMeta {
     fun: (context: Context, data?: any) => any;
@@ -14,6 +12,3 @@ export interface ParamInfo {
     token?: any;
 }
 export declare function analyzeParamDecorator(decoratorMeta: ParamDecoratorMeta | undefined, token: any): ParamInfo;
-export declare function createParamResolver(decoratorMeta: ParamDecoratorMeta | undefined, token: any, validationConfig?: ValidatorOptions): ParamResolver | AsyncParamResolver | null;
-export declare function createParamResolvers(paramMetas: Record<number, ParamDecoratorMeta> | undefined, argTypes: any[], validationConfig?: ValidatorOptions): (ParamResolver | AsyncParamResolver | null)[];
-export declare function hasAnyDIParam(resolvers: (ParamResolver | AsyncParamResolver | null)[]): boolean;

package/dist/route/ParamResolverFactory.js

@@ -1,12 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.analyzeParamDecorator = analyzeParamDecorator;
-exports.createParamResolver = createParamResolver;
-exports.createParamResolvers = createParamResolvers;
-exports.hasAnyDIParam = hasAnyDIParam;
-const class_transformer_1 = require("class-transformer");
-const class_validator_1 = require("class-validator");
-const HttpException_1 = require("../exceptions/HttpException");
 const ValidationCache_1 = require("../utils/ValidationCache");
 function analyzeParamDecorator(decoratorMeta, token) {
     if (!decoratorMeta) {
@@ -53,37 +47,3 @@ function inferTypeFromSource(resolver) {
     }
     return null;
 }
-function createValidationResolver(extractFn, token, validationConfig) {
-    return (context) => {
-        const value = extractFn(context);
-        const obj = (0, class_transformer_1.plainToInstance)(token, value);
-        const errors = (0, class_validator_1.validateSync)(obj, validationConfig);
-        if (errors.length > 0) {
-            throw new HttpException_1.HttpException(errors, 400);
-        }
-        return obj;
-    };
-}
-function createParamResolver(decoratorMeta, token, validationConfig) {
-    if (!decoratorMeta) {
-        return null;
-    }
-    const extractFn = (context) => decoratorMeta.fun(context, decoratorMeta.param);
-    const needsValidation = typeof token === 'function' && (0, ValidationCache_1.isValidatable)(token);
-    if (needsValidation) {
-        return createValidationResolver(extractFn, token, validationConfig);
-    }
-    return extractFn;
-}
-function createParamResolvers(paramMetas, argTypes, validationConfig) {
-    const resolvers = [];
-    for (let i = 0; i < argTypes.length; i++) {
-        const meta = paramMetas?.[i];
-        const token = argTypes[i];
-        resolvers.push(createParamResolver(meta, token, validationConfig));
-    }
-    return resolvers;
-}
-function hasAnyDIParam(resolvers) {
-    return resolvers.some((r) => r === null);
-}

package/dist/route/RouteCompiler.d.ts

@@ -1,19 +1,19 @@
-import { type ValidatorOptions } from 'class-validator';
 import type { TokenRouteWithProvider } from '../container/ContainerConfiguration';
+import type { ValidatorAdapter } from '../validation/ValidatorAdapter';
 import type { Container } from '../container/container';
 import { ProviderScope } from '../domain/provider-scope';
 import { type CompiledRoute } from './CompiledRoute';
 export interface RouteCompilerOptions {
     container: Container;
     controllerScopes: Map<any, ProviderScope>;
-    validationConfig?: ValidatorOptions;
+    validatorAdapter: ValidatorAdapter;
     hasOnRequestHook: boolean;
     hasOnResponseHook: boolean;
 }
 export declare class RouteCompiler {
     private container;
     private controllerScopes;
-    private validationConfig?;
+    private validatorAdapter;
     private hasOnRequestHook;
     private hasOnResponseHook;
     constructor(options: RouteCompilerOptions);

package/dist/route/RouteCompiler.js

@@ -1,11 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RouteCompiler = void 0;
-const class_transformer_1 = require("class-transformer");
-const class_validator_1 = require("class-validator");
 const provider_scope_1 = require("../domain/provider-scope");
 const Metadata_1 = require("../domain/Metadata");
-const HttpException_1 = require("../exceptions/HttpException");
 const getMethodArgTypes_1 = require("../utils/getMethodArgTypes");
 const CompiledRoute_1 = require("./CompiledRoute");
 const ParamResolverFactory_1 = require("./ParamResolverFactory");
@@ -14,7 +11,7 @@ class RouteCompiler {
     constructor(options) {
         this.container = options.container;
         this.controllerScopes = options.controllerScopes;
-        this.validationConfig = options.validationConfig;
+        this.validatorAdapter = options.validatorAdapter;
         this.hasOnRequestHook = options.hasOnRequestHook;
         this.hasOnResponseHook = options.hasOnResponseHook;
     }
@@ -158,7 +155,6 @@ class RouteCompiler {
     }
     createValidatedHandler(instance, methodName, paramInfos, hasBodyParam) {
         const handler = instance[methodName].bind(instance);
-        const config = this.validationConfig;
         const resolveArg = (ctx, param) => {
             let value;
             switch (param.type) {
@@ -184,12 +180,7 @@ class RouteCompiler {
                     value = undefined;
             }
             if (param.needsValidation && param.token) {
-                const obj = (0, class_transformer_1.plainToInstance)(param.token, value);
-                const errors = (0, class_validator_1.validateSync)(obj, config);
-                if (errors.length > 0) {
-                    throw new HttpException_1.HttpException(errors, 400);
-                }
-                return obj;
+                return this.validatorAdapter.validateAndTransform(param.token, value);
             }
             return value;
         };

package/dist/utils/ValidationCache.d.ts

@@ -1,3 +1,5 @@
+import type { ValidatorAdapter } from '../validation/ValidatorAdapter';
+export declare function setValidatorAdapter(adapter: ValidatorAdapter): void;
 export declare function isValidatable(token: Function): boolean;
 export declare function preloadValidationForParams(args: any[]): number[];
 export declare function clearValidationCache(): void;

package/dist/utils/ValidationCache.js

@@ -1,14 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.setValidatorAdapter = setValidatorAdapter;
 exports.isValidatable = isValidatable;
 exports.preloadValidationForParams = preloadValidationForParams;
 exports.clearValidationCache = clearValidationCache;
-const isClassValidator_1 = require("./isClassValidator");
+let currentAdapter = null;
 const cache = new Map();
+function setValidatorAdapter(adapter) {
+    currentAdapter = adapter;
+    cache.clear();
+}
 function isValidatable(token) {
+    if (!currentAdapter) {
+        throw new Error('Validator adapter not initialized. Call setValidatorAdapter() first.');
+    }
     let result = cache.get(token);
     if (result === undefined) {
-        result = (0, isClassValidator_1.isClassValidator)(token);
+        result = currentAdapter.hasValidation(token);
         cache.set(token, result);
     }
     return result;

package/dist/utils/index.d.ts

@@ -4,7 +4,6 @@ export * from './isString';
 export * from './isFunction';
 export * from './getConstructorArgNames';
 export * from './getValue';
-export * from './isClassValidator';
 export * from './getMethodArgTypes';
 export * from './getClassOrSymbol';
 export * from './isRequestScope';

package/dist/utils/index.js

@@ -20,7 +20,6 @@ __exportStar(require("./isString"), exports);
 __exportStar(require("./isFunction"), exports);
 __exportStar(require("./getConstructorArgNames"), exports);
 __exportStar(require("./getValue"), exports);
-__exportStar(require("./isClassValidator"), exports);
 __exportStar(require("./getMethodArgTypes"), exports);
 __exportStar(require("./getClassOrSymbol"), exports);
 __exportStar(require("./isRequestScope"), exports);

package/dist/validation/ValidatorAdapter.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Base interface for validation adapters
+ * Adapters provide validation capabilities for different libraries (Zod, class-validator, etc.)
+ */
+export interface ValidatorAdapter<TOptions = any> {
+    /**
+     * Checks if a class/function has validation metadata
+     * Used by ValidationCache for detection and optimization
+     *
+     * @param target - The class/function to check
+     * @returns true if validation metadata exists
+     */
+    hasValidation(target: Function): boolean;
+    /**
+     * Validates and transforms a value to the target type
+     *
+     * @param target - The DTO class to validate against
+     * @param value - The raw value to validate (usually from request body/query/params)
+     * @returns Transformed and validated instance
+     * @throws HttpException with formatted errors on validation failure
+     */
+    validateAndTransform(target: Function, value: any): any;
+    /**
+     * Get the name of the validator (for debugging/logging)
+     *
+     * @returns The validator name (e.g., "ZodAdapter", "ClassValidatorAdapter")
+     */
+    getName(): string;
+    /**
+     * Get the adapter options (for internal use)
+     */
+    getOptions(): TOptions;
+}
+/**
+ * Constructor type for validator adapters
+ */
+export type ValidatorAdapterConstructor<TOptions = any> = new (options?: TOptions) => ValidatorAdapter<TOptions>;
+/**
+ * Type to extract options type from a ValidatorAdapter constructor
+ */
+export type ValidatorAdapterOptions<TAdapter> = TAdapter extends new (options?: infer TOptions) => any ? TOptions : never;
+/**
+ * Validation configuration with adapter and options
+ */
+export interface ValidationConfig<TAdapter extends ValidatorAdapterConstructor = ValidatorAdapterConstructor> {
+    adapter?: TAdapter;
+    options?: ValidatorAdapterOptions<TAdapter>;
+}
+/**
+ * Helper function to create a strongly-typed validation config.
+ * Use this to get proper autocomplete for adapter options.
+ *
+ * @example
+ * ```typescript
+ * const app = new Carno({
+ *   validation: defineValidation({
+ *     adapter: ClassValidatorAdapter,
+ *     options: { whitelist: true } // ✓ Autocomplete works!
+ *   })
+ * });
+ * ```
+ */
+export declare function defineValidation<TAdapter extends ValidatorAdapterConstructor>(config: {
+    adapter: TAdapter;
+    options?: ValidatorAdapterOptions<TAdapter>;
+}): ValidationConfig<TAdapter>;

package/dist/validation/ValidatorAdapter.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defineValidation = defineValidation;
+/**
+ * Helper function to create a strongly-typed validation config.
+ * Use this to get proper autocomplete for adapter options.
+ *
+ * @example
+ * ```typescript
+ * const app = new Carno({
+ *   validation: defineValidation({
+ *     adapter: ClassValidatorAdapter,
+ *     options: { whitelist: true } // ✓ Autocomplete works!
+ *   })
+ * });
+ * ```
+ */
+function defineValidation(config) {
+    return config;
+}

package/dist/validation/adapters/ClassValidatorAdapter.d.ts

@@ -0,0 +1,23 @@
+import type { ValidatorAdapter } from "../ValidatorAdapter";
+export interface ClassValidatorAdapterOptions {
+    skipMissingProperties?: boolean;
+    whitelist?: boolean;
+    forbidNonWhitelisted?: boolean;
+    forbidUnknownValues?: boolean;
+    disableErrorMessages?: boolean;
+    errorHttpStatusCode?: number;
+    dismissDefaultMessages?: boolean;
+    validationError?: {
+        target?: boolean;
+        value?: boolean;
+    };
+    stopAtFirstError?: boolean;
+}
+export declare class ClassValidatorAdapter implements ValidatorAdapter<ClassValidatorAdapterOptions> {
+    private options;
+    constructor(options?: ClassValidatorAdapterOptions);
+    getName(): string;
+    getOptions(): ClassValidatorAdapterOptions;
+    hasValidation(target: Function): boolean;
+    validateAndTransform(target: Function, value: any): any;
+}

package/dist/validation/adapters/ClassValidatorAdapter.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClassValidatorAdapter = void 0;
+const HttpException_1 = require("../../exceptions/HttpException");
+const formatValidationErrors_1 = require("../../utils/formatValidationErrors");
+let classValidator;
+let classTransformer;
+try {
+    classValidator = require("class-validator");
+    classTransformer = require("class-transformer");
+}
+catch (error) {
+    // Will be checked in constructor
+}
+class ClassValidatorAdapter {
+    constructor(options = {}) {
+        this.options = options;
+        if (!classValidator || !classTransformer) {
+            throw new Error("ClassValidatorAdapter requires class-validator and class-transformer. " +
+                "Install with: npm install class-validator class-transformer");
+        }
+    }
+    getName() {
+        return "ClassValidatorAdapter";
+    }
+    getOptions() {
+        return this.options;
+    }
+    hasValidation(target) {
+        const { getMetadataStorage } = classValidator;
+        const metadataStorage = getMetadataStorage();
+        const validationMetadata = metadataStorage.getTargetValidationMetadatas(target, "", false, false, []);
+        return validationMetadata.length > 0;
+    }
+    validateAndTransform(target, value) {
+        const { validateSync } = classValidator;
+        const { plainToInstance } = classTransformer;
+        const instance = plainToInstance(target, value);
+        const errors = validateSync(instance, this.options);
+        if (errors.length > 0) {
+            const formatted = (0, formatValidationErrors_1.formatValidationErrors)(errors);
+            throw new HttpException_1.HttpException(formatted, 400);
+        }
+        return instance;
+    }
+}
+exports.ClassValidatorAdapter = ClassValidatorAdapter;