@carno.js/core 0.2.10 → 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,7 +56,7 @@ 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;
@@ -62,6 +65,7 @@ export declare class Carno<TAdapter extends ValidatorAdapterConstructor = Valida
     private reportHookFailure;
     private resolveLogger;
     private isCorsEnabled;
+    private errorResponse;
     private handlePreflightRequest;
     private applyCorsHeaders;
     close(closeActiveConnections?: boolean): void;

package/dist/Carno.js

@@ -21,36 +21,52 @@ const RouteExecutor_1 = require("./route/RouteExecutor");
 const memoirist_1 = __importDefault(require("./route/memoirist"));
 const CompiledRoute_1 = require("./route/CompiledRoute");
 const logger_service_1 = require("./services/logger.service");
-const parseUrl = require("parseurl-fast");
+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.corsCache.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) => {
             this.resolveLogger().error("Unhandled error", error);
@@ -161,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();
@@ -183,48 +201,48 @@ class Carno {
     }
     createHttpServer(port) {
         this.server = Bun.serve({ port, fetch: this.fetch, error: this.catcher });
-        this.resolveLogger().info(`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) {
-            response = compiled.isAsync
-                ? await compiled.boundHandler(context)
-                : compiled.boundHandler(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.corsCache.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 {
@@ -266,6 +284,22 @@ class Carno {
     isCorsEnabled() {
         return !!this.config.cors;
     }
+    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 response;
+    }
     handlePreflightRequest(request) {
         const origin = request.headers.get("origin");
         if (!origin || !this.corsCache.isOriginAllowed(origin)) {
@@ -295,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/domain/Context.d.ts

@@ -45,6 +45,7 @@ export declare class Context {
     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>;

package/dist/domain/Context.js

@@ -41,7 +41,6 @@ let Context = Context_1 = class Context {
         this._rawBody = null;
         this._bodyParsed = false;
         this.req = undefined;
-        this.param = {};
         this.status = 200;
     }
     get headers() {
@@ -113,6 +112,13 @@ let Context = Context_1 = class Context {
         }
         return ctx;
     }
+    static createFastContext(request, params) {
+        const ctx = new Context_1();
+        ctx.req = request;
+        ctx.param = params;
+        ctx._bodyParsed = true;
+        return ctx;
+    }
     static async createFromRequest(url, request, server) {
         const ctx = Context_1.createFromRequestSync(url, request, server);
         if (!ctx._bodyParsed) {

package/dist/route/Matcher.d.ts

@@ -1,16 +1,11 @@
 import { TokenRouteWithProvider, TokenRouteWithProviderMap } from "../container";
 import { Context } from "../domain";
+interface ParsedUrl {
+    pathname: string;
+}
 declare class Matcher {
     match(request: Request, routes: TokenRouteWithProviderMap, context: Context): TokenRouteWithProvider;
-    /**
-     * Identify route by url path.
-     * The route can have params (:param) and wildcards (*).
-     *
-     * @param route
-     * @param url
-     * @param context
-     */
-    identifyRoute(route: TokenRouteWithProvider, url: URL, context: Context): boolean;
+    identifyRoute(route: TokenRouteWithProvider, url: ParsedUrl, context: Context): boolean;
 }
 export declare const RouteResolver: Matcher;
 export {};

package/dist/route/Matcher.js

@@ -1,7 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RouteResolver = void 0;
-const parseUrl = require('parseurl-fast');
+function parseUrl(request) {
+    const url = request.url;
+    const startIndex = url.indexOf('/', 12);
+    const queryIndex = url.indexOf('?', startIndex);
+    if (queryIndex === -1) {
+        return { pathname: startIndex === -1 ? '/' : url.slice(startIndex) };
+    }
+    return { pathname: url.slice(startIndex, queryIndex) };
+}
 class Matcher {
     match(request, routes, context) {
         const method = request.method.toLowerCase();
@@ -10,20 +18,12 @@ class Matcher {
         }
         const routeMethod = routes.get(method);
         const url = parseUrl(request);
-        const route = routeMethod?.find(route => this.identifyRoute(route, url, context));
+        const route = routeMethod?.find((route) => this.identifyRoute(route, url, context));
         if (!route) {
             throw new Error('Method not allowed');
         }
         return route;
     }
-    /**
-     * Identify route by url path.
-     * The route can have params (:param) and wildcards (*).
-     *
-     * @param route
-     * @param url
-     * @param context
-     */
     identifyRoute(route, url, context) {
         const urlPath = url.pathname.split('/');
         const routePathSegments = route.path.split('/');

package/dist/route/RouteExecutor.d.ts

@@ -2,13 +2,11 @@ import { InjectorService, TokenRouteWithProvider } from "../container";
 import { Context, LocalsContainer } from "../domain";
 import type { CompiledRoute } from "./CompiledRoute";
 declare class Router {
-    private readonly jsonHeaders;
     private readonly textHeaders;
     executeRoute(routeStore: CompiledRoute | TokenRouteWithProvider, injector: InjectorService, context: Context, locals: LocalsContainer): Promise<Response>;
     mountResponse(result: unknown, context: Context): Response;
     private isNativeResponse;
     private isBodyInit;
-    private createJsonResponse;
 }
 export declare const RouteExecutor: Router;
 export {};

package/dist/route/RouteExecutor.js

@@ -4,7 +4,6 @@ exports.RouteExecutor = void 0;
 const events_1 = require("../events");
 class Router {
     constructor() {
-        this.jsonHeaders = { "Content-Type": "application/json" };
         this.textHeaders = { "Content-Type": "text/html" };
     }
     async executeRoute(routeStore, injector, context, locals) {
@@ -41,7 +40,7 @@ class Router {
         if (this.isBodyInit(result)) {
             return new Response(result, { status });
         }
-        return this.createJsonResponse(result, status);
+        return Response.json(result, { status });
     }
     mountResponse(result, context) {
         const status = context.getResponseStatus() || 200;
@@ -61,7 +60,7 @@ class Router {
         if (this.isBodyInit(result)) {
             return new Response(result, { status });
         }
-        return this.createJsonResponse(result, status);
+        return Response.json(result, { status });
     }
     isNativeResponse(result) {
         return result instanceof Response;
@@ -81,15 +80,5 @@ class Router {
         }
         return result instanceof FormData || result instanceof URLSearchParams;
     }
-    createJsonResponse(body, status) {
-        try {
-            const json = JSON.stringify(body);
-            return new Response(json, { status, headers: this.jsonHeaders });
-        }
-        catch (error) {
-            const fallback = JSON.stringify({ error: "Serialization failed" });
-            return new Response(fallback, { status: 500, headers: this.jsonHeaders });
-        }
-    }
 }
 exports.RouteExecutor = new Router();

package/dist/route/memoirist.d.ts

@@ -23,7 +23,6 @@ export declare class Memoirist<T> {
     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;

package/dist/route/memoirist.js

@@ -170,15 +170,19 @@ class Memoirist {
         return node.store;
     }
     find(method, url) {
-        const cacheKey = this.buildCacheKey(method, url);
-        if (this.routeCache.has(cacheKey)) {
-            return this.routeCache.get(cacheKey);
+        let methodCache = this.routeCache.get(url);
+        if (methodCache && methodCache[method] !== undefined) {
+            return methodCache[method];
         }
         const root = this.root[method];
         if (!root)
             return null;
         const result = matchRoute(url, url.length, root, 0);
-        this.routeCache.set(cacheKey, result);
+        if (!methodCache) {
+            methodCache = {};
+            this.routeCache.set(url, methodCache);
+        }
+        methodCache[method] = result;
         return result;
     }
     updateStore(method, path, oldStore, newStore) {
@@ -210,10 +214,6 @@ class Memoirist {
         }
         return false;
     }
-    buildCacheKey(method, url) {
-        const normalizedMethod = method.toLowerCase();
-        return `${normalizedMethod}:${url}`;
-    }
     invalidateCache() {
         this.routeCache.clear();
     }

package/dist/services/logger.service.js

@@ -9,13 +9,6 @@ class LoggerService {
     constructor(injector) {
         this.injector = injector;
         const pinoConfig = this.injector.applicationConfig.logger || {};
-        pinoConfig['transport'] = pinoConfig.transport || {
-            target: 'pino-pretty',
-            options: {
-                colorize: true,
-                ignore: 'pid,hostname',
-            },
-        };
         this.logger = (0, pino_1.default)(pinoConfig);
     }
     child(bindings) {

package/dist/testing/core-testing.js

@@ -4,7 +4,11 @@ exports.createCoreTestHarness = createCoreTestHarness;
 exports.withCoreApplication = withCoreApplication;
 const Carno_1 = require("../Carno");
 async function createCoreTestHarness(options = {}) {
-    const app = new Carno_1.Carno(options.config);
+    const config = { ...options.config };
+    if (config.disableStartupLog === undefined) {
+        config.disableStartupLog = true;
+    }
+    const app = new Carno_1.Carno(config);
     applyPlugins(app, options.plugins);
     const boot = await bootApplication(app, options);
     const injector = app.getInjector();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@carno.js/core",
-  "version": "0.2.10",
+  "version": "0.2.11",
   "description": "Carno.js is a framework for building web applications object oriented with TypeScript and Bun.sh",
   "keywords": [
     "bun",
@@ -62,5 +62,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "5c765c2c9172bec7f509ca2513f6c10472ec89eb"
+  "gitHead": "495ba33561d058107b1bb76d737a0d38a361f5b2"
 }