Merge pull request #12035 from nestjs/fix/globals-in-lazy-modules

fix(core): allow importing providers from global modules in lazy modules

integration/lazy-modules/e2e/lazy-import-global-modules.spec.ts

@@ -0,0 +1,29 @@
+import { INestApplication } from '@nestjs/common';
+import { Test } from '@nestjs/testing';
+import * as chai from 'chai';
+import { expect } from 'chai';
+import chaiAsPromised = require('chai-as-promised');
+import { AppModule } from '../src/app.module';
+chai.use(chaiAsPromised);
+
+describe('Lazy imports', () => {
+  let server;
+  let app: INestApplication;
+
+  beforeEach(async () => {
+    const module = await Test.createTestingModule({
+      imports: [AppModule],
+    }).compile();
+
+    app = module.createNestApplication();
+    server = app.getHttpAdapter().getInstance();
+  });
+
+  it(`should allow imports of global modules`, async () => {
+    await expect(app.init()).to.eventually.be.fulfilled;
+  });
+
+  afterEach(async () => {
+    await app.close();
+  });
+});

integration/lazy-modules/src/app.module.ts

@@ -0,0 +1,16 @@
+import { Module } from '@nestjs/common';
+import { LazyModuleLoader } from '@nestjs/core';
+import { EagerModule } from './eager.module';
+import { GlobalModule } from './global.module';
+import { LazyModule } from './lazy.module';
+
+@Module({
+  imports: [GlobalModule, EagerModule],
+})
+export class AppModule {
+  constructor(public loader: LazyModuleLoader) {}
+
+  async onApplicationBootstrap() {
+    await this.loader.load(() => LazyModule);
+  }
+}

integration/lazy-modules/src/eager.module.ts

@@ -0,0 +1,12 @@
+import { Module, Injectable } from '@nestjs/common';
+import { GlobalService } from './global.module';
+
+@Injectable()
+export class EagerService {
+  constructor(public globalService: GlobalService) {}
+}
+
+@Module({
+  providers: [EagerService],
+})
+export class EagerModule {}

integration/lazy-modules/src/global.module.ts

@@ -0,0 +1,13 @@
+import { Module, Injectable, Global } from '@nestjs/common';
+
+@Injectable()
+export class GlobalService {
+  constructor() {}
+}
+
+@Global()
+@Module({
+  providers: [GlobalService],
+  exports: [GlobalService],
+})
+export class GlobalModule {}

integration/lazy-modules/src/lazy.module.ts

@@ -0,0 +1,12 @@
+import { Module, Injectable } from '@nestjs/common';
+import { GlobalService } from './global.module';
+
+@Injectable()
+export class LazyService {
+  constructor(public globalService: GlobalService) {}
+}
+
+@Module({
+  providers: [LazyService],
+})
+export class LazyModule {}

integration/lazy-modules/src/main.ts

@@ -0,0 +1,8 @@
+import { NestFactory } from '@nestjs/core';
+import { AppModule } from './app.module';
+
+async function bootstrap() {
+  const app = await NestFactory.create(AppModule);
+  await app.listen(3000);
+}
+bootstrap();

packages/core/injector/container.ts

@@ -70,7 +70,13 @@ export class NestContainer {
   public async addModule(
     metatype: ModuleMetatype,
     scope: ModuleScope,
-  ): Promise<Module | undefined> {
+  ): Promise<
+    | {
+        moduleRef: Module;
+        inserted: boolean;
+      }
+    | undefined
+  > {
     // In DependenciesScanner#scanForModules we already check for undefined or invalid modules
     // We still need to catch the edge-case of `forwardRef(() => undefined)`
     if (!metatype) {
@@ -80,24 +86,36 @@ export class NestContainer {
       metatype,
     );
     if (this.modules.has(token)) {
-      return this.modules.get(token);
+      return {
+        moduleRef: this.modules.get(token),
+        inserted: true,
+      };
     }
 
-    return this.setModule(
-      {
-        token,
-        type,
-        dynamicMetadata,
-      },
-      scope,
-    );
+    return {
+      moduleRef: await this.setModule(
+        {
+          token,
+          type,
+          dynamicMetadata,
+        },
+        scope,
+      ),
+      inserted: true,
+    };
   }
 
   public async replaceModule(
     metatypeToReplace: ModuleMetatype,
     newMetatype: ModuleMetatype,
     scope: ModuleScope,
-  ): Promise<Module | undefined> {
+  ): Promise<
+    | {
+        moduleRef: Module;
+        inserted: boolean;
+      }
+    | undefined
+  > {
     // In DependenciesScanner#scanForModules we already check for undefined or invalid modules
     // We still need to catch the edge-case of `forwardRef(() => undefined)`
     if (!metatypeToReplace || !newMetatype) {
@@ -109,14 +127,17 @@ export class NestContainer {
       newMetatype,
     );
 
-    return this.setModule(
-      {
-        token,
-        type,
-        dynamicMetadata,
-      },
-      scope,
-    );
+    return {
+      moduleRef: await this.setModule(
+        {
+          token,
+          type,
+          dynamicMetadata,
+        },
+        scope,
+      ),
+      inserted: false,
+    };
   }
 
   private async setModule(

packages/core/injector/lazy-module-loader/lazy-module-loader.ts

@@ -31,6 +31,7 @@ export class LazyModuleLoader {
     const moduleInstances = await this.dependenciesScanner.scanForModules({
       moduleDefinition: moduleClassOrDynamicDefinition,
       overrides: this.moduleOverrides,
+      lazy: true,
     });
     if (moduleInstances.length === 0) {
       // The module has been loaded already. In this case, we must

packages/core/scanner.ts

@@ -2,9 +2,9 @@ import { DynamicModule, ForwardReference, Provider } from '@nestjs/common';
 import {
   CATCH_WATERMARK,
   CONTROLLER_WATERMARK,
-  EnhancerSubtype,
   ENHANCER_KEY_TO_SUBTYPE_MAP,
   EXCEPTION_FILTERS_METADATA,
+  EnhancerSubtype,
   GUARDS_METADATA,
   INJECTABLE_WATERMARK,
   INTERCEPTORS_METADATA,
@@ -68,6 +68,7 @@ interface ModulesScanParameters {
   scope?: Type<unknown>[];
   ctxRegistry?: (ForwardReference | DynamicModule | Type<unknown>)[];
   overrides?: ModuleOverride[];
+  lazy?: boolean;
 }
 
 export class DependenciesScanner {
@@ -99,23 +100,24 @@ export class DependenciesScanner {
 
   public async scanForModules({
     moduleDefinition,
+    lazy,
     scope = [],
     ctxRegistry = [],
     overrides = [],
   }: ModulesScanParameters): Promise<Module[]> {
-    const moduleInstance = await this.insertOrOverrideModule(
-      moduleDefinition,
-      overrides,
-      scope,
-    );
+    const { moduleRef: moduleInstance, inserted: moduleInserted } =
+      (await this.insertOrOverrideModule(moduleDefinition, overrides, scope)) ??
+      {};
 
     moduleDefinition =
       this.getOverrideModuleByModule(moduleDefinition, overrides)?.newModule ??
       moduleDefinition;
+
     moduleDefinition =
       moduleDefinition instanceof Promise
         ? await moduleDefinition
         : moduleDefinition;
+
     ctxRegistry.push(moduleDefinition);
 
     if (this.isForwardReference(moduleDefinition)) {
@@ -153,19 +155,30 @@ export class DependenciesScanner {
         scope: [].concat(scope, moduleDefinition),
         ctxRegistry,
         overrides,
+        lazy,
       });
       registeredModuleRefs = registeredModuleRefs.concat(moduleRefs);
     }
     if (!moduleInstance) {
       return registeredModuleRefs;
     }
+
+    if (lazy && moduleInserted) {
+      this.container.bindGlobalsToImports(moduleInstance);
+    }
     return [moduleInstance].concat(registeredModuleRefs);
   }
 
   public async insertModule(
     moduleDefinition: any,
     scope: Type<unknown>[],
-  ): Promise<Module | undefined> {
+  ): Promise<
+    | {
+        moduleRef: Module;
+        inserted: boolean;
+      }
+    | undefined
+  > {
     const moduleToAdd = this.isForwardReference(moduleDefinition)
       ? moduleDefinition.forwardRef()
       : moduleDefinition;
@@ -523,7 +536,13 @@ export class DependenciesScanner {
     moduleDefinition: ModuleDefinition,
     overrides: ModuleOverride[],
     scope: Type<unknown>[],
-  ): Promise<Module | undefined> {
+  ): Promise<
+    | {
+        moduleRef: Module;
+        inserted: boolean;
+      }
+    | undefined
+  > {
     const overrideModule = this.getOverrideModuleByModule(
       moduleDefinition,
       overrides,
@@ -563,7 +582,13 @@ export class DependenciesScanner {
     moduleToOverride: ModuleDefinition,
     newModule: ModuleDefinition,
     scope: Type<unknown>[],
-  ): Promise<Module | undefined> {
+  ): Promise<
+    | {
+        moduleRef: Module;
+        inserted: boolean;
+      }
+    | undefined
+  > {
     return this.container.replaceModule(
       this.isForwardReference(moduleToOverride)
         ? moduleToOverride.forwardRef()

packages/core/test/injector/injector.spec.ts

@@ -1,4 +1,5 @@
 import { Optional } from '@nestjs/common';
+import { PARAMTYPES_METADATA } from '@nestjs/common/constants';
 import * as chai from 'chai';
 import { expect } from 'chai';
 import * as chaiAsPromised from 'chai-as-promised';
@@ -10,7 +11,6 @@ import { NestContainer } from '../../injector/container';
 import { Injector, PropertyDependency } from '../../injector/injector';
 import { InstanceWrapper } from '../../injector/instance-wrapper';
 import { Module } from '../../injector/module';
-import { PARAMTYPES_METADATA } from '@nestjs/common/constants';
 
 chai.use(chaiAsPromised);
 
@@ -710,17 +710,17 @@ describe('Injector', () => {
       const container = new NestContainer();
       const moduleCtor = class TestModule {};
       const ctx = STATIC_CONTEXT;
-      const module = await container.addModule(moduleCtor, []);
+      const { moduleRef } = await container.addModule(moduleCtor, []);
 
-      module.addProvider({
+      moduleRef.addProvider({
         provide: TestClass,
         useClass: TestClass,
       });
 
       const instance = await injector.loadPerContext(
         new TestClass(),
-        module,
-        module.providers,
+        moduleRef,
+        moduleRef.providers,
         ctx,
       );
       expect(instance).to.be.instanceOf(TestClass);

packages/core/test/inspector/graph-inspector.spec.ts

@@ -129,7 +129,7 @@ describe('GraphInspector', () => {
     class RandomPipe {}
 
     it('should inspect all modules', async () => {
-      const moduleRef = await container.addModule(TestModule, []);
+      const { moduleRef } = await container.addModule(TestModule, []);
       moduleRef.addController(AController);
 
       const subtype = 'interceptor';

packages/core/test/nest-application-context.spec.ts

@@ -1,12 +1,12 @@
 import { InjectionToken, Scope } from '@nestjs/common';
 import { expect } from 'chai';
+import * as sinon from 'sinon';
 import { ContextIdFactory } from '../helpers/context-id-factory';
 import { NestContainer } from '../injector/container';
 import { Injector } from '../injector/injector';
 import { InstanceLoader } from '../injector/instance-loader';
 import { GraphInspector } from '../inspector/graph-inspector';
 import { NestApplicationContext } from '../nest-application-context';
-import * as sinon from 'sinon';
 
 describe('NestApplicationContext', () => {
   class A {}
@@ -22,15 +22,15 @@ describe('NestApplicationContext', () => {
       injector,
       new GraphInspector(nestContainer),
     );
-    const module = await nestContainer.addModule(class T {}, []);
+    const { moduleRef } = await nestContainer.addModule(class T {}, []);
 
     nestContainer.addProvider(
       {
         provide: injectionKey,
         useClass: A,
         scope,
       },
-      module.token,
+      moduleRef.token,
     );
 
     nestContainer.addInjectable(
@@ -39,7 +39,7 @@ describe('NestApplicationContext', () => {
         useClass: A,
         scope,
       },
-      module.token,
+      moduleRef.token,
       'interceptor',
     );