@carno.js/core 0.2.9 → 0.2.10

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

package/dist/route/JITCompiler.js

@@ -2,137 +2,244 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.compileRouteHandler = compileRouteHandler;
 exports.compileValidatedHandler = compileValidatedHandler;
+const TEXT_HEADERS = Object.freeze({
+    'Content-Type': 'text/html'
+});
+const JSON_HEADERS = Object.freeze({
+    'Content-Type': 'application/json'
+});
+function isBodyInitResult(result) {
+    if (!result) {
+        return false;
+    }
+    if (result instanceof ReadableStream) {
+        return true;
+    }
+    if (result instanceof Blob || result instanceof ArrayBuffer) {
+        return true;
+    }
+    if (ArrayBuffer.isView(result)) {
+        return true;
+    }
+    return result instanceof FormData || result instanceof URLSearchParams;
+}
+/**
+ * Cria handler inline com response building integrado.
+ * Usado quando não há parâmetros.
+ */
+function createInlineResponseHandler(handler, isAsync) {
+    if (isAsync) {
+        return async (c) => {
+            const r = await handler();
+            const s = c.getResponseStatus() || 200;
+            if (typeof r === 'string')
+                return new Response(r, { status: s, headers: TEXT_HEADERS });
+            if (r instanceof Response)
+                return r;
+            if (r == null)
+                return new Response('', { status: s, headers: TEXT_HEADERS });
+            if (typeof r === 'number' || typeof r === 'boolean') {
+                return new Response(String(r), { status: s, headers: TEXT_HEADERS });
+            }
+            if (isBodyInitResult(r)) {
+                return new Response(r, { status: s });
+            }
+            return new Response(JSON.stringify(r), { status: s, headers: JSON_HEADERS });
+        };
+    }
+    return (c) => {
+        const r = handler();
+        const s = c.getResponseStatus() || 200;
+        if (typeof r === 'string')
+            return new Response(r, { status: s, headers: TEXT_HEADERS });
+        if (r instanceof Response)
+            return r;
+        if (r == null)
+            return new Response('', { status: s, headers: TEXT_HEADERS });
+        if (typeof r === 'number' || typeof r === 'boolean') {
+            return new Response(String(r), { status: s, headers: TEXT_HEADERS });
+        }
+        if (isBodyInitResult(r)) {
+            return new Response(r, { status: s });
+        }
+        return new Response(JSON.stringify(r), { status: s, headers: JSON_HEADERS });
+    };
+}
 function escapeKey(key) {
-    return key.replace(/['"\\]/g, '\\$&');
+    return key.replace(/['\"\\]/g, '\\$&');
 }
-function buildArgExpression(param, index) {
+/**
+ * Gera expressão de acesso a parâmetro inline.
+ * Otimizado para evitar chamadas de função quando possível.
+ */
+function buildArgExpression(param) {
     const key = param.key ? escapeKey(param.key) : undefined;
     switch (param.type) {
         case 'param':
-            return key ? `ctx.param['${key}']` : 'ctx.param';
+            return key ? `c.param['${key}']` : 'c.param';
         case 'query':
-            return key ? `ctx.query['${key}']` : 'ctx.query';
+            return key ? `c.query['${key}']` : 'c.query';
         case 'body':
-            return key ? `ctx.body['${key}']` : 'ctx.body';
+            return key ? `c.body['${key}']` : 'c.body';
         case 'headers':
-            return key
-                ? `ctx.headers.get('${key}')`
-                : 'ctx.headers';
+            return key ? `c.headers.get('${key}')` : 'c.headers';
         case 'req':
-            return 'ctx.req';
+            return 'c.req';
         case 'locals':
-            return 'ctx.locals';
-        case 'di':
-            return `resolvers[${index}](ctx)`;
+            return 'c.locals';
         default:
-            return `resolvers[${index}](ctx)`;
+            return 'undefined';
     }
 }
+/**
+ * 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
+ */
 function compileRouteHandler(instance, methodName, paramInfos) {
     const handler = instance[methodName].bind(instance);
     if (paramInfos.length === 0) {
-        return () => handler();
+        return createInlineResponseHandler(handler, false);
     }
-    const hasBodyParam = paramInfos.some((p) => p.type === 'body');
     const hasDIParam = paramInfos.some((p) => p.type === 'di');
     if (hasDIParam) {
         return createFallbackHandler(handler, paramInfos);
     }
+    const hasBodyParam = paramInfos.some((p) => p.type === 'body');
     const argExpressions = paramInfos.map(buildArgExpression);
+    const argsCode = argExpressions.join(',');
     if (hasBodyParam) {
-        return createAsyncHandler(handler, argExpressions);
+        const code = `return async function(c){
+await c.getBody();
+const r=await h(${argsCode});
+const s=c.getResponseStatus()||200;
+if(typeof r==='string')return new Response(r,{status:s,headers:TH});
+if(r instanceof Response)return r;
+if(r==null)return new Response('',{status:s,headers:TH});
+if(typeof r==='number'||typeof r==='boolean')return new Response(String(r),{status:s,headers:TH});
+if(isBI(r))return new Response(r,{status:s});
+return new Response(JSON.stringify(r),{status:s,headers:JH});
+}`;
+        return new Function('h', 'TH', 'JH', 'isBI', code)(handler, TEXT_HEADERS, JSON_HEADERS, isBodyInitResult);
     }
-    return createSyncHandler(handler, argExpressions);
-}
-function createSyncHandler(handler, argExpressions) {
-    const code = `
-    return function compiledHandler(ctx) {
-      return handler(${argExpressions.join(', ')});
-    }
-  `;
-    return new Function('handler', code)(handler);
-}
-function createAsyncHandler(handler, argExpressions) {
-    const code = `
-    return async function compiledHandler(ctx) {
-      await ctx.getBody();
-      return handler(${argExpressions.join(', ')});
-    }
-  `;
-    return new Function('handler', code)(handler);
+    const code = `return function(c){
+const r=h(${argsCode});
+const s=c.getResponseStatus()||200;
+if(typeof r==='string')return new Response(r,{status:s,headers:TH});
+if(r instanceof Response)return r;
+if(r==null)return new Response('',{status:s,headers:TH});
+if(typeof r==='number'||typeof r==='boolean')return new Response(String(r),{status:s,headers:TH});
+if(isBI(r))return new Response(r,{status:s});
+return new Response(JSON.stringify(r),{status:s,headers:JH});
+}`;
+    return new Function('h', 'TH', 'JH', 'isBI', code)(handler, TEXT_HEADERS, JSON_HEADERS, isBodyInitResult);
 }
+/**
+ * Handler fallback para casos com DI.
+ */
 function createFallbackHandler(handler, paramInfos) {
     return (ctx) => {
-        const args = [];
-        for (const param of paramInfos) {
-            switch (param.type) {
-                case 'param':
-                    args.push(param.key ? ctx.param[param.key] : ctx.param);
-                    break;
-                case 'query':
-                    args.push(param.key ? ctx.query[param.key] : ctx.query);
-                    break;
-                case 'body':
-                    args.push(param.key ? ctx.body[param.key] : ctx.body);
-                    break;
-                case 'headers':
-                    args.push(param.key ? ctx.headers.get(param.key) : ctx.headers);
-                    break;
-                case 'req':
-                    args.push(ctx.req);
-                    break;
-                case 'locals':
-                    args.push(ctx.locals);
-                    break;
-                default:
-                    args.push(undefined);
-                    break;
-            }
-        }
+        const args = resolveArgs(paramInfos, ctx);
         return handler(...args);
     };
 }
-function compileValidatedHandler(instance, methodName, paramInfos, validators) {
+/**
+ * Resolve argumentos para fallback handler.
+ */
+function resolveArgs(paramInfos, ctx) {
+    const args = new Array(paramInfos.length);
+    let i = 0;
+    for (const param of paramInfos) {
+        args[i++] = resolveArg(param, ctx);
+    }
+    return args;
+}
+/**
+ * Resolve um argumento individual.
+ */
+function resolveArg(param, ctx) {
+    switch (param.type) {
+        case 'param':
+            return param.key ? ctx.param[param.key] : ctx.param;
+        case 'query':
+            return param.key ? ctx.query[param.key] : ctx.query;
+        case 'body':
+            return param.key ? ctx.body[param.key] : ctx.body;
+        case 'headers':
+            return param.key ? ctx.headers.get(param.key) : ctx.headers;
+        case 'req':
+            return ctx.req;
+        case 'locals':
+            return ctx.locals;
+        default:
+            return undefined;
+    }
+}
+/**
+ * Compila handler com validação inline.
+ */
+function compileValidatedHandler(instance, methodName, paramInfos, validatorAdapter) {
     const handler = instance[methodName].bind(instance);
     const hasBodyParam = paramInfos.some((p) => p.type === 'body');
-    const resolveArg = (ctx, param, index) => {
-        let value;
-        switch (param.type) {
-            case 'param':
-                value = param.key ? ctx.param[param.key] : ctx.param;
-                break;
-            case 'query':
-                value = param.key ? ctx.query[param.key] : ctx.query;
-                break;
-            case 'body':
-                value = param.key ? ctx.body[param.key] : ctx.body;
-                break;
-            case 'headers':
-                value = param.key ? ctx.headers.get(param.key) : ctx.headers;
-                break;
-            case 'req':
-                value = ctx.req;
-                break;
-            case 'locals':
-                value = ctx.locals;
-                break;
-            default:
-                value = undefined;
-        }
-        if (param.needsValidation && validators[index]) {
-            return validators[index](value);
-        }
-        return value;
-    };
+    if (paramInfos.length === 0) {
+        return createInlineResponseHandler(handler, false);
+    }
+    const { argAssignments, argList, tokenParams, tokenValues, } = buildValidatedArgs(paramInfos);
     if (hasBodyParam) {
-        return async (ctx) => {
-            await ctx.getBody();
-            const args = paramInfos.map((p, i) => resolveArg(ctx, p, i));
-            return handler(...args);
-        };
+        const code = `return async function(c){\nawait c.getBody();\n${argAssignments}\nconst r=await h(${argList});\nconst s=c.getResponseStatus()||200;\nif(typeof r==='string')return new Response(r,{status:s,headers:TH});\nif(r instanceof Response)return r;\nif(r==null)return new Response('',{status:s,headers:TH});\nif(typeof r==='number'||typeof r==='boolean')return new Response(String(r),{status:s,headers:TH});\nif(isBI(r))return new Response(r,{status:s});\nreturn new Response(JSON.stringify(r),{status:s,headers:JH});\n}`;
+        return new Function('h', 'va', ...tokenParams, 'TH', 'JH', 'isBI', code)(handler, validatorAdapter, ...tokenValues, TEXT_HEADERS, JSON_HEADERS, isBodyInitResult);
     }
-    return (ctx) => {
-        const args = paramInfos.map((p, i) => resolveArg(ctx, p, i));
-        return handler(...args);
+    const code = `return function(c){\n${argAssignments}\nconst r=h(${argList});\nconst s=c.getResponseStatus()||200;\nif(typeof r==='string')return new Response(r,{status:s,headers:TH});\nif(r instanceof Response)return r;\nif(r==null)return new Response('',{status:s,headers:TH});\nif(typeof r==='number'||typeof r==='boolean')return new Response(String(r),{status:s,headers:TH});\nif(isBI(r))return new Response(r,{status:s});\nreturn new Response(JSON.stringify(r),{status:s,headers:JH});\n}`;
+    return new Function('h', 'va', ...tokenParams, 'TH', 'JH', 'isBI', code)(handler, validatorAdapter, ...tokenValues, TEXT_HEADERS, JSON_HEADERS, isBodyInitResult);
+}
+function buildValidatedArgs(paramInfos) {
+    const assignments = [];
+    const args = [];
+    const tokenParams = [];
+    const tokenValues = [];
+    let index = 0;
+    for (const param of paramInfos) {
+        const argName = `a${index}`;
+        const argExpr = buildArgExpression(param);
+        const tokenName = getTokenParamName(param, index, tokenParams, tokenValues);
+        const valueExpr = buildValidatedExpression(argExpr, tokenName);
+        assignments.push(`const ${argName}=${valueExpr};`);
+        args.push(argName);
+        index += 1;
+    }
+    return {
+        argAssignments: assignments.join('\n'),
+        argList: args.join(','),
+        tokenParams,
+        tokenValues,
     };
 }
+function buildValidatedExpression(argExpr, tokenName) {
+    if (!tokenName) {
+        return argExpr;
+    }
+    return `va.validateAndTransform(${tokenName}, ${argExpr})`;
+}
+function getTokenParamName(param, index, tokenParams, tokenValues) {
+    if (!param.needsValidation || !param.token) {
+        return null;
+    }
+    const tokenName = `t${index}`;
+    tokenParams.push(tokenName);
+    tokenValues.push(param.token);
+    return tokenName;
+}

package/dist/route/RouteCompiler.d.ts

@@ -25,5 +25,4 @@ export declare class RouteCompiler {
     private createStandardRoute;
     private createComplexRoute;
     private createFallbackRoute;
-    private createValidatedHandler;
 }

package/dist/route/RouteCompiler.js

@@ -67,7 +67,7 @@ class RouteCompiler {
         const hasBodyParam = paramInfos.some((p) => p.type === 'body');
         let boundHandler;
         if (hasValidation) {
-            boundHandler = this.createValidatedHandler(instance, route.methodName, paramInfos, hasBodyParam);
+            boundHandler = (0, JITCompiler_1.compileValidatedHandler)(instance, route.methodName, paramInfos, this.validatorAdapter);
         }
         else {
             boundHandler = (0, JITCompiler_1.compileRouteHandler)(instance, route.methodName, paramInfos);
@@ -153,48 +153,5 @@ class RouteCompiler {
             original: route,
         };
     }
-    createValidatedHandler(instance, methodName, paramInfos, hasBodyParam) {
-        const handler = instance[methodName].bind(instance);
-        const resolveArg = (ctx, param) => {
-            let value;
-            switch (param.type) {
-                case 'param':
-                    value = param.key ? ctx.param[param.key] : ctx.param;
-                    break;
-                case 'query':
-                    value = param.key ? ctx.query[param.key] : ctx.query;
-                    break;
-                case 'body':
-                    value = param.key ? ctx.body[param.key] : ctx.body;
-                    break;
-                case 'headers':
-                    value = param.key ? ctx.headers.get(param.key) : ctx.headers;
-                    break;
-                case 'req':
-                    value = ctx.req;
-                    break;
-                case 'locals':
-                    value = ctx.locals;
-                    break;
-                default:
-                    value = undefined;
-            }
-            if (param.needsValidation && param.token) {
-                return this.validatorAdapter.validateAndTransform(param.token, value);
-            }
-            return value;
-        };
-        if (hasBodyParam) {
-            return async (ctx) => {
-                await ctx.getBody();
-                const args = paramInfos.map((p) => resolveArg(ctx, p));
-                return handler(...args);
-            };
-        }
-        return (ctx) => {
-            const args = paramInfos.map((p) => resolveArg(ctx, p));
-            return handler(...args);
-        };
-    }
 }
 exports.RouteCompiler = RouteCompiler;

package/dist/route/RouteExecutor.js

@@ -24,7 +24,24 @@ class Router {
         if (injector.hasOnResponseHook()) {
             await injector.callHook(events_1.EventType.OnResponse, { context, result });
         }
-        return this.mountResponse(result, context);
+        const status = context.getResponseStatus() || 200;
+        if (result instanceof Response) {
+            return result;
+        }
+        if (result === null || result === undefined) {
+            return new Response("", { status, headers: this.textHeaders });
+        }
+        const resultType = typeof result;
+        if (resultType === "string") {
+            return new Response(result, { status, headers: this.textHeaders });
+        }
+        if (resultType === "number" || resultType === "boolean") {
+            return new Response(String(result), { status, headers: this.textHeaders });
+        }
+        if (this.isBodyInit(result)) {
+            return new Response(result, { status });
+        }
+        return this.createJsonResponse(result, status);
     }
     mountResponse(result, context) {
         const status = context.getResponseStatus() || 200;

package/dist/route/memoirist.d.ts

@@ -18,10 +18,13 @@ export interface Node<T> {
 export declare class Memoirist<T> {
     root: Record<string, Node<T>>;
     history: [string, string, T][];
+    private routeCache;
     private static regex;
     add(method: string, path: string, store: T): FindResult<T>['store'];
     find(method: string, url: string): FindResult<T> | null;
     updateStore(method: string, path: string, oldStore: T, newStore: T): boolean;
+    private buildCacheKey;
+    private invalidateCache;
     private updateHistoryStore;
     private normalizePath;
     private findNode;