@carno.js/core 0.2.8 → 0.2.10

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

package/dist/domain/cors-headers-cache.js

@@ -2,6 +2,46 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CorsHeadersCache = void 0;
 const cors_config_1 = require("./cors-config");
+const allowAnyOrigin = () => {
+    return true;
+};
+const denyAnyOrigin = () => {
+    return false;
+};
+function buildOriginAllowed(origins) {
+    if (origins === '*') {
+        return allowAnyOrigin;
+    }
+    if (typeof origins === 'string') {
+        return createExactOriginMatcher(origins);
+    }
+    if (Array.isArray(origins)) {
+        return createSetOriginMatcher(origins);
+    }
+    if (origins instanceof RegExp) {
+        return createRegexOriginMatcher(origins);
+    }
+    if (typeof origins === 'function') {
+        return origins;
+    }
+    return denyAnyOrigin;
+}
+function createExactOriginMatcher(origin) {
+    return (value) => {
+        return value === origin;
+    };
+}
+function createSetOriginMatcher(origins) {
+    const originSet = new Set(origins);
+    return (value) => {
+        return originSet.has(value);
+    };
+}
+function createRegexOriginMatcher(origins) {
+    return (value) => {
+        return origins.test(value);
+    };
+}
 class CorsHeadersCache {
     constructor(config) {
         this.config = config;
@@ -18,6 +58,7 @@ class CorsHeadersCache {
             : null;
         this.hasCredentials = !!config.credentials;
         this.isWildcard = config.origins === '*';
+        this.originAllowed = buildOriginAllowed(config.origins);
     }
     get(origin) {
         const cacheKey = this.isWildcard ? '*' : origin;
@@ -53,5 +94,8 @@ class CorsHeadersCache {
         }
         return response;
     }
+    isOriginAllowed(origin) {
+        return this.originAllowed(origin);
+    }
 }
 exports.CorsHeadersCache = CorsHeadersCache;

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/FastPathExecutor.d.ts

@@ -1,4 +1,12 @@
 import type { Context } from '../domain/Context';
 import type { CompiledRoute } from './CompiledRoute';
-export declare function executeSimpleRoute(compiled: CompiledRoute, context: Context): Promise<any>;
-export declare function executeSimpleRouteSync(compiled: CompiledRoute, context: Context): any;
+/**
+ * Fast path executor completo - executa handler e monta response inline.
+ * Máximo 2 type checks no fast path.
+ */
+export declare function executeFastPath(compiled: CompiledRoute, context: Context): Promise<Response>;
+/**
+ * Fast path executor síncrono - para handlers que não retornam Promise.
+ * Elimina overhead de async/await quando handler é síncrono.
+ */
+export declare function executeFastPathSync(compiled: CompiledRoute, context: Context): Response;

package/dist/route/FastPathExecutor.js

@@ -1,19 +1,50 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.executeSimpleRoute = executeSimpleRoute;
-exports.executeSimpleRouteSync = executeSimpleRouteSync;
-async function executeSimpleRoute(compiled, context) {
-    if (!compiled.boundHandler) {
-        throw new Error('Simple route must have a bound handler');
+exports.executeFastPath = executeFastPath;
+exports.executeFastPathSync = executeFastPathSync;
+/**
+ * Frozen header objects - V8 otimiza acesso a objetos frozen.
+ * Criados uma vez no startup, reutilizados em todas requests.
+ */
+const JSON_HEADERS = Object.freeze({
+    'Content-Type': 'application/json'
+});
+const TEXT_HEADERS = Object.freeze({
+    'Content-Type': 'text/html'
+});
+/**
+ * Fast path executor completo - executa handler e monta response inline.
+ * Máximo 2 type checks no fast path.
+ */
+async function executeFastPath(compiled, context) {
+    const result = await compiled.boundHandler(context);
+    const status = context.getResponseStatus() || 200;
+    if (typeof result === 'string') {
+        return new Response(result, { status, headers: TEXT_HEADERS });
     }
-    if (compiled.isAsync) {
-        return compiled.boundHandler(context);
+    if (result instanceof Response) {
+        return result;
     }
-    return compiled.boundHandler(context);
+    if (result === null || result === undefined) {
+        return new Response('', { status, headers: TEXT_HEADERS });
+    }
+    return new Response(JSON.stringify(result), { status, headers: JSON_HEADERS });
 }
-function executeSimpleRouteSync(compiled, context) {
-    if (!compiled.boundHandler) {
-        throw new Error('Simple route must have a bound handler');
+/**
+ * Fast path executor síncrono - para handlers que não retornam Promise.
+ * Elimina overhead de async/await quando handler é síncrono.
+ */
+function executeFastPathSync(compiled, context) {
+    const result = compiled.boundHandler(context);
+    const status = context.getResponseStatus() || 200;
+    if (typeof result === 'string') {
+        return new Response(result, { status, headers: TEXT_HEADERS });
+    }
+    if (result instanceof Response) {
+        return result;
+    }
+    if (result === null || result === undefined) {
+        return new Response('', { status, headers: TEXT_HEADERS });
     }
-    return compiled.boundHandler(context);
+    return new Response(JSON.stringify(result), { status, headers: JSON_HEADERS });
 }

package/dist/route/JITCompiler.d.ts

@@ -1,4 +1,28 @@
 import type { ParamInfo } from './ParamResolverFactory';
 import type { CompiledHandler, AsyncCompiledHandler } from './CompiledRoute';
+/**
+ * Compila route handler em função otimizada.
+ *
+ * Estratégias de otimização:
+ * - Inline de acesso a parâmetros
+ * - Bind do handler no compile time
+ * - Código gerado monomórfico
+ * - Sem overhead de resolvers array
+ */
+/**
+ * Compila route handler em função otimizada que retorna Response inline.
+ *
+ * Estratégias de otimização:
+ * - Inline de acesso a parâmetros
+ * - Inline de response building (elimina executeFastPath)
+ * - Bind do handler no compile time
+ * - Código gerado monomórfico
+ * - Headers pré-frozen para otimização V8
+ */
 export declare function compileRouteHandler(instance: any, methodName: string, paramInfos: ParamInfo[]): CompiledHandler | AsyncCompiledHandler;
-export declare function compileValidatedHandler(instance: any, methodName: string, paramInfos: ParamInfo[], validators: ((value: any) => any)[]): CompiledHandler | AsyncCompiledHandler;
+/**
+ * Compila handler com validação inline.
+ */
+export declare function compileValidatedHandler(instance: any, methodName: string, paramInfos: ParamInfo[], validatorAdapter: {
+    validateAndTransform: (token: any, value: any) => any;
+}): CompiledHandler | AsyncCompiledHandler;