Module re-exporting in NestJS - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

What is the main purpose of module re-exporting in NestJS?

In NestJS, why would you use module re-exporting?

A To automatically generate controllers for all imported modules

B To duplicate providers across multiple modules for better performance

C To prevent any module from accessing shared services

D To allow other modules to access providers from a module without importing it directly

💡 Hint

Think about how to share services without importing every module everywhere.

Module re-exporting lets a module export providers it imports, so other modules can access them by importing only the re-exporting module.

❓ component_behavior

intermediate

What will be the output when accessing a service from a re-exported module?

Given the following NestJS modules, what will happen when AppModule injects SharedService?

NestJS

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

@Injectable()
export class SharedService {
  getMessage() {
    return 'Hello from SharedService';
  }
}

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

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

@Module({
  imports: [CoreModule],
})
export class AppModule {
  constructor(private sharedService: SharedService) {}
  getMessage() {
    return this.sharedService.getMessage();
  }
}

A 'Hello from SharedService' will be returned successfully

B A runtime error because SharedService is not provided in AppModule

C A compile-time error due to missing provider in CoreModule

D AppModule will create a new instance of SharedService ignoring CoreModule

💡 Hint

Consider how exports and imports work in NestJS modules.

CoreModule imports and re-exports SharedModule, which exports SharedService. AppModule imports CoreModule, so it can inject SharedService successfully.

📝 Syntax

advanced

Identify the correct way to re-export a module in NestJS

Which of the following code snippets correctly re-exports SharedModule inside CoreModule?

A

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

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

B

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

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

C

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

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

D

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

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

💡 Hint

Remember that to re-export a module, it must be both imported and exported.

To re-export a module, you must list it in both imports and exports arrays of the @Module decorator.

🔧 Debug

advanced

Why does injecting a re-exported service cause a runtime error?

Consider these modules:

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

@Injectable()
export class ServiceA {}

@Module({
  providers: [ServiceA],
})
export class ModuleA {}

@Module({
  imports: [ModuleA],
  exports: [ModuleA],
})
export class ModuleB {}

@Module({
  imports: [ModuleB],
})
export class AppModule {
  constructor(private serviceA: ServiceA) {}
}

Why does NestJS throw a runtime error that ServiceA is not available in AppModule?

A Because ServiceA is not decorated with @Injectable()

B Because ModuleB forgot to import ServiceA directly

C Because ModuleA does not export ServiceA, so ModuleB cannot re-export it

D Because AppModule must import ModuleA directly to access ServiceA

💡 Hint

Check what each module exports and imports.

ModuleA provides ServiceA but does not export it. ModuleB imports and exports ModuleA, but since ServiceA is not exported by ModuleA, it is not available to ModuleB or AppModule.

❓ state_output

expert

What is the number of instances created for a re-exported provider?

Given these modules and service, how many instances of SingletonService will be created when AppModule injects it?

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

@Injectable()
export class SingletonService {
  id = Math.random();
}

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

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

@Module({
  imports: [CoreModule, SharedModule],
})
export class AppModule {
  constructor(public coreService: SingletonService, public sharedService: SingletonService) {}
}

How many different instances of SingletonService exist in AppModule?

A One instance shared between coreService and sharedService

B Two separate instances, one for each injection

C Zero instances because of circular imports

D Three instances due to multiple imports

💡 Hint

Think about how NestJS handles singleton providers across modules.

Even though SharedModule is imported twice (directly and via CoreModule), NestJS creates only one instance of SingletonService because providers are singletons within the application context.