@carno.js/core 0.2.8 → 0.2.10

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;
@@ -58,8 +60,8 @@ export declare class Carno {
     private closeHttpServer;
     private exitProcess;
     private reportHookFailure;
+    private resolveLogger;
     private isCorsEnabled;
-    private isOriginAllowed;
     private handlePreflightRequest;
     private applyCorsHeaders;
     close(closeActiveConnections?: boolean): void;

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");
@@ -18,10 +20,8 @@ const HttpException_1 = require("./exceptions/HttpException");
 const RouteExecutor_1 = require("./route/RouteExecutor");
 const memoirist_1 = __importDefault(require("./route/memoirist"));
 const CompiledRoute_1 = require("./route/CompiledRoute");
-const FastPathExecutor_1 = require("./route/FastPathExecutor");
 const logger_service_1 = require("./services/logger.service");
 const parseUrl = require("parseurl-fast");
-// todo: change console.log for LoggerService.
 class Carno {
     constructor(config = {}) {
         this.config = config;
@@ -43,7 +43,7 @@ class Carno {
                     });
                     if (this.isCorsEnabled()) {
                         const origin = request.headers.get("origin");
-                        if (origin && this.isOriginAllowed(origin)) {
+                        if (origin && this.corsCache.isOriginAllowed(origin)) {
                             response = this.applyCorsHeaders(response, origin);
                         }
                     }
@@ -53,14 +53,24 @@ class Carno {
             }
         };
         this.catcher = (error) => {
-            console.error("Unhandled error:", error);
+            this.resolveLogger().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 +158,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();
@@ -158,7 +169,7 @@ class Carno {
     }
     registerShutdownHandlers() {
         const shutdown = async (signal) => {
-            console.log(`\nReceived ${signal}, starting graceful shutdown...`);
+            this.resolveLogger().info(`Received ${signal}, starting graceful shutdown...`);
             await this.handleShutdownHook();
         };
         node_process_1.default.on("SIGTERM", () => shutdown("SIGTERM"));
@@ -172,7 +183,7 @@ class Carno {
     }
     createHttpServer(port) {
         this.server = Bun.serve({ port, fetch: this.fetch, error: this.catcher });
-        console.log(`Server running on port ${port}`);
+        this.resolveLogger().info(`Server running on port ${port}`);
     }
     async fetcher(request, server) {
         if (this.isCorsEnabled()) {
@@ -193,8 +204,9 @@ class Carno {
         let response;
         const isCompiledRoute = compiled.routeType !== undefined;
         if (isCompiledRoute && compiled.routeType === CompiledRoute_1.RouteType.SIMPLE) {
-            const result = await (0, FastPathExecutor_1.executeSimpleRoute)(compiled, context);
-            response = RouteExecutor_1.RouteExecutor.mountResponse(result, context);
+            response = compiled.isAsync
+                ? await compiled.boundHandler(context)
+                : compiled.boundHandler(context);
         }
         else {
             const needsLocalsContainer = isCompiledRoute
@@ -208,7 +220,7 @@ class Carno {
         }
         if (this.isCorsEnabled()) {
             const origin = request.headers.get("origin");
-            if (origin && this.isOriginAllowed(origin)) {
+            if (origin && this.corsCache.isOriginAllowed(origin)) {
                 response = this.applyCorsHeaders(response, origin);
             }
         }
@@ -235,42 +247,28 @@ class Carno {
     }
     closeHttpServer() {
         if (this.server) {
-            console.log("Closing HTTP server...");
+            this.resolveLogger().info("Closing HTTP server...");
             this.server.stop(true);
         }
     }
     exitProcess(code = 0) {
-        console.log("Shutdown complete.");
+        this.resolveLogger().info("Shutdown complete.");
         node_process_1.default.exit(code);
     }
     reportHookFailure(event, error) {
-        console.error(`Lifecycle hook ${event} failed`, error);
+        this.resolveLogger().error(`Lifecycle hook ${event} failed`, error);
+    }
+    resolveLogger() {
+        const provider = this.injector.get(logger_service_1.LoggerService);
+        const instance = provider?.instance;
+        return instance ?? new logger_service_1.LoggerService(this.injector);
     }
     isCorsEnabled() {
         return !!this.config.cors;
     }
-    isOriginAllowed(origin) {
-        if (!origin || !this.config.cors) {
-            return false;
-        }
-        const { origins } = this.config.cors;
-        if (typeof origins === "string") {
-            return origins === "*" || origins === origin;
-        }
-        if (Array.isArray(origins)) {
-            return origins.includes(origin);
-        }
-        if (origins instanceof RegExp) {
-            return origins.test(origin);
-        }
-        if (typeof origins === "function") {
-            return origins(origin);
-        }
-        return false;
-    }
     handlePreflightRequest(request) {
         const origin = request.headers.get("origin");
-        if (!this.isOriginAllowed(origin)) {
+        if (!origin || !this.corsCache.isOriginAllowed(origin)) {
             return new Response(null, { status: 403 });
         }
         const corsHeaders = this.corsCache.get(origin);

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/container/middleware.resolver.js

@@ -14,21 +14,21 @@ class MiddlewareResolver {
         let currentIndex = 0;
         const next = async () => {
             if (currentIndex >= middlewares.length) {
-                // Se já processamos todos os middlewares, não faz nada.
-                // Isso evita o erro "Middleware stack exhausted" se um middleware chamar `next()`
-                // quando não há mais middlewares.
+                // If all middlewares are already processed, do nothing.
+                // This avoids "Middleware stack exhausted" if a middleware calls `next()`
+                // when there are no more middlewares.
                 return;
             }
             const middleware = middlewares[currentIndex++];
             // @ts-ignore
             const instance = injector.invoke(middleware, local);
-            // Await a execução do middleware.
-            // Se o middleware lançar uma exceção, ela será propagada.
+            // Await the middleware execution.
+            // If the middleware throws, the exception will propagate.
             await instance.handle(context, next);
         };
         if (middlewares.length === 0)
             return;
-        // Inicia a execução dos middlewares
+        // Start the middleware execution
         await next();
     }
 }

package/dist/domain/BaseContext.d.ts

@@ -0,0 +1,15 @@
+/**
+ * BaseContext - Interface mínima que todo contexto deve implementar.
+ *
+ * Define o contrato básico para FastContext e Context,
+ * permitindo que handlers compilados trabalhem com ambos.
+ */
+export interface BaseContext {
+    readonly req: Request;
+    param: Record<string, string>;
+    readonly headers: Headers;
+    readonly query: Record<string, string>;
+    status: number;
+    setResponseStatus(status: number): void;
+    getResponseStatus(): number;
+}

package/dist/domain/Context.d.ts

@@ -1,36 +1,57 @@
 import { Server } from 'bun';
+/**
+ * Context otimizado com shape mínimo e lazy loading.
+ *
+ * Shape fixo mínimo (sempre alocado):
+ * - req: Request
+ * - param: Record<string, string>
+ * - status: number
+ *
+ * Lazy loading (só aloca quando usado):
+ * - query: Record<string, string> (getter lazy)
+ * - headers: Headers (getter que retorna req.headers)
+ * - body: Record<string, any> (getter lazy)
+ * - locals: Record<string, any> (getter lazy)
+ * - rawBody: ArrayBuffer (lazy)
+ *
+ * V8/JSC otimiza shape consistente. Propriedades lazy não quebram
+ * monomorfismo porque são getters, não props dinâmicas.
+ */
 export declare class Context {
-    query: Record<string, any>;
-    private _body;
-    rawBody?: ArrayBuffer;
-    param: Record<string, any>;
     req: Request;
-    headers: Request["headers"];
-    locals: Record<string, any>;
-    private resultStatus;
-    private _pendingRequest;
+    param: Record<string, string>;
+    status: number;
+    private _queryString;
+    private _query;
+    private _locals;
+    private _body;
+    private _rawBody;
     private _bodyParsed;
     private constructor();
+    get headers(): Headers;
+    get query(): Record<string, string>;
+    set query(value: Record<string, string>);
+    get locals(): Record<string, any>;
+    set locals(value: Record<string, any>);
     get body(): Record<string, any>;
     set body(value: Record<string, any>);
+    get rawBody(): ArrayBuffer | undefined;
+    set rawBody(value: ArrayBuffer | undefined);
     getBody(): Promise<Record<string, any>>;
     isBodyParsed(): boolean;
-    static createFromRequest(url: any, request: Request, server: Server<any>): Promise<Context>;
-    static createFromRequestSync(url: any, request: Request, server: Server<any>): Context;
-    static createFromRequestWithBody(url: any, request: Request, server: Server<any>): Promise<Context>;
-    static createFromJob(job: any): Context;
-    private setQuery;
-    private setBody;
-    private setReq;
-    private setHeaders;
-    setParam(param: Record<string, any>): void;
     setResponseStatus(status: number): void;
     getResponseStatus(): number;
-    private buildQueryObject;
-    private resolveBody;
-    private parseJsonFromBuffer;
-    private parseJsonText;
-    private isEmptyBuffer;
-    private parseUrlEncodedFromBuffer;
-    private decodeBuffer;
+    setParam(param: Record<string, string>): void;
+    static createFromRequestSync(url: {
+        query?: string;
+    }, request: Request, server: Server<any>): Context;
+    static createFromRequest(url: {
+        query?: string;
+    }, request: Request, server: Server<any>): Promise<Context>;
+    static createFromJob(job: any): Context;
+    private parseQueryString;
+    private parseBody;
+    private parseJsonBody;
+    private parseFormDataBody;
+    private parseUrlEncodedBody;
 }