@carno.js/core 0.2.3 → 0.2.5

package/dist/domain/cors-headers-cache.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CorsHeadersCache = void 0;
+const cors_config_1 = require("./cors-config");
+class CorsHeadersCache {
+    constructor(config) {
+        this.config = config;
+        this.cache = new Map();
+        const methods = config.methods || cors_config_1.DEFAULT_CORS_METHODS;
+        this.methodsString = methods.join(', ');
+        const allowedHeaders = config.allowedHeaders || cors_config_1.DEFAULT_CORS_ALLOWED_HEADERS;
+        this.allowedHeadersString = allowedHeaders.join(', ');
+        this.exposedHeadersString = config.exposedHeaders?.length
+            ? config.exposedHeaders.join(', ')
+            : null;
+        this.maxAgeString = config.maxAge !== undefined
+            ? config.maxAge.toString()
+            : null;
+        this.hasCredentials = !!config.credentials;
+        this.isWildcard = config.origins === '*';
+    }
+    get(origin) {
+        const cacheKey = this.isWildcard ? '*' : origin;
+        let cached = this.cache.get(cacheKey);
+        if (cached) {
+            return cached;
+        }
+        cached = this.buildHeaders(origin);
+        this.cache.set(cacheKey, cached);
+        return cached;
+    }
+    buildHeaders(origin) {
+        const headers = {
+            'Access-Control-Allow-Origin': this.isWildcard ? '*' : origin,
+            'Access-Control-Allow-Methods': this.methodsString,
+            'Access-Control-Allow-Headers': this.allowedHeadersString,
+        };
+        if (this.hasCredentials) {
+            headers['Access-Control-Allow-Credentials'] = 'true';
+        }
+        if (this.exposedHeadersString) {
+            headers['Access-Control-Expose-Headers'] = this.exposedHeadersString;
+        }
+        if (this.maxAgeString) {
+            headers['Access-Control-Max-Age'] = this.maxAgeString;
+        }
+        return headers;
+    }
+    applyToResponse(response, origin) {
+        const corsHeaders = this.get(origin);
+        for (const key in corsHeaders) {
+            response.headers.set(key, corsHeaders[key]);
+        }
+        return response;
+    }
+}
+exports.CorsHeadersCache = CorsHeadersCache;

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;