@nestjs/core 9.4.3 → 10.0.1

package/router/router-module.js

@@ -13,7 +13,7 @@ exports.targetModulesByContainer = new WeakMap();
 /**
  * @publicApi
  */
-let RouterModule = RouterModule_1 = class RouterModule {
+let RouterModule = exports.RouterModule = RouterModule_1 = class RouterModule {
     constructor(modulesContainer, routes) {
         this.modulesContainer = modulesContainer;
         this.routes = routes;
@@ -37,9 +37,12 @@ let RouterModule = RouterModule_1 = class RouterModule {
                 return routeOrType;
             }
             if (routeOrType.children) {
-                return Object.assign(Object.assign({}, routeOrType), { children: this.deepCloneRoutes(routeOrType.children) });
+                return {
+                    ...routeOrType,
+                    children: this.deepCloneRoutes(routeOrType.children),
+                };
             }
-            return Object.assign({}, routeOrType);
+            return { ...routeOrType };
         });
     }
     initialize() {
@@ -62,16 +65,15 @@ let RouterModule = RouterModule_1 = class RouterModule {
             moduleClassSet = new WeakSet();
             exports.targetModulesByContainer.set(this.modulesContainer, moduleClassSet);
         }
-        const moduleRef = Array.from(this.modulesContainer.values()).find(item => (item === null || item === void 0 ? void 0 : item.metatype) === moduleCtor);
+        const moduleRef = Array.from(this.modulesContainer.values()).find(item => item?.metatype === moduleCtor);
         if (!moduleRef) {
             return;
         }
         moduleClassSet.add(moduleRef);
     }
 };
-RouterModule = RouterModule_1 = tslib_1.__decorate([
+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);
-exports.RouterModule = RouterModule;

package/router/routes-resolver.js

@@ -105,16 +105,16 @@ class RoutesResolver {
     getModulePathMetadata(metatype) {
         const modulesContainer = this.container.getModules();
         const modulePath = Reflect.getMetadata(constants_1.MODULE_PATH + modulesContainer.applicationId, metatype);
-        return modulePath !== null && modulePath !== void 0 ? modulePath : Reflect.getMetadata(constants_1.MODULE_PATH, metatype);
+        return modulePath ?? Reflect.getMetadata(constants_1.MODULE_PATH, metatype);
     }
     getHostMetadata(metatype) {
         return Reflect.getMetadata(constants_1.HOST_METADATA, metatype);
     }
     getVersionMetadata(metatype) {
-        var _a;
         const versioningConfig = this.applicationConfig.getVersioning();
         if (versioningConfig) {
-            return ((_a = Reflect.getMetadata(constants_1.VERSION_METADATA, metatype)) !== null && _a !== void 0 ? _a : versioningConfig.defaultVersion);
+            return (Reflect.getMetadata(constants_1.VERSION_METADATA, metatype) ??
+                versioningConfig.defaultVersion);
         }
     }
 }

package/router/sse-stream.js

@@ -37,13 +37,18 @@ class SseStream extends stream_1.Transform {
     }
     pipe(destination, options) {
         if (destination.writeHead) {
-            destination.writeHead(200, Object.assign(Object.assign({}, options === null || options === void 0 ? void 0 : options.additionalHeaders), { 
+            destination.writeHead(200, {
+                ...options?.additionalHeaders,
                 // See https://github.com/dunglas/mercure/blob/master/hub/subscribe.go#L124-L130
-                'Content-Type': 'text/event-stream', Connection: 'keep-alive', 
+                'Content-Type': 'text/event-stream',
+                Connection: 'keep-alive',
                 // Disable cache, even for old browsers and proxies
-                'Cache-Control': 'private, no-cache, no-store, must-revalidate, max-age=0, no-transform', Pragma: 'no-cache', Expire: '0', 
+                'Cache-Control': 'private, no-cache, no-store, must-revalidate, max-age=0, no-transform',
+                Pragma: 'no-cache',
+                Expire: '0',
                 // NGINX support https://www.nginx.com/resources/wiki/start/topics/examples/x-accel/#x-accel-buffering
-                'X-Accel-Buffering': 'no' }));
+                'X-Accel-Buffering': 'no',
+            });
             destination.flushHeaders();
         }
         destination.write('\n');

package/scanner.d.ts

@@ -6,7 +6,15 @@ import { NestContainer } from './injector/container';
 import { InstanceWrapper } from './injector/instance-wrapper';
 import { Module } from './injector/module';
 import { GraphInspector } from './inspector/graph-inspector';
+import { ModuleDefinition } from './interfaces/module-definition.interface';
+import { ModuleOverride } from './interfaces/module-override.interface';
 import { MetadataScanner } from './metadata-scanner';
+interface ModulesScanParameters {
+    moduleDefinition: ModuleDefinition;
+    scope?: Type<unknown>[];
+    ctxRegistry?: (ForwardReference | DynamicModule | Type<unknown>)[];
+    overrides?: ModuleOverride[];
+}
 export declare class DependenciesScanner {
     private readonly container;
     private readonly metadataScanner;
@@ -14,8 +22,10 @@ export declare class DependenciesScanner {
     private readonly applicationConfig;
     private readonly applicationProvidersApplyMap;
     constructor(container: NestContainer, metadataScanner: MetadataScanner, graphInspector: GraphInspector, applicationConfig?: ApplicationConfig);
-    scan(module: Type<any>): Promise<void>;
-    scanForModules(moduleDefinition: ForwardReference | Type<unknown> | DynamicModule | Promise<DynamicModule>, scope?: Type<unknown>[], ctxRegistry?: (ForwardReference | DynamicModule | Type<unknown>)[]): Promise<Module[]>;
+    scan(module: Type<any>, options?: {
+        overrides?: ModuleOverride[];
+    }): Promise<void>;
+    scanForModules({ moduleDefinition, scope, ctxRegistry, overrides, }: ModulesScanParameters): Promise<Module[]>;
     insertModule(moduleDefinition: any, scope: Type<unknown>[]): Promise<Module | undefined>;
     scanModulesForDependencies(modules?: Map<string, Module>): Promise<void>;
     reflectImports(module: Type<unknown>, token: string, context: string): Promise<void>;
@@ -36,8 +46,11 @@ export declare class DependenciesScanner {
     insertInjectable(injectable: Type<Injectable> | object, token: string, host: Type<Injectable>, subtype: EnhancerSubtype, methodKey?: string): InstanceWrapper<any>;
     insertExportedProvider(exportedProvider: Type<Injectable>, token: string): void;
     insertController(controller: Type<Controller>, token: string): void;
+    private insertOrOverrideModule;
+    private getOverrideModuleByModule;
+    private overrideModule;
     reflectMetadata<T = any>(metadataKey: string, metatype: Type<any>): T[];
-    registerCoreModule(): Promise<void>;
+    registerCoreModule(overrides?: ModuleOverride[]): Promise<void>;
     /**
      * Add either request or transient globally scoped enhancers
      * to all controllers metadata storage
@@ -69,3 +82,4 @@ export declare class DependenciesScanner {
     private isForwardReference;
     private isRequestOrTransient;
 }
+export {};

package/scanner.js

@@ -22,16 +22,22 @@ class DependenciesScanner {
         this.applicationConfig = applicationConfig;
         this.applicationProvidersApplyMap = [];
     }
-    async scan(module) {
-        await this.registerCoreModule();
-        await this.scanForModules(module);
+    async scan(module, options) {
+        await this.registerCoreModule(options?.overrides);
+        await this.scanForModules({
+            moduleDefinition: module,
+            overrides: options?.overrides,
+        });
         await this.scanModulesForDependencies();
         this.calculateModulesDistance();
         this.addScopedEnhancersMetadata();
         this.container.bindGlobalScope();
     }
-    async scanForModules(moduleDefinition, scope = [], ctxRegistry = []) {
-        const moduleInstance = await this.insertModule(moduleDefinition, scope);
+    async scanForModules({ moduleDefinition, scope = [], ctxRegistry = [], overrides = [], }) {
+        const moduleInstance = await this.insertOrOverrideModule(moduleDefinition, overrides, scope);
+        moduleDefinition =
+            this.getOverrideModuleByModule(moduleDefinition, overrides)?.newModule ??
+                moduleDefinition;
         moduleDefinition =
             moduleDefinition instanceof Promise
                 ? await moduleDefinition
@@ -58,7 +64,12 @@ class DependenciesScanner {
             if (ctxRegistry.includes(innerModule)) {
                 continue;
             }
-            const moduleRefs = await this.scanForModules(innerModule, [].concat(scope, moduleDefinition), ctxRegistry);
+            const moduleRefs = await this.scanForModules({
+                moduleDefinition: innerModule,
+                scope: [].concat(scope, moduleDefinition),
+                ctxRegistry,
+                overrides,
+            });
             registeredModuleRefs = registeredModuleRefs.concat(moduleRefs);
         }
         if (!moduleInstance) {
@@ -236,7 +247,11 @@ class DependenciesScanner {
             providerKey: providerToken,
             scope,
         });
-        const newProvider = Object.assign(Object.assign({}, provider), { provide: providerToken, scope });
+        const newProvider = {
+            ...provider,
+            provide: providerToken,
+            scope,
+        };
         const enhancerSubtype = constants_2.ENHANCER_TOKEN_TO_SUBTYPE_MAP[type];
         const factoryOrClassProvider = newProvider;
         if (this.isRequestOrTransient(factoryOrClassProvider.scope)) {
@@ -273,12 +288,36 @@ class DependenciesScanner {
     insertController(controller, token) {
         this.container.addController(controller, token);
     }
+    insertOrOverrideModule(moduleDefinition, overrides, scope) {
+        const overrideModule = this.getOverrideModuleByModule(moduleDefinition, overrides);
+        if (overrideModule !== undefined) {
+            return this.overrideModule(moduleDefinition, overrideModule.newModule, scope);
+        }
+        return this.insertModule(moduleDefinition, scope);
+    }
+    getOverrideModuleByModule(module, overrides) {
+        if (this.isForwardReference(module)) {
+            return overrides.find(moduleToOverride => {
+                return (moduleToOverride.moduleToReplace === module.forwardRef() ||
+                    moduleToOverride.moduleToReplace.forwardRef?.() === module.forwardRef());
+            });
+        }
+        return overrides.find(moduleToOverride => moduleToOverride.moduleToReplace === module);
+    }
+    async overrideModule(moduleToOverride, newModule, scope) {
+        return this.container.replaceModule(this.isForwardReference(moduleToOverride)
+            ? moduleToOverride.forwardRef()
+            : moduleToOverride, this.isForwardReference(newModule) ? newModule.forwardRef() : newModule, scope);
+    }
     reflectMetadata(metadataKey, metatype) {
         return Reflect.getMetadata(metadataKey, metatype) || [];
     }
-    async registerCoreModule() {
-        const moduleDefinition = internal_core_module_factory_1.InternalCoreModuleFactory.create(this.container, this, this.container.getModuleCompiler(), this.container.getHttpAdapterHostRef(), this.graphInspector);
-        const [instance] = await this.scanForModules(moduleDefinition);
+    async registerCoreModule(overrides) {
+        const moduleDefinition = internal_core_module_factory_1.InternalCoreModuleFactory.create(this.container, this, this.container.getModuleCompiler(), this.container.getHttpAdapterHostRef(), this.graphInspector, overrides);
+        const [instance] = await this.scanForModules({
+            moduleDefinition,
+            overrides,
+        });
         this.container.registerCoreModuleRef(instance);
     }
     /**

package/services/reflector.service.js

@@ -50,7 +50,10 @@ class Reflector {
                 return a.concat(b);
             }
             if ((0, shared_utils_1.isObject)(a) && (0, shared_utils_1.isObject)(b)) {
-                return Object.assign(Object.assign({}, a), b);
+                return {
+                    ...a,
+                    ...b,
+                };
             }
             return [a, b];
         });