Dynamic modules in NestJS - Mini Project: Build & Apply

Creating a Dynamic Module in NestJS

📖 Scenario: You are building a NestJS application that needs a configurable logging module. This module should allow different parts of the app to use it with custom settings.

🎯 Goal: Create a dynamic module called LoggerModule that accepts a configuration object with a logLevel property. This module should provide a LoggerService that uses the configured logLevel.

📋 What You'll Learn

Create a LoggerModule class with a static forRoot method that accepts a config object with logLevel string property.

Inside forRoot, return a dynamic module with module, providers, and exports properties.

Create a LoggerService class that uses the injected logLevel to control logging.

Use NestJS dependency injection to provide the logLevel value to LoggerService.

💡 Why This Matters

🌍 Real World

Dynamic modules let you build reusable NestJS modules that can be configured differently in various parts of your app, like database connections or logging.

💼 Career

Understanding dynamic modules is essential for building scalable and maintainable NestJS applications in professional backend development.

1

Create the LoggerModule class with forRoot method

Create a class called LoggerModule with a static method forRoot that accepts a parameter options of type { logLevel: string }. The method should return an object with a module property set to LoggerModule.

NestJS

class LoggerModule {
  // Your code here
}

Hint

Define a class and a static method that returns an object with a module property.

2

Add provider for logLevel token

Inside the forRoot method of LoggerModule, add a providers array to the returned object. This array should contain an object with provide set to 'LOG_LEVEL' and useValue set to options.logLevel. Also add exports array with 'LOG_LEVEL'.

NestJS

class LoggerModule {
  static forRoot(options: { logLevel: string }) {
    return {
      module: LoggerModule,
      // Your code here
    };
  }
}

Hint

Add providers and exports arrays to the returned object in forRoot.

3

Create LoggerService using injected logLevel

Create a class called LoggerService with a constructor that injects logLevel using @Inject('LOG_LEVEL'). Store it in a private readonly property called logLevel. Add a method log that accepts a message string and logs it only if logLevel is not 'none'.

NestJS

class LoggerModule {
  static forRoot(options: { logLevel: string }) {
    return {
      module: LoggerModule,
      providers: [
        {
          provide: 'LOG_LEVEL',
          useValue: options.logLevel
        }
      ],
      exports: ['LOG_LEVEL']
    };
  }
}

// Your code here

Hint

Use @Inject('LOG_LEVEL') in the constructor to get the log level value.

4

Add LoggerService provider and export to LoggerModule

In the forRoot method of LoggerModule, add LoggerService to the providers array and also add it to the exports array.

NestJS

import { Inject } from '@nestjs/common';

class LoggerModule {
  static forRoot(options: { logLevel: string }) {
    return {
      module: LoggerModule,
      providers: [
        {
          provide: 'LOG_LEVEL',
          useValue: options.logLevel
        },
        // Add LoggerService provider here
      ],
      exports: ['LOG_LEVEL' /* Add LoggerService export here */]
    };
  }
}

class LoggerService {
  constructor(@Inject('LOG_LEVEL') private readonly logLevel: string) {}

  log(message: string) {
    if (this.logLevel !== 'none') {
      console.log(`[${this.logLevel}] ${message}`);
    }
  }
}

Hint

Add LoggerService to both providers and exports arrays in forRoot.

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