Overide providers from imported module (not in testing context) about nest

[KostyaTretyak]

First of all, I agree with you that it's confusing, but it looks like I can understand why it happens.
Try running the following code:

import { NestFactory } from '@nestjs/core';
import { Inject, Module } from '@nestjs/common';

const tokenSymbol = Symbol('Some-Token');

@Module({
  providers: [{ provide: tokenSymbol, useValue: 'Batman' }],
  exports: [tokenSymbol],
})
class FirstModule {}

@Module({
  imports: [FirstModule],
  providers: [{ provide: tokenSymbol, useValue: 'Robin' }],
})
class SecondModule {
  constructor(@Inject(tokenSymbol) public batmanOrRobin: string) {}
}

async function bootstrap() {
  const app = await NestFactory.create(SecondModule);
  const value1 = app.get(tokenSymbol);
  console.log('per application:', value1);
  const value2 = app.get(SecondModule);
  console.log('per module:', value2.batmanOrRobin);
}
bootstrap();

This code prints the following values to the console:

per application: Batman
per module: Robin

The app.get(tokenSymbol) method returns the application-level provider value. First, Nest at the application level adds a provider with tokenSymbol taking the value from the SecondModule (Robin), and then this value is replaced by the value that is written in the FirstModule (Batman).

So the value returned by the Nest DI container depends on the scope.

[chandu]

Finally was able to make the tests pass (used select method of the NestApplication to set a module context).
I assumed the NestFactory.create would simulate something similar to select method for the root module passed as arg automatically, but apparently not.

  describe('Can override a provider imported via a module', () => {
    it('should work', async () => {
      @Module({
        providers: [{ provide: tokenSymbol, useValue: 'Batman' }],
      })
      class FirstModule {}

      @Module({
        imports: [FirstModule],
        providers: [
          {
            provide: tokenSymbol,
            useFactory() {
              return 'Robin';
            },
          },
        ],
        exports: [tokenSymbol],
      })
      class SecondModule {}

      let app: INestApplication | null = null;
      try {
        app = await NestFactory.create(SecondModule, {
          logger: false,
        });

        const selectedApp = app.select(SecondModule);

        const value = selectedApp.get(tokenSymbol, {
          strict: true,
        });
        expect(value).toEqual('Robin');
      } finally {
        app?.close();
      }
    });
  });

[KostyaTretyak]

By the way, you don't even export any providers from FirstModule. It seems that the problem is only observed in your tests. In the real application, everything works as you would expect:

import { NestFactory } from '@nestjs/core';
import { Controller, Get, Inject, Module } from '@nestjs/common';

const tokenSymbol = Symbol('Some-Token');

@Module({
  providers: [{ provide: tokenSymbol, useValue: 'Batman' }],
  exports: [tokenSymbol],
})
class FirstModule {}

@Controller()
export class FirstController {
  constructor(@Inject(tokenSymbol) private batmanOrRobin: string) {}

  @Get()
  getHello(): string {
    return this.batmanOrRobin;
  }
}

@Module({
  imports: [FirstModule],
  providers: [{ provide: tokenSymbol, useValue: 'Robin' }],
  controllers: [FirstController],
})
class SecondModule {}

@Module({
  imports: [SecondModule],
})
export class AppModule {}

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  await app.listen(3000);
}
bootstrap();

[chandu]

By the way, you don't even export any providers from FirstModule. It seems that the problem is only observed in your tests. In the real application, everything works as you would expect:

import { NestFactory } from '@nestjs/core';
import { Controller, Get, Inject, Module } from '@nestjs/common';

const tokenSymbol = Symbol('Some-Token');

@Module({
  providers: [{ provide: tokenSymbol, useValue: 'Batman' }],
  exports: [tokenSymbol],
})
class FirstModule {}

@Controller()
export class FirstController {
  constructor(@Inject(tokenSymbol) private batmanOrRobin: string) {}

  @Get()
  getHello(): string {
    return this.batmanOrRobin;
  }
}

@Module({
  imports: [FirstModule],
  providers: [{ provide: tokenSymbol, useValue: 'Robin' }],
  controllers: [FirstController],
})
class SecondModule {}

@Module({
  imports: [SecondModule],
})
export class AppModule {}

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  await app.listen(3000);
}
bootstrap();

I have updated my test to use NestFactory.create and it's still failing.
I have pushed the changes I have done to : https://github.com/chandu/nest-override-modules
Speciafically, https://github.com/chandu/nest-override-modules/blob/main/src/override.spec.ts#L38

[chandu]

Thanks @KostyaTretyak . Yes, I have run a similar check and am able to verify the returned values.
I think the root cause of my confusion is aroud how the NestApplication instance behaves w.r.t to the root module.
What still surprises me is the app is able to resolve a provider from FirstModule even when it is not exported and the FirstModule is not used as a root module.