@carno.js/core 0.2.9 → 0.2.11

package/dist/Carno.d.ts

@@ -12,6 +12,7 @@ export interface ApplicationConfig<TAdapter extends ValidatorAdapterConstructor
     providers?: any[];
     cors?: CorsConfig;
     globalMiddlewares?: any[];
+    disableStartupLog?: boolean;
 }
 export declare class Carno<TAdapter extends ValidatorAdapterConstructor = ValidatorAdapterConstructor> {
     config: ApplicationConfig<TAdapter>;
@@ -20,6 +21,8 @@ export declare class Carno<TAdapter extends ValidatorAdapterConstructor = Valida
     private corsCache?;
     private readonly emptyLocals;
     private validatorAdapter;
+    private corsEnabled;
+    private hasOnRequestHook;
     private fetch;
     private server;
     constructor(config?: ApplicationConfig<TAdapter>);
@@ -53,15 +56,16 @@ export declare class Carno<TAdapter extends ValidatorAdapterConstructor = Valida
     getHttpServer(): Server<any>;
     getInjector(): import("./container").InjectorService;
     private createHttpServer;
-    private fetcher;
+    private fetcherAsync;
     private catcher;
     private bootstrapApplication;
     private handleShutdownHook;
     private closeHttpServer;
     private exitProcess;
     private reportHookFailure;
+    private resolveLogger;
     private isCorsEnabled;
-    private isOriginAllowed;
+    private errorResponse;
     private handlePreflightRequest;
     private applyCorsHeaders;
     close(closeActiveConnections?: boolean): void;

package/dist/Carno.js

@@ -20,42 +20,56 @@ 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.
+const METHOD_MAP = {
+    GET: 'get',
+    POST: 'post',
+    PUT: 'put',
+    DELETE: 'delete',
+    PATCH: 'patch',
+    HEAD: 'head',
+    OPTIONS: 'options'
+};
 class Carno {
     constructor(config = {}) {
         this.config = config;
         this.router = new memoirist_1.default();
         this.injector = (0, createInjector_1.createInjector)();
         this.emptyLocals = new LocalsContainer_1.LocalsContainer();
-        this.fetch = async (request, server) => {
-            try {
-                return await this.fetcher(request, server);
-            }
-            catch (error) {
-                if (error instanceof HttpException_1.HttpException) {
-                    let response = new Response(JSON.stringify({
-                        message: error.getResponse(),
-                        statusCode: error.getStatus(),
-                    }), {
-                        status: error.statusCode,
-                        headers: { "Content-Type": "application/json" },
-                    });
-                    if (this.isCorsEnabled()) {
-                        const origin = request.headers.get("origin");
-                        if (origin && this.isOriginAllowed(origin)) {
-                            response = this.applyCorsHeaders(response, origin);
-                        }
-                    }
-                    return response;
+        this.corsEnabled = false;
+        this.hasOnRequestHook = false;
+        this.fetch = (request, server) => {
+            const method = request.method;
+            if (this.corsEnabled) {
+                const origin = request.headers.get("origin");
+                if (method === "OPTIONS" && origin) {
+                    return this.handlePreflightRequest(request);
                 }
-                throw error;
             }
+            const url = request.url;
+            const startIndex = url.indexOf('/', 12);
+            const queryIndex = url.indexOf('?', startIndex);
+            const pathname = queryIndex === -1
+                ? (startIndex === -1 ? '/' : url.slice(startIndex))
+                : url.slice(startIndex, queryIndex);
+            const methodLower = METHOD_MAP[method] || method.toLowerCase();
+            const route = this.router.find(methodLower, pathname);
+            if (!route) {
+                return this.errorResponse(request, "Method not allowed", 404);
+            }
+            const compiled = route.store;
+            const isCompiledRoute = compiled.routeType !== undefined;
+            const isSimpleRoute = isCompiledRoute && compiled.routeType === CompiledRoute_1.RouteType.SIMPLE;
+            const isGetOrHead = method === 'GET' || method === 'HEAD';
+            const hasQuery = queryIndex !== -1;
+            if (isSimpleRoute && isGetOrHead && !this.corsEnabled && !hasQuery && !compiled.isAsync) {
+                const context = Context_1.Context.createFastContext(request, route.params);
+                return compiled.boundHandler(context);
+            }
+            return this.fetcherAsync(request, server, route, compiled, isSimpleRoute, hasQuery, queryIndex, url);
         };
         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();
@@ -163,6 +177,8 @@ class Carno {
         (0, ValidationCache_1.setValidatorAdapter)(this.validatorAdapter);
         this.loadProvidersAndControllers();
         await this.injector.loadModule((0, createContainer_1.createContainer)(), this.config, this.router, this.validatorAdapter);
+        this.corsEnabled = !!this.config.cors;
+        this.hasOnRequestHook = this.injector.hasOnRequestHook();
     }
     async listen(port = 3000) {
         this.registerShutdownHandlers();
@@ -171,7 +187,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,47 +201,48 @@ class Carno {
     }
     createHttpServer(port) {
         this.server = Bun.serve({ port, fetch: this.fetch, error: this.catcher });
-        console.log(`Server running on port ${port}`);
+        if (!this.config.disableStartupLog) {
+            this.resolveLogger().info(`Server running on port ${port}`);
+        }
     }
-    async fetcher(request, server) {
-        if (this.isCorsEnabled()) {
-            const origin = request.headers.get("origin");
-            if (request.method === "OPTIONS" && origin) {
-                return this.handlePreflightRequest(request);
+    async fetcherAsync(request, server, route, compiled, isSimpleRoute, hasQuery, queryIndex, url) {
+        try {
+            let response;
+            const query = hasQuery ? url.slice(queryIndex + 1) : undefined;
+            const context = Context_1.Context.createFromRequestSync({ query }, request, server);
+            context.param = route.params;
+            if (isSimpleRoute) {
+                response = compiled.isAsync
+                    ? await compiled.boundHandler(context)
+                    : compiled.boundHandler(context);
             }
-        }
-        const urlParsed = parseUrl(request);
-        const routePath = this.discoverRoutePath(urlParsed);
-        const route = this.router.find(request.method.toLowerCase(), routePath);
-        if (!route) {
-            throw new HttpException_1.HttpException("Method not allowed", 404);
-        }
-        const compiled = route.store;
-        const context = Context_1.Context.createFromRequestSync(urlParsed, request, server);
-        context.param = route.params;
-        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);
-        }
-        else {
-            const needsLocalsContainer = isCompiledRoute
-                ? compiled.needsLocalsContainer
-                : true;
-            const locals = this.resolveLocalsContainer(needsLocalsContainer, context);
-            if (this.injector.hasOnRequestHook()) {
-                await this.injector.callHook(on_event_1.EventType.OnRequest, { context });
+            else {
+                const needsLocalsContainer = compiled.routeType !== undefined
+                    ? compiled.needsLocalsContainer
+                    : true;
+                const locals = this.resolveLocalsContainer(needsLocalsContainer, context);
+                if (this.hasOnRequestHook) {
+                    await this.injector.callHook(on_event_1.EventType.OnRequest, { context });
+                }
+                response = await RouteExecutor_1.RouteExecutor.executeRoute(compiled, this.injector, context, locals);
+            }
+            if (this.corsEnabled) {
+                const origin = request.headers.get("origin");
+                if (origin && this.corsCache.isOriginAllowed(origin)) {
+                    if (!(response instanceof Response)) {
+                        response = RouteExecutor_1.RouteExecutor.mountResponse(response, context);
+                    }
+                    return this.applyCorsHeaders(response, origin);
+                }
             }
-            response = await RouteExecutor_1.RouteExecutor.executeRoute(compiled, this.injector, context, locals);
+            return response;
         }
-        if (this.isCorsEnabled()) {
-            const origin = request.headers.get("origin");
-            if (origin && this.isOriginAllowed(origin)) {
-                response = this.applyCorsHeaders(response, origin);
+        catch (error) {
+            if (error instanceof HttpException_1.HttpException) {
+                return this.errorResponse(request, error.getResponse(), error.getStatus());
             }
+            throw error;
         }
-        return response;
     }
     async bootstrapApplication() {
         try {
@@ -248,42 +265,44 @@ 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);
+    errorResponse(request, message, statusCode) {
+        let response = new Response(JSON.stringify({
+            message,
+            statusCode,
+        }), {
+            status: statusCode,
+            headers: { "Content-Type": "application/json" },
+        });
+        if (this.corsEnabled) {
+            const origin = request.headers.get("origin");
+            if (origin && this.corsCache.isOriginAllowed(origin)) {
+                response = this.applyCorsHeaders(response, origin);
+            }
         }
-        return false;
+        return response;
     }
     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);
@@ -310,10 +329,10 @@ class Carno {
         return locals;
     }
     discoverRoutePath(url) {
-        if (url?.pathname) {
-            return url.pathname;
+        if (typeof url === 'string') {
+            return url;
         }
-        return url?.path || "/";
+        return url?.pathname || url?.path || '/';
     }
 }
 exports.Carno = Carno;

package/dist/container/InjectorService.js

@@ -99,10 +99,12 @@ let InjectorService = InjectorService_1 = class InjectorService {
         }
         return this.invoke(token, locals);
     }
-    async invokeRoute(route, context, locals, instance) {
-        await middleware_resolver_1.MiddlewareRes.resolveMiddlewares(route, this, locals);
-        const result = await this.methodInvoker.invoke(instance, route.methodName, locals, context, (t, l) => this.invoke(t, l));
-        return result;
+    invokeRoute(route, context, locals, instance) {
+        const middlewarePromise = middleware_resolver_1.MiddlewareRes.resolveMiddlewares(route, this, locals);
+        if (middlewarePromise instanceof Promise) {
+            return middlewarePromise.then(() => this.methodInvoker.invoke(instance, route.methodName, locals, context, (t, l) => this.invoke(t, l)));
+        }
+        return this.methodInvoker.invoke(instance, route.methodName, locals, context, (t, l) => this.invoke(t, l));
     }
     scopeOf(provider) {
         return provider.scope || provider_scope_1.ProviderScope.SINGLETON;

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,58 @@
 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 createFastContext(request: Request, params: Record<string, 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;
 }