@carno.js/core 0.2.11 → 1.0.2

package/dist/container/InjectorService.d.ts

@@ -1,58 +0,0 @@
-import type { ApplicationConfig } from "../Carno";
-import { TokenProvider } from "../commons/registries/ProviderControl";
-import type { ValidatorAdapter } from "../validation/ValidatorAdapter";
-import { Context } from "../domain/Context";
-import { LocalsContainer } from "../domain/LocalsContainer";
-import { Provider } from "../domain/provider";
-import { ProviderScope } from "../domain/provider-scope";
-import { EventType } from "../events/on-event";
-import Memoirist from "../route/memoirist";
-import { ContainerConfiguration, TokenRouteWithProvider } from "./ContainerConfiguration";
-import { Container } from "./container";
-export declare class InjectorService {
-    settings: ContainerConfiguration;
-    container: Container;
-    applicationConfig: ApplicationConfig;
-    router: Memoirist<TokenRouteWithProvider>;
-    private hooksByEvent;
-    private _hasOnRequestHook;
-    private _hasOnResponseHook;
-    private controllerScopes;
-    private routeResolver;
-    private dependencyResolver;
-    private methodInvoker;
-    private validatorAdapter;
-    loadModule(container: Container, applicationConfig: ApplicationConfig, router: Memoirist<any>, validatorAdapter: ValidatorAdapter): Promise<void>;
-    private initializeResolvers;
-    private ensureProvider;
-    get(token: TokenProvider): Provider | undefined;
-    invoke(token: TokenProvider, locals?: LocalsContainer): 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 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;
-    private saveInjector;
-    private removeUnknownProviders;
-    private isProviderAllowed;
-}

package/dist/container/InjectorService.js

@@ -1,286 +0,0 @@
-"use strict";
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var InjectorService_1;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.InjectorService = void 0;
-const Injectable_decorator_1 = require("../commons/decorators/Injectable.decorator");
-const commons_1 = require("../commons");
-const ProviderControl_1 = require("../commons/registries/ProviderControl");
-const constants_1 = require("../constants");
-const default_routes_carno_1 = require("../default-routes-carno");
-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");
-const isPrimitiveType_1 = require("../utils/isPrimitiveType");
-const nameOf_1 = require("../utils/nameOf");
-const ContainerConfiguration_1 = require("./ContainerConfiguration");
-const container_1 = require("./container");
-const middleware_resolver_1 = require("./middleware.resolver");
-const RouteResolver_1 = require("./RouteResolver");
-const DependencyResolver_1 = require("./DependencyResolver");
-const MethodInvoker_1 = require("./MethodInvoker");
-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, validatorAdapter) {
-        this.container = container;
-        this.router = router;
-        this.applicationConfig = applicationConfig;
-        this.validatorAdapter = validatorAdapter;
-        this.initializeResolvers();
-        this.removeUnknownProviders();
-        this.saveInjector();
-        this.routeResolver.resolveControllers();
-        this.cacheControllerScopes();
-        this.cacheHooks();
-        await this.callHook(on_event_1.EventType.OnApplicationInit);
-        this.preInstantiateSingletonControllers();
-        this.compileRoutes();
-    }
-    initializeResolvers() {
-        this.routeResolver = new RouteResolver_1.RouteResolver(this.router, this.applicationConfig.globalMiddlewares);
-        this.dependencyResolver = new DependencyResolver_1.DependencyResolver(this.container);
-        this.methodInvoker = new MethodInvoker_1.MethodInvoker(this.applicationConfig, this.validatorAdapter);
-    }
-    ensureProvider(token) {
-        if (!this.container.has(token) && ProviderControl_1.GlobalProvider.has(token)) {
-            this.container.addProvider(token);
-        }
-        return this.container.get(token);
-    }
-    get(token) {
-        return this.ensureProvider(token);
-    }
-    invoke(token, locals = new LocalsContainer_1.LocalsContainer()) {
-        if (locals.has(token)) {
-            const stored = locals.get(token);
-            return stored?.instance ?? stored;
-        }
-        if ((0, isPrimitiveType_1.isPrimitiveType)(token)) {
-            return token;
-        }
-        const provider = this.ensureProvider(token);
-        if (!provider) {
-            throw new Error(`Provider not found for: ${(0, nameOf_1.nameOf)(token)}, check if it was imported into the module or imported without type-only import.`);
-        }
-        return this.dependencyResolver.resolve(provider, locals, (t, l) => this.invoke(t, l));
-    }
-    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);
-    }
-    invokeRoute(route, context, locals, instance) {
-        const middlewarePromise = middleware_resolver_1.MiddlewareRes.resolveMiddlewares(route, this, locals);
-        if (middlewarePromise instanceof Promise) {
-            return middlewarePromise.then(() => this.methodInvoker.invoke(instance, route.methodName, locals, context, (t, l) => this.invoke(t, l)));
-        }
-        return this.methodInvoker.invoke(instance, route.methodName, locals, context, (t, l) => this.invoke(t, l));
-    }
-    scopeOf(provider) {
-        return provider.scope || provider_scope_1.ProviderScope.SINGLETON;
-    }
-    async callHook(event, data = null) {
-        const hooks = this.getCachedHooks(event);
-        if (hooks.length === 0) {
-            return;
-        }
-        await this.runHookHandlers(hooks, data ?? {});
-    }
-    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 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,
-            validatorAdapter: this.validatorAdapter,
-            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) => {
-            return (second.priority ?? 0) - (first.priority ?? 0);
-        });
-    }
-    async runHookHandlers(hooks, data) {
-        for (const hook of hooks) {
-            await this.executeHook(hook, data);
-        }
-    }
-    async executeHook(hook, data) {
-        const instance = this.invoke(hook.target);
-        await instance[hook.methodName](data);
-    }
-    saveInjector() {
-        const provider = this.ensureProvider(InjectorService_1);
-        provider.instance = this;
-        this.container.set(InjectorService_1, provider);
-    }
-    removeUnknownProviders() {
-        if (!ProviderControl_1.GlobalProvider.has(logger_service_1.LoggerService)) {
-            (0, commons_1.registerProvider)({ provide: logger_service_1.LoggerService, useClass: logger_service_1.LoggerService, instance: new logger_service_1.LoggerService(this) });
-        }
-        const defaults = [
-            InjectorService_1,
-            Context_1.Context,
-            logger_service_1.LoggerService,
-            default_routes_carno_1.DefaultRoutesCarno,
-            cache_service_1.CacheService
-        ];
-        this.applicationConfig.providers = this.applicationConfig.providers || [];
-        this.applicationConfig.providers.push(...defaults);
-        let hooks = Metadata_1.Metadata.get(constants_1.CONTROLLER_EVENTS, Reflect);
-        for (let [token] of ProviderControl_1.GlobalProvider.entries()) {
-            if (!this.isProviderAllowed(token)) {
-                ProviderControl_1.GlobalProvider.delete(token);
-                if (hooks) {
-                    hooks = hooks.filter((hook) => hook.target !== token);
-                    Metadata_1.Metadata.set(constants_1.CONTROLLER_EVENTS, hooks, Reflect);
-                }
-            }
-        }
-    }
-    isProviderAllowed(token) {
-        if (!this.applicationConfig.providers) {
-            return false;
-        }
-        return this.applicationConfig.providers.some((provider) => {
-            if (provider?.provide) {
-                return provider.provide === token;
-            }
-            return provider === token;
-        });
-    }
-};
-exports.InjectorService = InjectorService;
-exports.InjectorService = InjectorService = InjectorService_1 = __decorate([
-    (0, Injectable_decorator_1.Injectable)()
-], InjectorService);

package/dist/container/MethodInvoker.d.ts

@@ -1,21 +0,0 @@
-import { ApplicationConfig } from "../Carno";
-import { TokenProvider } from "../commons/registries/ProviderControl";
-import { Context } from "../domain/Context";
-import { LocalsContainer } from "../domain/LocalsContainer";
-import type { ValidatorAdapter } from "../validation/ValidatorAdapter";
-export declare class MethodInvoker {
-    private applicationConfig;
-    private validatorAdapter;
-    private historyMethods;
-    constructor(applicationConfig: ApplicationConfig, validatorAdapter: ValidatorAdapter);
-    invoke(instance: any, methodName: string, locals: LocalsContainer, context: Context, invokeCallback: (token: TokenProvider, locals: LocalsContainer) => any): Promise<any>;
-    private getMethodInfo;
-    private getCachedMethod;
-    private cacheMethodInfo;
-    private setCachedMethod;
-    private resolveMethodServices;
-    private ensureBodyParsed;
-    private hasBodyParam;
-    private isBodyParam;
-    private resolveService;
-}

package/dist/container/MethodInvoker.js

@@ -1,83 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MethodInvoker = void 0;
-const Metadata_1 = require("../domain/Metadata");
-const getClassOrSymbol_1 = require("../utils/getClassOrSymbol");
-const getMethodArgTypes_1 = require("../utils/getMethodArgTypes");
-class MethodInvoker {
-    constructor(applicationConfig, validatorAdapter) {
-        this.applicationConfig = applicationConfig;
-        this.validatorAdapter = validatorAdapter;
-        this.historyMethods = new WeakMap();
-    }
-    async invoke(instance, methodName, locals, context, invokeCallback) {
-        const methodInfo = this.getMethodInfo(instance, methodName);
-        await this.ensureBodyParsed(methodInfo, context);
-        const services = this.resolveMethodServices(methodInfo, context, locals, invokeCallback);
-        return instance[methodName](...services);
-    }
-    getMethodInfo(instance, methodName) {
-        const cached = this.getCachedMethod(instance, methodName);
-        return cached || this.cacheMethodInfo(instance, methodName);
-    }
-    getCachedMethod(instance, methodName) {
-        const cachedMethod = this.historyMethods.get(instance);
-        return cachedMethod?.[methodName];
-    }
-    cacheMethodInfo(instance, methodName) {
-        const args = (0, getMethodArgTypes_1.getMethodArgTypes)(instance, methodName);
-        const params = Metadata_1.Metadata.getParamDecoratorFunc(instance, methodName);
-        const needsBody = this.hasBodyParam(params);
-        const methodInfo = { args, params, needsBody };
-        this.setCachedMethod(instance, methodName, methodInfo);
-        return methodInfo;
-    }
-    setCachedMethod(instance, methodName, methodInfo) {
-        const cachedMethod = this.historyMethods.get(instance) || {};
-        cachedMethod[methodName] = methodInfo;
-        this.historyMethods.set(instance, cachedMethod);
-    }
-    resolveMethodServices(methodInfo, context, locals, invokeCallback) {
-        const { args, params } = methodInfo;
-        const services = [];
-        for (let index = 0; index < args.length; index++) {
-            const service = this.resolveService(args[index], params[index], context, locals, invokeCallback);
-            services.push(service);
-        }
-        return services;
-    }
-    async ensureBodyParsed(methodInfo, context) {
-        if (!methodInfo.needsBody) {
-            return;
-        }
-        if (context.isBodyParsed()) {
-            return;
-        }
-        await context.getBody();
-    }
-    hasBodyParam(params) {
-        if (!params) {
-            return false;
-        }
-        return Object.values(params).some((param) => this.isBodyParam(param));
-    }
-    isBodyParam(param) {
-        if (param?.type === "body") {
-            return true;
-        }
-        if (!param?.fun) {
-            return false;
-        }
-        return String(param.fun).includes("context.body");
-    }
-    resolveService(token, param, context, locals, invokeCallback) {
-        if (!param) {
-            return invokeCallback((0, getClassOrSymbol_1.getClassOrSymbol)(token), locals);
-        }
-        const value = param.fun(context, param.param);
-        return this.validatorAdapter.hasValidation(token)
-            ? this.validatorAdapter.validateAndTransform(token, value)
-            : value;
-    }
-}
-exports.MethodInvoker = MethodInvoker;

package/dist/container/RouteResolver.d.ts

@@ -1,27 +0,0 @@
-import { TokenRouteWithProvider } from "./ContainerConfiguration";
-import Memoirist from "../route/memoirist";
-export declare class RouteResolver {
-    private router;
-    private globalMiddlewares;
-    constructor(router: Memoirist<TokenRouteWithProvider>, globalMiddlewares?: any[]);
-    resolveControllers(): void;
-    private getTopLevelControllers;
-    private buildRouteMap;
-    private processController;
-    private getControllerRoutes;
-    private getControllerMiddlewares;
-    private applyControllerPath;
-    private normalizePath;
-    private addRoutesToMap;
-    private filterRoutesByMethod;
-    private addMethodRoutes;
-    private createTokenRouteWithProvider;
-    private processChildren;
-    private resolveChildrenRoutes;
-    private processChildController;
-    private getValidChildController;
-    private applyChildPaths;
-    private buildChildPath;
-    private buildChildRoutes;
-    private registerRoutes;
-}

package/dist/container/RouteResolver.js

@@ -1,173 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RouteResolver = void 0;
-const ProviderControl_1 = require("../commons/registries/ProviderControl");
-const constants_1 = require("../constants");
-const domain_1 = require("../domain");
-const Metadata_1 = require("../domain/Metadata");
-const provider_type_1 = require("../domain/provider-type");
-class RouteResolver {
-    constructor(router, globalMiddlewares) {
-        this.router = router;
-        this.globalMiddlewares = [];
-        this.globalMiddlewares = globalMiddlewares || [];
-    }
-    resolveControllers() {
-        const controllers = this.getTopLevelControllers();
-        const hydrateRoute = this.buildRouteMap(controllers);
-        this.registerRoutes(hydrateRoute);
-    }
-    getTopLevelControllers() {
-        return ProviderControl_1.GlobalProvider.getByType(provider_type_1.ProviderType.CONTROLLER).filter((controller) => !controller.isChild());
-    }
-    buildRouteMap(controllers) {
-        const hydrateRoute = new Map();
-        for (const controller of controllers) {
-            this.processController(controller, hydrateRoute);
-        }
-        return hydrateRoute;
-    }
-    processController(controller, hydrateRoute) {
-        const routes = this.getControllerRoutes(controller);
-        if (routes.length === 0)
-            return;
-        const controllerMiddleware = this.getControllerMiddlewares(controller);
-        const processedRoutes = this.applyControllerPath(controller, routes);
-        this.addRoutesToMap(hydrateRoute, processedRoutes, controller, controllerMiddleware);
-        this.processChildren(controller, hydrateRoute, controllerMiddleware);
-    }
-    getControllerRoutes(controller) {
-        return Metadata_1.Metadata.get(constants_1.CONTROLLER_ROUTES, controller.token);
-    }
-    getControllerMiddlewares(controller) {
-        return Metadata_1.Metadata.get(constants_1.CONTROLLER_MIDDLEWARES, controller.token) || [];
-    }
-    applyControllerPath(controller, routes) {
-        if (!controller.path)
-            return routes;
-        return routes.map((route) => ({
-            ...route,
-            path: this.normalizePath(`${controller.path}${route.path}`),
-        }));
-    }
-    normalizePath(path) {
-        let normalized = path.endsWith("/") ? path.slice(0, -1) : path;
-        return normalized.startsWith("/") ? normalized : `/${normalized}`;
-    }
-    addRoutesToMap(hydrateRoute, routes, controller, controllerMiddleware) {
-        for (const method of Object.keys(domain_1.HttpMethod).map((key) => domain_1.HttpMethod[key])) {
-            const methodRoutes = this.filterRoutesByMethod(routes, method);
-            if (methodRoutes.length === 0)
-                continue;
-            this.addMethodRoutes(hydrateRoute, method, methodRoutes, controller, controllerMiddleware);
-        }
-    }
-    filterRoutesByMethod(routes, method) {
-        return routes.filter((route) => route.method.toLowerCase() === method);
-    }
-    addMethodRoutes(hydrateRoute, method, routes, controller, controllerMiddleware) {
-        const mappedRoutes = routes.map((route) => this.createTokenRouteWithProvider(route, controller, controllerMiddleware));
-        hydrateRoute.set(method, [
-            ...(hydrateRoute.get(method) || []),
-            ...mappedRoutes,
-        ]);
-    }
-    createTokenRouteWithProvider(route, controller, controllerMiddleware) {
-        return {
-            ...route,
-            provider: controller.token,
-            route,
-            middlewares: [
-                ...this.globalMiddlewares,
-                ...controllerMiddleware,
-                ...(Metadata_1.Metadata.get(constants_1.ROUTE_MIDDLEWARES, controller.token, route.methodName) || []),
-            ],
-        };
-    }
-    processChildren(controller, hydrateRoute, controllerMiddleware) {
-        if (!controller.children)
-            return;
-        const childrenRoutes = this.resolveChildrenRoutes(controller.path ?? "", controller.children, controllerMiddleware);
-        childrenRoutes.forEach((route) => {
-            const method = route.method.toLowerCase();
-            hydrateRoute.set(method, [
-                ...(hydrateRoute.get(method) || []),
-                route,
-            ]);
-        });
-    }
-    resolveChildrenRoutes(parentPath, children, parentMiddlewares) {
-        let childrenRoutes = [];
-        for (const childController of children) {
-            const routes = this.processChildController(childController, parentPath, parentMiddlewares);
-            childrenRoutes = [...childrenRoutes, ...routes];
-        }
-        return childrenRoutes;
-    }
-    processChildController(childController, parentPath, parentMiddlewares) {
-        const controller = this.getValidChildController(childController);
-        const childRoutes = this.getControllerRoutes(controller);
-        if (childRoutes.length === 0)
-            return [];
-        const childMiddlewares = this.getControllerMiddlewares(controller);
-        const processedRoutes = this.applyChildPaths(childRoutes, parentPath, controller);
-        return this.buildChildRoutes(processedRoutes, controller, parentMiddlewares, childMiddlewares);
-    }
-    getValidChildController(childController) {
-        const controller = ProviderControl_1.GlobalProvider.get(childController);
-        if (!controller) {
-            throw new Error(`Child ${childController} not is an controller. Please, check the providers configuration.`);
-        }
-        return controller;
-    }
-    applyChildPaths(routes, parentPath, controller) {
-        if (!parentPath)
-            return routes;
-        return routes.map((route) => ({
-            ...route,
-            path: this.buildChildPath(parentPath, controller.path, route.path),
-        }));
-    }
-    buildChildPath(parentPath, controllerPath, routePath) {
-        let path = controllerPath ?? "";
-        if (path.endsWith("/")) {
-            path = path.slice(0, -1);
-        }
-        if (!path.startsWith("/") && path) {
-            path = `/${path}`;
-        }
-        const fullPath = `${parentPath}${path}${routePath}`;
-        return this.normalizePath(fullPath);
-    }
-    buildChildRoutes(routes, controller, parentMiddlewares, childMiddlewares) {
-        let childRoutes = [];
-        for (const method of Object.keys(domain_1.HttpMethod).map((key) => domain_1.HttpMethod[key])) {
-            const methodRoutes = this.filterRoutesByMethod(routes, method);
-            if (methodRoutes.length === 0)
-                continue;
-            const mappedRoutes = methodRoutes.map((route) => ({
-                ...route,
-                provider: controller.token,
-                route,
-                middlewares: [
-                    ...this.globalMiddlewares,
-                    ...parentMiddlewares,
-                    ...childMiddlewares,
-                    ...(Metadata_1.Metadata.get(constants_1.ROUTE_MIDDLEWARES, controller.token, route.methodName) || []),
-                ],
-            }));
-            childRoutes = [...childRoutes, ...mappedRoutes];
-        }
-        if (controller.children) {
-            const nestedRoutes = this.resolveChildrenRoutes(controller.path, controller.children, childMiddlewares);
-            childRoutes = [...childRoutes, ...nestedRoutes];
-        }
-        return childRoutes;
-    }
-    registerRoutes(hydrateRoute) {
-        hydrateRoute.forEach((routes) => {
-            routes.forEach((route) => this.router.add(route.method.toLowerCase(), route.path, route));
-        });
-    }
-}
-exports.RouteResolver = RouteResolver;