@depup/nestjs__core 11.1.17-depup.0

package/router/router-explorer.js

@@ -0,0 +1,234 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RouterExplorer = void 0;
+const constants_1 = require("@nestjs/common/constants");
+const enums_1 = require("@nestjs/common/enums");
+const exceptions_1 = require("@nestjs/common/exceptions");
+const logger_service_1 = require("@nestjs/common/services/logger.service");
+const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
+const path_to_regexp_1 = require("path-to-regexp");
+const unknown_request_mapping_exception_1 = require("../errors/exceptions/unknown-request-mapping.exception");
+const guards_1 = require("../guards");
+const context_id_factory_1 = require("../helpers/context-id-factory");
+const execution_context_host_1 = require("../helpers/execution-context-host");
+const messages_1 = require("../helpers/messages");
+const router_method_factory_1 = require("../helpers/router-method-factory");
+const constants_2 = require("../injector/constants");
+const interceptors_1 = require("../interceptors");
+const pipes_1 = require("../pipes");
+const paths_explorer_1 = require("./paths-explorer");
+const request_constants_1 = require("./request/request-constants");
+const route_params_factory_1 = require("./route-params-factory");
+const router_execution_context_1 = require("./router-execution-context");
+class RouterExplorer {
+    constructor(metadataScanner, container, injector, routerProxy, exceptionsFilter, config, routePathFactory, graphInspector) {
+        this.container = container;
+        this.injector = injector;
+        this.routerProxy = routerProxy;
+        this.exceptionsFilter = exceptionsFilter;
+        this.routePathFactory = routePathFactory;
+        this.graphInspector = graphInspector;
+        this.routerMethodFactory = new router_method_factory_1.RouterMethodFactory();
+        this.logger = new logger_service_1.Logger(RouterExplorer.name, {
+            timestamp: true,
+        });
+        this.exceptionFiltersCache = new WeakMap();
+        this.pathsExplorer = new paths_explorer_1.PathsExplorer(metadataScanner);
+        const routeParamsFactory = new route_params_factory_1.RouteParamsFactory();
+        const pipesContextCreator = new pipes_1.PipesContextCreator(container, config);
+        const pipesConsumer = new pipes_1.PipesConsumer();
+        const guardsContextCreator = new guards_1.GuardsContextCreator(container, config);
+        const guardsConsumer = new guards_1.GuardsConsumer();
+        const interceptorsContextCreator = new interceptors_1.InterceptorsContextCreator(container, config);
+        const interceptorsConsumer = new interceptors_1.InterceptorsConsumer();
+        this.executionContextCreator = new router_execution_context_1.RouterExecutionContext(routeParamsFactory, pipesContextCreator, pipesConsumer, guardsContextCreator, guardsConsumer, interceptorsContextCreator, interceptorsConsumer, container.getHttpAdapterRef());
+    }
+    explore(instanceWrapper, moduleKey, httpAdapterRef, host, routePathMetadata) {
+        const { instance } = instanceWrapper;
+        const routerPaths = this.pathsExplorer.scanForPaths(instance);
+        this.applyPathsToRouterProxy(httpAdapterRef, routerPaths, instanceWrapper, moduleKey, routePathMetadata, host);
+    }
+    extractRouterPath(metatype) {
+        const path = Reflect.getMetadata(constants_1.PATH_METADATA, metatype);
+        if ((0, shared_utils_1.isUndefined)(path)) {
+            throw new unknown_request_mapping_exception_1.UnknownRequestMappingException(metatype);
+        }
+        if (Array.isArray(path)) {
+            return path.map(p => (0, shared_utils_1.addLeadingSlash)(p));
+        }
+        return [(0, shared_utils_1.addLeadingSlash)(path)];
+    }
+    applyPathsToRouterProxy(router, routeDefinitions, instanceWrapper, moduleKey, routePathMetadata, host) {
+        (routeDefinitions || []).forEach(routeDefinition => {
+            const { version: methodVersion } = routeDefinition;
+            routePathMetadata.methodVersion = methodVersion;
+            this.applyCallbackToRouter(router, routeDefinition, instanceWrapper, moduleKey, routePathMetadata, host);
+        });
+    }
+    applyCallbackToRouter(router, routeDefinition, instanceWrapper, moduleKey, routePathMetadata, host) {
+        const { path: paths, requestMethod, targetCallback, methodName, } = routeDefinition;
+        const { instance } = instanceWrapper;
+        const routerMethodRef = this.routerMethodFactory
+            .get(router, requestMethod)
+            .bind(router);
+        const isRequestScoped = !instanceWrapper.isDependencyTreeStatic();
+        const proxy = isRequestScoped
+            ? this.createRequestScopedHandler(instanceWrapper, requestMethod, this.container.getModuleByKey(moduleKey), moduleKey, methodName)
+            : this.createCallbackProxy(instance, targetCallback, methodName, moduleKey, requestMethod);
+        const isVersioned = (routePathMetadata.methodVersion ||
+            routePathMetadata.controllerVersion) &&
+            routePathMetadata.versioningOptions;
+        let routeHandler = this.applyHostFilter(host, proxy);
+        paths.forEach(path => {
+            if (isVersioned &&
+                routePathMetadata.versioningOptions.type !== enums_1.VersioningType.URI) {
+                // All versioning (except for URI Versioning) is done via the "Version Filter"
+                routeHandler = this.applyVersionFilter(router, routePathMetadata, routeHandler);
+            }
+            routePathMetadata.methodPath = path;
+            const pathsToRegister = this.routePathFactory.create(routePathMetadata, requestMethod);
+            pathsToRegister.forEach(path => {
+                const entrypointDefinition = {
+                    type: 'http-endpoint',
+                    methodName,
+                    className: instanceWrapper.name,
+                    classNodeId: instanceWrapper.id,
+                    metadata: {
+                        key: path,
+                        path,
+                        requestMethod: enums_1.RequestMethod[requestMethod],
+                        methodVersion: routePathMetadata.methodVersion,
+                        controllerVersion: routePathMetadata.controllerVersion,
+                    },
+                };
+                this.copyMetadataToCallback(targetCallback, routeHandler);
+                const normalizedPath = router.normalizePath
+                    ? router.normalizePath(path)
+                    : path;
+                const httpAdapter = this.container.getHttpAdapterRef();
+                const onRouteTriggered = httpAdapter.getOnRouteTriggered?.();
+                if (onRouteTriggered) {
+                    routerMethodRef(normalizedPath, (...args) => {
+                        onRouteTriggered(requestMethod, path);
+                        return routeHandler(...args);
+                    });
+                }
+                else {
+                    routerMethodRef(normalizedPath, routeHandler);
+                }
+                this.graphInspector.insertEntrypointDefinition(entrypointDefinition, instanceWrapper.id);
+            });
+            const pathsToLog = this.routePathFactory.create({
+                ...routePathMetadata,
+                versioningOptions: undefined,
+            }, requestMethod);
+            pathsToLog.forEach(path => {
+                if (isVersioned) {
+                    const version = this.routePathFactory.getVersion(routePathMetadata);
+                    this.logger.log((0, messages_1.VERSIONED_ROUTE_MAPPED_MESSAGE)(path, requestMethod, version));
+                }
+                else {
+                    this.logger.log((0, messages_1.ROUTE_MAPPED_MESSAGE)(path, requestMethod));
+                }
+            });
+        });
+    }
+    applyHostFilter(host, handler) {
+        if (!host) {
+            return handler;
+        }
+        const httpAdapterRef = this.container.getHttpAdapterRef();
+        const hosts = Array.isArray(host) ? host : [host];
+        const hostRegExps = hosts.map((host) => {
+            if (typeof host === 'string') {
+                try {
+                    return (0, path_to_regexp_1.pathToRegexp)(host);
+                }
+                catch (e) {
+                    if (e instanceof TypeError) {
+                        this.logger.error(`Unsupported host "${host}" syntax. In past releases, ?, *, and + were used to denote optional or repeating path parameters. The latest version of "path-to-regexp" now requires the use of named parameters. For example, instead of using a route like /users/* to capture all routes starting with "/users", you should use /users/*path. Please see the migration guide for more information.`);
+                    }
+                    throw e;
+                }
+            }
+            return { regexp: host, keys: [] };
+        });
+        const unsupportedFilteringErrorMessage = Array.isArray(host)
+            ? `HTTP adapter does not support filtering on hosts: ["${host.join('", "')}"]`
+            : `HTTP adapter does not support filtering on host: "${host}"`;
+        return (req, res, next) => {
+            req.hosts = {};
+            const hostname = httpAdapterRef.getRequestHostname(req) || '';
+            for (const exp of hostRegExps) {
+                const match = hostname.match(exp.regexp);
+                if (match) {
+                    if (exp.keys.length > 0) {
+                        exp.keys.forEach((key, i) => (req.hosts[key.name] = match[i + 1]));
+                    }
+                    else if (exp.regexp && match.groups) {
+                        for (const groupName in match.groups) {
+                            req.hosts[groupName] = match.groups[groupName];
+                        }
+                    }
+                    return handler(req, res, next);
+                }
+            }
+            if (!next) {
+                throw new exceptions_1.InternalServerErrorException(unsupportedFilteringErrorMessage);
+            }
+            return next();
+        };
+    }
+    applyVersionFilter(router, routePathMetadata, handler) {
+        const version = this.routePathFactory.getVersion(routePathMetadata);
+        return router.applyVersionFilter(handler, version, routePathMetadata.versioningOptions);
+    }
+    createCallbackProxy(instance, callback, methodName, moduleRef, requestMethod, contextId = constants_2.STATIC_CONTEXT, inquirerId) {
+        const executionContext = this.executionContextCreator.create(instance, callback, methodName, moduleRef, requestMethod, contextId, inquirerId);
+        const exceptionFilter = this.exceptionsFilter.create(instance, callback, moduleRef, contextId, inquirerId);
+        return this.routerProxy.createProxy(executionContext, exceptionFilter);
+    }
+    createRequestScopedHandler(instanceWrapper, requestMethod, moduleRef, moduleKey, methodName) {
+        const { instance } = instanceWrapper;
+        const collection = moduleRef.controllers;
+        const isTreeDurable = instanceWrapper.isDependencyTreeDurable();
+        return async (req, res, next) => {
+            try {
+                const contextId = this.getContextId(req, isTreeDurable);
+                const contextInstance = await this.injector.loadPerContext(instance, moduleRef, collection, contextId);
+                await this.createCallbackProxy(contextInstance, contextInstance[methodName], methodName, moduleKey, requestMethod, contextId, instanceWrapper.id)(req, res, next);
+            }
+            catch (err) {
+                let exceptionFilter = this.exceptionFiltersCache.get(instance[methodName]);
+                if (!exceptionFilter) {
+                    exceptionFilter = this.exceptionsFilter.create(instance, instance[methodName], moduleKey);
+                    this.exceptionFiltersCache.set(instance[methodName], exceptionFilter);
+                }
+                const host = new execution_context_host_1.ExecutionContextHost([req, res, next]);
+                exceptionFilter.next(err, host);
+            }
+        };
+    }
+    getContextId(request, isTreeDurable) {
+        const contextId = context_id_factory_1.ContextIdFactory.getByRequest(request);
+        if (!request[request_constants_1.REQUEST_CONTEXT_ID]) {
+            Object.defineProperty(request, request_constants_1.REQUEST_CONTEXT_ID, {
+                value: contextId,
+                enumerable: false,
+                writable: false,
+                configurable: false,
+            });
+            const requestProviderValue = isTreeDurable
+                ? contextId.payload
+                : Object.assign(request, contextId.payload);
+            this.container.registerRequestProvider(requestProviderValue, contextId);
+        }
+        return contextId;
+    }
+    copyMetadataToCallback(originalCallback, targetCallback) {
+        for (const key of Reflect.getMetadataKeys(originalCallback)) {
+            Reflect.defineMetadata(key, Reflect.getMetadata(key, originalCallback), targetCallback);
+        }
+    }
+}
+exports.RouterExplorer = RouterExplorer;

package/router/router-module.d.ts

@@ -0,0 +1,19 @@
+import { DynamicModule } from '@nestjs/common';
+import { Module as ModuleClass } from '../injector/module';
+import { ModulesContainer } from '../injector/modules-container';
+import { Routes } from './interfaces';
+export declare const ROUTES: unique symbol;
+export declare const targetModulesByContainer: WeakMap<ModulesContainer, WeakSet<ModuleClass>>;
+/**
+ * @publicApi
+ */
+export declare class RouterModule {
+    private readonly modulesContainer;
+    private readonly routes;
+    constructor(modulesContainer: ModulesContainer, routes: Routes);
+    static register(routes: Routes): DynamicModule;
+    private deepCloneRoutes;
+    private initialize;
+    private registerModulePathMetadata;
+    private updateTargetModulesCache;
+}

package/router/router-module.js

@@ -0,0 +1,80 @@
+"use strict";
+var RouterModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RouterModule = exports.targetModulesByContainer = exports.ROUTES = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+const constants_1 = require("@nestjs/common/constants");
+const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
+const modules_container_1 = require("../injector/modules-container");
+const utils_1 = require("./utils");
+exports.ROUTES = Symbol('ROUTES');
+exports.targetModulesByContainer = new WeakMap();
+/**
+ * @publicApi
+ */
+let RouterModule = RouterModule_1 = class RouterModule {
+    constructor(modulesContainer, routes) {
+        this.modulesContainer = modulesContainer;
+        this.routes = routes;
+        this.routes = this.deepCloneRoutes(routes);
+        this.initialize();
+    }
+    static register(routes) {
+        return {
+            module: RouterModule_1,
+            providers: [
+                {
+                    provide: exports.ROUTES,
+                    useValue: routes,
+                },
+            ],
+        };
+    }
+    deepCloneRoutes(routes) {
+        return routes.map((routeOrType) => {
+            if (typeof routeOrType === 'function') {
+                return routeOrType;
+            }
+            if (routeOrType.children) {
+                return {
+                    ...routeOrType,
+                    children: this.deepCloneRoutes(routeOrType.children),
+                };
+            }
+            return { ...routeOrType };
+        });
+    }
+    initialize() {
+        const flattenedRoutes = (0, utils_1.flattenRoutePaths)(this.routes);
+        flattenedRoutes.forEach(route => {
+            const modulePath = (0, shared_utils_1.normalizePath)(route.path);
+            this.registerModulePathMetadata(route.module, modulePath);
+            this.updateTargetModulesCache(route.module);
+        });
+    }
+    registerModulePathMetadata(moduleCtor, modulePath) {
+        Reflect.defineMetadata(constants_1.MODULE_PATH + this.modulesContainer.applicationId, modulePath, moduleCtor);
+    }
+    updateTargetModulesCache(moduleCtor) {
+        let moduleClassSet;
+        if (exports.targetModulesByContainer.has(this.modulesContainer)) {
+            moduleClassSet = exports.targetModulesByContainer.get(this.modulesContainer);
+        }
+        else {
+            moduleClassSet = new WeakSet();
+            exports.targetModulesByContainer.set(this.modulesContainer, moduleClassSet);
+        }
+        const moduleRef = Array.from(this.modulesContainer.values()).find(item => item?.metatype === moduleCtor);
+        if (!moduleRef) {
+            return;
+        }
+        moduleClassSet.add(moduleRef);
+    }
+};
+exports.RouterModule = RouterModule;
+exports.RouterModule = RouterModule = RouterModule_1 = tslib_1.__decorate([
+    (0, common_1.Module)({}),
+    tslib_1.__param(1, (0, common_1.Inject)(exports.ROUTES)),
+    tslib_1.__metadata("design:paramtypes", [modules_container_1.ModulesContainer, Array])
+], RouterModule);

package/router/router-proxy.d.ts

@@ -0,0 +1,6 @@
+import { ExceptionsHandler } from '../exceptions/exceptions-handler';
+export type RouterProxyCallback = <TRequest, TResponse>(req: TRequest, res: TResponse, next: () => void) => void | Promise<void>;
+export declare class RouterProxy {
+    createProxy(targetCallback: RouterProxyCallback, exceptionsHandler: ExceptionsHandler): <TRequest, TResponse>(req: TRequest, res: TResponse, next: () => void) => Promise<TResponse | undefined>;
+    createExceptionLayerProxy(targetCallback: <TError, TRequest, TResponse>(err: TError, req: TRequest, res: TResponse, next: () => void) => void | Promise<void>, exceptionsHandler: ExceptionsHandler): <TError, TRequest, TResponse>(err: TError, req: TRequest, res: TResponse, next: () => void) => Promise<TResponse | undefined>;
+}

package/router/router-proxy.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RouterProxy = void 0;
+const execution_context_host_1 = require("../helpers/execution-context-host");
+class RouterProxy {
+    createProxy(targetCallback, exceptionsHandler) {
+        return async (req, res, next) => {
+            try {
+                await targetCallback(req, res, next);
+            }
+            catch (e) {
+                const host = new execution_context_host_1.ExecutionContextHost([req, res, next]);
+                exceptionsHandler.next(e, host);
+                return res;
+            }
+        };
+    }
+    createExceptionLayerProxy(targetCallback, exceptionsHandler) {
+        return async (err, req, res, next) => {
+            try {
+                await targetCallback(err, req, res, next);
+            }
+            catch (e) {
+                const host = new execution_context_host_1.ExecutionContextHost([req, res, next]);
+                exceptionsHandler.next(e, host);
+                return res;
+            }
+        };
+    }
+}
+exports.RouterProxy = RouterProxy;

package/router/router-response-controller.d.ts

@@ -0,0 +1,28 @@
+import { HttpServer, RequestMethod } from '@nestjs/common';
+import { IncomingMessage } from 'http';
+import { Observable } from 'rxjs';
+import { AdditionalHeaders, WritableHeaderStream } from './sse-stream';
+export interface CustomHeader {
+    name: string;
+    value: string | (() => string);
+}
+export interface RedirectResponse {
+    url: string;
+    statusCode?: number;
+}
+export declare class RouterResponseController {
+    private readonly applicationRef;
+    private readonly logger;
+    constructor(applicationRef: HttpServer);
+    apply<TInput = any, TResponse = any>(result: TInput, response: TResponse, httpStatusCode?: number): Promise<any>;
+    redirect<TInput = any, TResponse = any>(resultOrDeferred: TInput, response: TResponse, redirectResponse: RedirectResponse): Promise<void>;
+    render<TInput = unknown, TResponse = unknown>(resultOrDeferred: TInput, response: TResponse, template: string): Promise<any>;
+    transformToResult(resultOrDeferred: any): Promise<any>;
+    getStatusByMethod(requestMethod: RequestMethod): number;
+    setHeaders<TResponse = unknown>(response: TResponse, headers: CustomHeader[]): void;
+    setStatus<TResponse = unknown>(response: TResponse, statusCode: number): void;
+    sse<TInput extends Observable<unknown> = any, TResponse extends WritableHeaderStream = any, TRequest extends IncomingMessage = any>(result: TInput | Promise<TInput>, response: TResponse, request: TRequest, options?: {
+        additionalHeaders: AdditionalHeaders;
+    }): Promise<void>;
+    private assertObservable;
+}

package/router/router-response-controller.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RouterResponseController = void 0;
+const common_1 = require("@nestjs/common");
+const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const sse_stream_1 = require("./sse-stream");
+class RouterResponseController {
+    constructor(applicationRef) {
+        this.applicationRef = applicationRef;
+        this.logger = new common_1.Logger(RouterResponseController.name);
+    }
+    async apply(result, response, httpStatusCode) {
+        return this.applicationRef.reply(response, result, httpStatusCode);
+    }
+    async redirect(resultOrDeferred, response, redirectResponse) {
+        const result = await this.transformToResult(resultOrDeferred);
+        const statusCode = result && result.statusCode
+            ? result.statusCode
+            : redirectResponse.statusCode
+                ? redirectResponse.statusCode
+                : common_1.HttpStatus.FOUND;
+        const url = result && result.url ? result.url : redirectResponse.url;
+        this.applicationRef.redirect(response, statusCode, url);
+    }
+    async render(resultOrDeferred, response, template) {
+        const result = await this.transformToResult(resultOrDeferred);
+        return this.applicationRef.render(response, template, result);
+    }
+    async transformToResult(resultOrDeferred) {
+        if ((0, rxjs_1.isObservable)(resultOrDeferred)) {
+            return (0, rxjs_1.lastValueFrom)(resultOrDeferred);
+        }
+        return resultOrDeferred;
+    }
+    getStatusByMethod(requestMethod) {
+        switch (requestMethod) {
+            case common_1.RequestMethod.POST:
+                return common_1.HttpStatus.CREATED;
+            default:
+                return common_1.HttpStatus.OK;
+        }
+    }
+    setHeaders(response, headers) {
+        headers.forEach(({ name, value }) => this.applicationRef.setHeader(response, name, typeof value === 'function' ? value() : value));
+    }
+    setStatus(response, statusCode) {
+        this.applicationRef.status(response, statusCode);
+    }
+    async sse(result, response, request, options) {
+        // It's possible that we sent headers already so don't use a stream
+        if (response.writableEnded) {
+            return;
+        }
+        const observableResult = await Promise.resolve(result);
+        this.assertObservable(observableResult);
+        const stream = new sse_stream_1.SseStream(request);
+        // Extract custom status code from response if it was set
+        const customStatusCode = response.statusCode;
+        const pipeOptions = typeof customStatusCode !== 'undefined'
+            ? { ...options, statusCode: customStatusCode }
+            : options;
+        stream.pipe(response, pipeOptions);
+        const subscription = observableResult
+            .pipe((0, operators_1.map)((message) => {
+            if ((0, shared_utils_1.isObject)(message)) {
+                return message;
+            }
+            return { data: message };
+        }), (0, operators_1.concatMap)(message => new Promise(resolve => stream.writeMessage(message, () => resolve()))), (0, operators_1.catchError)(err => {
+            const data = err instanceof Error ? err.message : err;
+            stream.writeMessage({ type: 'error', data }, writeError => {
+                if (writeError) {
+                    this.logger.error(writeError);
+                }
+            });
+            return rxjs_1.EMPTY;
+        }))
+            .subscribe({
+            complete: () => {
+                response.end();
+            },
+        });
+        request.on('close', () => {
+            subscription.unsubscribe();
+            if (!stream.writableEnded) {
+                stream.end();
+            }
+        });
+    }
+    assertObservable(value) {
+        if (!(0, rxjs_1.isObservable)(value)) {
+            throw new ReferenceError('You must return an Observable stream to use Server-Sent Events (SSE).');
+        }
+    }
+}
+exports.RouterResponseController = RouterResponseController;

package/router/routes-resolver.d.ts

@@ -0,0 +1,27 @@
+import { Controller, HttpServer } from '@nestjs/common/interfaces';
+import { ApplicationConfig } from '../application-config';
+import { NestContainer } from '../injector/container';
+import { Injector } from '../injector/injector';
+import { InstanceWrapper } from '../injector/instance-wrapper';
+import { GraphInspector } from '../inspector/graph-inspector';
+import { Resolver } from './interfaces/resolver.interface';
+export declare class RoutesResolver implements Resolver {
+    private readonly container;
+    private readonly applicationConfig;
+    private readonly injector;
+    private readonly logger;
+    private readonly routerProxy;
+    private readonly routePathFactory;
+    private readonly routerExceptionsFilter;
+    private readonly routerExplorer;
+    constructor(container: NestContainer, applicationConfig: ApplicationConfig, injector: Injector, graphInspector: GraphInspector);
+    resolve<T extends HttpServer>(applicationRef: T, globalPrefix: string): void;
+    registerRouters(routes: Map<string | symbol | Function, InstanceWrapper<Controller>>, moduleName: string, globalPrefix: string, modulePath: string, applicationRef: HttpServer): void;
+    registerNotFoundHandler(): void;
+    registerExceptionHandler(): void;
+    mapExternalException(err: any): any;
+    private isHttpFastifyError;
+    private getModulePathMetadata;
+    private getHostMetadata;
+    private getVersionMetadata;
+}

package/router/routes-resolver.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RoutesResolver = void 0;
+const common_1 = require("@nestjs/common");
+const constants_1 = require("@nestjs/common/constants");
+const logger_service_1 = require("@nestjs/common/services/logger.service");
+const messages_1 = require("../helpers/messages");
+const metadata_scanner_1 = require("../metadata-scanner");
+const route_path_factory_1 = require("./route-path-factory");
+const router_exception_filters_1 = require("./router-exception-filters");
+const router_explorer_1 = require("./router-explorer");
+const router_proxy_1 = require("./router-proxy");
+class RoutesResolver {
+    constructor(container, applicationConfig, injector, graphInspector) {
+        this.container = container;
+        this.applicationConfig = applicationConfig;
+        this.injector = injector;
+        this.logger = new logger_service_1.Logger(RoutesResolver.name, {
+            timestamp: true,
+        });
+        this.routerProxy = new router_proxy_1.RouterProxy();
+        const httpAdapterRef = container.getHttpAdapterRef();
+        this.routerExceptionsFilter = new router_exception_filters_1.RouterExceptionFilters(container, applicationConfig, httpAdapterRef);
+        this.routePathFactory = new route_path_factory_1.RoutePathFactory(this.applicationConfig);
+        const metadataScanner = new metadata_scanner_1.MetadataScanner();
+        this.routerExplorer = new router_explorer_1.RouterExplorer(metadataScanner, this.container, this.injector, this.routerProxy, this.routerExceptionsFilter, this.applicationConfig, this.routePathFactory, graphInspector);
+    }
+    resolve(applicationRef, globalPrefix) {
+        const modules = this.container.getModules();
+        modules.forEach(({ controllers, metatype }, moduleName) => {
+            const modulePath = this.getModulePathMetadata(metatype);
+            this.registerRouters(controllers, moduleName, globalPrefix, modulePath, applicationRef);
+        });
+    }
+    registerRouters(routes, moduleName, globalPrefix, modulePath, applicationRef) {
+        routes.forEach(instanceWrapper => {
+            const { metatype } = instanceWrapper;
+            const host = this.getHostMetadata(metatype);
+            const routerPaths = this.routerExplorer.extractRouterPath(metatype);
+            const controllerVersion = this.getVersionMetadata(metatype);
+            const controllerName = metatype.name;
+            routerPaths.forEach(path => {
+                const pathsToLog = this.routePathFactory.create({
+                    ctrlPath: path,
+                    modulePath,
+                    globalPrefix,
+                });
+                if (!controllerVersion) {
+                    pathsToLog.forEach(path => {
+                        const logMessage = (0, messages_1.CONTROLLER_MAPPING_MESSAGE)(controllerName, path);
+                        this.logger.log(logMessage);
+                    });
+                }
+                else {
+                    pathsToLog.forEach(path => {
+                        const logMessage = (0, messages_1.VERSIONED_CONTROLLER_MAPPING_MESSAGE)(controllerName, path, controllerVersion);
+                        this.logger.log(logMessage);
+                    });
+                }
+                const versioningOptions = this.applicationConfig.getVersioning();
+                const routePathMetadata = {
+                    ctrlPath: path,
+                    modulePath,
+                    globalPrefix,
+                    controllerVersion,
+                    versioningOptions,
+                };
+                this.routerExplorer.explore(instanceWrapper, moduleName, applicationRef, host, routePathMetadata);
+            });
+        });
+    }
+    registerNotFoundHandler() {
+        const applicationRef = this.container.getHttpAdapterRef();
+        const callback = (req, res) => {
+            const method = applicationRef.getRequestMethod(req);
+            const url = applicationRef.getRequestUrl(req);
+            throw new common_1.NotFoundException(`Cannot ${method} ${url}`);
+        };
+        const handler = this.routerExceptionsFilter.create({}, callback, undefined);
+        const proxy = this.routerProxy.createProxy(callback, handler);
+        applicationRef.setNotFoundHandler &&
+            applicationRef.setNotFoundHandler(proxy, this.applicationConfig.getGlobalPrefix());
+    }
+    registerExceptionHandler() {
+        const callback = (err, req, res, next) => {
+            throw this.mapExternalException(err);
+        };
+        const handler = this.routerExceptionsFilter.create({}, callback, undefined);
+        const proxy = this.routerProxy.createExceptionLayerProxy(callback, handler);
+        const applicationRef = this.container.getHttpAdapterRef();
+        applicationRef.setErrorHandler &&
+            applicationRef.setErrorHandler(proxy, this.applicationConfig.getGlobalPrefix());
+    }
+    mapExternalException(err) {
+        switch (true) {
+            // SyntaxError is thrown by Express body-parser when given invalid JSON (#422, #430)
+            // URIError is thrown by Express when given a path parameter with an invalid percentage
+            // encoding, e.g. '%FF' (#8915)
+            case err instanceof SyntaxError || err instanceof URIError:
+                return new common_1.BadRequestException(err.message);
+            case this.isHttpFastifyError(err):
+                return new common_1.HttpException(err.message, err.statusCode);
+            default:
+                return err;
+        }
+    }
+    isHttpFastifyError(error) {
+        // condition based on this code - https://github.com/fastify/fastify-error/blob/d669b150a82968322f9f7be992b2f6b463272de3/index.js#L22
+        return (error.statusCode !== undefined &&
+            error instanceof Error &&
+            error.name === 'FastifyError');
+    }
+    getModulePathMetadata(metatype) {
+        const modulesContainer = this.container.getModules();
+        const modulePath = Reflect.getMetadata(constants_1.MODULE_PATH + modulesContainer.applicationId, metatype);
+        return modulePath ?? Reflect.getMetadata(constants_1.MODULE_PATH, metatype);
+    }
+    getHostMetadata(metatype) {
+        return Reflect.getMetadata(constants_1.HOST_METADATA, metatype);
+    }
+    getVersionMetadata(metatype) {
+        const versioningConfig = this.applicationConfig.getVersioning();
+        if (versioningConfig) {
+            return (Reflect.getMetadata(constants_1.VERSION_METADATA, metatype) ??
+                versioningConfig.defaultVersion);
+        }
+    }
+}
+exports.RoutesResolver = RoutesResolver;