Dynamic modules in NestJS - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What is the output of this dynamic module registration?

Consider this NestJS dynamic module code. What will be the value of ConfigService.get('mode') after importing ConfigModule.forRoot({ mode: 'production' }) in the root module?

NestJS

import { Module, DynamicModule } from '@nestjs/common';

@Module({})
export class ConfigModule {
  static forRoot(options: { mode: string }): DynamicModule {
    return {
      module: ConfigModule,
      providers: [
        {
          provide: 'CONFIG_OPTIONS',
          useValue: options,
        },
        {
          provide: ConfigService,
          useFactory: (opts) => new ConfigService(opts.mode),
          inject: ['CONFIG_OPTIONS'],
        },
      ],
      exports: [ConfigService],
    };
  }
}

export class ConfigService {
  constructor(private mode: string) {}
  get(key: string) {
    if (key === 'mode') return this.mode;
    return null;
  }
}

A 'production'

B 'development'

C undefined

D null

💡 Hint

Look at how the ConfigService is created using the useFactory and what value is passed from forRoot.

The ConfigModule.forRoot method receives an options object with mode: 'production'. This value is provided as CONFIG_OPTIONS. The ConfigService is created using a factory that receives these options and sets the mode property. So, calling get('mode') returns 'production'.

📝 Syntax

intermediate

Which option correctly defines a dynamic module with async configuration?

You want to create a dynamic module that loads configuration asynchronously. Which code snippet correctly implements forRootAsync in NestJS?

A

static forRootAsync(options: { useFactory: () => Promise<{ apiKey: string }> }): DynamicModule {
  return {
    module: ConfigModule,
    providers: [
      {
        provide: 'CONFIG_OPTIONS',
        useFactory: options.useFactory,
        inject: ['CONFIG_OPTIONS'],
      },
      ConfigService,
    ],
    exports: [ConfigService],
  };
}

B

static forRootAsync(options: { useFactory: () => Promise<{ apiKey: string }> }): DynamicModule {
  return {
    module: ConfigModule,
    providers: [
      {
        provide: 'CONFIG_OPTIONS',
        useFactory: options.useFactory,
      },
      ConfigService,
    ],
    exports: [ConfigService],
  };
}

C

static forRootAsync(options: { useFactory: () => Promise<{ apiKey: string }> }): DynamicModule {
  return {
    module: ConfigModule,
    providers: [
      {
        provide: 'CONFIG_OPTIONS',
        useValue: options.useFactory(),
      },
      ConfigService,
    ],
    exports: [ConfigService],
  };
}

D

static forRootAsync(options: { useFactory: () => Promise<{ apiKey: string }> }): DynamicModule {
  return {
    module: ConfigModule,
    providers: [
      {
        provide: 'CONFIG_OPTIONS',
        useFactory: options.useFactory,
        inject: [],
      },
      {
        provide: ConfigService,
        useFactory: async (opts) => new ConfigService((await opts).apiKey),
        inject: ['CONFIG_OPTIONS'],
      },
    ],
    exports: [ConfigService],
  };
}

💡 Hint

Remember that async factories require useFactory with async and proper injection.

Option D correctly uses useFactory with async and injects CONFIG_OPTIONS to create ConfigService. It awaits the promise returned by the factory. Other options either misuse useValue with a promise or have wrong injection.

🔧 Debug

advanced

Why does this dynamic module cause a runtime error?

Given this dynamic module code, why does NestJS throw a runtime error about missing provider for 'API_KEY'?

NestJS

import { Module, DynamicModule, Injectable, Inject } from '@nestjs/common';

@Module({})
export class ApiModule {
  static forRoot(apiKey: string): DynamicModule {
    return {
      module: ApiModule,
      providers: [
        {
          provide: 'API_KEY',
          useValue: apiKey,
        },
        ApiService,
      ],
      exports: [ApiService],
    };
  }
}

@Injectable()
export class ApiService {
  constructor(@Inject('API_KEY') private readonly key: string) {}
}

A The 'API_KEY' provider is missing from the providers array.

B The ApiService constructor parameter is not decorated with @Inject('API_KEY'), so Nest cannot inject the value.

C The dynamic module does not export 'API_KEY', so it cannot be injected.

D The ApiService class is not decorated with @Injectable(), so it cannot be instantiated.

💡 Hint

Check how NestJS matches constructor parameters to providers.

In NestJS, to inject a custom provider like 'API_KEY' into a constructor parameter, you must use the @Inject('API_KEY') decorator. Without it, Nest cannot resolve the dependency and throws an error. The other options are incorrect because the provider exists and ApiService is injectable by default if decorated.

🧠 Conceptual

advanced

What is the main benefit of using dynamic modules in NestJS?

Why would a developer choose to use dynamic modules instead of static modules in NestJS?

A To automatically generate REST endpoints without writing controllers.

B To improve runtime performance by compiling modules ahead of time.

C To allow modules to be configured with different parameters at import time, enabling reusable and customizable modules.

D To enable modules to be lazy-loaded only when needed by the application.

💡 Hint

Think about how dynamic modules accept parameters and change behavior.

Dynamic modules allow passing configuration options when importing them, so the same module can behave differently depending on the parameters. This makes modules reusable and flexible. The other options describe unrelated features.

❓ state_output

expert

What is the value of service.getValue() after this dynamic module setup?

Given the following NestJS dynamic module and service, what will service.getValue() return after importing ExampleModule.forFeature({ value: 42 })?

NestJS

import { Module, DynamicModule, Injectable, Inject } from '@nestjs/common';

@Injectable()
export class ExampleService {
  constructor(@Inject('FEATURE_OPTIONS') private options: { value: number }) {}
  getValue() {
    return this.options.value;
  }
}

@Module({})
export class ExampleModule {
  static forFeature(options: { value: number }): DynamicModule {
    return {
      module: ExampleModule,
      providers: [
        {
          provide: 'FEATURE_OPTIONS',
          useValue: options,
        },
        ExampleService,
      ],
      exports: [ExampleService],
    };
  }
}

A 42

B Throws a runtime error due to missing provider

C null

D undefined

💡 Hint

Check how the service receives the injected options and what value is passed.

The ExampleModule.forFeature method provides FEATURE_OPTIONS with { value: 42 }. The ExampleService injects this and returns options.value, which is 42.