@carno.js/core 0.2.7 → 0.2.9

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;

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

@@ -0,0 +1,14 @@
+import type { ValidatorAdapter } from "../ValidatorAdapter";
+export interface ZodAdapterOptions {
+}
+export declare class ZodAdapter implements ValidatorAdapter<ZodAdapterOptions> {
+    private options;
+    constructor(options?: ZodAdapterOptions);
+    getName(): string;
+    getOptions(): ZodAdapterOptions;
+    hasValidation(target: Function): boolean;
+    validateAndTransform(target: Function, value: any): any;
+    private getSchema;
+    private formatZodErrors;
+    private buildFieldPath;
+}

package/dist/validation/adapters/ZodAdapter.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZodAdapter = void 0;
+const Metadata_1 = require("../../domain/Metadata");
+const HttpException_1 = require("../../exceptions/HttpException");
+const constants_1 = require("../../constants");
+class ZodAdapter {
+    constructor(options = {}) {
+        this.options = options;
+    }
+    getName() {
+        return "ZodAdapter";
+    }
+    getOptions() {
+        return this.options;
+    }
+    hasValidation(target) {
+        return Metadata_1.Metadata.has(constants_1.VALIDATION_ZOD_SCHEMA, target);
+    }
+    validateAndTransform(target, value) {
+        const schema = this.getSchema(target);
+        if (!schema) {
+            return value;
+        }
+        const result = schema.safeParse(value);
+        if (!result.success) {
+            const formattedErrors = this.formatZodErrors(result.error);
+            throw new HttpException_1.HttpException(formattedErrors, 400);
+        }
+        return result.data;
+    }
+    getSchema(target) {
+        return Metadata_1.Metadata.get(constants_1.VALIDATION_ZOD_SCHEMA, target);
+    }
+    formatZodErrors(error) {
+        const issuesMap = new Map();
+        for (const issue of error.issues) {
+            const field = this.buildFieldPath(issue.path);
+            if (!issuesMap.has(field)) {
+                issuesMap.set(field, []);
+            }
+            issuesMap.get(field).push(issue.message);
+        }
+        return Array.from(issuesMap.entries()).map(([field, messages]) => ({
+            field,
+            messages,
+        }));
+    }
+    buildFieldPath(path) {
+        if (path.length === 0) {
+            return "body";
+        }
+        return path.map(p => String(p)).join(".");
+    }
+}
+exports.ZodAdapter = ZodAdapter;

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

@@ -0,0 +1,4 @@
+export { ZodAdapter } from "./ZodAdapter";
+export type { ZodAdapterOptions } from "./ZodAdapter";
+export { ClassValidatorAdapter } from "./ClassValidatorAdapter";
+export type { ClassValidatorAdapterOptions } from "./ClassValidatorAdapter";

package/dist/validation/adapters/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClassValidatorAdapter = exports.ZodAdapter = void 0;
+var ZodAdapter_1 = require("./ZodAdapter");
+Object.defineProperty(exports, "ZodAdapter", { enumerable: true, get: function () { return ZodAdapter_1.ZodAdapter; } });
+var ClassValidatorAdapter_1 = require("./ClassValidatorAdapter");
+Object.defineProperty(exports, "ClassValidatorAdapter", { enumerable: true, get: function () { return ClassValidatorAdapter_1.ClassValidatorAdapter; } });

package/dist/validation/index.d.ts

@@ -0,0 +1,3 @@
+export type { ValidatorAdapter, ValidatorAdapterConstructor, ValidationConfig, ValidatorAdapterOptions, } from "./ValidatorAdapter";
+export { defineValidation } from "./ValidatorAdapter";
+export * from "./adapters";

package/dist/validation/index.js

@@ -0,0 +1,20 @@
+"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 });
+exports.defineValidation = void 0;
+var ValidatorAdapter_1 = require("./ValidatorAdapter");
+Object.defineProperty(exports, "defineValidation", { enumerable: true, get: function () { return ValidatorAdapter_1.defineValidation; } });
+__exportStar(require("./adapters"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@carno.js/core",
-  "version": "0.2.7",
+  "version": "0.2.9",
   "description": "Carno.js is a framework for building web applications object oriented with TypeScript and Bun.sh",
   "keywords": [
     "bun",
@@ -33,23 +33,34 @@
   "license": "MIT",
   "dependencies": {
     "bentocache": "^1.0.0-beta.5",
-    "class-transformer": "^0.5.1",
-    "class-validator": "^0.14.0",
     "globby": "^10.0.2",
     "parseurl-fast": "^1.2.0",
     "pino": "^8.16.1",
     "pino-pretty": "^10.2.3",
-    "reflect-metadata": "^0.1.13"
+    "reflect-metadata": "^0.1.13",
+    "zod": "^4.3.4"
   },
   "devDependencies": {
     "@types/globby": "^9.1.0",
-    "bun-types": "latest"
+    "bun-types": "latest",
+    "class-transformer": "^0.5.1",
+    "class-validator": "^0.14.3"
   },
   "peerDependencies": {
+    "class-transformer": "^0.5.1",
+    "class-validator": "^0.14.0",
     "typescript": "^5.0.0"
   },
+  "peerDependenciesMeta": {
+    "class-validator": {
+      "optional": true
+    },
+    "class-transformer": {
+      "optional": true
+    }
+  },
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "4abd763d3be38f53df2073a55bbc03e5deb3eeb6"
+  "gitHead": "cc116bcd2f96e3cf6e87bbb38d5e4dfe1245150a"
 }

package/dist/Cheetah.d.ts

@@ -1,65 +0,0 @@
-import { Server } from "bun";
-import { ValidatorOptions } from "class-validator";
-import * as pino from "pino";
-import { TokenRouteWithProvider } from "./container/ContainerConfiguration";
-import { CorsConfig } from "./domain/cors-config";
-import Memoirist from "./route/memoirist";
-export interface ApplicationConfig {
-    validation?: ValidatorOptions;
-    logger?: pino.LoggerOptions;
-    exports?: any[];
-    providers?: any[];
-    cors?: CorsConfig;
-    globalMiddlewares?: any[];
-}
-export declare class Cheetah {
-    config: ApplicationConfig;
-    router: Memoirist<TokenRouteWithProvider>;
-    private injector;
-    private fetch;
-    private server;
-    constructor(config?: ApplicationConfig);
-    /**
-     * Use the Cheetah plugin.
-     *
-     * @param plugin
-     */
-    use(plugin: Cheetah): 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(".").InjectorService;
-    private createHttpServer;
-    private fetcher;
-    private catcher;
-    private bootstrapApplication;
-    private handleShutdownHook;
-    private closeHttpServer;
-    private exitProcess;
-    private reportHookFailure;
-    private isCorsEnabled;
-    private isOriginAllowed;
-    private buildCorsHeaders;
-    private handlePreflightRequest;
-    private applyCorsHeaders;
-    close(closeActiveConnections?: boolean): void;
-    private discoverRoutePath;
-}