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.

Practice

1. What is the main purpose of a dynamic module in NestJS?

easy

A. To automatically generate database schemas

B. To create modules without any providers or exports

C. To replace the need for controllers in an application

D. To allow configuration of modules with custom options at runtime

Solution

1. Step 1: Understand dynamic module concept

   Dynamic modules let you pass custom options to configure the module when importing it.

2. Step 2: Identify the main purpose

   This flexibility helps reuse modules with different settings instead of hardcoding them.

3. Final Answer:

   To allow configuration of modules with custom options at runtime -> Option D

4. Quick Check:

   Dynamic modules = configurable modules [OK]

Hint: Dynamic modules customize modules with options [OK]

Common Mistakes:

• Thinking dynamic modules remove controllers
• Believing dynamic modules auto-generate schemas
• Assuming dynamic modules have no providers

2. Which of the following is the correct way to define a dynamic module method in NestJS?

easy

A. constructor(options: ModuleOptions): void { ... }

B. static forRoot(options: ModuleOptions): DynamicModule { ... }

C. export function createModule(options: ModuleOptions) { ... }

D. async initialize(options: ModuleOptions): Promise<void> { ... }

Solution

1. Step 1: Recall dynamic module pattern

   Dynamic modules use a static method, commonly named forRoot, returning a DynamicModule object.

2. Step 2: Match method signature

   Only a static method can be called without creating an instance, fitting the dynamic module pattern.

3. Final Answer:

   static forRoot(options: ModuleOptions): DynamicModule { ... } -> Option B

4. Quick Check:

   Dynamic module method = static forRoot [OK]

Hint: Dynamic modules use static forRoot method [OK]

Common Mistakes:

• Using constructor instead of static method
• Defining dynamic module as a normal function
• Making dynamic module method async without returning DynamicModule

3. Given this dynamic module code, what will be the value of the exported provider's token?

export class LoggerModule {
  static forRoot(prefix: string): DynamicModule {
    return {
      module: LoggerModule,
      providers: [
        { provide: 'LOGGER_PREFIX', useValue: prefix },
      ],
      exports: ['LOGGER_PREFIX'],
    };
  }
}

medium

A. 'prefix'

B. 'LoggerModule'

C. 'LOGGER_PREFIX'

D. 'useValue'

Solution

1. Step 1: Identify provider token

   The provider uses the key 'provide' with value 'LOGGER_PREFIX' which is the token for injection.

2. Step 2: Confirm exported token

   The exports array includes 'LOGGER_PREFIX', so this token is available outside the module.

3. Final Answer:

   'LOGGER_PREFIX' -> Option C

4. Quick Check:

   Provider token = 'LOGGER_PREFIX' [OK]

Hint: Provider token is the 'provide' string value [OK]

Common Mistakes:

• Confusing module name with provider token
• Using variable name 'prefix' as token
• Thinking useValue is the token

4. Identify the error in this dynamic module definition:

export class CacheModule {
  static forRoot(options: { ttl: number }): DynamicModule {
    return {
      module: CacheModule,
      providers: [
        { provide: 'CACHE_TTL', useFactory: (options) => options.ttl },
      ],
      exports: ['CACHE_TTL'],
    };
  }
}

medium

A. The useFactory function cannot access options parameter directly

B. The module property should be a string, not a class

C. Exports array must include providers, not strings

D. Static methods cannot return DynamicModule

Solution

1. Step 1: Analyze useFactory context

   The useFactory function runs later and cannot directly access the outer options variable without injection.

2. Step 2: Identify correct pattern

   To use options inside useFactory, it must be passed via inject or closure properly; direct access causes runtime error.

3. Final Answer:

   The useFactory function cannot access options parameter directly -> Option A

4. Quick Check:

   useFactory needs inject or closure for options [OK]

Hint: useFactory can't directly use outer variables [OK]

Common Mistakes:

• Thinking module property must be string
• Believing exports must list provider objects
• Assuming static methods can't return DynamicModule

5. You want to create a dynamic module that accepts a configuration object and provides two services using that config. Which approach correctly implements this pattern?

hard

A. Use a static forRoot method returning a DynamicModule with providers using useValue for config and export both services

B. Create a constructor in the module class that sets config and exports services directly

C. Define services inside the module without any configuration and import them normally

D. Use a global module without any providers and configure services externally

Solution

1. Step 1: Understand dynamic module pattern for config

   Dynamic modules use a static method (like forRoot) to accept config and return a DynamicModule object with providers.

2. Step 2: Provide config and services properly

   Use useValue or useFactory to inject config into providers, and export services to make them available outside.

3. Final Answer:

   Use a static forRoot method returning a DynamicModule with providers using useValue for config and export both services -> Option A

4. Quick Check:

   Dynamic module with static forRoot and providers = Use a static forRoot method returning a DynamicModule with providers using useValue for config and export both services [OK]

Hint: Use static forRoot with providers and exports [OK]

Common Mistakes:

• Trying to configure modules via constructor
• Not exporting services after providing them
• Using global module without providers for config