@carno.js/core 0.2.9 → 0.2.10

package/dist/Carno.d.ts

@@ -60,8 +60,8 @@ export declare class Carno<TAdapter extends ValidatorAdapterConstructor = Valida
     private closeHttpServer;
     private exitProcess;
     private reportHookFailure;
+    private resolveLogger;
     private isCorsEnabled;
-    private isOriginAllowed;
     private handlePreflightRequest;
     private applyCorsHeaders;
     close(closeActiveConnections?: boolean): void;

package/dist/Carno.js

@@ -20,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;
@@ -45,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);
                         }
                     }
@@ -55,7 +53,7 @@ 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();
@@ -171,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"));
@@ -185,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()) {
@@ -206,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
@@ -221,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);
             }
         }
@@ -248,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/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/BaseContext.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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;
 }

package/dist/domain/Context.js

@@ -15,144 +15,165 @@ const http_code_enum_1 = require("../commons/http-code.enum");
 const Injectable_decorator_1 = require("../commons/decorators/Injectable.decorator");
 const HttpException_1 = require("../exceptions/HttpException");
 const provider_scope_1 = require("./provider-scope");
+/**
+ * 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.
+ */
 let Context = Context_1 = class Context {
     constructor() {
-        this.query = {};
-        this._body = {};
-        this.param = {};
-        this.headers = new Headers();
-        this.locals = {};
-        this._pendingRequest = null;
+        this._query = null;
+        this._locals = null;
+        this._body = null;
+        this._rawBody = null;
         this._bodyParsed = false;
+        this.req = undefined;
+        this.param = {};
+        this.status = 200;
+    }
+    get headers() {
+        return this.req.headers;
+    }
+    get query() {
+        if (this._query === null) {
+            this._query = this.parseQueryString();
+        }
+        return this._query;
+    }
+    set query(value) {
+        this._query = value;
+    }
+    get locals() {
+        if (this._locals === null) {
+            this._locals = {};
+        }
+        return this._locals;
+    }
+    set locals(value) {
+        this._locals = value;
     }
     get body() {
+        if (this._body === null) {
+            return {};
+        }
         return this._body;
     }
     set body(value) {
         this._body = value;
         this._bodyParsed = true;
     }
+    get rawBody() {
+        return this._rawBody ?? undefined;
+    }
+    set rawBody(value) {
+        this._rawBody = value ?? null;
+    }
     async getBody() {
-        if (!this._bodyParsed && this._pendingRequest) {
-            await this.resolveBody(this._pendingRequest);
-            this._pendingRequest = null;
-            this._bodyParsed = true;
+        if (!this._bodyParsed) {
+            await this.parseBody();
         }
-        return this._body;
+        return this._body ?? {};
     }
     isBodyParsed() {
         return this._bodyParsed;
     }
-    static async createFromRequest(url, request, server) {
-        const context = Context_1.createFromRequestSync(url, request, server);
-        if (context._pendingRequest) {
-            await context.getBody();
-        }
-        return context;
+    setResponseStatus(status) {
+        this.status = status;
+    }
+    getResponseStatus() {
+        return this.status;
+    }
+    setParam(param) {
+        this.param = param;
     }
     static createFromRequestSync(url, request, server) {
-        const context = new Context_1();
-        context.setQuery(url);
-        context.setReq(request);
-        // @ts-ignore
-        context.setHeaders(request.headers);
-        if (request.method !== 'GET' && request.method !== 'HEAD') {
-            context._pendingRequest = request;
+        const ctx = new Context_1();
+        ctx.req = request;
+        ctx.param = {};
+        ctx._queryString = url.query;
+        const method = request.method;
+        if (method !== 'GET' && method !== 'HEAD') {
+            ctx._bodyParsed = false;
         }
         else {
-            context._bodyParsed = true;
+            ctx._bodyParsed = true;
         }
-        return context;
+        return ctx;
     }
-    static async createFromRequestWithBody(url, request, server) {
-        const context = Context_1.createFromRequestSync(url, request, server);
-        if (context._pendingRequest) {
-            await context.getBody();
+    static async createFromRequest(url, request, server) {
+        const ctx = Context_1.createFromRequestSync(url, request, server);
+        if (!ctx._bodyParsed) {
+            await ctx.getBody();
         }
-        return context;
+        return ctx;
     }
     static createFromJob(job) {
-        const context = new Context_1();
-        return context;
-    }
-    // @ts-ignore
-    setQuery({ query }) {
-        this.query = this.buildQueryObject(query);
+        return new Context_1();
     }
-    setBody(body) {
-        for (const [key, value] of body.entries()) {
-            this._body[key] = value;
+    parseQueryString() {
+        if (!this._queryString) {
+            return {};
         }
+        return Object.fromEntries(new URLSearchParams(this._queryString));
     }
-    setReq(req) {
-        this.req = req;
-    }
-    setHeaders(headers) {
-        this.headers = headers;
-    }
-    setParam(param) {
-        this.param = param;
-    }
-    setResponseStatus(status) {
-        this.resultStatus = status;
-    }
-    getResponseStatus() {
-        return this.resultStatus;
-    }
-    buildQueryObject(query) {
-        return query ? Object.fromEntries(new URLSearchParams(query)) : {};
-    }
-    async resolveBody(request) {
-        const contentType = request.headers.get('content-type') || '';
-        // Clone request once - preserve original request untouched
-        const clonedRequest = request.clone();
-        // FormData multipart requires consuming as formData
-        if (contentType.includes('multipart/form-data')) {
-            // Need separate clone for rawBody since formData() consumes the body
-            this.rawBody = await request.clone().arrayBuffer();
-            this.setBody(await clonedRequest.formData());
+    async parseBody() {
+        this._bodyParsed = true;
+        const contentType = this.req.headers.get('content-type') ?? '';
+        if (contentType.includes('application/json')) {
+            this._body = await this.parseJsonBody();
             return;
         }
-        // For all other content types, consume body once as ArrayBuffer from clone
-        this.rawBody = await clonedRequest.arrayBuffer();
-        if (contentType.includes('application/json')) {
-            this._body = this.parseJsonFromBuffer(this.rawBody);
+        if (contentType.includes('multipart/form-data')) {
+            this._body = await this.parseFormDataBody();
             return;
         }
         if (contentType.includes('application/x-www-form-urlencoded')) {
-            this._body = this.parseUrlEncodedFromBuffer(this.rawBody);
+            this._body = await this.parseUrlEncodedBody();
             return;
         }
-        // Plain text or unknown content type
-        this._body = { body: this.decodeBuffer(this.rawBody) };
+        this._body = {};
     }
-    parseJsonFromBuffer(buffer) {
-        if (this.isEmptyBuffer(buffer)) {
+    async parseJsonBody() {
+        const contentLength = this.req.headers.get('content-length');
+        if (contentLength === '0') {
             return {};
         }
-        return this.parseJsonText(this.decodeBuffer(buffer));
-    }
-    parseJsonText(text) {
         try {
-            return JSON.parse(text);
+            const payload = await this.req.json();
+            return payload;
         }
         catch {
-            throw new HttpException_1.HttpException("Invalid JSON body", http_code_enum_1.HttpCode.BAD_REQUEST);
+            throw new HttpException_1.HttpException('Invalid JSON body', http_code_enum_1.HttpCode.BAD_REQUEST);
         }
     }
-    isEmptyBuffer(buffer) {
-        return buffer.byteLength === 0;
+    async parseFormDataBody() {
+        const formData = await this.req.formData();
+        const result = {};
+        for (const [key, value] of formData.entries()) {
+            result[key] = value;
+        }
+        return result;
     }
-    parseUrlEncodedFromBuffer(buffer) {
-        if (buffer.byteLength === 0) {
+    async parseUrlEncodedBody() {
+        const text = await this.req.text();
+        if (!text) {
             return {};
         }
-        const text = this.decodeBuffer(buffer);
         return Object.fromEntries(new URLSearchParams(text));
     }
-    decodeBuffer(buffer) {
-        return new TextDecoder().decode(buffer);
-    }
 };
 exports.Context = Context;
 exports.Context = Context = Context_1 = __decorate([

package/dist/domain/FastContext.d.ts

@@ -0,0 +1,34 @@
+import type { BaseContext } from './BaseContext';
+/**
+ * FastContext - Contexto mínimo monomórfico para fast path.
+ *
+ * Shape fixo otimizado para V8/JSC JIT:
+ * - Apenas 3 propriedades diretas: req, param, status
+ * - Lazy getters para headers e query (zero alocação se não usados)
+ * - Sem locals, sem body, sem flags extras
+ * - Monomórfico: sempre mesmo shape, JIT otimiza agressivamente
+ *
+ * Usado quando:
+ * - Rota SIMPLE (RouteType.SIMPLE)
+ * - Sem middlewares
+ * - Sem DI
+ * - Sem body parsing
+ */
+export declare class FastContext implements BaseContext {
+    readonly req: Request;
+    param: Record<string, string>;
+    status: number;
+    private _query;
+    private _queryString;
+    constructor(req: Request, param: Record<string, string>, queryString: string | undefined);
+    get headers(): Headers;
+    get query(): Record<string, string>;
+    setResponseStatus(status: number): void;
+    getResponseStatus(): number;
+    private parseQueryString;
+}
+/**
+ * Factory otimizado para criar FastContext.
+ * Extrai queryString inline sem overhead de parseUrl.
+ */
+export declare function createFastContext(req: Request, param: Record<string, string>, url: string): FastContext;

package/dist/domain/FastContext.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FastContext = void 0;
+exports.createFastContext = createFastContext;
+/**
+ * FastContext - Contexto mínimo monomórfico para fast path.
+ *
+ * Shape fixo otimizado para V8/JSC JIT:
+ * - Apenas 3 propriedades diretas: req, param, status
+ * - Lazy getters para headers e query (zero alocação se não usados)
+ * - Sem locals, sem body, sem flags extras
+ * - Monomórfico: sempre mesmo shape, JIT otimiza agressivamente
+ *
+ * Usado quando:
+ * - Rota SIMPLE (RouteType.SIMPLE)
+ * - Sem middlewares
+ * - Sem DI
+ * - Sem body parsing
+ */
+class FastContext {
+    constructor(req, param, queryString) {
+        this.req = req;
+        this.param = param;
+        this.status = 200;
+        this._query = null;
+        this._queryString = queryString;
+    }
+    get headers() {
+        return this.req.headers;
+    }
+    get query() {
+        if (this._query === null) {
+            this._query = this.parseQueryString();
+        }
+        return this._query;
+    }
+    setResponseStatus(status) {
+        this.status = status;
+    }
+    getResponseStatus() {
+        return this.status;
+    }
+    parseQueryString() {
+        if (!this._queryString) {
+            return {};
+        }
+        return Object.fromEntries(new URLSearchParams(this._queryString));
+    }
+}
+exports.FastContext = FastContext;
+/**
+ * Factory otimizado para criar FastContext.
+ * Extrai queryString inline sem overhead de parseUrl.
+ */
+function createFastContext(req, param, url) {
+    const queryIdx = url.indexOf('?');
+    const queryString = queryIdx !== -1 ? url.slice(queryIdx + 1) : undefined;
+    return new FastContext(req, param, queryString);
+}

package/dist/domain/cors-headers-cache.d.ts

@@ -8,8 +8,10 @@ export declare class CorsHeadersCache {
     private readonly maxAgeString;
     private readonly hasCredentials;
     private readonly isWildcard;
+    private readonly originAllowed;
     constructor(config: CorsConfig);
     get(origin: string): Record<string, string>;
     private buildHeaders;
     applyToResponse(response: Response, origin: string): Response;
+    isOriginAllowed(origin: string): boolean;
 }