@depup/nestjs__core 11.1.17-depup.0

package/errors/exceptions/unknown-export.exception.d.ts

@@ -0,0 +1,4 @@
+import { RuntimeException } from './runtime.exception';
+export declare class UnknownExportException extends RuntimeException {
+    constructor(token: string | symbol, moduleName: string);
+}

package/errors/exceptions/unknown-export.exception.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnknownExportException = void 0;
+const messages_1 = require("../messages");
+const runtime_exception_1 = require("./runtime.exception");
+class UnknownExportException extends runtime_exception_1.RuntimeException {
+    constructor(token, moduleName) {
+        super((0, messages_1.UNKNOWN_EXPORT_MESSAGE)(token, moduleName));
+    }
+}
+exports.UnknownExportException = UnknownExportException;

package/errors/exceptions/unknown-module.exception.d.ts

@@ -0,0 +1,4 @@
+import { RuntimeException } from './runtime.exception';
+export declare class UnknownModuleException extends RuntimeException {
+    constructor(moduleName?: string);
+}

package/errors/exceptions/unknown-module.exception.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnknownModuleException = void 0;
+const runtime_exception_1 = require("./runtime.exception");
+class UnknownModuleException extends runtime_exception_1.RuntimeException {
+    constructor(moduleName) {
+        super(`Nest could not select the given module (${moduleName ? `"${moduleName}"` : 'it'} does not exist in current context).`);
+    }
+}
+exports.UnknownModuleException = UnknownModuleException;

package/errors/exceptions/unknown-request-mapping.exception.d.ts

@@ -0,0 +1,5 @@
+import type { Type } from '@nestjs/common';
+import { RuntimeException } from './runtime.exception';
+export declare class UnknownRequestMappingException extends RuntimeException {
+    constructor(metatype: Type);
+}

package/errors/exceptions/unknown-request-mapping.exception.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnknownRequestMappingException = void 0;
+const runtime_exception_1 = require("./runtime.exception");
+const messages_1 = require("../messages");
+class UnknownRequestMappingException extends runtime_exception_1.RuntimeException {
+    constructor(metatype) {
+        super((0, messages_1.UNKNOWN_REQUEST_MAPPING)(metatype));
+    }
+}
+exports.UnknownRequestMappingException = UnknownRequestMappingException;

package/errors/exceptions-zone.d.ts

@@ -0,0 +1,5 @@
+export declare class ExceptionsZone {
+    private static readonly exceptionHandler;
+    static run(callback: () => void, teardown: ((err: any) => void) | undefined, autoFlushLogs: boolean): void;
+    static asyncRun(callback: () => Promise<void>, teardown: ((err: any) => void) | undefined, autoFlushLogs: boolean): Promise<void>;
+}

package/errors/exceptions-zone.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExceptionsZone = void 0;
+const common_1 = require("@nestjs/common");
+const exception_handler_1 = require("./exception-handler");
+const DEFAULT_TEARDOWN = () => process.exit(1);
+class ExceptionsZone {
+    static run(callback, teardown = DEFAULT_TEARDOWN, autoFlushLogs) {
+        try {
+            callback();
+        }
+        catch (e) {
+            this.exceptionHandler.handle(e);
+            if (autoFlushLogs) {
+                common_1.Logger.flush();
+            }
+            teardown(e);
+        }
+    }
+    static async asyncRun(callback, teardown = DEFAULT_TEARDOWN, autoFlushLogs) {
+        try {
+            await callback();
+        }
+        catch (e) {
+            this.exceptionHandler.handle(e);
+            if (autoFlushLogs) {
+                common_1.Logger.flush();
+            }
+            teardown(e);
+        }
+    }
+}
+exports.ExceptionsZone = ExceptionsZone;
+ExceptionsZone.exceptionHandler = new exception_handler_1.ExceptionHandler();

package/errors/messages.d.ts

@@ -0,0 +1,17 @@
+import type { ForwardReference, Type } from '@nestjs/common';
+import { InjectorDependencyContext } from '../injector/injector';
+import { Module } from '../injector/module';
+export declare const UNKNOWN_DEPENDENCIES_MESSAGE: (type: string | symbol, unknownDependencyContext: InjectorDependencyContext, moduleRef: Module | undefined) => string;
+export declare const INVALID_MIDDLEWARE_MESSAGE: (text: TemplateStringsArray, name: string) => string;
+export declare const UNDEFINED_FORWARDREF_MESSAGE: (scope: Type<any>[]) => string;
+export declare const INVALID_MODULE_MESSAGE: (parentModule: any, index: number, scope: any[]) => string;
+export declare const USING_INVALID_CLASS_AS_A_MODULE_MESSAGE: (metatypeUsedAsAModule: Type | ForwardReference, scope: any[]) => string;
+export declare const UNDEFINED_MODULE_MESSAGE: (parentModule: any, index: number, scope: any[]) => string;
+export declare const UNKNOWN_EXPORT_MESSAGE: (token: string | symbol | undefined, module: string) => string;
+export declare const INVALID_CLASS_MESSAGE: (text: TemplateStringsArray, value: any) => string;
+export declare const INVALID_CLASS_SCOPE_MESSAGE: (text: TemplateStringsArray, name: string | undefined) => string;
+export declare const UNKNOWN_REQUEST_MAPPING: (metatype: Type) => string;
+export declare const INVALID_MIDDLEWARE_CONFIGURATION = "An invalid middleware configuration has been passed inside the module 'configure()' method.";
+export declare const UNHANDLED_RUNTIME_EXCEPTION = "Unhandled Runtime Exception.";
+export declare const INVALID_EXCEPTION_FILTER = "Invalid exception filters (@UseFilters()).";
+export declare const MICROSERVICES_PACKAGE_NOT_FOUND_EXCEPTION = "Unable to load @nestjs/microservices package. (Please make sure that it's already installed.)";

package/errors/messages.js

@@ -0,0 +1,174 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MICROSERVICES_PACKAGE_NOT_FOUND_EXCEPTION = exports.INVALID_EXCEPTION_FILTER = exports.UNHANDLED_RUNTIME_EXCEPTION = exports.INVALID_MIDDLEWARE_CONFIGURATION = exports.UNKNOWN_REQUEST_MAPPING = exports.INVALID_CLASS_SCOPE_MESSAGE = exports.INVALID_CLASS_MESSAGE = exports.UNKNOWN_EXPORT_MESSAGE = exports.UNDEFINED_MODULE_MESSAGE = exports.USING_INVALID_CLASS_AS_A_MODULE_MESSAGE = exports.INVALID_MODULE_MESSAGE = exports.UNDEFINED_FORWARDREF_MESSAGE = exports.INVALID_MIDDLEWARE_MESSAGE = exports.UNKNOWN_DEPENDENCIES_MESSAGE = void 0;
+const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
+/**
+ * Returns the name of an instance or `undefined`
+ * @param instance The instance which should get the name from
+ */
+const getInstanceName = (instance) => {
+    if (instance?.forwardRef) {
+        return instance.forwardRef()?.name;
+    }
+    if (instance?.module) {
+        return instance.module?.name;
+    }
+    return instance?.name;
+};
+/**
+ * Returns the name of the dependency.
+ * Tries to get the class name, otherwise the string value
+ * (= injection token). As fallback to any falsy value for `dependency`, it
+ * returns `fallbackValue`
+ * @param dependency The name of the dependency to be displayed
+ * @param fallbackValue The fallback value if the dependency is falsy
+ * @param disambiguated Whether dependency's name is disambiguated with double quotes
+ */
+const getDependencyName = (dependency, fallbackValue, disambiguated = true) => 
+// use class name
+getInstanceName(dependency) ||
+    // use injection token (symbol)
+    ((0, shared_utils_1.isSymbol)(dependency) && dependency.toString()) ||
+    // use string directly
+    (dependency
+        ? disambiguated
+            ? `"${dependency}"`
+            : dependency
+        : undefined) ||
+    // otherwise
+    fallbackValue;
+/**
+ * Returns the name of the module
+ * Tries to get the class name. As fallback it returns 'current'.
+ * @param module The module which should get displayed
+ */
+const getModuleName = (module) => (module && getInstanceName(module.metatype)) || 'current';
+const stringifyScope = (scope) => (scope || []).map(getInstanceName).join(' -> ');
+const UNKNOWN_DEPENDENCIES_MESSAGE = (type, unknownDependencyContext, moduleRef) => {
+    const { index, name, dependencies, key } = unknownDependencyContext;
+    const moduleName = getModuleName(moduleRef);
+    const dependencyName = getDependencyName(name, 'dependency');
+    const isImportTypeIssue = !(0, shared_utils_1.isNil)(index) &&
+        dependencies &&
+        (dependencies[index] === undefined ||
+            dependencies[index] === Object ||
+            (typeof dependencies[index] === 'function' &&
+                dependencies[index].name === 'Object'));
+    let potentialSolutions;
+    if (isImportTypeIssue) {
+        potentialSolutions = `\n
+Potential solutions:
+- The dependency at index [${index}] appears to be undefined at runtime
+- This commonly occurs when using 'import type' instead of 'import' for injectable classes
+- Check your imports and change:
+  ❌ import type { SomeService } from './some.service';
+  ✅ import { SomeService } from './some.service';
+- Ensure the imported class is decorated with @Injectable() or is a valid provider
+- If using dynamic imports, ensure the class is available at runtime, not just for type checking
+
+For more common dependency resolution issues, see: https://docs.nestjs.com/faq/common-errors`;
+    }
+    else {
+        potentialSolutions =
+            // If module's name is well defined
+            moduleName !== 'current'
+                ? `\n
+Potential solutions:
+- Is ${moduleName} a valid NestJS module?
+- If ${dependencyName} is a provider, is it part of the current ${moduleName}?
+- If ${dependencyName} is exported from a separate @Module, is that module imported within ${moduleName}?
+  @Module({
+    imports: [ /* the Module containing ${dependencyName} */ ]
+  })
+
+For more common dependency resolution issues, see: https://docs.nestjs.com/faq/common-errors`
+                : `\n
+Potential solutions:
+- If ${dependencyName} is a provider, is it part of the current Module?
+- If ${dependencyName} is exported from a separate @Module, is that module imported within Module?
+  @Module({
+    imports: [ /* the Module containing ${dependencyName} */ ]
+  })
+
+For more common dependency resolution issues, see: https://docs.nestjs.com/faq/common-errors`;
+    }
+    let message = `Nest can't resolve dependencies of the ${type.toString()}`;
+    if ((0, shared_utils_1.isNil)(index)) {
+        message += `. Please make sure that the "${key.toString()}" property is available in the current context.${potentialSolutions}`;
+        return message;
+    }
+    const dependenciesName = (dependencies || []).map(dependencyName => getDependencyName(dependencyName, '+', false));
+    dependenciesName[index] = '?';
+    const tokenFragment = !isImportTypeIssue && name !== undefined ? ` ${dependencyName}` : '';
+    const contextLabel = isImportTypeIssue ? 'current' : moduleName;
+    message += ` (`;
+    message += dependenciesName.join(', ');
+    message += `). Please make sure that the argument${tokenFragment} at index [${index}]`;
+    message += ` is available in the ${contextLabel} module.`;
+    message += potentialSolutions;
+    return message;
+};
+exports.UNKNOWN_DEPENDENCIES_MESSAGE = UNKNOWN_DEPENDENCIES_MESSAGE;
+const INVALID_MIDDLEWARE_MESSAGE = (text, name) => `The middleware doesn't provide the 'use' method (${name})`;
+exports.INVALID_MIDDLEWARE_MESSAGE = INVALID_MIDDLEWARE_MESSAGE;
+const UNDEFINED_FORWARDREF_MESSAGE = (scope) => `Nest cannot create the module instance. Often, this is because of a circular dependency between modules. Use forwardRef() to avoid it.
+
+(Read more: https://docs.nestjs.com/fundamentals/circular-dependency)
+Scope [${stringifyScope(scope)}]
+`;
+exports.UNDEFINED_FORWARDREF_MESSAGE = UNDEFINED_FORWARDREF_MESSAGE;
+const INVALID_MODULE_MESSAGE = (parentModule, index, scope) => {
+    const parentModuleName = parentModule?.name || 'module';
+    return `Nest cannot create the ${parentModuleName} instance.
+Received an unexpected value at index [${index}] of the ${parentModuleName} "imports" array.
+
+Scope [${stringifyScope(scope)}]`;
+};
+exports.INVALID_MODULE_MESSAGE = INVALID_MODULE_MESSAGE;
+const USING_INVALID_CLASS_AS_A_MODULE_MESSAGE = (metatypeUsedAsAModule, scope) => {
+    const metatypeNameQuote = `"${getInstanceName(metatypeUsedAsAModule)}"`;
+    return `Classes annotated with @Injectable(), @Catch(), and @Controller() decorators must not appear in the "imports" array of a module.
+Please remove ${metatypeNameQuote} (including forwarded occurrences, if any) from all of the "imports" arrays.
+
+Scope [${stringifyScope(scope)}]
+`;
+};
+exports.USING_INVALID_CLASS_AS_A_MODULE_MESSAGE = USING_INVALID_CLASS_AS_A_MODULE_MESSAGE;
+const UNDEFINED_MODULE_MESSAGE = (parentModule, index, scope) => {
+    const parentModuleName = parentModule?.name || 'module';
+    return `Nest cannot create the ${parentModuleName} instance.
+The module at index [${index}] of the ${parentModuleName} "imports" array is undefined.
+
+Potential causes:
+- A circular dependency between modules. Use forwardRef() to avoid it. Read more: https://docs.nestjs.com/fundamentals/circular-dependency
+- The module at index [${index}] is of type "undefined". Check your import statements and the type of the module.
+
+Scope [${stringifyScope(scope)}]`;
+};
+exports.UNDEFINED_MODULE_MESSAGE = UNDEFINED_MODULE_MESSAGE;
+const UNKNOWN_EXPORT_MESSAGE = (token = 'item', module) => {
+    token = (0, shared_utils_1.isSymbol)(token) ? token.toString() : token;
+    return `Nest cannot export a provider/module that is not a part of the currently processed module (${module}). Please verify whether the exported ${token} is available in this particular context.
+
+Possible Solutions:
+- Is ${token} part of the relevant providers/imports within ${module}?
+
+For more common dependency resolution issues, see: https://docs.nestjs.com/faq/common-errors
+`;
+};
+exports.UNKNOWN_EXPORT_MESSAGE = UNKNOWN_EXPORT_MESSAGE;
+const INVALID_CLASS_MESSAGE = (text, value) => `ModuleRef cannot instantiate class (${value} is not constructable).`;
+exports.INVALID_CLASS_MESSAGE = INVALID_CLASS_MESSAGE;
+const INVALID_CLASS_SCOPE_MESSAGE = (text, name) => `${name || 'This class'} is marked as a scoped provider. Request and transient-scoped providers can't be used in combination with "get()" method. Please, use "resolve()" instead.`;
+exports.INVALID_CLASS_SCOPE_MESSAGE = INVALID_CLASS_SCOPE_MESSAGE;
+const UNKNOWN_REQUEST_MAPPING = (metatype) => {
+    const className = metatype.name;
+    return className
+        ? `An invalid controller has been detected. "${className}" does not have the @Controller() decorator but it is being listed in the "controllers" array of some module.`
+        : `An invalid controller has been detected. Perhaps, one of your controllers is missing the @Controller() decorator.`;
+};
+exports.UNKNOWN_REQUEST_MAPPING = UNKNOWN_REQUEST_MAPPING;
+exports.INVALID_MIDDLEWARE_CONFIGURATION = `An invalid middleware configuration has been passed inside the module 'configure()' method.`;
+exports.UNHANDLED_RUNTIME_EXCEPTION = `Unhandled Runtime Exception.`;
+exports.INVALID_EXCEPTION_FILTER = `Invalid exception filters (@UseFilters()).`;
+exports.MICROSERVICES_PACKAGE_NOT_FOUND_EXCEPTION = `Unable to load @nestjs/microservices package. (Please make sure that it's already installed.)`;

package/exceptions/base-exception-filter-context.d.ts

@@ -0,0 +1,14 @@
+import { Type } from '@nestjs/common/interfaces';
+import { ExceptionFilter } from '@nestjs/common/interfaces/exceptions/exception-filter.interface';
+import { ContextCreator } from '../helpers/context-creator';
+import { NestContainer } from '../injector/container';
+import { InstanceWrapper } from '../injector/instance-wrapper';
+export declare class BaseExceptionFilterContext extends ContextCreator {
+    private readonly container;
+    protected moduleContext: string;
+    constructor(container: NestContainer);
+    createConcreteContext<T extends any[], R extends any[]>(metadata: T, contextId?: import("../injector/instance-wrapper").ContextId, inquirerId?: string): R;
+    getFilterInstance(filter: Function | ExceptionFilter, contextId?: import("../injector/instance-wrapper").ContextId, inquirerId?: string): ExceptionFilter | null;
+    getInstanceByMetatype(metatype: Type<unknown>): InstanceWrapper | undefined;
+    reflectCatchExceptions(instance: ExceptionFilter): Type<any>[];
+}

package/exceptions/base-exception-filter-context.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseExceptionFilterContext = void 0;
+const constants_1 = require("@nestjs/common/constants");
+const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
+const iterare_1 = require("iterare");
+const context_creator_1 = require("../helpers/context-creator");
+const constants_2 = require("../injector/constants");
+class BaseExceptionFilterContext extends context_creator_1.ContextCreator {
+    constructor(container) {
+        super();
+        this.container = container;
+    }
+    createConcreteContext(metadata, contextId = constants_2.STATIC_CONTEXT, inquirerId) {
+        if ((0, shared_utils_1.isEmpty)(metadata)) {
+            return [];
+        }
+        return (0, iterare_1.iterate)(metadata)
+            .filter(instance => instance && ((0, shared_utils_1.isFunction)(instance.catch) || instance.name))
+            .map(filter => this.getFilterInstance(filter, contextId, inquirerId))
+            .filter(item => !!item)
+            .map(instance => ({
+            func: instance.catch.bind(instance),
+            exceptionMetatypes: this.reflectCatchExceptions(instance),
+        }))
+            .toArray();
+    }
+    getFilterInstance(filter, contextId = constants_2.STATIC_CONTEXT, inquirerId) {
+        const isObject = !!filter.catch;
+        if (isObject) {
+            return filter;
+        }
+        const instanceWrapper = this.getInstanceByMetatype(filter);
+        if (!instanceWrapper) {
+            return null;
+        }
+        const instanceHost = instanceWrapper.getInstanceByContextId(this.getContextId(contextId, instanceWrapper), inquirerId);
+        return instanceHost && instanceHost.instance;
+    }
+    getInstanceByMetatype(metatype) {
+        if (!this.moduleContext) {
+            return;
+        }
+        const collection = this.container.getModules();
+        const moduleRef = collection.get(this.moduleContext);
+        if (!moduleRef) {
+            return;
+        }
+        return moduleRef.injectables.get(metatype);
+    }
+    reflectCatchExceptions(instance) {
+        const prototype = Object.getPrototypeOf(instance);
+        return (Reflect.getMetadata(constants_1.FILTER_CATCH_EXCEPTIONS, prototype.constructor) || []);
+    }
+}
+exports.BaseExceptionFilterContext = BaseExceptionFilterContext;

package/exceptions/base-exception-filter.d.ts

@@ -0,0 +1,20 @@
+import { ArgumentsHost, ExceptionFilter, HttpServer } from '@nestjs/common';
+import { AbstractHttpAdapter } from '../adapters';
+import { HttpAdapterHost } from '../helpers/http-adapter-host';
+export declare class BaseExceptionFilter<T = any> implements ExceptionFilter<T> {
+    protected readonly applicationRef?: HttpServer | undefined;
+    private static readonly logger;
+    protected readonly httpAdapterHost?: HttpAdapterHost;
+    constructor(applicationRef?: HttpServer | undefined);
+    catch(exception: T, host: ArgumentsHost): void;
+    handleUnknownError(exception: T, host: ArgumentsHost, applicationRef: AbstractHttpAdapter | HttpServer): void;
+    isExceptionObject(err: any): err is Error;
+    /**
+     * Checks if the thrown error comes from the "http-errors" library.
+     * @param err error object
+     */
+    isHttpError(err: any): err is {
+        statusCode: number;
+        message: string;
+    };
+}

package/exceptions/base-exception-filter.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseExceptionFilter = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
+const constants_1 = require("../constants");
+const http_adapter_host_1 = require("../helpers/http-adapter-host");
+class BaseExceptionFilter {
+    constructor(applicationRef) {
+        this.applicationRef = applicationRef;
+    }
+    catch(exception, host) {
+        const applicationRef = this.applicationRef ||
+            (this.httpAdapterHost && this.httpAdapterHost.httpAdapter);
+        if (!(exception instanceof common_1.HttpException)) {
+            return this.handleUnknownError(exception, host, applicationRef);
+        }
+        const res = exception.getResponse();
+        const message = (0, shared_utils_1.isObject)(res)
+            ? res
+            : {
+                statusCode: exception.getStatus(),
+                message: res,
+            };
+        const response = host.getArgByIndex(1);
+        if (!applicationRef.isHeadersSent(response)) {
+            applicationRef.reply(response, message, exception.getStatus());
+        }
+        else {
+            applicationRef.end(response);
+        }
+    }
+    handleUnknownError(exception, host, applicationRef) {
+        const body = this.isHttpError(exception)
+            ? {
+                statusCode: exception.statusCode,
+                message: exception.message,
+            }
+            : {
+                statusCode: common_1.HttpStatus.INTERNAL_SERVER_ERROR,
+                message: constants_1.MESSAGES.UNKNOWN_EXCEPTION_MESSAGE,
+            };
+        const response = host.getArgByIndex(1);
+        if (!applicationRef.isHeadersSent(response)) {
+            applicationRef.reply(response, body, body.statusCode);
+        }
+        else {
+            applicationRef.end(response);
+        }
+        if (!(exception instanceof common_1.IntrinsicException)) {
+            BaseExceptionFilter.logger.error(exception);
+        }
+    }
+    isExceptionObject(err) {
+        return (0, shared_utils_1.isObject)(err) && !!err.message;
+    }
+    /**
+     * Checks if the thrown error comes from the "http-errors" library.
+     * @param err error object
+     */
+    isHttpError(err) {
+        return err?.statusCode && err?.message;
+    }
+}
+exports.BaseExceptionFilter = BaseExceptionFilter;
+BaseExceptionFilter.logger = new common_1.Logger('ExceptionsHandler');
+tslib_1.__decorate([
+    (0, common_1.Optional)(),
+    (0, common_1.Inject)(),
+    tslib_1.__metadata("design:type", http_adapter_host_1.HttpAdapterHost)
+], BaseExceptionFilter.prototype, "httpAdapterHost", void 0);

package/exceptions/exceptions-handler.d.ts

@@ -0,0 +1,10 @@
+import { HttpException } from '@nestjs/common';
+import { ExceptionFilterMetadata } from '@nestjs/common/interfaces/exceptions/exception-filter-metadata.interface';
+import { ArgumentsHost } from '@nestjs/common/interfaces/features/arguments-host.interface';
+import { BaseExceptionFilter } from './base-exception-filter';
+export declare class ExceptionsHandler extends BaseExceptionFilter {
+    private filters;
+    next(exception: Error | HttpException, ctx: ArgumentsHost): void;
+    setCustomFilters(filters: ExceptionFilterMetadata[]): void;
+    invokeCustomFilters<T = any>(exception: T, ctx: ArgumentsHost): boolean;
+}

package/exceptions/exceptions-handler.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExceptionsHandler = void 0;
+const select_exception_filter_metadata_util_1 = require("@nestjs/common/utils/select-exception-filter-metadata.util");
+const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
+const invalid_exception_filter_exception_1 = require("../errors/exceptions/invalid-exception-filter.exception");
+const base_exception_filter_1 = require("./base-exception-filter");
+class ExceptionsHandler extends base_exception_filter_1.BaseExceptionFilter {
+    constructor() {
+        super(...arguments);
+        this.filters = [];
+    }
+    next(exception, ctx) {
+        if (this.invokeCustomFilters(exception, ctx)) {
+            return;
+        }
+        super.catch(exception, ctx);
+    }
+    setCustomFilters(filters) {
+        if (!Array.isArray(filters)) {
+            throw new invalid_exception_filter_exception_1.InvalidExceptionFilterException();
+        }
+        this.filters = filters;
+    }
+    invokeCustomFilters(exception, ctx) {
+        if ((0, shared_utils_1.isEmpty)(this.filters)) {
+            return false;
+        }
+        const filter = (0, select_exception_filter_metadata_util_1.selectExceptionFilterMetadata)(this.filters, exception);
+        filter && filter.func(exception, ctx);
+        return !!filter;
+    }
+}
+exports.ExceptionsHandler = ExceptionsHandler;

package/exceptions/external-exception-filter-context.d.ts

@@ -0,0 +1,12 @@
+import { Controller } from '@nestjs/common/interfaces';
+import { ApplicationConfig } from '../application-config';
+import { NestContainer } from '../injector/container';
+import { RouterProxyCallback } from '../router/router-proxy';
+import { BaseExceptionFilterContext } from './base-exception-filter-context';
+import { ExternalExceptionsHandler } from './external-exceptions-handler';
+export declare class ExternalExceptionFilterContext extends BaseExceptionFilterContext {
+    private readonly config?;
+    constructor(container: NestContainer, config?: ApplicationConfig | undefined);
+    create(instance: Controller, callback: RouterProxyCallback, module: string, contextId?: import("../injector/instance-wrapper").ContextId, inquirerId?: string): ExternalExceptionsHandler;
+    getGlobalMetadata<T extends any[]>(contextId?: import("../injector/instance-wrapper").ContextId, inquirerId?: string): T;
+}

package/exceptions/external-exception-filter-context.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExternalExceptionFilterContext = void 0;
+const constants_1 = require("@nestjs/common/constants");
+const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
+const iterare_1 = require("iterare");
+const constants_2 = require("../injector/constants");
+const base_exception_filter_context_1 = require("./base-exception-filter-context");
+const external_exceptions_handler_1 = require("./external-exceptions-handler");
+class ExternalExceptionFilterContext extends base_exception_filter_context_1.BaseExceptionFilterContext {
+    constructor(container, config) {
+        super(container);
+        this.config = config;
+    }
+    create(instance, callback, module, contextId = constants_2.STATIC_CONTEXT, inquirerId) {
+        this.moduleContext = module;
+        const exceptionHandler = new external_exceptions_handler_1.ExternalExceptionsHandler();
+        const filters = this.createContext(instance, callback, constants_1.EXCEPTION_FILTERS_METADATA, contextId, inquirerId);
+        if ((0, shared_utils_1.isEmpty)(filters)) {
+            return exceptionHandler;
+        }
+        exceptionHandler.setCustomFilters(filters.reverse());
+        return exceptionHandler;
+    }
+    getGlobalMetadata(contextId = constants_2.STATIC_CONTEXT, inquirerId) {
+        if (!this.config) {
+            return [];
+        }
+        const globalFilters = this.config.getGlobalFilters();
+        if (contextId === constants_2.STATIC_CONTEXT && !inquirerId) {
+            return globalFilters;
+        }
+        const scopedFilterWrappers = this.config.getGlobalRequestFilters();
+        const scopedFilters = (0, iterare_1.iterate)(scopedFilterWrappers)
+            .map(wrapper => wrapper.getInstanceByContextId(contextId, inquirerId))
+            .filter(host => !!host)
+            .map(host => host.instance)
+            .toArray();
+        return globalFilters.concat(scopedFilters);
+    }
+}
+exports.ExternalExceptionFilterContext = ExternalExceptionFilterContext;

package/exceptions/external-exception-filter.d.ts

@@ -0,0 +1,5 @@
+import { ArgumentsHost } from '@nestjs/common';
+export declare class ExternalExceptionFilter<T = any, R = any> {
+    private static readonly logger;
+    catch(exception: T, host: ArgumentsHost): R | Promise<R>;
+}

package/exceptions/external-exception-filter.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExternalExceptionFilter = void 0;
+const common_1 = require("@nestjs/common");
+class ExternalExceptionFilter {
+    catch(exception, host) {
+        if (exception instanceof Error &&
+            !(exception instanceof common_1.IntrinsicException)) {
+            ExternalExceptionFilter.logger.error(exception);
+        }
+        throw exception;
+    }
+}
+exports.ExternalExceptionFilter = ExternalExceptionFilter;
+ExternalExceptionFilter.logger = new common_1.Logger('ExceptionsHandler');

package/exceptions/external-exceptions-handler.d.ts

@@ -0,0 +1,9 @@
+import { ExceptionFilterMetadata } from '@nestjs/common/interfaces/exceptions';
+import { ArgumentsHost } from '@nestjs/common/interfaces/features/arguments-host.interface';
+import { ExternalExceptionFilter } from './external-exception-filter';
+export declare class ExternalExceptionsHandler extends ExternalExceptionFilter {
+    private filters;
+    next(exception: Error, host: ArgumentsHost): Promise<any>;
+    setCustomFilters(filters: ExceptionFilterMetadata[]): void;
+    invokeCustomFilters<T = any>(exception: T, host: ArgumentsHost): Promise<any> | null;
+}

package/exceptions/external-exceptions-handler.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExternalExceptionsHandler = void 0;
+const select_exception_filter_metadata_util_1 = require("@nestjs/common/utils/select-exception-filter-metadata.util");
+const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
+const invalid_exception_filter_exception_1 = require("../errors/exceptions/invalid-exception-filter.exception");
+const external_exception_filter_1 = require("./external-exception-filter");
+class ExternalExceptionsHandler extends external_exception_filter_1.ExternalExceptionFilter {
+    constructor() {
+        super(...arguments);
+        this.filters = [];
+    }
+    next(exception, host) {
+        const result = this.invokeCustomFilters(exception, host);
+        if (result) {
+            return result;
+        }
+        return super.catch(exception, host);
+    }
+    setCustomFilters(filters) {
+        if (!Array.isArray(filters)) {
+            throw new invalid_exception_filter_exception_1.InvalidExceptionFilterException();
+        }
+        this.filters = filters;
+    }
+    invokeCustomFilters(exception, host) {
+        if ((0, shared_utils_1.isEmpty)(this.filters)) {
+            return null;
+        }
+        const filter = (0, select_exception_filter_metadata_util_1.selectExceptionFilterMetadata)(this.filters, exception);
+        return filter ? filter.func(exception, host) : null;
+    }
+}
+exports.ExternalExceptionsHandler = ExternalExceptionsHandler;

package/exceptions/index.d.ts

@@ -0,0 +1 @@
+export * from './base-exception-filter';

package/exceptions/index.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./base-exception-filter"), exports);

package/guards/constants.d.ts

@@ -0,0 +1 @@
+export declare const FORBIDDEN_MESSAGE = "Forbidden resource";

package/guards/constants.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FORBIDDEN_MESSAGE = void 0;
+exports.FORBIDDEN_MESSAGE = 'Forbidden resource';