@carno.js/core 0.2.3

package/dist/container/InjectorService.js

@@ -0,0 +1,157 @@
+"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 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 request_logger_service_1 = require("../services/request-logger.service");
+let InjectorService = InjectorService_1 = class InjectorService {
+    constructor() {
+        this.settings = new ContainerConfiguration_1.ContainerConfiguration();
+        this.container = new container_1.Container();
+        this.applicationConfig = {};
+    }
+    async loadModule(container, applicationConfig, router) {
+        this.container = container;
+        this.router = router;
+        this.applicationConfig = applicationConfig;
+        this.initializeResolvers();
+        this.removeUnknownProviders();
+        this.saveInjector();
+        this.routeResolver.resolveControllers();
+        await this.callHook(on_event_1.EventType.OnApplicationInit);
+    }
+    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);
+    }
+    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));
+    }
+    async invokeRoute(route, context, locals) {
+        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));
+    }
+    scopeOf(provider) {
+        return provider.scope || provider_scope_1.ProviderScope.SINGLETON;
+    }
+    async callHook(event, data = null) {
+        const hooks = this.getHooksByEvent(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 [];
+        }
+        const filtered = hooks.filter((hook) => hook.eventName === event);
+        return this.sortHooksByPriority(filtered);
+    }
+    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,
+            request_logger_service_1.RequestLogger
+        ];
+        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

@@ -0,0 +1,17 @@
+import { ApplicationConfig } from "../Carno";
+import { TokenProvider } from "../commons/registries/ProviderControl";
+import { Context } from "../domain/Context";
+import { LocalsContainer } from "../domain/LocalsContainer";
+export declare class MethodInvoker {
+    private applicationConfig;
+    private historyMethods;
+    constructor(applicationConfig: ApplicationConfig);
+    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 resolveService;
+    private validateAndTransform;
+}

package/dist/container/MethodInvoker.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MethodInvoker = void 0;
+const class_transformer_1 = require("class-transformer");
+const class_validator_1 = require("class-validator");
+const Metadata_1 = require("../domain/Metadata");
+const HttpException_1 = require("../exceptions/HttpException");
+const getClassOrSymbol_1 = require("../utils/getClassOrSymbol");
+const getMethodArgTypes_1 = require("../utils/getMethodArgTypes");
+const isClassValidator_1 = require("../utils/isClassValidator");
+class MethodInvoker {
+    constructor(applicationConfig) {
+        this.applicationConfig = applicationConfig;
+        this.historyMethods = new WeakMap();
+    }
+    async invoke(instance, methodName, locals, context, invokeCallback) {
+        const methodInfo = this.getMethodInfo(instance, methodName);
+        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 methodInfo = { args, params };
+        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;
+    }
+    resolveService(token, param, context, locals, invokeCallback) {
+        if (!param) {
+            return invokeCallback((0, getClassOrSymbol_1.getClassOrSymbol)(token), locals);
+        }
+        const value = param.fun(context, param.param);
+        return (0, isClassValidator_1.isClassValidator)(token)
+            ? this.validateAndTransform(token, value)
+            : value;
+    }
+    validateAndTransform(token, value) {
+        const obj = (0, class_transformer_1.plainToInstance)(token, value);
+        const errors = (0, class_validator_1.validateSync)(obj, this.applicationConfig.validation);
+        // todo: deve retornar apenas os erros e não o objeto class-validator inteiro.
+        if (errors.length > 0) {
+            throw new HttpException_1.HttpException(errors, 400);
+        }
+        return obj;
+    }
+}
+exports.MethodInvoker = MethodInvoker;

package/dist/container/RouteResolver.d.ts

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

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

package/dist/container/container.d.ts

@@ -0,0 +1,41 @@
+import { TokenProvider } from '../commons';
+import { Provider, ProviderType } from '../domain';
+export declare class Container extends Map<TokenProvider, Provider> {
+    /**
+     *
+     * @param token
+     * @param settings
+     */
+    add(token: TokenProvider, settings?: Partial<Provider>): this;
+    /**
+     * Add a provider to the
+     * @param token
+     * @param settings
+     */
+    addProvider(token: TokenProvider, settings?: Partial<Provider>): this;
+    /**
+     *
+     * @param token
+     */
+    hasProvider(token: TokenProvider): boolean;
+    /**
+     * Add a provider to the
+     * @param token
+     * @param provider
+     */
+    setProvider(token: TokenProvider, provider: Provider): this;
+    /**
+     * The getProvider() method returns a specified element from a Map object.
+     * @returns Returns the element associated with the specified key or undefined if the key can't be found in the Map object.
+     * @param token
+     */
+    getProvider<T extends Provider = Provider>(token: TokenProvider): T | undefined;
+    /**
+     * Get all providers registered in the injector container.
+     *
+     * @param {ProviderType} type Filter the list by the given ProviderType.
+     * @returns {[TokenProvider , Provider<any>][]}
+     */
+    getProviders(type?: ProviderType | string): Provider[];
+    addProviders(container: Map<TokenProvider, Provider>): void;
+}

package/dist/container/container.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Container = void 0;
+const commons_1 = require("../commons");
+const domain_1 = require("../domain");
+class Container extends Map {
+    /**
+     *
+     * @param token
+     * @param settings
+     */
+    add(token, settings = {}) {
+        const provider = commons_1.GlobalProvider.get(token)?.clone() || new domain_1.Provider(token);
+        Object.assign(provider, settings);
+        return this.set(token, provider);
+    }
+    /**
+     * Add a provider to the
+     * @param token
+     * @param settings
+     */
+    addProvider(token, settings = {}) {
+        return this.add(token, settings);
+    }
+    /**
+     *
+     * @param token
+     */
+    hasProvider(token) {
+        return super.has(token);
+    }
+    /**
+     * Add a provider to the
+     * @param token
+     * @param provider
+     */
+    setProvider(token, provider) {
+        return super.set(token, provider);
+    }
+    /**
+     * The getProvider() method returns a specified element from a Map object.
+     * @returns Returns the element associated with the specified key or undefined if the key can't be found in the Map object.
+     * @param token
+     */
+    getProvider(token) {
+        return super.get(token);
+    }
+    /**
+     * Get all providers registered in the injector container.
+     *
+     * @param {ProviderType} type Filter the list by the given ProviderType.
+     * @returns {[TokenProvider , Provider<any>][]}
+     */
+    getProviders(type) {
+        // @ts-ignore
+        return [...this].reduce((providers, [_, provider]) => {
+            if (provider.type === type || !type) {
+                return [...providers, provider];
+            }
+            return providers;
+        }, []);
+    }
+    addProviders(container) {
+        container.forEach((provider) => {
+            if (!this.hasProvider(provider.provide)) {
+                this.setProvider(provider.provide, provider.clone());
+            }
+        });
+    }
+}
+exports.Container = Container;

package/dist/container/createContainer.d.ts

@@ -0,0 +1,3 @@
+import { Type } from "../commons";
+import { Container } from './container';
+export declare function createContainer(rootModule?: Type<any>): Container;

package/dist/container/createContainer.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createContainer = createContainer;
+const container_1 = require("./container");
+function createContainer(rootModule) {
+    const container = new container_1.Container();
+    //    const container = new Container(GlobalProvider.entries());
+    if (rootModule) {
+        container.delete(rootModule);
+    }
+    return container;
+}

package/dist/container/createInjector.d.ts

@@ -0,0 +1,2 @@
+import { InjectorService } from "./InjectorService.js";
+export declare function createInjector(): InjectorService;

package/dist/container/createInjector.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createInjector = createInjector;
+const InjectorService_js_1 = require("./InjectorService.js");
+function createInjector() {
+    return new InjectorService_js_1.InjectorService();
+}

package/dist/container/index.d.ts

@@ -0,0 +1,6 @@
+export * from './container';
+export * from './ContainerConfiguration';
+export * from './createContainer';
+export * from './createInjector';
+export * from './middleware.resolver';
+export * from './InjectorService';

package/dist/container/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./container"), exports);
+__exportStar(require("./ContainerConfiguration"), exports);
+__exportStar(require("./createContainer"), exports);
+__exportStar(require("./createInjector"), exports);
+__exportStar(require("./middleware.resolver"), exports);
+__exportStar(require("./InjectorService"), exports);

package/dist/container/middleware.resolver.d.ts

@@ -0,0 +1,9 @@
+import { InjectorService } from './InjectorService';
+import { TokenRouteWithProvider } from './ContainerConfiguration';
+import { LocalsContainer } from '../domain/LocalsContainer';
+declare class MiddlewareResolver {
+    resolveMiddlewares(route: TokenRouteWithProvider, injector: InjectorService, local: LocalsContainer): Promise<void>;
+    private resolve;
+}
+export declare const MiddlewareRes: MiddlewareResolver;
+export {};

package/dist/container/middleware.resolver.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MiddlewareRes = void 0;
+const Context_1 = require("../domain/Context");
+class MiddlewareResolver {
+    async resolveMiddlewares(route, injector, local) {
+        if (route.middlewares.length == 0) {
+            return;
+        }
+        await this.resolve(route.middlewares, injector, local);
+    }
+    async resolve(middlewares, injector, local) {
+        const context = local.get(Context_1.Context);
+        let currentIndex = 0;
+        const next = async () => {
+            if (currentIndex >= middlewares.length) {
+                // Se já processamos todos os middlewares, não faz nada.
+                // Isso evita o erro "Middleware stack exhausted" se um middleware chamar `next()`
+                // quando não há mais middlewares.
+                return;
+            }
+            const middleware = middlewares[currentIndex++];
+            // @ts-ignore
+            const instance = injector.invoke(middleware, local);
+            // Await a execução do middleware.
+            // Se o middleware lançar uma exceção, ela será propagada.
+            await instance.handle(context, next);
+        };
+        if (middlewares.length === 0)
+            return;
+        // Inicia a execução dos middlewares
+        await next();
+    }
+}
+exports.MiddlewareRes = new MiddlewareResolver();

package/dist/default-routes-carno.d.ts

@@ -0,0 +1,3 @@
+export declare class DefaultRoutesCarno {
+    favicon(): Promise<boolean>;
+}