@carno.js/core 0.2.4 → 0.2.5

package/dist/Carno.d.ts

@@ -4,6 +4,7 @@ import * as pino from "pino";
 import { TokenRouteWithProvider } from "./container/ContainerConfiguration";
 import { CorsConfig } from "./domain/cors-config";
 import Memoirist from "./route/memoirist";
+import { type CompiledRoute } from "./route/CompiledRoute";
 export interface ApplicationConfig {
     validation?: ValidatorOptions;
     logger?: pino.LoggerOptions;
@@ -14,9 +15,10 @@ export interface ApplicationConfig {
 }
 export declare class Carno {
     config: ApplicationConfig;
-    router: Memoirist<TokenRouteWithProvider>;
+    router: Memoirist<CompiledRoute | TokenRouteWithProvider>;
     private injector;
     private corsCache?;
+    private readonly emptyLocals;
     private fetch;
     private server;
     constructor(config?: ApplicationConfig);
@@ -61,5 +63,7 @@ export declare class Carno {
     private handlePreflightRequest;
     private applyCorsHeaders;
     close(closeActiveConnections?: boolean): void;
+    private resolveLocalsContainer;
+    private buildLocalsContainer;
     private discoverRoutePath;
 }

package/dist/Carno.js

@@ -17,6 +17,8 @@ const on_event_1 = require("./events/on-event");
 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.
@@ -25,6 +27,7 @@ class Carno {
         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);
@@ -179,17 +182,30 @@ class Carno {
             }
         }
         const urlParsed = parseUrl(request);
-        const context = await Context_1.Context.createFromRequest(urlParsed, request, server);
-        await this.injector.callHook(on_event_1.EventType.OnRequest, { context });
-        const local = new LocalsContainer_1.LocalsContainer();
         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;
-        local.set(Context_1.Context, context);
-        let response = await RouteExecutor_1.RouteExecutor.executeRoute(route.store, this.injector, context, local);
+        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 });
+            }
+            response = await RouteExecutor_1.RouteExecutor.executeRoute(compiled, this.injector, context, locals);
+        }
         if (this.isCorsEnabled()) {
             const origin = request.headers.get("origin");
             if (origin && this.isOriginAllowed(origin)) {
@@ -269,6 +285,17 @@ class Carno {
     close(closeActiveConnections = false) {
         this.server?.stop(closeActiveConnections);
     }
+    resolveLocalsContainer(needsLocalsContainer, context) {
+        if (!needsLocalsContainer) {
+            return this.emptyLocals;
+        }
+        return this.buildLocalsContainer(context);
+    }
+    buildLocalsContainer(context) {
+        const locals = new LocalsContainer_1.LocalsContainer();
+        locals.set(Context_1.Context, context);
+        return locals;
+    }
     discoverRoutePath(url) {
         if (url?.pathname) {
             return url.pathname;

package/dist/container/DependencyResolver.d.ts

@@ -1,6 +1,7 @@
 import { TokenProvider } from "../commons/registries/ProviderControl";
 import { LocalsContainer } from "../domain/LocalsContainer";
 import { Provider } from "../domain/provider";
+import { ProviderScope } from "../domain/provider-scope";
 import { Container } from "./container";
 export declare class DependencyResolver {
     private container;
@@ -8,6 +9,7 @@ export declare class DependencyResolver {
     resolve(provider: Provider, locals: LocalsContainer, invokeCallback: (token: TokenProvider, locals: LocalsContainer) => any): any;
     private validateProvider;
     private determineScope;
+    resolveScope(provider: Provider): ProviderScope;
     private hasRequestScopeDependency;
     private createInstance;
     private resolveServices;

package/dist/container/DependencyResolver.js

@@ -30,6 +30,10 @@ class DependencyResolver {
         const hasRequestDep = this.hasRequestScopeDependency(deps);
         return hasRequestDep ? provider_scope_1.ProviderScope.REQUEST : provider_scope_1.ProviderScope.SINGLETON;
     }
+    resolveScope(provider) {
+        const scope = this.determineScope(provider);
+        return scope;
+    }
     hasRequestScopeDependency(deps) {
         if (deps.length === 0)
             return false;

package/dist/container/InjectorService.d.ts

@@ -13,6 +13,10 @@ export declare class InjectorService {
     container: Container;
     applicationConfig: ApplicationConfig;
     router: Memoirist<TokenRouteWithProvider>;
+    private hooksByEvent;
+    private _hasOnRequestHook;
+    private _hasOnResponseHook;
+    private controllerScopes;
     private routeResolver;
     private dependencyResolver;
     private methodInvoker;
@@ -21,10 +25,28 @@ export declare class InjectorService {
     private ensureProvider;
     get(token: TokenProvider): Provider | undefined;
     invoke(token: TokenProvider, locals?: LocalsContainer): any;
-    invokeRoute(route: TokenRouteWithProvider, context: Context, locals: LocalsContainer): Promise<any>;
+    resolveControllerInstance(token: TokenProvider, locals: LocalsContainer): any;
+    invokeRoute(route: TokenRouteWithProvider, context: Context, locals: LocalsContainer, instance: any): Promise<any>;
     scopeOf(provider: Provider): ProviderScope | undefined;
     callHook(event: EventType, data?: unknown): Promise<void>;
-    private getHooksByEvent;
+    private getCachedHooks;
+    private cacheHooks;
+    hasHook(event: EventType): boolean;
+    hasOnRequestHook(): boolean;
+    hasOnResponseHook(): boolean;
+    private cacheControllerScopes;
+    private buildControllerScopeMap;
+    private getControllers;
+    private getControllerScope;
+    private preInstantiateSingletonControllers;
+    private compileRoutes;
+    private ensureControllerInstance;
+    private buildHooksByEvent;
+    private readAllHooks;
+    private groupHooksByEvent;
+    private appendHook;
+    private sortHookMap;
+    private sortAndStore;
     private sortHooksByPriority;
     private runHookHandlers;
     private executeHook;

package/dist/container/InjectorService.js

@@ -17,6 +17,7 @@ const Context_1 = require("../domain/Context");
 const LocalsContainer_1 = require("../domain/LocalsContainer");
 const Metadata_1 = require("../domain/Metadata");
 const provider_scope_1 = require("../domain/provider-scope");
+const provider_type_1 = require("../domain/provider-type");
 const on_event_1 = require("../events/on-event");
 const logger_service_1 = require("../services/logger.service");
 const cache_service_1 = require("../cache/cache.service");
@@ -28,12 +29,16 @@ const middleware_resolver_1 = require("./middleware.resolver");
 const RouteResolver_1 = require("./RouteResolver");
 const DependencyResolver_1 = require("./DependencyResolver");
 const MethodInvoker_1 = require("./MethodInvoker");
-const request_logger_service_1 = require("../services/request-logger.service");
+const RouteCompiler_1 = require("../route/RouteCompiler");
 let InjectorService = InjectorService_1 = class InjectorService {
     constructor() {
         this.settings = new ContainerConfiguration_1.ContainerConfiguration();
         this.container = new container_1.Container();
         this.applicationConfig = {};
+        this.hooksByEvent = new Map();
+        this._hasOnRequestHook = false;
+        this._hasOnResponseHook = false;
+        this.controllerScopes = new Map();
     }
     async loadModule(container, applicationConfig, router) {
         this.container = container;
@@ -43,6 +48,10 @@ let InjectorService = InjectorService_1 = class InjectorService {
         this.removeUnknownProviders();
         this.saveInjector();
         this.routeResolver.resolveControllers();
+        this.cacheControllerScopes();
+        this.preInstantiateSingletonControllers();
+        this.cacheHooks();
+        this.compileRoutes();
         await this.callHook(on_event_1.EventType.OnApplicationInit);
     }
     initializeResolvers() {
@@ -73,27 +82,145 @@ let InjectorService = InjectorService_1 = class InjectorService {
         }
         return this.dependencyResolver.resolve(provider, locals, (t, l) => this.invoke(t, l));
     }
-    async invokeRoute(route, context, locals) {
+    resolveControllerInstance(token, locals) {
+        const provider = this.ensureProvider(token);
+        if (!provider) {
+            const message = `Provider not found for: ${(0, nameOf_1.nameOf)(token)}, check if it was ` +
+                `imported into the module or imported without type-only import.`;
+            throw new Error(message);
+        }
+        const scope = this.getControllerScope(provider);
+        if (scope !== provider_scope_1.ProviderScope.SINGLETON) {
+            return this.invoke(token, locals);
+        }
+        if (provider.instance) {
+            return provider.instance;
+        }
+        return this.invoke(token, locals);
+    }
+    async invokeRoute(route, context, locals, instance) {
         await middleware_resolver_1.MiddlewareRes.resolveMiddlewares(route, this, locals);
-        return this.methodInvoker.invoke(route.provider.instance, route.methodName, locals, context, (t, l) => this.invoke(t, l));
+        const result = await this.methodInvoker.invoke(instance, route.methodName, locals, context, (t, l) => this.invoke(t, l));
+        return result;
     }
     scopeOf(provider) {
         return provider.scope || provider_scope_1.ProviderScope.SINGLETON;
     }
     async callHook(event, data = null) {
-        const hooks = this.getHooksByEvent(event);
+        const hooks = this.getCachedHooks(event);
         if (hooks.length === 0) {
             return;
         }
         await this.runHookHandlers(hooks, data ?? {});
     }
-    getHooksByEvent(event) {
-        const hooks = Metadata_1.Metadata.get(constants_1.CONTROLLER_EVENTS, Reflect);
-        if (!hooks) {
-            return [];
+    getCachedHooks(event) {
+        return this.hooksByEvent.get(event) ?? [];
+    }
+    cacheHooks() {
+        this.hooksByEvent = this.buildHooksByEvent();
+        this._hasOnRequestHook = (this.hooksByEvent.get(on_event_1.EventType.OnRequest)?.length ?? 0) > 0;
+        this._hasOnResponseHook = (this.hooksByEvent.get(on_event_1.EventType.OnResponse)?.length ?? 0) > 0;
+    }
+    hasHook(event) {
+        if (event === on_event_1.EventType.OnRequest) {
+            return this._hasOnRequestHook;
+        }
+        if (event === on_event_1.EventType.OnResponse) {
+            return this._hasOnResponseHook;
+        }
+        return (this.hooksByEvent.get(event)?.length ?? 0) > 0;
+    }
+    hasOnRequestHook() {
+        return this._hasOnRequestHook;
+    }
+    hasOnResponseHook() {
+        return this._hasOnResponseHook;
+    }
+    cacheControllerScopes() {
+        const controllers = this.getControllers();
+        this.controllerScopes = this.buildControllerScopeMap(controllers);
+    }
+    buildControllerScopeMap(controllers) {
+        const scoped = new Map();
+        controllers.forEach((controller) => {
+            const scope = this.dependencyResolver.resolveScope(controller);
+            scoped.set(controller.token, scope);
+        });
+        return scoped;
+    }
+    getControllers() {
+        const controllers = ProviderControl_1.GlobalProvider.getByType(provider_type_1.ProviderType.CONTROLLER);
+        return controllers;
+    }
+    getControllerScope(controller) {
+        const cached = this.controllerScopes.get(controller.token);
+        if (cached) {
+            return cached;
         }
-        const filtered = hooks.filter((hook) => hook.eventName === event);
-        return this.sortHooksByPriority(filtered);
+        const scope = this.dependencyResolver.resolveScope(controller);
+        this.controllerScopes.set(controller.token, scope);
+        return scope;
+    }
+    preInstantiateSingletonControllers() {
+        const controllers = this.getControllers();
+        for (const controller of controllers) {
+            const scope = this.getControllerScope(controller);
+            if (scope !== provider_scope_1.ProviderScope.SINGLETON) {
+                continue;
+            }
+            this.ensureControllerInstance(controller);
+        }
+    }
+    compileRoutes() {
+        const compiler = new RouteCompiler_1.RouteCompiler({
+            container: this.container,
+            controllerScopes: this.controllerScopes,
+            validationConfig: this.applicationConfig.validation,
+            hasOnRequestHook: this._hasOnRequestHook,
+            hasOnResponseHook: this._hasOnResponseHook,
+        });
+        const routesToCompile = [...this.router.history];
+        for (const [method, path, store] of routesToCompile) {
+            if (!store || store.routeType !== undefined) {
+                continue;
+            }
+            const compiled = compiler.compile(store);
+            if (!compiled) {
+                continue;
+            }
+            this.router.updateStore(method, path, store, compiled);
+        }
+    }
+    ensureControllerInstance(controller) {
+        if (controller.instance) {
+            return;
+        }
+        this.invoke(controller.token);
+    }
+    buildHooksByEvent() {
+        const hooks = this.readAllHooks();
+        return this.groupHooksByEvent(hooks);
+    }
+    readAllHooks() {
+        return Metadata_1.Metadata.get(constants_1.CONTROLLER_EVENTS, Reflect) ?? [];
+    }
+    groupHooksByEvent(hooks) {
+        const grouped = new Map();
+        hooks.forEach((hook) => this.appendHook(grouped, hook));
+        return this.sortHookMap(grouped);
+    }
+    appendHook(grouped, hook) {
+        const list = grouped.get(hook.eventName) ?? [];
+        list.push(hook);
+        grouped.set(hook.eventName, list);
+    }
+    sortHookMap(grouped) {
+        const sorted = new Map();
+        grouped.forEach((hooks, event) => this.sortAndStore(sorted, event, hooks));
+        return sorted;
+    }
+    sortAndStore(target, event, hooks) {
+        target.set(event, this.sortHooksByPriority(hooks));
     }
     sortHooksByPriority(hooks) {
         return hooks.slice().sort((first, second) => {
@@ -123,8 +250,7 @@ let InjectorService = InjectorService_1 = class InjectorService {
             Context_1.Context,
             logger_service_1.LoggerService,
             default_routes_carno_1.DefaultRoutesCarno,
-            cache_service_1.CacheService,
-            request_logger_service_1.RequestLogger
+            cache_service_1.CacheService
         ];
         this.applicationConfig.providers = this.applicationConfig.providers || [];
         this.applicationConfig.providers.push(...defaults);

package/dist/domain/Context.d.ts

@@ -1,23 +1,28 @@
 import { Server } from 'bun';
 export declare class Context {
     query: Record<string, any>;
-    body: Record<string, any>;
+    private _body;
     rawBody?: ArrayBuffer;
     param: Record<string, any>;
     req: Request;
     headers: Request["headers"];
     locals: Record<string, any>;
-    trackingId: string;
     private resultStatus;
+    private _pendingRequest;
+    private _bodyParsed;
     private constructor();
+    get body(): Record<string, any>;
+    set body(value: Record<string, any>);
+    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;
-    private setTrackingId;
-    private setTrackingIdFromJob;
     setParam(param: Record<string, any>): void;
     setResponseStatus(status: number): void;
     getResponseStatus(): number;

package/dist/domain/Context.js

@@ -18,26 +18,61 @@ const provider_scope_1 = require("./provider-scope");
 let Context = Context_1 = class Context {
     constructor() {
         this.query = {};
-        this.body = {};
+        this._body = {};
         this.param = {};
         this.headers = new Headers();
         this.locals = {};
+        this._pendingRequest = null;
+        this._bodyParsed = false;
+    }
+    get body() {
+        return this._body;
+    }
+    set body(value) {
+        this._body = value;
+        this._bodyParsed = true;
+    }
+    async getBody() {
+        if (!this._bodyParsed && this._pendingRequest) {
+            await this.resolveBody(this._pendingRequest);
+            this._pendingRequest = null;
+            this._bodyParsed = true;
+        }
+        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;
+    }
+    static createFromRequestSync(url, request, server) {
         const context = new Context_1();
         context.setQuery(url);
-        if (request.method !== 'GET') {
-            await context.resolveBody(request);
-        }
         context.setReq(request);
         // @ts-ignore
         context.setHeaders(request.headers);
-        context.setTrackingId(request);
+        if (request.method !== 'GET' && request.method !== 'HEAD') {
+            context._pendingRequest = request;
+        }
+        else {
+            context._bodyParsed = true;
+        }
+        return context;
+    }
+    static async createFromRequestWithBody(url, request, server) {
+        const context = Context_1.createFromRequestSync(url, request, server);
+        if (context._pendingRequest) {
+            await context.getBody();
+        }
         return context;
     }
     static createFromJob(job) {
         const context = new Context_1();
-        context.setTrackingIdFromJob(job);
         return context;
     }
     // @ts-ignore
@@ -46,7 +81,7 @@ let Context = Context_1 = class Context {
     }
     setBody(body) {
         for (const [key, value] of body.entries()) {
-            this.body[key] = value;
+            this._body[key] = value;
         }
     }
     setReq(req) {
@@ -55,27 +90,6 @@ let Context = Context_1 = class Context {
     setHeaders(headers) {
         this.headers = headers;
     }
-    setTrackingId(request) {
-        const headerTrackingId = request.headers.get('x-tracking-id');
-        if (headerTrackingId) {
-            this.trackingId = headerTrackingId;
-            return;
-        }
-        this.trackingId = crypto.randomUUID();
-    }
-    setTrackingIdFromJob(job) {
-        const trackingIdFromData = job.data?.__trackingId;
-        if (trackingIdFromData) {
-            this.trackingId = trackingIdFromData;
-            return;
-        }
-        const trackingIdFromProperty = job.trackingId;
-        if (trackingIdFromProperty) {
-            this.trackingId = trackingIdFromProperty;
-            return;
-        }
-        this.trackingId = crypto.randomUUID();
-    }
     setParam(param) {
         this.param = param;
     }
@@ -102,15 +116,15 @@ let Context = Context_1 = class Context {
         // 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);
+            this._body = this.parseJsonFromBuffer(this.rawBody);
             return;
         }
         if (contentType.includes('application/x-www-form-urlencoded')) {
-            this.body = this.parseUrlEncodedFromBuffer(this.rawBody);
+            this._body = this.parseUrlEncodedFromBuffer(this.rawBody);
             return;
         }
         // Plain text or unknown content type
-        this.body = { body: this.decodeBuffer(this.rawBody) };
+        this._body = { body: this.decodeBuffer(this.rawBody) };
     }
     parseJsonFromBuffer(buffer) {
         if (this.isEmptyBuffer(buffer)) {

package/dist/index.d.ts

@@ -10,7 +10,6 @@ export * from "./constants";
 export * from "./utils";
 export * from "./default-routes-carno";
 export * from "./services/logger.service";
-export * from "./services/request-logger.service";
 export * from "./cache/cache.service";
 export * from "./cache/bento-cache.driver";
 export * from "./testing";

package/dist/index.js

@@ -26,7 +26,6 @@ __exportStar(require("./constants"), exports);
 __exportStar(require("./utils"), exports);
 __exportStar(require("./default-routes-carno"), exports);
 __exportStar(require("./services/logger.service"), exports);
-__exportStar(require("./services/request-logger.service"), exports);
 __exportStar(require("./cache/cache.service"), exports);
 __exportStar(require("./cache/bento-cache.driver"), exports);
 __exportStar(require("./testing"), exports);

package/dist/route/CompiledRoute.d.ts

@@ -0,0 +1,23 @@
+import type { Context } from '../domain/Context';
+import type { TokenRouteWithProvider } from '../container/ContainerConfiguration';
+export declare enum RouteType {
+    SIMPLE = 0,
+    STANDARD = 1,
+    COMPLEX = 2
+}
+export type ParamResolver = (context: Context) => any;
+export type AsyncParamResolver = (context: Context) => Promise<any>;
+export type CompiledHandler = (context: Context) => any;
+export type AsyncCompiledHandler = (context: Context) => Promise<any>;
+export interface CompiledRoute {
+    routeType: RouteType;
+    controllerInstance: any | null;
+    boundHandler: CompiledHandler | AsyncCompiledHandler | null;
+    paramResolvers: (ParamResolver | AsyncParamResolver | null)[];
+    needsLocalsContainer: boolean;
+    hasMiddlewares: boolean;
+    hasValidation: boolean;
+    validationIndices: number[];
+    isAsync: boolean;
+    original: TokenRouteWithProvider;
+}

package/dist/route/CompiledRoute.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RouteType = void 0;
+var RouteType;
+(function (RouteType) {
+    RouteType[RouteType["SIMPLE"] = 0] = "SIMPLE";
+    RouteType[RouteType["STANDARD"] = 1] = "STANDARD";
+    RouteType[RouteType["COMPLEX"] = 2] = "COMPLEX";
+})(RouteType || (exports.RouteType = RouteType = {}));

package/dist/route/FastPathExecutor.d.ts

@@ -0,0 +1,4 @@
+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;

package/dist/route/FastPathExecutor.js

@@ -0,0 +1,19 @@
+"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');
+    }
+    if (compiled.isAsync) {
+        return compiled.boundHandler(context);
+    }
+    return compiled.boundHandler(context);
+}
+function executeSimpleRouteSync(compiled, context) {
+    if (!compiled.boundHandler) {
+        throw new Error('Simple route must have a bound handler');
+    }
+    return compiled.boundHandler(context);
+}

package/dist/route/JITCompiler.d.ts

@@ -0,0 +1,4 @@
+import type { ParamInfo } from './ParamResolverFactory';
+import type { CompiledHandler, AsyncCompiledHandler } from './CompiledRoute';
+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;

package/dist/route/JITCompiler.js

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compileRouteHandler = compileRouteHandler;
+exports.compileValidatedHandler = compileValidatedHandler;
+function escapeKey(key) {
+    return key.replace(/['"\\]/g, '\\$&');
+}
+function buildArgExpression(param, index) {
+    const key = param.key ? escapeKey(param.key) : undefined;
+    switch (param.type) {
+        case 'param':
+            return key ? `ctx.param['${key}']` : 'ctx.param';
+        case 'query':
+            return key ? `ctx.query['${key}']` : 'ctx.query';
+        case 'body':
+            return key ? `ctx.body['${key}']` : 'ctx.body';
+        case 'headers':
+            return key
+                ? `ctx.headers.get('${key}')`
+                : 'ctx.headers';
+        case 'req':
+            return 'ctx.req';
+        case 'locals':
+            return 'ctx.locals';
+        case 'di':
+            return `resolvers[${index}](ctx)`;
+        default:
+            return `resolvers[${index}](ctx)`;
+    }
+}
+function compileRouteHandler(instance, methodName, paramInfos) {
+    const handler = instance[methodName].bind(instance);
+    if (paramInfos.length === 0) {
+        return () => handler();
+    }
+    const hasBodyParam = paramInfos.some((p) => p.type === 'body');
+    const hasDIParam = paramInfos.some((p) => p.type === 'di');
+    if (hasDIParam) {
+        return createFallbackHandler(handler, paramInfos);
+    }
+    const argExpressions = paramInfos.map(buildArgExpression);
+    if (hasBodyParam) {
+        return createAsyncHandler(handler, argExpressions);
+    }
+    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);
+}
+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;
+            }
+        }
+        return handler(...args);
+    };
+}
+function compileValidatedHandler(instance, methodName, paramInfos, validators) {
+    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 (hasBodyParam) {
+        return async (ctx) => {
+            await ctx.getBody();
+            const args = paramInfos.map((p, i) => resolveArg(ctx, p, i));
+            return handler(...args);
+        };
+    }
+    return (ctx) => {
+        const args = paramInfos.map((p, i) => resolveArg(ctx, p, i));
+        return handler(...args);
+    };
+}

package/dist/route/ParamResolverFactory.d.ts

@@ -0,0 +1,17 @@
+import { type ValidatorOptions } from 'class-validator';
+import type { Context } from '../domain/Context';
+import type { ParamResolver, AsyncParamResolver } from './CompiledRoute';
+export interface ParamDecoratorMeta {
+    fun: (context: Context, data?: any) => any;
+    param?: any;
+}
+export interface ParamInfo {
+    type: 'body' | 'query' | 'param' | 'headers' | 'req' | 'locals' | 'di';
+    key?: string;
+    needsValidation: boolean;
+    token?: any;
+}
+export declare function analyzeParamDecorator(decoratorMeta: ParamDecoratorMeta | undefined, token: any): ParamInfo;
+export declare function createParamResolver(decoratorMeta: ParamDecoratorMeta | undefined, token: any, validationConfig?: ValidatorOptions): ParamResolver | AsyncParamResolver | null;
+export declare function createParamResolvers(paramMetas: Record<number, ParamDecoratorMeta> | undefined, argTypes: any[], validationConfig?: ValidatorOptions): (ParamResolver | AsyncParamResolver | null)[];
+export declare function hasAnyDIParam(resolvers: (ParamResolver | AsyncParamResolver | null)[]): boolean;

package/dist/route/ParamResolverFactory.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeParamDecorator = analyzeParamDecorator;
+exports.createParamResolver = createParamResolver;
+exports.createParamResolvers = createParamResolvers;
+exports.hasAnyDIParam = hasAnyDIParam;
+const class_transformer_1 = require("class-transformer");
+const class_validator_1 = require("class-validator");
+const HttpException_1 = require("../exceptions/HttpException");
+const ValidationCache_1 = require("../utils/ValidationCache");
+function analyzeParamDecorator(decoratorMeta, token) {
+    if (!decoratorMeta) {
+        return { type: 'di', needsValidation: false, token };
+    }
+    const funcStr = decoratorMeta.fun.toString();
+    const key = decoratorMeta.param;
+    const needsValidation = typeof token === 'function' && (0, ValidationCache_1.isValidatable)(token);
+    if (funcStr.includes('context.body')) {
+        return { type: 'body', key, needsValidation, token };
+    }
+    if (funcStr.includes('context.query')) {
+        return { type: 'query', key, needsValidation, token };
+    }
+    if (funcStr.includes('context.param')) {
+        return { type: 'param', key, needsValidation, token };
+    }
+    if (funcStr.includes('context.headers')) {
+        return { type: 'headers', key, needsValidation, token };
+    }
+    if (funcStr.includes('context.req')) {
+        return { type: 'req', needsValidation: false, token };
+    }
+    if (funcStr.includes('context.locals')) {
+        return { type: 'locals', needsValidation: false, token };
+    }
+    return { type: 'di', needsValidation: false, token };
+}
+function createValidationResolver(extractFn, token, validationConfig) {
+    return (context) => {
+        const value = extractFn(context);
+        const obj = (0, class_transformer_1.plainToInstance)(token, value);
+        const errors = (0, class_validator_1.validateSync)(obj, validationConfig);
+        if (errors.length > 0) {
+            throw new HttpException_1.HttpException(errors, 400);
+        }
+        return obj;
+    };
+}
+function createParamResolver(decoratorMeta, token, validationConfig) {
+    if (!decoratorMeta) {
+        return null;
+    }
+    const extractFn = (context) => decoratorMeta.fun(context, decoratorMeta.param);
+    const needsValidation = typeof token === 'function' && (0, ValidationCache_1.isValidatable)(token);
+    if (needsValidation) {
+        return createValidationResolver(extractFn, token, validationConfig);
+    }
+    return extractFn;
+}
+function createParamResolvers(paramMetas, argTypes, validationConfig) {
+    const resolvers = [];
+    for (let i = 0; i < argTypes.length; i++) {
+        const meta = paramMetas?.[i];
+        const token = argTypes[i];
+        resolvers.push(createParamResolver(meta, token, validationConfig));
+    }
+    return resolvers;
+}
+function hasAnyDIParam(resolvers) {
+    return resolvers.some((r) => r === null);
+}

package/dist/route/RouteCompiler.d.ts

@@ -0,0 +1,29 @@
+import { type ValidatorOptions } from 'class-validator';
+import type { TokenRouteWithProvider } from '../container/ContainerConfiguration';
+import type { Container } from '../container/container';
+import { ProviderScope } from '../domain/provider-scope';
+import { type CompiledRoute } from './CompiledRoute';
+export interface RouteCompilerOptions {
+    container: Container;
+    controllerScopes: Map<any, ProviderScope>;
+    validationConfig?: ValidatorOptions;
+    hasOnRequestHook: boolean;
+    hasOnResponseHook: boolean;
+}
+export declare class RouteCompiler {
+    private container;
+    private controllerScopes;
+    private validationConfig?;
+    private hasOnRequestHook;
+    private hasOnResponseHook;
+    constructor(options: RouteCompilerOptions);
+    compile(route: TokenRouteWithProvider): CompiledRoute | null;
+    private classifyRoute;
+    private analyzeMethodParams;
+    private createSimpleRoute;
+    private createStandardRouteWithInstance;
+    private createStandardRoute;
+    private createComplexRoute;
+    private createFallbackRoute;
+    private createValidatedHandler;
+}

package/dist/route/RouteCompiler.js

@@ -0,0 +1,209 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RouteCompiler = void 0;
+const class_transformer_1 = require("class-transformer");
+const class_validator_1 = require("class-validator");
+const provider_scope_1 = require("../domain/provider-scope");
+const Metadata_1 = require("../domain/Metadata");
+const HttpException_1 = require("../exceptions/HttpException");
+const getMethodArgTypes_1 = require("../utils/getMethodArgTypes");
+const CompiledRoute_1 = require("./CompiledRoute");
+const ParamResolverFactory_1 = require("./ParamResolverFactory");
+const JITCompiler_1 = require("./JITCompiler");
+class RouteCompiler {
+    constructor(options) {
+        this.container = options.container;
+        this.controllerScopes = options.controllerScopes;
+        this.validationConfig = options.validationConfig;
+        this.hasOnRequestHook = options.hasOnRequestHook;
+        this.hasOnResponseHook = options.hasOnResponseHook;
+    }
+    compile(route) {
+        if (!route || !route.provider) {
+            return null;
+        }
+        const provider = this.container.get(route.provider);
+        if (!provider) {
+            return this.createFallbackRoute(route);
+        }
+        const scope = this.controllerScopes.get(provider.token);
+        const isSingleton = scope === provider_scope_1.ProviderScope.SINGLETON;
+        const instance = isSingleton ? provider.instance : null;
+        if (!instance) {
+            return this.createStandardRoute(route, provider);
+        }
+        const paramInfos = this.analyzeMethodParams(instance, route.methodName);
+        const routeType = this.classifyRoute(route, paramInfos, isSingleton);
+        if (routeType === CompiledRoute_1.RouteType.SIMPLE) {
+            return this.createSimpleRoute(route, instance, paramInfos);
+        }
+        if (routeType === CompiledRoute_1.RouteType.STANDARD) {
+            return this.createStandardRouteWithInstance(route, instance, paramInfos);
+        }
+        return this.createComplexRoute(route, paramInfos);
+    }
+    classifyRoute(route, paramInfos, isSingleton) {
+        if (!isSingleton) {
+            return CompiledRoute_1.RouteType.COMPLEX;
+        }
+        const hasMiddlewares = route.middlewares.length > 0;
+        const hasDIParams = paramInfos.some((p) => p.type === 'di');
+        const hasHooks = this.hasOnRequestHook || this.hasOnResponseHook;
+        if (hasMiddlewares || hasDIParams || hasHooks) {
+            return CompiledRoute_1.RouteType.STANDARD;
+        }
+        return CompiledRoute_1.RouteType.SIMPLE;
+    }
+    analyzeMethodParams(instance, methodName) {
+        const argTypes = (0, getMethodArgTypes_1.getMethodArgTypes)(instance, methodName);
+        const decoratorMetas = Metadata_1.Metadata.getParamDecoratorFunc(instance, methodName);
+        return argTypes.map((token, index) => {
+            const meta = decoratorMetas?.[index];
+            return (0, ParamResolverFactory_1.analyzeParamDecorator)(meta, token);
+        });
+    }
+    createSimpleRoute(route, instance, paramInfos) {
+        const hasValidation = paramInfos.some((p) => p.needsValidation);
+        const validationIndices = paramInfos
+            .map((p, i) => (p.needsValidation ? i : -1))
+            .filter((i) => i >= 0);
+        const hasBodyParam = paramInfos.some((p) => p.type === 'body');
+        let boundHandler;
+        if (hasValidation) {
+            boundHandler = this.createValidatedHandler(instance, route.methodName, paramInfos, hasBodyParam);
+        }
+        else {
+            boundHandler = (0, JITCompiler_1.compileRouteHandler)(instance, route.methodName, paramInfos);
+        }
+        return {
+            routeType: CompiledRoute_1.RouteType.SIMPLE,
+            controllerInstance: instance,
+            boundHandler,
+            paramResolvers: [],
+            needsLocalsContainer: false,
+            hasMiddlewares: false,
+            hasValidation,
+            validationIndices,
+            isAsync: hasBodyParam,
+            original: route,
+        };
+    }
+    createStandardRouteWithInstance(route, instance, paramInfos) {
+        const hasValidation = paramInfos.some((p) => p.needsValidation);
+        const validationIndices = paramInfos
+            .map((p, i) => (p.needsValidation ? i : -1))
+            .filter((i) => i >= 0);
+        const hasDIParams = paramInfos.some((p) => p.type === 'di');
+        const hasBodyParam = paramInfos.some((p) => p.type === 'body');
+        const hasMiddlewares = route.middlewares.length > 0;
+        const needsLocalsContainer = hasDIParams || hasMiddlewares;
+        return {
+            routeType: CompiledRoute_1.RouteType.STANDARD,
+            controllerInstance: instance,
+            boundHandler: null,
+            paramResolvers: [],
+            needsLocalsContainer,
+            hasMiddlewares,
+            hasValidation,
+            validationIndices,
+            isAsync: hasBodyParam || hasDIParams,
+            original: route,
+        };
+    }
+    createStandardRoute(route, provider) {
+        return {
+            routeType: CompiledRoute_1.RouteType.STANDARD,
+            controllerInstance: null,
+            boundHandler: null,
+            paramResolvers: [],
+            needsLocalsContainer: true,
+            hasMiddlewares: route.middlewares.length > 0,
+            hasValidation: false,
+            validationIndices: [],
+            isAsync: true,
+            original: route,
+        };
+    }
+    createComplexRoute(route, paramInfos) {
+        const hasValidation = paramInfos.some((p) => p.needsValidation);
+        const validationIndices = paramInfos
+            .map((p, i) => (p.needsValidation ? i : -1))
+            .filter((i) => i >= 0);
+        return {
+            routeType: CompiledRoute_1.RouteType.COMPLEX,
+            controllerInstance: null,
+            boundHandler: null,
+            paramResolvers: [],
+            needsLocalsContainer: true,
+            hasMiddlewares: route.middlewares.length > 0,
+            hasValidation,
+            validationIndices,
+            isAsync: true,
+            original: route,
+        };
+    }
+    createFallbackRoute(route) {
+        return {
+            routeType: CompiledRoute_1.RouteType.COMPLEX,
+            controllerInstance: null,
+            boundHandler: null,
+            paramResolvers: [],
+            needsLocalsContainer: true,
+            hasMiddlewares: route.middlewares.length > 0,
+            hasValidation: false,
+            validationIndices: [],
+            isAsync: true,
+            original: route,
+        };
+    }
+    createValidatedHandler(instance, methodName, paramInfos, hasBodyParam) {
+        const handler = instance[methodName].bind(instance);
+        const config = this.validationConfig;
+        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) {
+                const obj = (0, class_transformer_1.plainToInstance)(param.token, value);
+                const errors = (0, class_validator_1.validateSync)(obj, config);
+                if (errors.length > 0) {
+                    throw new HttpException_1.HttpException(errors, 400);
+                }
+                return obj;
+            }
+            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.d.ts

@@ -1,10 +1,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(route: TokenRouteWithProvider, injector: InjectorService, context: Context, locals: LocalsContainer): Promise<Response>;
-    private mountResponse;
+    executeRoute(routeStore: CompiledRoute | TokenRouteWithProvider, injector: InjectorService, context: Context, locals: LocalsContainer): Promise<Response>;
+    mountResponse(result: unknown, context: Context): Response;
     private isNativeResponse;
     private isBodyInit;
     private createJsonResponse;

package/dist/route/RouteExecutor.js

@@ -7,15 +7,23 @@ class Router {
         this.jsonHeaders = { "Content-Type": "application/json" };
         this.textHeaders = { "Content-Type": "text/html" };
     }
-    async executeRoute(route, injector, context, locals) {
-        const provider = injector.invoke(route.provider, locals);
-        route.provider.instance = provider;
-        // @ts-ignore
-        if (!provider[route.methodName]) {
+    async executeRoute(routeStore, injector, context, locals) {
+        const isCompiled = routeStore.routeType !== undefined;
+        const tokenRoute = isCompiled
+            ? routeStore.original
+            : routeStore;
+        const controllerInstance = isCompiled
+            ? routeStore.controllerInstance
+            : null;
+        const controller = controllerInstance
+            ?? injector.resolveControllerInstance(tokenRoute.provider, locals);
+        if (!controller[tokenRoute.methodName]) {
             throw new Error("Controller not found");
         }
-        const result = await injector.invokeRoute(route, context, locals);
-        await injector.callHook(events_1.EventType.OnResponse, { context, result });
+        const result = await injector.invokeRoute(tokenRoute, context, locals, controller);
+        if (injector.hasOnResponseHook()) {
+            await injector.callHook(events_1.EventType.OnResponse, { context, result });
+        }
         return this.mountResponse(result, context);
     }
     mountResponse(result, context) {

package/dist/route/memoirist.d.ts

@@ -21,5 +21,9 @@ export declare class Memoirist<T> {
     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 updateHistoryStore;
+    private normalizePath;
+    private findNode;
 }
 export default Memoirist;

package/dist/route/memoirist.js

@@ -167,11 +167,100 @@ class Memoirist {
             return null;
         return matchRoute(url, url.length, root, 0);
     }
+    updateStore(method, path, oldStore, newStore) {
+        const node = this.findNode(method, path);
+        if (!node) {
+            return false;
+        }
+        if (node.store === oldStore) {
+            node.store = newStore;
+            this.updateHistoryStore(method, path, newStore);
+            return true;
+        }
+        if (node.params?.store === oldStore) {
+            node.params.store = newStore;
+            this.updateHistoryStore(method, path, newStore);
+            return true;
+        }
+        if (node.wildcardStore === oldStore) {
+            node.wildcardStore = newStore;
+            this.updateHistoryStore(method, path, newStore);
+            return true;
+        }
+        return false;
+    }
+    updateHistoryStore(method, path, newStore) {
+        const normalizedPath = this.normalizePath(path);
+        for (let i = 0; i < this.history.length; i++) {
+            const [m, p] = this.history[i];
+            if (m === method && this.normalizePath(p) === normalizedPath) {
+                this.history[i] = [method, p, newStore];
+                break;
+            }
+        }
+    }
+    normalizePath(path) {
+        if (path === '') {
+            return '/';
+        }
+        return path[0] !== '/' ? `/${path}` : path;
+    }
+    findNode(method, path) {
+        if (path === '') {
+            path = '/';
+        }
+        else if (path[0] !== '/') {
+            path = `/${path}`;
+        }
+        const isWildcard = path[path.length - 1] === '*';
+        if (isWildcard) {
+            path = path.slice(0, -1);
+        }
+        const inertParts = path.split(Memoirist.regex.static);
+        const paramParts = path.match(Memoirist.regex.params) || [];
+        if (inertParts[inertParts.length - 1] === '') {
+            inertParts.pop();
+        }
+        let node = this.root[method];
+        if (!node) {
+            return null;
+        }
+        let paramPartsIndex = 0;
+        for (let i = 0; i < inertParts.length; ++i) {
+            let part = inertParts[i];
+            if (i > 0) {
+                paramPartsIndex++;
+                if (!node.params?.inert) {
+                    return null;
+                }
+                node = node.params.inert;
+            }
+            for (let j = 0;;) {
+                if (j === part.length) {
+                    break;
+                }
+                if (j === node.part.length) {
+                    if (!node.inert?.has(part.charCodeAt(j))) {
+                        return null;
+                    }
+                    node = node.inert.get(part.charCodeAt(j));
+                    part = part.slice(j);
+                    j = 0;
+                    continue;
+                }
+                if (part[j] !== node.part[j]) {
+                    return null;
+                }
+                ++j;
+            }
+        }
+        return node;
+    }
 }
 exports.Memoirist = Memoirist;
 Memoirist.regex = {
-    static: /:.+?(?=\/|$)/,
-    params: /:.+?(?=\/|$)/g
+    static: /:[^/]+/,
+    params: /:[^/]+/g
 };
 const matchRoute = (url, urlLength, node, startIndex) => {
     const part = node?.part;

package/dist/utils/ValidationCache.d.ts

@@ -0,0 +1,3 @@
+export declare function isValidatable(token: Function): boolean;
+export declare function preloadValidationForParams(args: any[]): number[];
+export declare function clearValidationCache(): void;

package/dist/utils/ValidationCache.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isValidatable = isValidatable;
+exports.preloadValidationForParams = preloadValidationForParams;
+exports.clearValidationCache = clearValidationCache;
+const isClassValidator_1 = require("./isClassValidator");
+const cache = new Map();
+function isValidatable(token) {
+    let result = cache.get(token);
+    if (result === undefined) {
+        result = (0, isClassValidator_1.isClassValidator)(token);
+        cache.set(token, result);
+    }
+    return result;
+}
+function preloadValidationForParams(args) {
+    const indices = [];
+    for (let i = 0; i < args.length; i++) {
+        if (typeof args[i] === 'function' && isValidatable(args[i])) {
+            indices.push(i);
+        }
+    }
+    return indices;
+}
+function clearValidationCache() {
+    cache.clear();
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@carno.js/core",
-  "version": "0.2.4",
+  "version": "0.2.5",
   "description": "Carno.js is a framework for building web applications object oriented with TypeScript and Bun.sh",
   "keywords": [
     "bun",
@@ -51,5 +51,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "91d257751a1386de821cd4dd3252fce3c070cfca"
+  "gitHead": "2be3063988696f2cd3eb13363e1f679b9f58c2f1"
 }