Shared modules in NestJS - Mini Project: Build & Apply

Creating and Using Shared Modules in NestJS

📖 Scenario: You are building a NestJS application that needs to share a simple service across multiple modules. To avoid repeating code, you will create a shared module that exports this service so other modules can use it easily.

🎯 Goal: Build a shared module in NestJS that provides a LoggerService. Then import this shared module into another module to use the LoggerService.

📋 What You'll Learn

Create a LoggerService class with a method log(message: string) that logs messages.

Create a SharedModule that provides and exports LoggerService.

Create a FeatureModule that imports SharedModule.

Inject LoggerService into a service inside FeatureModule and use its log method.

💡 Why This Matters

🌍 Real World

Shared modules are common in real NestJS apps to provide reusable services like logging, configuration, or database access across many parts of the app.

💼 Career

Understanding shared modules is essential for building scalable and maintainable backend applications with NestJS, a popular framework used in many companies.

1

Create the LoggerService

Create a class called LoggerService with a method log(message: string) that logs the message to the console using console.log.

NestJS

# Create LoggerService class with log method
# Your code here

Hint

Use console.log inside the log method to print the message.

2

Create SharedModule that provides and exports LoggerService

Create a NestJS module called SharedModule that provides and exports the LoggerService. Use the @Module decorator with providers and exports arrays containing LoggerService.

NestJS

export class LoggerService {
  log(message: string) {
    console.log(message);
  }
}

// Create SharedModule with @Module decorator
// Your code here

Hint

Use @Module decorator from @nestjs/common and include LoggerService in both providers and exports.

3

Create FeatureModule that imports SharedModule

Create a NestJS module called FeatureModule that imports the SharedModule. Use the @Module decorator with an imports array containing SharedModule.

NestJS

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

export class LoggerService {
  log(message: string) {
    console.log(message);
  }
}

@Module({
  providers: [LoggerService],
  exports: [LoggerService]
})
export class SharedModule {}

// Create FeatureModule that imports SharedModule
// Your code here

Hint

Use @Module decorator and add SharedModule to the imports array.

4

Inject LoggerService into a service in FeatureModule and use it

Create a service class called FeatureService inside FeatureModule. Inject LoggerService in its constructor and call this.logger.log('FeatureService initialized') inside the constructor.

NestJS

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

export class LoggerService {
  log(message: string) {
    console.log(message);
  }
}

@Module({
  providers: [LoggerService],
  exports: [LoggerService]
})
export class SharedModule {}

@Module({
  imports: [SharedModule]
})
export class FeatureModule {}

// Create FeatureService that injects LoggerService and logs a message
// Your code here

Hint

Use @Injectable() on FeatureService, inject LoggerService in the constructor, and call log method.

Practice

1. What is the main purpose of a Shared Module in NestJS?

easy

A. To define database entities

B. To create a new controller for handling requests

C. To share providers and services across multiple modules

D. To configure middleware for the application

Solution

1. Step 1: Understand the role of Shared Modules

   Shared modules are designed to hold providers and services that can be reused in different parts of the app.

2. Step 2: Compare with other module roles

   Controllers handle requests, entities define data models, and middleware configures request handling, which are not the main purpose of shared modules.

3. Final Answer:

   To share providers and services across multiple modules -> Option C

4. Quick Check:

   Shared modules = share providers [OK]

Hint: Shared modules share providers, not controllers or entities [OK]

Common Mistakes:

• Confusing shared modules with controllers
• Thinking shared modules define database entities
• Assuming shared modules configure middleware

2. Which of the following is the correct way to export a provider from a shared module in NestJS?

easy

A. Add the provider to the exports array in the module decorator

B. Add the provider to the controllers array

C. Add the provider to the imports array

D. Add the provider to the bootstrap array

Solution

1. Step 1: Recall module decorator properties

   Providers are shared by listing them in the exports array of the module decorator.

2. Step 2: Understand other arrays

   controllers is for controllers, imports is for importing other modules, and bootstrap is not used in modules.

3. Final Answer:

   Add the provider to the exports array in the module decorator -> Option A

4. Quick Check:

   Export providers via exports array [OK]

Hint: Use exports array to share providers [OK]

Common Mistakes:

• Putting providers in controllers array
• Confusing imports with exports
• Using bootstrap array which doesn't exist in modules

3. Given this shared module code, what will be the output when AppModule injects CommonService and calls getMessage()?

import { Module } from '@nestjs/common';
import { CommonService } from './common.service';

@Module({
  providers: [CommonService],
  exports: [CommonService],
})
export class SharedModule {}

// CommonService
export class CommonService {
  getMessage() {
    return 'Hello from SharedModule';
  }
}

// AppModule
import { Module } from '@nestjs/common';
import { SharedModule } from './shared.module';

@Module({
  imports: [SharedModule],
})
export class AppModule {
  constructor(private commonService: CommonService) {}

  printMessage() {
    console.log(this.commonService.getMessage());
  }
}

medium

A. Error: CommonService not found

B. Undefined

C. Hello from SharedModule

D. Hello from AppModule

Solution

1. Step 1: Check provider export and import

   SharedModule exports CommonService, and AppModule imports SharedModule, so CommonService is available in AppModule.

2. Step 2: Understand service method call

   Calling getMessage() returns the string 'Hello from SharedModule'.

3. Final Answer:

   Error: CommonService not found -> Option A

4. Quick Check:

   Service must be injected via constructor and registered as provider [OK]

Hint: Import shared module to access exported services [OK]

Common Mistakes:

• Forgetting to export the provider
• Not importing the shared module in AppModule
• Assuming service returns undefined

4. Identify the error in this shared module setup:

import { Module } from '@nestjs/common';
import { LoggerService } from './logger.service';

@Module({
  providers: [LoggerService],
  imports: [LoggerService],
  exports: [LoggerService],
})
export class LoggerModule {}

medium

A. LoggerService must be declared as a global provider

B. LoggerService should not be in the imports array

C. LoggerService should not be exported

D. LoggerService must be in controllers array

Solution

1. Step 1: Review module decorator arrays

   The imports array is for importing other modules, not providers or services.

2. Step 2: Identify correct placement

   LoggerService should be in providers and exports, but not in imports.

3. Final Answer:

   LoggerService should not be in the imports array -> Option B

4. Quick Check:

   Imports array = modules only [OK]

Hint: Imports array only accepts modules, not providers [OK]

Common Mistakes:

• Putting providers in imports array
• Confusing controllers with providers
• Thinking exports are optional for sharing

5. You have two modules, FeatureModule and SharedModule. SharedModule exports UtilityService. You want FeatureModule to use UtilityService and also export it for other modules. How should you configure FeatureModule to achieve this?

hard

A. Import SharedModule and add UtilityService to FeatureModule controllers

B. Only import SharedModule in FeatureModule, no exports needed

C. Declare UtilityService again in FeatureModule providers and exports

D. Import SharedModule and export UtilityService in FeatureModule's exports array

Solution

1. Step 1: Import SharedModule in FeatureModule

   To use UtilityService, FeatureModule must import SharedModule which exports it.

2. Step 2: Export UtilityService from FeatureModule

   To share UtilityService further, FeatureModule must export it in its exports array.

3. Final Answer:

   Import SharedModule and export UtilityService in FeatureModule's exports array -> Option D

4. Quick Check:

   Import then export to re-share service [OK]

Hint: Import then export shared service to re-share it [OK]

Common Mistakes:

• Not exporting UtilityService from FeatureModule
• Re-declaring UtilityService providers unnecessarily
• Adding services to controllers array