@depup/nestjs__core 11.1.17-depup.0

package/discovery/discoverable-meta-host-collection.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiscoverableMetaHostCollection = void 0;
+class DiscoverableMetaHostCollection {
+    /**
+     * Adds a link between a class reference and a metadata key.
+     * @param target The class reference.
+     * @param metadataKey The metadata key.
+     */
+    static addClassMetaHostLink(target, metadataKey) {
+        this.metaHostLinks.set(target, metadataKey);
+    }
+    /**
+     * Inspects a provider instance wrapper and adds it to the collection of providers
+     * if it has a metadata key.
+     * @param hostContainerRef A reference to the modules container.
+     * @param instanceWrapper A provider instance wrapper.
+     * @returns void
+     */
+    static inspectProvider(hostContainerRef, instanceWrapper) {
+        return this.inspectInstanceWrapper(hostContainerRef, instanceWrapper, this.providersByMetaKey);
+    }
+    /**
+     * Inspects a controller instance wrapper and adds it to the collection of controllers
+     * if it has a metadata key.
+     * @param hostContainerRef A reference to the modules container.
+     * @param instanceWrapper A controller's instance wrapper.
+     * @returns void
+     */
+    static inspectController(hostContainerRef, instanceWrapper) {
+        return this.inspectInstanceWrapper(hostContainerRef, instanceWrapper, this.controllersByMetaKey);
+    }
+    static insertByMetaKey(metaKey, instanceWrapper, collection) {
+        if (collection.has(metaKey)) {
+            const wrappers = collection.get(metaKey);
+            wrappers.add(instanceWrapper);
+        }
+        else {
+            const wrappers = new Set();
+            wrappers.add(instanceWrapper);
+            collection.set(metaKey, wrappers);
+        }
+    }
+    static getProvidersByMetaKey(hostContainerRef, metaKey) {
+        const wrappersByMetaKey = this.providersByMetaKey.get(hostContainerRef);
+        return wrappersByMetaKey?.get(metaKey) ?? new Set();
+    }
+    static getControllersByMetaKey(hostContainerRef, metaKey) {
+        const wrappersByMetaKey = this.controllersByMetaKey.get(hostContainerRef);
+        return wrappersByMetaKey?.get(metaKey) ?? new Set();
+    }
+    static inspectInstanceWrapper(hostContainerRef, instanceWrapper, wrapperByMetaKeyMap) {
+        const metaKey = DiscoverableMetaHostCollection.getMetaKeyByInstanceWrapper(instanceWrapper);
+        if (!metaKey) {
+            return;
+        }
+        let collection;
+        if (wrapperByMetaKeyMap.has(hostContainerRef)) {
+            collection = wrapperByMetaKeyMap.get(hostContainerRef);
+        }
+        else {
+            collection = new Map();
+            wrapperByMetaKeyMap.set(hostContainerRef, collection);
+        }
+        this.insertByMetaKey(metaKey, instanceWrapper, collection);
+    }
+    static getMetaKeyByInstanceWrapper(instanceWrapper) {
+        return this.metaHostLinks.get(
+        // NOTE: Regarding the ternary statement below,
+        // - The condition `!wrapper.metatype` is needed because when we use `useValue`
+        // the value of `wrapper.metatype` will be `null`.
+        // - The condition `wrapper.inject` is needed here because when we use
+        // `useFactory`, the value of `wrapper.metatype` will be the supplied
+        // factory function.
+        // For both cases, we should use `wrapper.instance.constructor` instead
+        // of `wrapper.metatype` to resolve processor's class properly.
+        // But since calling `wrapper.instance` could degrade overall performance
+        // we must defer it as much we can.
+        instanceWrapper.metatype || instanceWrapper.inject
+            ? (instanceWrapper.instance?.constructor ?? instanceWrapper.metatype)
+            : instanceWrapper.metatype);
+    }
+}
+exports.DiscoverableMetaHostCollection = DiscoverableMetaHostCollection;
+/**
+ * A map of class references to metadata keys.
+ */
+DiscoverableMetaHostCollection.metaHostLinks = new Map();
+/**
+ * A map of metadata keys to instance wrappers (providers) with the corresponding metadata key.
+ * The map is weakly referenced by the modules container (unique per application).
+ */
+DiscoverableMetaHostCollection.providersByMetaKey = new WeakMap();
+/**
+ * A map of metadata keys to instance wrappers (controllers) with the corresponding metadata key.
+ * The map is weakly referenced by the modules container (unique per application).
+ */
+DiscoverableMetaHostCollection.controllersByMetaKey = new WeakMap();

package/discovery/discovery-module.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @publicApi
+ */
+export declare class DiscoveryModule {
+}

package/discovery/discovery-module.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiscoveryModule = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+const metadata_scanner_1 = require("../metadata-scanner");
+const discovery_service_1 = require("./discovery-service");
+/**
+ * @publicApi
+ */
+let DiscoveryModule = class DiscoveryModule {
+};
+exports.DiscoveryModule = DiscoveryModule;
+exports.DiscoveryModule = DiscoveryModule = tslib_1.__decorate([
+    (0, common_1.Module)({
+        providers: [metadata_scanner_1.MetadataScanner, discovery_service_1.DiscoveryService],
+        exports: [metadata_scanner_1.MetadataScanner, discovery_service_1.DiscoveryService],
+    })
+], DiscoveryModule);

package/discovery/discovery-service.d.ts

@@ -0,0 +1,76 @@
+import { CustomDecorator } from '@nestjs/common';
+import { InstanceWrapper } from '../injector/instance-wrapper';
+import { Module } from '../injector/module';
+import { ModulesContainer } from '../injector/modules-container';
+/**
+ * @publicApi
+ */
+export interface FilterByInclude {
+    /**
+     * List of modules to include (whitelist) into the discovery process.
+     */
+    include?: Function[];
+}
+/**
+ * @publicApi
+ */
+export interface FilterByMetadataKey {
+    /**
+     * A key to filter controllers and providers by.
+     * Only instance wrappers with the specified metadata key will be returned.
+     */
+    metadataKey?: string;
+}
+/**
+ * @publicApi
+ */
+export type DiscoveryOptions = FilterByInclude | FilterByMetadataKey;
+/**
+ * @publicApi
+ */
+export type DiscoverableDecorator<T> = ((opts?: T) => CustomDecorator) & {
+    KEY: string;
+};
+/**
+ * @publicApi
+ */
+export declare class DiscoveryService {
+    private readonly modulesContainer;
+    constructor(modulesContainer: ModulesContainer);
+    /**
+     * Creates a decorator that can be used to decorate classes and methods with metadata.
+     * The decorator will also add the class to the collection of discoverable classes (by metadata key).
+     * Decorated classes can be discovered using the `getProviders` and `getControllers` methods.
+     * @returns A decorator function.
+     */
+    static createDecorator<T>(): DiscoverableDecorator<T>;
+    /**
+     * Returns an array of instance wrappers (providers).
+     * Depending on the options, the array will contain either all providers or only providers with the specified metadata key.
+     * @param options Discovery options.
+     * @param modules A list of modules to filter by.
+     * @returns An array of instance wrappers (providers).
+     */
+    getProviders(options?: DiscoveryOptions, modules?: Module[]): InstanceWrapper[];
+    /**
+     * Returns an array of instance wrappers (controllers).
+     * Depending on the options, the array will contain either all controllers or only controllers with the specified metadata key.
+     * @param options Discovery options.
+     * @param modules A list of modules to filter by.
+     * @returns An array of instance wrappers (controllers).
+     */
+    getControllers(options?: DiscoveryOptions, modules?: Module[]): InstanceWrapper[];
+    /**
+     * Retrieves metadata from the specified instance wrapper.
+     * @param decorator The decorator to retrieve metadata of.
+     * @param instanceWrapper Reference to the instance wrapper.
+     * @param methodKey An optional method key to retrieve metadata from.
+     * @returns Discovered metadata.
+     */
+    getMetadataByDecorator<T extends DiscoverableDecorator<any>>(decorator: T, instanceWrapper: InstanceWrapper, methodKey?: string): T extends DiscoverableDecorator<infer R> ? R | undefined : T | undefined;
+    /**
+     * Returns a list of modules to be used for discovery.
+     */
+    protected getModules(options?: DiscoveryOptions): Module[];
+    private includeWhitelisted;
+}

package/discovery/discovery-service.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiscoveryService = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+const uid_1 = require("uid");
+const modules_container_1 = require("../injector/modules-container");
+const discoverable_meta_host_collection_1 = require("./discoverable-meta-host-collection");
+/**
+ * @publicApi
+ */
+let DiscoveryService = class DiscoveryService {
+    constructor(modulesContainer) {
+        this.modulesContainer = modulesContainer;
+    }
+    /**
+     * Creates a decorator that can be used to decorate classes and methods with metadata.
+     * The decorator will also add the class to the collection of discoverable classes (by metadata key).
+     * Decorated classes can be discovered using the `getProviders` and `getControllers` methods.
+     * @returns A decorator function.
+     */
+    static createDecorator() {
+        const metadataKey = (0, uid_1.uid)(21);
+        const decoratorFn = (opts) => (target, key, descriptor) => {
+            if (!descriptor) {
+                discoverable_meta_host_collection_1.DiscoverableMetaHostCollection.addClassMetaHostLink(target, metadataKey);
+            }
+            (0, common_1.SetMetadata)(metadataKey, opts ?? {})(target, key, descriptor);
+        };
+        decoratorFn.KEY = metadataKey;
+        return decoratorFn;
+    }
+    /**
+     * Returns an array of instance wrappers (providers).
+     * Depending on the options, the array will contain either all providers or only providers with the specified metadata key.
+     * @param options Discovery options.
+     * @param modules A list of modules to filter by.
+     * @returns An array of instance wrappers (providers).
+     */
+    getProviders(options = {}, modules = this.getModules(options)) {
+        if ('metadataKey' in options) {
+            const providers = discoverable_meta_host_collection_1.DiscoverableMetaHostCollection.getProvidersByMetaKey(this.modulesContainer, options.metadataKey);
+            return Array.from(providers);
+        }
+        const providers = modules.map(item => [...item.providers.values()]);
+        return (0, common_1.flatten)(providers);
+    }
+    /**
+     * Returns an array of instance wrappers (controllers).
+     * Depending on the options, the array will contain either all controllers or only controllers with the specified metadata key.
+     * @param options Discovery options.
+     * @param modules A list of modules to filter by.
+     * @returns An array of instance wrappers (controllers).
+     */
+    getControllers(options = {}, modules = this.getModules(options)) {
+        if ('metadataKey' in options) {
+            const controllers = discoverable_meta_host_collection_1.DiscoverableMetaHostCollection.getControllersByMetaKey(this.modulesContainer, options.metadataKey);
+            return Array.from(controllers);
+        }
+        const controllers = modules.map(item => [...item.controllers.values()]);
+        return (0, common_1.flatten)(controllers);
+    }
+    /**
+     * Retrieves metadata from the specified instance wrapper.
+     * @param decorator The decorator to retrieve metadata of.
+     * @param instanceWrapper Reference to the instance wrapper.
+     * @param methodKey An optional method key to retrieve metadata from.
+     * @returns Discovered metadata.
+     */
+    getMetadataByDecorator(decorator, instanceWrapper, methodKey) {
+        if (methodKey) {
+            return Reflect.getMetadata(decorator.KEY, instanceWrapper.instance[methodKey]);
+        }
+        const clsRef = instanceWrapper.instance?.constructor ?? instanceWrapper.metatype;
+        return Reflect.getMetadata(decorator.KEY, clsRef);
+    }
+    /**
+     * Returns a list of modules to be used for discovery.
+     */
+    getModules(options = {}) {
+        const includeInOpts = 'include' in options;
+        if (!includeInOpts) {
+            const moduleRefs = [...this.modulesContainer.values()];
+            return moduleRefs;
+        }
+        const whitelisted = this.includeWhitelisted(options.include);
+        return whitelisted;
+    }
+    includeWhitelisted(include) {
+        const moduleRefs = [...this.modulesContainer.values()];
+        return moduleRefs.filter(({ metatype }) => include.some(item => item === metatype));
+    }
+};
+exports.DiscoveryService = DiscoveryService;
+exports.DiscoveryService = DiscoveryService = tslib_1.__decorate([
+    (0, common_1.Injectable)(),
+    tslib_1.__metadata("design:paramtypes", [modules_container_1.ModulesContainer])
+], DiscoveryService);

package/discovery/index.d.ts

@@ -0,0 +1,2 @@
+export * from './discovery-module';
+export * from './discovery-service';

package/discovery/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./discovery-module"), exports);
+tslib_1.__exportStar(require("./discovery-service"), exports);

package/errors/exception-handler.d.ts

@@ -0,0 +1,4 @@
+export declare class ExceptionHandler {
+    private static readonly logger;
+    handle(exception: Error): void;
+}

package/errors/exception-handler.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExceptionHandler = void 0;
+const logger_service_1 = require("@nestjs/common/services/logger.service");
+class ExceptionHandler {
+    handle(exception) {
+        ExceptionHandler.logger.error(exception);
+    }
+}
+exports.ExceptionHandler = ExceptionHandler;
+ExceptionHandler.logger = new logger_service_1.Logger(ExceptionHandler.name);

package/errors/exceptions/circular-dependency.exception.d.ts

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

package/errors/exceptions/circular-dependency.exception.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CircularDependencyException = void 0;
+const runtime_exception_1 = require("./runtime.exception");
+class CircularDependencyException extends runtime_exception_1.RuntimeException {
+    constructor(context) {
+        const ctx = context ? ` inside ${context}` : ``;
+        super(`A circular dependency has been detected${ctx}. Please, make sure that each side of a bidirectional relationships are decorated with "forwardRef()". Note that circular relationships between custom providers (e.g., factories) are not supported since functions cannot be called more than once.`);
+    }
+}
+exports.CircularDependencyException = CircularDependencyException;

package/errors/exceptions/index.d.ts

@@ -0,0 +1,8 @@
+export * from './circular-dependency.exception';
+export * from './runtime.exception';
+export * from './unknown-element.exception';
+export * from './invalid-class-scope.exception';
+export * from './invalid-class.exception';
+export * from './unknown-export.exception';
+export * from './unknown-module.exception';
+export * from './undefined-forwardref.exception';

package/errors/exceptions/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./circular-dependency.exception"), exports);
+tslib_1.__exportStar(require("./runtime.exception"), exports);
+tslib_1.__exportStar(require("./unknown-element.exception"), exports);
+tslib_1.__exportStar(require("./invalid-class-scope.exception"), exports);
+tslib_1.__exportStar(require("./invalid-class.exception"), exports);
+tslib_1.__exportStar(require("./unknown-export.exception"), exports);
+tslib_1.__exportStar(require("./unknown-module.exception"), exports);
+tslib_1.__exportStar(require("./undefined-forwardref.exception"), exports);

package/errors/exceptions/invalid-class-module.exception.d.ts

@@ -0,0 +1,4 @@
+import { RuntimeException } from './runtime.exception';
+export declare class InvalidClassModuleException extends RuntimeException {
+    constructor(metatypeUsedAsAModule: any, scope: any[]);
+}

package/errors/exceptions/invalid-class-module.exception.js

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

package/errors/exceptions/invalid-class-scope.exception.d.ts

@@ -0,0 +1,5 @@
+import { Abstract, Type } from '@nestjs/common/interfaces';
+import { RuntimeException } from './runtime.exception';
+export declare class InvalidClassScopeException extends RuntimeException {
+    constructor(metatypeOrToken: Type<any> | Abstract<any> | string | symbol);
+}

package/errors/exceptions/invalid-class-scope.exception.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvalidClassScopeException = void 0;
+const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
+const messages_1 = require("../messages");
+const runtime_exception_1 = require("./runtime.exception");
+class InvalidClassScopeException extends runtime_exception_1.RuntimeException {
+    constructor(metatypeOrToken) {
+        let name = (0, shared_utils_1.isFunction)(metatypeOrToken)
+            ? metatypeOrToken.name
+            : metatypeOrToken;
+        name = name && name.toString();
+        super((0, messages_1.INVALID_CLASS_SCOPE_MESSAGE) `${name}`);
+    }
+}
+exports.InvalidClassScopeException = InvalidClassScopeException;

package/errors/exceptions/invalid-class.exception.d.ts

@@ -0,0 +1,4 @@
+import { RuntimeException } from './runtime.exception';
+export declare class InvalidClassException extends RuntimeException {
+    constructor(value: any);
+}

package/errors/exceptions/invalid-class.exception.js

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

package/errors/exceptions/invalid-exception-filter.exception.d.ts

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

package/errors/exceptions/invalid-exception-filter.exception.js

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

package/errors/exceptions/invalid-middleware-configuration.exception.d.ts

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

package/errors/exceptions/invalid-middleware-configuration.exception.js

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

package/errors/exceptions/invalid-middleware.exception.d.ts

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

package/errors/exceptions/invalid-middleware.exception.js

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

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

@@ -0,0 +1,4 @@
+import { RuntimeException } from './runtime.exception';
+export declare class InvalidModuleException extends RuntimeException {
+    constructor(parentModule: any, index: number, scope: any[]);
+}

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

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

package/errors/exceptions/runtime.exception.d.ts

@@ -0,0 +1,4 @@
+export declare class RuntimeException extends Error {
+    constructor(message?: string);
+    what(): string;
+}

package/errors/exceptions/runtime.exception.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RuntimeException = void 0;
+class RuntimeException extends Error {
+    constructor(message = ``) {
+        super(message);
+    }
+    what() {
+        return this.message;
+    }
+}
+exports.RuntimeException = RuntimeException;

package/errors/exceptions/undefined-dependency.exception.d.ts

@@ -0,0 +1,6 @@
+import { InjectorDependencyContext } from '../../injector/injector';
+import { Module } from '../../injector/module';
+import { RuntimeException } from './runtime.exception';
+export declare class UndefinedDependencyException extends RuntimeException {
+    constructor(type: string, undefinedDependencyContext: InjectorDependencyContext, moduleRef?: Module);
+}

package/errors/exceptions/undefined-dependency.exception.js

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

package/errors/exceptions/undefined-forwardref.exception.d.ts

@@ -0,0 +1,5 @@
+import { RuntimeException } from './runtime.exception';
+import { Type } from '@nestjs/common';
+export declare class UndefinedForwardRefException extends RuntimeException {
+    constructor(scope: Type<any>[]);
+}

package/errors/exceptions/undefined-forwardref.exception.js

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

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

@@ -0,0 +1,4 @@
+import { RuntimeException } from './runtime.exception';
+export declare class UndefinedModuleException extends RuntimeException {
+    constructor(parentModule: any, index: number, scope: any[]);
+}

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

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

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

@@ -0,0 +1,16 @@
+import { InjectorDependencyContext } from '../../injector/injector';
+import { Module } from '../../injector/module';
+import { RuntimeException } from './runtime.exception';
+export declare class UnknownDependenciesException extends RuntimeException {
+    readonly type: string | symbol;
+    readonly context: InjectorDependencyContext;
+    readonly metadata?: {
+        id: string;
+    } | undefined;
+    readonly moduleRef: {
+        id: string;
+    } | undefined;
+    constructor(type: string | symbol, context: InjectorDependencyContext, moduleRef?: Module, metadata?: {
+        id: string;
+    } | undefined);
+}

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

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnknownDependenciesException = void 0;
+const messages_1 = require("../messages");
+const runtime_exception_1 = require("./runtime.exception");
+class UnknownDependenciesException extends runtime_exception_1.RuntimeException {
+    constructor(type, context, moduleRef, metadata) {
+        super((0, messages_1.UNKNOWN_DEPENDENCIES_MESSAGE)(type, context, moduleRef));
+        this.type = type;
+        this.context = context;
+        this.metadata = metadata;
+        this.moduleRef = moduleRef && { id: moduleRef.id };
+    }
+}
+exports.UnknownDependenciesException = UnknownDependenciesException;

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

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

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

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnknownElementException = void 0;
+const runtime_exception_1 = require("./runtime.exception");
+class UnknownElementException extends runtime_exception_1.RuntimeException {
+    constructor(name) {
+        name = name && name.toString();
+        super(`Nest could not find ${name || 'given'} element (this provider does not exist in the current context)`);
+    }
+}
+exports.UnknownElementException = UnknownElementException;