How to read environment variables inside the app module import statement?

Question

I have created a module called DmaModule, and expect the consumer of it to pass in some options into it during its instantiation. These options are dmaHost, superadminUsername, and superadminPassword. In order for me to get these options, I have to grab them from the environment variables.

I want to pass them as options, and I don't want to read them as environment variables inside the module.

Here is my AppModule:

import { Module } from '@nestjs/common';
import { DmaModule } from '@app/dma';
import { ConfigModule, ConfigService } from '@nestjs/config';
@Module({
  imports: [
    ConfigModule.forRoot({
      isGlobal: true, // Makes the ConfigModule globally available
      envFilePath: `.env.${process.env.NODE_ENV}`,
    }),
    DmaModule.forRootAsync({
      inject: [ConfigService],
      imports: [ConfigModule],
      useFactory: (config: ConfigService) => ({
        dmaHost: config.get<string>('DMA_HOST'),
        superadminUsername: config.get<string>('DMA_SUPERADMIN_USERNAME'),
        superadminPassword: config.get<string>('DMA_SUPERADMIN_PASSWORD'),
      }),
    }),
  ],
  controllers: [],
  providers: [],
})
export class AppModule {}

And here is my DmaModule:

import { DynamicModule, Module } from '@nestjs/common';
import { DmaClientProvider } from './providers/dma-client-provider/dma-client-provider';

export const DMA_PROPS_TOKEN = 'DMA_MODULE_OPTIONS';

export interface DmaModuleProps {
  dmaHost: string;
  superadminUsername: string;
  superadminPassword: string;
}

interface RootOptions {
  imports: any[];
  inject: any[];
  useFactory: (...args: any[]) => DmaModuleProps;
}

@Module({
  imports: [],
  providers: [DmaClientProvider], // << 👈 take a look here
  exports: [],
})
export class DmaModule {
  static forRootAsync(options: RootOptions): DynamicModule {
    return {
      module: DmaModule,
      providers: [
        {
          provide: DMA_PROPS_TOKEN,
          useFactory: options.useFactory,
          inject: options.inject,
        },
      ],
      exports: [DMA_PROPS_TOKEN],
    };
  }
}

I want now to start using these options passed to the DmaModule and be able to give them to the services and providers listed under the DmaModule.

So I have a provider called DmaClientProvider, and I want to simply console.log() the options passed from the AppModule down to the DmaModule inside of the DmaClientProvider.

Here is my DmaClientProvider code:

import { Inject, Injectable } from '@nestjs/common';
import { DMA_PROPS_TOKEN, DmaModuleProps } from '@app/dma/dma.module';

@Injectable()
export class DmaClientProvider {
  constructor(
    @Inject(DMA_PROPS_TOKEN) private readonly options: DmaModuleProps,
  ) {
    console.log(options);
  }
}

I thought it will work, but I am getting this error:

╰─>$ npm run start:dev                                                                                                                                               20:02:11

> [email protected] start:dev
> cross-env NODE_ENV=development nest start --watch


 Info  Webpack is building your sources...

webpack 5.92.1 compiled successfully in 408 ms
Type-checking in progress...
[Nest] 290429  - 07/12/2024, 8:02:17 PM     LOG [NestFactory] Starting Nest application...
[Nest] 290429  - 07/12/2024, 8:02:17 PM     LOG [InjectorLogger] Nest encountered an undefined dependency. This may be due to a circular import or a missing dependency declaration.
[Nest] 290429  - 07/12/2024, 8:02:17 PM   ERROR [ExceptionHandler] Nest can't resolve dependencies of the DmaClientProvider (?). Please make sure that the argument dependency at index [0] is available in the DmaModule context.

Potential solutions:
- Is DmaModule a valid NestJS module?
- If dependency is a provider, is it part of the current DmaModule?
- If dependency is exported from a separate @Module, is that module imported within DmaModule?
  @Module({
    imports: [ /* the Module containing dependency */ ]
  })

Error: Nest can't resolve dependencies of the DmaClientProvider (?). Please make sure that the argument dependency at index [0] is available in the DmaModule context.

Potential solutions:
- Is DmaModule a valid NestJS module?
- If dependency is a provider, is it part of the current DmaModule?
- If dependency is exported from a separate @Module, is that module imported within DmaModule?
  @Module({
    imports: [ /* the Module containing dependency */ ]
  })

Here is my folder structure:

╰─>$ tree -I node_modules/                                                                                                                                           21:16:25
.
├── dist
│   └── main.js
├── libs
│   └── dma
│       ├── src
│       │   ├── dma.module.ts
│       │   ├── dma.service.spec.ts
│       │   ├── dma.service.ts
│       │   ├── index.ts
│       │   ├── modules
│       │   │   ├── dma-user-groups
│       │   │   │   ├── dma-user-groups.module.ts
│       │   │   │   ├── dma-user-groups.service.spec.ts
│       │   │   │   └── dma-user-groups.service.ts
│       │   │   └── dma-users
│       │   │       ├── dma-users.module.ts
│       │   │       ├── dma-users.service.spec.ts
│       │   │       └── dma-users.service.ts
│       │   └── providers
│       │       └── dma-client-provider
│       │           ├── dma-client-provider.spec.ts
│       │           ├── dma-client-provider.ts
│       │           └── dmaEndpoints.ts
│       └── tsconfig.lib.json
├── nest-cli.json
├── package.json
├── package-lock.json
├── README.md
├── src
│   ├── app.controller.spec.ts
│   ├── app.controller.ts
│   ├── app.module.ts
│   ├── app.service.ts
│   └── main.ts
├── test
│   ├── app.e2e-spec.ts
│   └── jest-e2e.json
├── tsconfig.build.json
└── tsconfig.json

11 directories, 28 files

Answer 1

The solution was to simply use the name of the token litrally, and not to import it, I don't know why, if someone knows please let me know in the comments so I can update my answer.

I needed to change the

import { DMA_PROPS_TOKEN, DmaModuleProps } from '@app/dma/dma.module
// ...
@Inject(DMA_PROPS_TOKEN) private readonly options: DmaModuleProps

to

import { DMA_PROPS_TOKEN, DmaModuleProps } from '@app/dma/dma.module
// ...
@Inject("DMA_PROPS_TOKEN") private readonly options: DmaModuleProps