Shared modules in NestJS - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

How does a Shared Module affect service instances in NestJS?

Consider a NestJS Shared Module that exports a service. What happens to the service instance when this Shared Module is imported into multiple feature modules?

NestJS

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

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

// FeatureModuleA and FeatureModuleB both import SharedModule

A SharedService is not instantiated unless explicitly provided in each feature module.

B Each feature module gets its own separate instance of SharedService.

C SharedService instances are created per request in each feature module.

D All feature modules share the same single instance of SharedService.

💡 Hint

Think about how NestJS handles providers exported from a shared module.

Importing a non-global Shared Module into multiple feature modules shares the same instance of the providers because NestJS uses a single injector per application context.

📝 Syntax

intermediate

Correct way to define a Shared Module in NestJS

Which of the following code snippets correctly defines a Shared Module that exports a service for reuse?

A

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

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

B

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

@Module({
  imports: [SharedService],
  exports: [SharedService],
})
export class SharedModule {}

C

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

@Module({
  providers: [SharedService],
  imports: [SharedService],
})
export class SharedModule {}

D

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

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

💡 Hint

Remember that services must be listed as providers to be injectable.

Services must be declared in the providers array to be instantiated by NestJS. Exporting them makes them available to other modules.

🔧 Debug

advanced

Why does importing a Shared Module twice cause multiple instances?

Given a Shared Module imported into two different modules, why might you see multiple instances of a service instead of one?

NestJS

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

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

// AppModule imports SharedModule twice accidentally

A Because SharedService is not exported, so each module creates its own instance.

B Because the Shared Module is imported multiple times without being global, NestJS creates separate instances per import.

C Because SharedService is marked as transient, so new instances are created each time.

D Because the Shared Module is lazy loaded, causing multiple instances.

💡 Hint

Consider how NestJS handles module imports and singleton scope.

When a module is imported multiple times without being global, NestJS creates separate injector contexts, leading to multiple instances of providers.

❓ state_output

advanced

What is the output when a Shared Service maintains state across modules?

Consider a SharedService with a counter property incremented by two different feature modules. What will be the final counter value after both modules increment it once?

NestJS

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

@Injectable()
export class SharedService {
  counter = 0;
  increment() {
    this.counter++;
  }
}

// Both FeatureModuleA and FeatureModuleB import SharedModule which exports SharedService
// Each calls sharedService.increment() once

A 2

B 1

C 0

D Error: counter is undefined

💡 Hint

Think about whether the service instance is shared or duplicated.

Since the Shared Module is imported normally, the same instance of SharedService is shared across modules, so the counter increments twice.

🧠 Conceptual

expert

How to make a Shared Module globally available in NestJS?

Which approach correctly makes a Shared Module globally available so it does not need to be imported in every module?

A Declare the Shared Module inside main.ts bootstrap function.

B Use the 'global: true' option inside @Module decorator.

C Add @Global() decorator to the Shared Module and export the providers.

D Import the Shared Module in the root AppModule only.

💡 Hint

Check NestJS documentation about global modules.

Using the @Global() decorator marks the module as global, so its exported providers are available everywhere without explicit imports.