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/lazy-module-loader.ts

@@ -21,9 +21,10 @@ export class LazyModuleLoader {
       | DynamicModule,
   ): Promise<ModuleRef> {
     const moduleClassOrDynamicDefinition = await loaderFn();
-    const moduleInstances = await this.dependenciesScanner.scanForModules(
-      moduleClassOrDynamicDefinition,
-    );
+    const moduleInstances =
+      await this.dependenciesScanner.scanForModulesForLazyModules(
+        moduleClassOrDynamicDefinition,
+      );
     if (moduleInstances.length === 0) {
       // The module has been loaded already. In this case, we must
       // retrieve a module reference from the existing container.

packages/core/scanner.ts

@@ -77,6 +77,18 @@ export class DependenciesScanner {
     this.container.bindGlobalScope();
   }
 
+  public async scanForModulesForLazyModules(
+    moduleDefinition: Type<unknown> | DynamicModule,
+  ): Promise<Module[]> {
+    const modules = await this.scanForModules(moduleDefinition);
+    // We need to bind global scope to the lazy module because the bind phase happens before it was created
+    // The only one we need to bind is the actual module we are scanning the dependencies for,
+    // this modules is the first element in the modules list comming from the scan
+    this.container.bindGlobalsToImports(modules[0]);
+
+    return modules;
+  }
+
   public async scanForModules(
     moduleDefinition:
       | ForwardReference