@carno.js/core 0.2.3 → 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,8 +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);
@@ -57,9 +60,10 @@ export declare class Carno {
     private reportHookFailure;
     private isCorsEnabled;
     private isOriginAllowed;
-    private buildCorsHeaders;
     private handlePreflightRequest;
     private applyCorsHeaders;
     close(closeActiveConnections?: boolean): void;
+    private resolveLocalsContainer;
+    private buildLocalsContainer;
     private discoverRoutePath;
 }

package/dist/Carno.js

@@ -12,11 +12,13 @@ const createInjector_1 = require("./container/createInjector");
 const domain_1 = require("./domain");
 const Context_1 = require("./domain/Context");
 const LocalsContainer_1 = require("./domain/LocalsContainer");
-const cors_config_1 = require("./domain/cors-config");
+const cors_headers_cache_1 = require("./domain/cors-headers-cache");
 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);
@@ -53,6 +56,9 @@ class Carno {
             console.error("Unhandled error:", error);
             return new Response("Internal Server Error", { status: 500 });
         };
+        if (config.cors) {
+            this.corsCache = new cors_headers_cache_1.CorsHeadersCache(config.cors);
+        }
         void this.bootstrapApplication();
     }
     /**
@@ -176,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)) {
@@ -249,54 +268,34 @@ class Carno {
         }
         return false;
     }
-    buildCorsHeaders(origin) {
-        const cors = this.config.cors;
-        const headers = {};
-        const allowedOrigin = typeof cors.origins === "string" && cors.origins === "*"
-            ? "*"
-            : origin;
-        headers["Access-Control-Allow-Origin"] = allowedOrigin;
-        if (cors.credentials) {
-            headers["Access-Control-Allow-Credentials"] = "true";
-        }
-        const methods = cors.methods || cors_config_1.DEFAULT_CORS_METHODS;
-        headers["Access-Control-Allow-Methods"] = methods.join(", ");
-        const allowedHeaders = cors.allowedHeaders || cors_config_1.DEFAULT_CORS_ALLOWED_HEADERS;
-        headers["Access-Control-Allow-Headers"] = allowedHeaders.join(", ");
-        if (cors.exposedHeaders && cors.exposedHeaders.length > 0) {
-            headers["Access-Control-Expose-Headers"] = cors.exposedHeaders.join(", ");
-        }
-        if (cors.maxAge !== undefined) {
-            headers["Access-Control-Max-Age"] = cors.maxAge.toString();
-        }
-        return headers;
-    }
     handlePreflightRequest(request) {
         const origin = request.headers.get("origin");
         if (!this.isOriginAllowed(origin)) {
             return new Response(null, { status: 403 });
         }
-        const corsHeaders = this.buildCorsHeaders(origin);
+        const corsHeaders = this.corsCache.get(origin);
         return new Response(null, {
             status: 204,
             headers: corsHeaders,
         });
     }
     applyCorsHeaders(response, origin) {
-        const corsHeaders = this.buildCorsHeaders(origin);
-        const newHeaders = new Headers(response.headers);
-        for (const [key, value] of Object.entries(corsHeaders)) {
-            newHeaders.set(key, value);
-        }
-        return new Response(response.body, {
-            status: response.status,
-            statusText: response.statusText,
-            headers: newHeaders,
-        });
+        return this.corsCache.applyToResponse(response, origin);
     }
     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,26 +1,36 @@
 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;
     private buildQueryObject;
     private resolveBody;
+    private parseJsonFromBuffer;
+    private parseJsonText;
+    private isEmptyBuffer;
+    private parseUrlEncodedFromBuffer;
+    private decodeBuffer;
 }

package/dist/domain/Context.js

@@ -11,31 +11,68 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 var Context_1;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Context = void 0;
+const http_code_enum_1 = require("../commons/http-code.enum");
 const Injectable_decorator_1 = require("../commons/decorators/Injectable.decorator");
+const HttpException_1 = require("../exceptions/HttpException");
 const provider_scope_1 = require("./provider-scope");
 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
@@ -44,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) {
@@ -53,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;
     }
@@ -88,16 +104,54 @@ let Context = Context_1 = class Context {
     }
     async resolveBody(request) {
         const contentType = request.headers.get('content-type') || '';
-        this.rawBody = await request.clone().arrayBuffer();
+        // Clone request once - preserve original request untouched
+        const clonedRequest = request.clone();
+        // FormData multipart requires consuming as formData
+        if (contentType.includes('multipart/form-data')) {
+            // Need separate clone for rawBody since formData() consumes the body
+            this.rawBody = await request.clone().arrayBuffer();
+            this.setBody(await clonedRequest.formData());
+            return;
+        }
+        // For all other content types, consume body once as ArrayBuffer from clone
+        this.rawBody = await clonedRequest.arrayBuffer();
         if (contentType.includes('application/json')) {
-            this.body = await request.clone().json();
+            this._body = this.parseJsonFromBuffer(this.rawBody);
             return;
         }
-        if (contentType.includes('application/x-www-form-urlencoded') || contentType.includes('multipart/form-data')) {
-            this.setBody(await request.clone().formData());
+        if (contentType.includes('application/x-www-form-urlencoded')) {
+            this._body = this.parseUrlEncodedFromBuffer(this.rawBody);
             return;
         }
-        this.body = { body: await request.clone().text() };
+        // Plain text or unknown content type
+        this._body = { body: this.decodeBuffer(this.rawBody) };
+    }
+    parseJsonFromBuffer(buffer) {
+        if (this.isEmptyBuffer(buffer)) {
+            return {};
+        }
+        return this.parseJsonText(this.decodeBuffer(buffer));
+    }
+    parseJsonText(text) {
+        try {
+            return JSON.parse(text);
+        }
+        catch {
+            throw new HttpException_1.HttpException("Invalid JSON body", http_code_enum_1.HttpCode.BAD_REQUEST);
+        }
+    }
+    isEmptyBuffer(buffer) {
+        return buffer.byteLength === 0;
+    }
+    parseUrlEncodedFromBuffer(buffer) {
+        if (buffer.byteLength === 0) {
+            return {};
+        }
+        const text = this.decodeBuffer(buffer);
+        return Object.fromEntries(new URLSearchParams(text));
+    }
+    decodeBuffer(buffer) {
+        return new TextDecoder().decode(buffer);
     }
 };
 exports.Context = Context;

package/dist/domain/cors-headers-cache.d.ts

@@ -0,0 +1,15 @@
+import { CorsConfig } from './cors-config';
+export declare class CorsHeadersCache {
+    private readonly config;
+    private readonly cache;
+    private readonly methodsString;
+    private readonly allowedHeadersString;
+    private readonly exposedHeadersString;
+    private readonly maxAgeString;
+    private readonly hasCredentials;
+    private readonly isWildcard;
+    constructor(config: CorsConfig);
+    get(origin: string): Record<string, string>;
+    private buildHeaders;
+    applyToResponse(response: Response, origin: string): Response;
+}