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.

Practice

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

easy

A. To share modules through another module for better organization

B. To create multiple instances of the same module

C. To prevent modules from being imported anywhere

D. To automatically generate services inside a module

Solution

1. Step 1: Understand module re-exporting concept

   Module re-exporting allows one module to share its imported modules with other modules by re-exporting them.

2. Step 2: Identify the purpose in NestJS

   This helps keep the app organized and makes modules easier to maintain by avoiding repeated imports.

3. Final Answer:

   To share modules through another module for better organization -> Option A

4. Quick Check:

   Module re-exporting = sharing modules [OK]

Hint: Re-exporting means sharing modules via another module [OK]

Common Mistakes:

• Thinking re-exporting creates new module instances
• Believing it blocks module imports
• Confusing it with automatic service generation

2. Which syntax correctly re-exports a module named SharedModule inside another module's decorator?

easy

A. @Module({ exports: [SharedModule] })

B. @Module({ imports: [], exports: [SharedModule] })

C. @Module({ imports: [SharedModule] })

D. @Module({ imports: [SharedModule], exports: [SharedModule] })

Solution

1. Step 1: Recall NestJS module decorator structure

   To re-export a module, it must be both imported and exported in the module decorator.

2. Step 2: Check each option

   The syntax with both imports: [SharedModule] and exports: [SharedModule] is correct. Syntaxes missing either array are incorrect.

3. Final Answer:

   @Module({ imports: [SharedModule], exports: [SharedModule] }) -> Option D

4. Quick Check:

   Import and export to re-export [OK]

Hint: Re-export needs both imports and exports arrays [OK]

Common Mistakes:

• Only exporting without importing
• Only importing without exporting
• Leaving either array empty when re-exporting

3. Given these modules, what will be the output of console.log(appModuleImports) if AppModule imports CoreModule which re-exports SharedModule?

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

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

Assuming appModuleImports is the list of modules available inside AppModule.

medium

A. [SharedModule]

B. [CoreModule, SharedModule]

C. [CoreModule]

D. []

Solution

1. Step 1: Understand re-export effect on imports

   CoreModule imports and exports SharedModule, so any module importing CoreModule also gets SharedModule.

2. Step 2: Analyze AppModule imports

   AppModule imports CoreModule, so it has access to both CoreModule and SharedModule.

3. Final Answer:

   [CoreModule, SharedModule] -> Option B

4. Quick Check:

   Re-exported modules appear in importing module imports [OK]

Hint: Re-exported modules appear as if directly imported [OK]

Common Mistakes:

• Assuming only CoreModule is available
• Thinking SharedModule is hidden
• Ignoring exports array effect

4. Identify the error in this module re-exporting code:

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

medium

A. SharedModule is imported but not exported, so it is not re-exported

B. SharedModule should not be in imports when re-exporting

C. exports array cannot be empty in any module

D. CoreModule must import AppModule to re-export SharedModule

Solution

1. Step 1: Check imports and exports arrays

   SharedModule is imported but not exported, so CoreModule does not re-export it.

2. Step 2: Understand re-export requirement

   To re-export a module, it must be listed in both imports and exports arrays.

3. Final Answer:

   SharedModule is imported but not exported, so it is not re-exported -> Option A

4. Quick Check:

   Re-export needs both imports and exports [OK]

Hint: Exports must include imported modules to re-export [OK]

Common Mistakes:

• Leaving exports empty when re-exporting
• Confusing imports-only as re-export
• Thinking exports array is optional

5. You have three modules: SharedModule, CoreModule, and FeatureModule. CoreModule imports and re-exports SharedModule. FeatureModule imports CoreModule. How can you modify FeatureModule to also re-export SharedModule without importing it directly?

hard

A. Add imports: [SharedModule] in FeatureModule

B. Add exports: [SharedModule] in FeatureModule

C. Add exports: [CoreModule] in @Module decorator of FeatureModule

D. Add providers: [SharedModule] in FeatureModule

Solution

1. Step 1: Understand re-export chaining

   FeatureModule imports CoreModule, which re-exports SharedModule, so FeatureModule has access to SharedModule.

2. Step 2: Re-export SharedModule via CoreModule

   To re-export SharedModule from FeatureModule without importing it directly, FeatureModule must export CoreModule.

3. Final Answer:

   Add exports: [CoreModule] in @Module decorator of FeatureModule -> Option C

4. Quick Check:

   Export imported module to re-export its exports [OK]

Hint: Export imported module to re-export its exports [OK]

Common Mistakes:

• Trying to export SharedModule without importing it
• Adding SharedModule to providers array
• Importing SharedModule directly instead of re-exporting