@depup/nestjs__core 11.2.3-depup.0 → 12.0.2-depup.0

package/helpers/safe-instance-decorator.js

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeSafeInstanceDecorator = makeSafeInstanceDecorator;
-const common_1 = require("@nestjs/common");
-const logger = new common_1.Logger('InstrumentLogger');
+import { Logger } from '@nestjs/common';
+const logger = new Logger('InstrumentLogger');
 /**
  * Wraps an `instrument.instanceDecorator` so that a decorator throwing on a
  * given instance (e.g. when inspecting a Proxy whose traps throw outside of
@@ -10,7 +7,7 @@ const logger = new common_1.Logger('InstrumentLogger');
  * crash the application bootstrap. The original, undecorated instance is
  * used instead and a warning is logged.
  */
-function makeSafeInstanceDecorator(decorator) {
+export function makeSafeInstanceDecorator(decorator) {
     return (target) => {
         try {
             return decorator(target);

package/hooks/before-app-shutdown.hook.d.ts

@@ -1,9 +1,9 @@
-import { Module } from '../injector/module';
+import { Module } from '../injector/module.js';
 /**
  * Calls the `beforeApplicationShutdown` function on the module and its children
  * (providers / controllers).
  *
- * @param module The module which will be initialized
+ * @param moduleRef The module which will be initialized
  * @param signal The signal which caused the shutdown
  */
-export declare function callBeforeAppShutdownHook(module: Module, signal?: string): Promise<void>;
+export declare function callBeforeAppShutdownHook(moduleRef: Module, signal?: string): Promise<void>;

package/hooks/before-app-shutdown.hook.js

@@ -1,23 +1,22 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.callBeforeAppShutdownHook = callBeforeAppShutdownHook;
-const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
-const iterare_1 = require("iterare");
-const transient_instances_1 = require("../injector/helpers/transient-instances");
+import { Logger } from '@nestjs/common';
+import { isFunction, isNil } from '@nestjs/common/internal';
+import { iterate } from 'iterare';
+import { getInstancesGroupedByHierarchyLevel } from './utils/get-instances-grouped-by-hierarchy-level.js';
+import { getSortedHierarchyLevels } from './utils/get-sorted-hierarchy-levels.js';
 /**
  * Checks if the given instance has the `beforeApplicationShutdown` function
  *
  * @param instance The instance which should be checked
  */
 function hasBeforeApplicationShutdownHook(instance) {
-    return (0, shared_utils_1.isFunction)(instance.beforeApplicationShutdown);
+    return isFunction(instance.beforeApplicationShutdown);
 }
 /**
  * Calls the given instances
  */
 function callOperator(instances, signal) {
-    return (0, iterare_1.iterate)(instances)
-        .filter(instance => !(0, shared_utils_1.isNil)(instance))
+    return iterate(instances)
+        .filter(instance => !isNil(instance))
         .filter(hasBeforeApplicationShutdownHook)
         .map(async (instance) => instance.beforeApplicationShutdown(signal))
         .toArray();
@@ -26,26 +25,29 @@ function callOperator(instances, signal) {
  * Calls the `beforeApplicationShutdown` function on the module and its children
  * (providers / controllers).
  *
- * @param module The module which will be initialized
+ * @param moduleRef The module which will be initialized
  * @param signal The signal which caused the shutdown
  */
-async function callBeforeAppShutdownHook(module, signal) {
-    const providers = module.getNonAliasProviders();
+export async function callBeforeAppShutdownHook(moduleRef, signal) {
+    const providers = moduleRef.getNonAliasProviders();
     const [_, moduleClassHost] = providers.shift();
-    const instances = [
-        ...module.controllers,
-        ...providers,
-        ...module.injectables,
-        ...module.middlewares,
-    ];
-    const nonTransientInstances = (0, transient_instances_1.getNonTransientInstances)(instances);
-    await Promise.all(callOperator(nonTransientInstances, signal));
-    const transientInstances = (0, transient_instances_1.getTransientInstances)(instances);
-    await Promise.all(callOperator(transientInstances, signal));
+    const groupedInstances = getInstancesGroupedByHierarchyLevel(moduleRef.controllers, moduleRef.injectables, moduleRef.middlewares, providers);
+    const levels = getSortedHierarchyLevels(groupedInstances, 'DESC');
+    for (const level of levels) {
+        const results = await Promise.allSettled(callOperator(groupedInstances.get(level), signal));
+        results
+            .filter((result) => result.status === 'rejected')
+            .forEach(result => Logger.error(result.reason, result.reason?.stack));
+    }
     const moduleClassInstance = moduleClassHost.instance;
     if (moduleClassInstance &&
         hasBeforeApplicationShutdownHook(moduleClassInstance) &&
         moduleClassHost.isDependencyTreeStatic()) {
-        await moduleClassInstance.beforeApplicationShutdown(signal);
+        try {
+            await moduleClassInstance.beforeApplicationShutdown(signal);
+        }
+        catch (err) {
+            Logger.error(err, err?.stack);
+        }
     }
 }

package/hooks/index.d.ts

@@ -1,5 +1,5 @@
-export * from './on-app-bootstrap.hook';
-export * from './on-app-shutdown.hook';
-export * from './on-module-destroy.hook';
-export * from './on-module-init.hook';
-export * from './before-app-shutdown.hook';
+export * from './on-app-bootstrap.hook.js';
+export * from './on-app-shutdown.hook.js';
+export * from './on-module-destroy.hook.js';
+export * from './on-module-init.hook.js';
+export * from './before-app-shutdown.hook.js';

package/hooks/index.js

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./on-app-bootstrap.hook"), exports);
-tslib_1.__exportStar(require("./on-app-shutdown.hook"), exports);
-tslib_1.__exportStar(require("./on-module-destroy.hook"), exports);
-tslib_1.__exportStar(require("./on-module-init.hook"), exports);
-tslib_1.__exportStar(require("./before-app-shutdown.hook"), exports);
+export * from './on-app-bootstrap.hook.js';
+export * from './on-app-shutdown.hook.js';
+export * from './on-module-destroy.hook.js';
+export * from './on-module-init.hook.js';
+export * from './before-app-shutdown.hook.js';

package/hooks/on-app-bootstrap.hook.d.ts

@@ -1,8 +1,8 @@
-import { Module } from '../injector/module';
+import { Module } from '../injector/module.js';
 /**
  * Calls the `onApplicationBootstrap` function on the module and its children
  * (providers / controllers).
  *
- * @param module The module which will be initialized
+ * @param moduleRef The module which will be initialized
  */
-export declare function callModuleBootstrapHook(module: Module): Promise<any>;
+export declare function callModuleBootstrapHook(moduleRef: Module): Promise<any>;

package/hooks/on-app-bootstrap.hook.js

@@ -1,23 +1,21 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.callModuleBootstrapHook = callModuleBootstrapHook;
-const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
-const iterare_1 = require("iterare");
-const transient_instances_1 = require("../injector/helpers/transient-instances");
+import { isFunction, isNil } from '@nestjs/common/internal';
+import { iterate } from 'iterare';
+import { getInstancesGroupedByHierarchyLevel } from './utils/get-instances-grouped-by-hierarchy-level.js';
+import { getSortedHierarchyLevels } from './utils/get-sorted-hierarchy-levels.js';
 /**
  * Checks if the given instance has the `onApplicationBootstrap` function
  *
  * @param instance The instance which should be checked
  */
 function hasOnAppBootstrapHook(instance) {
-    return (0, shared_utils_1.isFunction)(instance.onApplicationBootstrap);
+    return isFunction(instance.onApplicationBootstrap);
 }
 /**
  * Calls the given instances
  */
 function callOperator(instances) {
-    return (0, iterare_1.iterate)(instances)
-        .filter(instance => !(0, shared_utils_1.isNil)(instance))
+    return iterate(instances)
+        .filter(instance => !isNil(instance))
         .filter(hasOnAppBootstrapHook)
         .map(async (instance) => instance.onApplicationBootstrap())
         .toArray();
@@ -26,23 +24,18 @@ function callOperator(instances) {
  * Calls the `onApplicationBootstrap` function on the module and its children
  * (providers / controllers).
  *
- * @param module The module which will be initialized
+ * @param moduleRef The module which will be initialized
  */
-async function callModuleBootstrapHook(module) {
-    const providers = module.getNonAliasProviders();
+export async function callModuleBootstrapHook(moduleRef) {
+    const providers = moduleRef.getNonAliasProviders();
     // Module (class) instance is the first element of the providers array
     // Lifecycle hook has to be called once all classes are properly initialized
     const [_, moduleClassHost] = providers.shift();
-    const instances = [
-        ...module.controllers,
-        ...providers,
-        ...module.injectables,
-        ...module.middlewares,
-    ];
-    const nonTransientInstances = (0, transient_instances_1.getNonTransientInstances)(instances);
-    await Promise.all(callOperator(nonTransientInstances));
-    const transientInstances = (0, transient_instances_1.getTransientInstances)(instances);
-    await Promise.all(callOperator(transientInstances));
+    const groupedInstances = getInstancesGroupedByHierarchyLevel(moduleRef.controllers, moduleRef.injectables, moduleRef.middlewares, providers);
+    const levels = getSortedHierarchyLevels(groupedInstances);
+    for (const level of levels) {
+        await Promise.all(callOperator(groupedInstances.get(level)));
+    }
     // Call the instance itself
     const moduleClassInstance = moduleClassHost.instance;
     if (moduleClassInstance &&

package/hooks/on-app-shutdown.hook.d.ts

@@ -1,9 +1,9 @@
-import { Module } from '../injector/module';
+import { Module } from '../injector/module.js';
 /**
  * Calls the `onApplicationShutdown` function on the module and its children
  * (providers / controllers).
  *
- * @param module The module which will be initialized
+ * @param moduleRef The module which will be initialized
  * @param signal
  */
-export declare function callAppShutdownHook(module: Module, signal?: string): Promise<any>;
+export declare function callAppShutdownHook(moduleRef: Module, signal?: string): Promise<any>;

package/hooks/on-app-shutdown.hook.js

@@ -1,23 +1,22 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.callAppShutdownHook = callAppShutdownHook;
-const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
-const iterare_1 = require("iterare");
-const transient_instances_1 = require("../injector/helpers/transient-instances");
+import { Logger } from '@nestjs/common';
+import { isFunction, isNil } from '@nestjs/common/internal';
+import { iterate } from 'iterare';
+import { getInstancesGroupedByHierarchyLevel } from './utils/get-instances-grouped-by-hierarchy-level.js';
+import { getSortedHierarchyLevels } from './utils/get-sorted-hierarchy-levels.js';
 /**
  * Checks if the given instance has the `onApplicationShutdown` function
  *
  * @param instance The instance which should be checked
  */
 function hasOnAppShutdownHook(instance) {
-    return (0, shared_utils_1.isFunction)(instance.onApplicationShutdown);
+    return isFunction(instance.onApplicationShutdown);
 }
 /**
  * Calls the given instances
  */
 function callOperator(instances, signal) {
-    return (0, iterare_1.iterate)(instances)
-        .filter(instance => !(0, shared_utils_1.isNil)(instance))
+    return iterate(instances)
+        .filter(instance => !isNil(instance))
         .filter(hasOnAppShutdownHook)
         .map(async (instance) => instance.onApplicationShutdown(signal))
         .toArray();
@@ -26,29 +25,32 @@ function callOperator(instances, signal) {
  * Calls the `onApplicationShutdown` function on the module and its children
  * (providers / controllers).
  *
- * @param module The module which will be initialized
+ * @param moduleRef The module which will be initialized
  * @param signal
  */
-async function callAppShutdownHook(module, signal) {
-    const providers = module.getNonAliasProviders();
+export async function callAppShutdownHook(moduleRef, signal) {
+    const providers = moduleRef.getNonAliasProviders();
     // Module (class) instance is the first element of the providers array
     // Lifecycle hook has to be called once all classes are properly initialized
     const [_, moduleClassHost] = providers.shift();
-    const instances = [
-        ...module.controllers,
-        ...providers,
-        ...module.injectables,
-        ...module.middlewares,
-    ];
-    const nonTransientInstances = (0, transient_instances_1.getNonTransientInstances)(instances);
-    await Promise.all(callOperator(nonTransientInstances, signal));
-    const transientInstances = (0, transient_instances_1.getTransientInstances)(instances);
-    await Promise.all(callOperator(transientInstances, signal));
+    const groupedInstances = getInstancesGroupedByHierarchyLevel(moduleRef.controllers, moduleRef.injectables, moduleRef.middlewares, providers);
+    const levels = getSortedHierarchyLevels(groupedInstances, 'DESC');
+    for (const level of levels) {
+        const results = await Promise.allSettled(callOperator(groupedInstances.get(level), signal));
+        results
+            .filter((result) => result.status === 'rejected')
+            .forEach(result => Logger.error(result.reason, result.reason?.stack));
+    }
     // Call the instance itself
     const moduleClassInstance = moduleClassHost.instance;
     if (moduleClassInstance &&
         hasOnAppShutdownHook(moduleClassInstance) &&
         moduleClassHost.isDependencyTreeStatic()) {
-        await moduleClassInstance.onApplicationShutdown(signal);
+        try {
+            await moduleClassInstance.onApplicationShutdown(signal);
+        }
+        catch (err) {
+            Logger.error(err, err?.stack);
+        }
     }
 }

package/hooks/on-module-destroy.hook.d.ts

@@ -1,8 +1,8 @@
-import { Module } from '../injector/module';
+import { Module } from '../injector/module.js';
 /**
  * Calls the `onModuleDestroy` function on the module and its children
  * (providers / controllers).
  *
- * @param module The module which will be initialized
+ * @param moduleRef The module which will be initialized
  */
-export declare function callModuleDestroyHook(module: Module): Promise<any>;
+export declare function callModuleDestroyHook(moduleRef: Module): Promise<any>;

package/hooks/on-module-destroy.hook.js

@@ -1,23 +1,22 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.callModuleDestroyHook = callModuleDestroyHook;
-const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
-const iterare_1 = require("iterare");
-const transient_instances_1 = require("../injector/helpers/transient-instances");
+import { Logger } from '@nestjs/common';
+import { isFunction, isNil } from '@nestjs/common/internal';
+import { iterate } from 'iterare';
+import { getInstancesGroupedByHierarchyLevel } from './utils/get-instances-grouped-by-hierarchy-level.js';
+import { getSortedHierarchyLevels } from './utils/get-sorted-hierarchy-levels.js';
 /**
  * Returns true or false if the given instance has a `onModuleDestroy` function
  *
  * @param instance The instance which should be checked
  */
 function hasOnModuleDestroyHook(instance) {
-    return (0, shared_utils_1.isFunction)(instance.onModuleDestroy);
+    return isFunction(instance.onModuleDestroy);
 }
 /**
  * Calls the given instances onModuleDestroy hook
  */
 function callOperator(instances) {
-    return (0, iterare_1.iterate)(instances)
-        .filter(instance => !(0, shared_utils_1.isNil)(instance))
+    return iterate(instances)
+        .filter(instance => !isNil(instance))
         .filter(hasOnModuleDestroyHook)
         .map(async (instance) => instance.onModuleDestroy())
         .toArray();
@@ -26,28 +25,31 @@ function callOperator(instances) {
  * Calls the `onModuleDestroy` function on the module and its children
  * (providers / controllers).
  *
- * @param module The module which will be initialized
+ * @param moduleRef The module which will be initialized
  */
-async function callModuleDestroyHook(module) {
-    const providers = module.getNonAliasProviders();
+export async function callModuleDestroyHook(moduleRef) {
+    const providers = moduleRef.getNonAliasProviders();
     // Module (class) instance is the first element of the providers array
     // Lifecycle hook has to be called once all classes are properly destroyed
     const [_, moduleClassHost] = providers.shift();
-    const instances = [
-        ...module.controllers,
-        ...providers,
-        ...module.injectables,
-        ...module.middlewares,
-    ];
-    const nonTransientInstances = (0, transient_instances_1.getNonTransientInstances)(instances);
-    await Promise.all(callOperator(nonTransientInstances));
-    const transientInstances = (0, transient_instances_1.getTransientInstances)(instances);
-    await Promise.all(callOperator(transientInstances));
+    const groupedInstances = getInstancesGroupedByHierarchyLevel(moduleRef.controllers, moduleRef.injectables, moduleRef.middlewares, providers);
+    const levels = getSortedHierarchyLevels(groupedInstances, 'DESC');
+    for (const level of levels) {
+        const results = await Promise.allSettled(callOperator(groupedInstances.get(level)));
+        results
+            .filter((result) => result.status === 'rejected')
+            .forEach(result => Logger.error(result.reason, result.reason?.stack));
+    }
     // Call the module instance itself
     const moduleClassInstance = moduleClassHost.instance;
     if (moduleClassInstance &&
         hasOnModuleDestroyHook(moduleClassInstance) &&
         moduleClassHost.isDependencyTreeStatic()) {
-        await moduleClassInstance.onModuleDestroy();
+        try {
+            await moduleClassInstance.onModuleDestroy();
+        }
+        catch (err) {
+            Logger.error(err, err?.stack);
+        }
     }
 }

package/hooks/on-module-init.hook.d.ts

@@ -1,8 +1,8 @@
-import { Module } from '../injector/module';
+import { Module } from '../injector/module.js';
 /**
  * Calls the `onModuleInit` function on the module and its children
  * (providers / controllers).
  *
- * @param module The module which will be initialized
+ * @param moduleRef The module which will be initialized
  */
-export declare function callModuleInitHook(module: Module): Promise<void>;
+export declare function callModuleInitHook(moduleRef: Module): Promise<void>;

package/hooks/on-module-init.hook.js

@@ -1,23 +1,21 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.callModuleInitHook = callModuleInitHook;
-const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
-const iterare_1 = require("iterare");
-const transient_instances_1 = require("../injector/helpers/transient-instances");
+import { isFunction, isNil } from '@nestjs/common/internal';
+import { iterate } from 'iterare';
+import { getInstancesGroupedByHierarchyLevel } from './utils/get-instances-grouped-by-hierarchy-level.js';
+import { getSortedHierarchyLevels } from './utils/get-sorted-hierarchy-levels.js';
 /**
  * Returns true or false if the given instance has a `onModuleInit` function
  *
  * @param instance The instance which should be checked
  */
 function hasOnModuleInitHook(instance) {
-    return (0, shared_utils_1.isFunction)(instance.onModuleInit);
+    return isFunction(instance.onModuleInit);
 }
 /**
  * Calls the given instances
  */
 function callOperator(instances) {
-    return (0, iterare_1.iterate)(instances)
-        .filter(instance => !(0, shared_utils_1.isNil)(instance))
+    return iterate(instances)
+        .filter(instance => !isNil(instance))
         .filter(hasOnModuleInitHook)
         .map(async (instance) => instance.onModuleInit())
         .toArray();
@@ -26,23 +24,18 @@ function callOperator(instances) {
  * Calls the `onModuleInit` function on the module and its children
  * (providers / controllers).
  *
- * @param module The module which will be initialized
+ * @param moduleRef The module which will be initialized
  */
-async function callModuleInitHook(module) {
-    const providers = module.getNonAliasProviders();
+export async function callModuleInitHook(moduleRef) {
+    const providers = moduleRef.getNonAliasProviders();
     // Module (class) instance is the first element of the providers array
     // Lifecycle hook has to be called once all classes are properly initialized
     const [_, moduleClassHost] = providers.shift();
-    const instances = [
-        ...module.controllers,
-        ...providers,
-        ...module.injectables,
-        ...module.middlewares,
-    ];
-    const nonTransientInstances = (0, transient_instances_1.getNonTransientInstances)(instances);
-    await Promise.all(callOperator(nonTransientInstances));
-    const transientInstances = (0, transient_instances_1.getTransientInstances)(instances);
-    await Promise.all(callOperator(transientInstances));
+    const groupedInstances = getInstancesGroupedByHierarchyLevel(moduleRef.controllers, moduleRef.injectables, moduleRef.middlewares, providers);
+    const levels = getSortedHierarchyLevels(groupedInstances);
+    for (const level of levels) {
+        await Promise.all(callOperator(groupedInstances.get(level)));
+    }
     // Call the instance itself
     const moduleClassInstance = moduleClassHost.instance;
     if (moduleClassInstance &&

package/hooks/utils/get-instances-grouped-by-hierarchy-level.d.ts

@@ -0,0 +1,3 @@
+import { InjectionToken } from '@nestjs/common';
+import { InstanceWrapper } from '../../injector/instance-wrapper.js';
+export declare function getInstancesGroupedByHierarchyLevel(...collections: Array<Map<InjectionToken, InstanceWrapper> | Array<[InjectionToken, InstanceWrapper]>>): Map<number, unknown[]>;

package/hooks/utils/get-instances-grouped-by-hierarchy-level.js

@@ -0,0 +1,27 @@
+export function getInstancesGroupedByHierarchyLevel(...collections) {
+    const groupedByHierarchyLevel = new Map();
+    for (const collection of collections) {
+        for (const [_, wrapper] of collection) {
+            if (!wrapper.isDependencyTreeStatic()) {
+                continue;
+            }
+            const level = wrapper.hierarchyLevel;
+            if (!groupedByHierarchyLevel.has(level)) {
+                groupedByHierarchyLevel.set(level, []);
+            }
+            const byHierarchyLevelGroup = groupedByHierarchyLevel.get(level);
+            if (wrapper.isTransient) {
+                const staticTransientInstances = wrapper
+                    .getStaticTransientInstances()
+                    .filter(i => !!i)
+                    .map(i => i.instance);
+                byHierarchyLevelGroup.push(...staticTransientInstances);
+                continue;
+            }
+            if (wrapper.instance) {
+                byHierarchyLevelGroup.push(wrapper.instance);
+            }
+        }
+    }
+    return groupedByHierarchyLevel;
+}

package/hooks/utils/get-sorted-hierarchy-levels.d.ts

@@ -0,0 +1 @@
+export declare function getSortedHierarchyLevels(groups: Map<number, unknown[]>, order?: 'ASC' | 'DESC'): number[];

package/hooks/utils/get-sorted-hierarchy-levels.js

@@ -0,0 +1,7 @@
+export function getSortedHierarchyLevels(groups, order = 'ASC') {
+    const comparator = order === 'ASC'
+        ? (a, b) => a - b
+        : (a, b) => b - a;
+    const levels = Array.from(groups.keys()).sort(comparator);
+    return levels;
+}

package/index.d.ts

@@ -1,17 +1,17 @@
 import 'reflect-metadata';
-export * from './adapters';
-export * from './application-config';
-export { APP_FILTER, APP_GUARD, APP_INTERCEPTOR, APP_PIPE } from './constants';
-export * from './discovery';
-export * from './exceptions';
-export * from './helpers';
-export * from './injector';
-export * from './inspector';
-export * from './metadata-scanner';
-export * from './middleware';
-export * from './nest-application';
-export * from './nest-application-context';
-export { IEntryNestModule, NestFactory } from './nest-factory';
-export * from './repl';
-export * from './router';
-export * from './services';
+export * from './adapters/index.js';
+export * from './application-config.js';
+export { APP_FILTER, APP_GUARD, APP_INTERCEPTOR, APP_PIPE, } from './constants.js';
+export * from './discovery/index.js';
+export * from './exceptions/index.js';
+export * from './helpers/index.js';
+export * from './injector/index.js';
+export * from './inspector/index.js';
+export * from './metadata-scanner.js';
+export * from './middleware/index.js';
+export * from './nest-application.js';
+export * from './nest-application-context.js';
+export { IEntryNestModule, NestFactory } from './nest-factory.js';
+export * from './repl/index.js';
+export * from './router/index.js';
+export * from './services/index.js';

package/index.js

@@ -1,32 +1,23 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.NestFactory = exports.APP_PIPE = exports.APP_INTERCEPTOR = exports.APP_GUARD = exports.APP_FILTER = void 0;
-const tslib_1 = require("tslib");
 /*
  * Nest @core
  * Copyright(c) 2017 - 2025 Kamil Mysliwiec
  * https://nestjs.com
  * MIT Licensed
  */
-require("reflect-metadata");
-tslib_1.__exportStar(require("./adapters"), exports);
-tslib_1.__exportStar(require("./application-config"), exports);
-var constants_1 = require("./constants");
-Object.defineProperty(exports, "APP_FILTER", { enumerable: true, get: function () { return constants_1.APP_FILTER; } });
-Object.defineProperty(exports, "APP_GUARD", { enumerable: true, get: function () { return constants_1.APP_GUARD; } });
-Object.defineProperty(exports, "APP_INTERCEPTOR", { enumerable: true, get: function () { return constants_1.APP_INTERCEPTOR; } });
-Object.defineProperty(exports, "APP_PIPE", { enumerable: true, get: function () { return constants_1.APP_PIPE; } });
-tslib_1.__exportStar(require("./discovery"), exports);
-tslib_1.__exportStar(require("./exceptions"), exports);
-tslib_1.__exportStar(require("./helpers"), exports);
-tslib_1.__exportStar(require("./injector"), exports);
-tslib_1.__exportStar(require("./inspector"), exports);
-tslib_1.__exportStar(require("./metadata-scanner"), exports);
-tslib_1.__exportStar(require("./middleware"), exports);
-tslib_1.__exportStar(require("./nest-application"), exports);
-tslib_1.__exportStar(require("./nest-application-context"), exports);
-var nest_factory_1 = require("./nest-factory");
-Object.defineProperty(exports, "NestFactory", { enumerable: true, get: function () { return nest_factory_1.NestFactory; } });
-tslib_1.__exportStar(require("./repl"), exports);
-tslib_1.__exportStar(require("./router"), exports);
-tslib_1.__exportStar(require("./services"), exports);
+import 'reflect-metadata';
+export * from './adapters/index.js';
+export * from './application-config.js';
+export { APP_FILTER, APP_GUARD, APP_INTERCEPTOR, APP_PIPE, } from './constants.js';
+export * from './discovery/index.js';
+export * from './exceptions/index.js';
+export * from './helpers/index.js';
+export * from './injector/index.js';
+export * from './inspector/index.js';
+export * from './metadata-scanner.js';
+export * from './middleware/index.js';
+export * from './nest-application.js';
+export * from './nest-application-context.js';
+export { NestFactory } from './nest-factory.js';
+export * from './repl/index.js';
+export * from './router/index.js';
+export * from './services/index.js';

package/injector/abstract-instance-resolver.d.ts

@@ -1,9 +1,9 @@
-import { Abstract, Type } from '@nestjs/common';
-import { GetOrResolveOptions } from '@nestjs/common/interfaces';
-import { Injector } from './injector';
-import { InstanceLinksHost } from './instance-links-host';
-import { ContextId } from './instance-wrapper';
-import { Module } from './module';
+import { type Abstract, type Type } from '@nestjs/common';
+import { Injector } from './injector.js';
+import { InstanceLinksHost } from './instance-links-host.js';
+import { ContextId } from './instance-wrapper.js';
+import { Module } from './module.js';
+import type { GetOrResolveOptions } from '@nestjs/common/internal';
 export declare abstract class AbstractInstanceResolver {
     protected abstract instanceLinksHost: InstanceLinksHost;
     protected abstract injector: Injector;