Global modules in NestJS - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What happens when a module is marked as global in NestJS?

Consider a NestJS module decorated with @Global(). What is the effect of this decorator on the module's providers?

NestJS

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

@Global()
@Module({
  providers: [MyService],
  exports: [MyService],
})
export class MyGlobalModule {}

A The providers are automatically available in all modules without needing to import this module.

B The providers are available only within this module and must be imported explicitly elsewhere.

C The providers are available globally but only if the module is imported in the root module.

D The providers are available globally but only if the module is imported in every module explicitly.

💡 Hint

Think about how @Global() affects module imports and provider availability.

When a module is decorated with @Global(), its exported providers become available automatically in every module without needing to import the global module explicitly.

📝 Syntax

intermediate

Identify the correct syntax to create a global module in NestJS

Which of the following code snippets correctly defines a global module in NestJS?

A

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

@Global()
@Module({
  providers: [Service],
  exports: [Service],
})
export class GlobalModule {}

B

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

@Global
@Module({
  providers: [Service],
  exports: [Service],
})
export class GlobalModule {}

C

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

@Module({
  providers: [Service],
  exports: [Service],
})
export class GlobalModule {}

D

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

@Module({
  providers: [Service],
  exports: [Service],
})
@Global()
export class GlobalModule {}

💡 Hint

Remember the order and syntax of decorators in TypeScript.

The @Global() decorator must be placed above the @Module() decorator to correctly mark the module as global.

❓ state_output

advanced

What is the output when accessing a global provider without importing its module?

Given a global module exporting a service, what happens when another module injects that service without importing the global module?

NestJS

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

@Injectable()
export class GlobalService {
  getMessage() {
    return 'Hello from global service';
  }
}

@Global()
@Module({
  providers: [GlobalService],
  exports: [GlobalService],
})
export class GlobalModule {}

@Module({})
export class FeatureModule {
  constructor(private readonly globalService: GlobalService) {}
  printMessage() {
    return this.globalService.getMessage();
  }
}

A A runtime error occurs: Nest can't resolve dependencies of FeatureModule.

B 'Hello from global service' is returned successfully.

C The service is undefined and causes a TypeError when calling getMessage.

D The service returns null because it was not imported explicitly.

💡 Hint

Think about how global modules affect provider injection.

Global modules make their exported providers available everywhere, so FeatureModule can inject GlobalService without importing GlobalModule.

🔧 Debug

advanced

Why does a global provider cause a duplicate provider error?

Consider two global modules both exporting a provider with the same token. What error occurs and why?

NestJS

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

@Injectable()
export class SharedService {}

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

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

A No error occurs; NestJS merges providers automatically.

B A compile-time error occurs: Cannot redeclare class SharedService.

C The last imported global module overrides the provider silently.

D A runtime error occurs: Duplicate provider token detected.

💡 Hint

Think about how NestJS handles provider tokens in the global scope.

Having two global modules exporting providers with the same token causes a runtime error because NestJS cannot resolve which provider to use.

🧠 Conceptual

expert

How to properly share a global service with dynamic configuration?

You want to create a global module that provides a service configurable with options passed during module import. Which approach correctly supports this pattern?

A Mark the service as <code>@Injectable({ global: true })</code> and pass options via dependency injection.

B Create a global module without <code>forRoot()</code> and set configuration inside the service constructor using environment variables.

C Use <code>@Global()</code> on a module with a static <code>forRoot()</code> method returning a dynamic module with providers configured by options.

D Use <code>@Global()</code> on a module and pass options directly to the constructor of the service.

💡 Hint

Think about how NestJS supports dynamic modules and global scope.

The recommended pattern is to create a global module with a static forRoot() method that returns a dynamic module configured with providers using the passed options.