Feature modules in NestJS - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What is the output when importing a feature module with providers?

Consider a NestJS feature module that provides a service. What happens when this module is imported into the root module?

NestJS

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

@Injectable()
export class GreetingService {
  getGreeting() {
    return 'Hello from Feature Module!';
  }
}

@Module({
  providers: [GreetingService],
  exports: [GreetingService],
})
export class FeatureModule {}

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

// In a controller inside AppModule
constructor(private greetingService: GreetingService) {}

getHello() {
  return this.greetingService.getGreeting();
}

A The GreetingService is not available in AppModule and will cause a runtime error.

B The GreetingService is only available inside FeatureModule and cannot be injected elsewhere.

C The FeatureModule must be declared in controllers to use GreetingService.

D The AppModule can use GreetingService and get 'Hello from Feature Module!' as output.

💡 Hint

Think about how providers are shared when exported from a module.

When a feature module exports a provider, importing that module makes the provider available for injection in the importing module.

📝 Syntax

intermediate

Which option correctly defines a feature module with a controller and service?

Identify the correct NestJS feature module syntax that includes a controller and a service.

A

import { Module } from '@nestjs/common';
import { MyController } from './my.controller';
import { MyService } from './my.service';

@Module({
  controllers: (MyController),
  providers: (MyService),
})
export class MyFeatureModule {}

B

import { Module } from '@nestjs/common';
import { MyController } from './my.controller';
import { MyService } from './my.service';

@Module({
  controllers: MyController,
  providers: MyService,
})
export class MyFeatureModule {}

C

import { Module } from '@nestjs/common';
import { MyController } from './my.controller';
import { MyService } from './my.service';

@Module({
  controllers: [MyController],
  providers: [MyService],
})
export class MyFeatureModule {}

D

import { Module } from '@nestjs/common';
import { MyController } from './my.controller';
import { MyService } from './my.service';

@Module({
  controller: [MyController],
  provider: [MyService],
})
export class MyFeatureModule {}

💡 Hint

Check the property names and array syntax in the @Module decorator.

The @Module decorator expects arrays for controllers and providers properties. Property names must be plural and spelled correctly.

🔧 Debug

advanced

Why does injecting a service from a feature module cause a runtime error?

Given a feature module that provides a service but the service injection fails with 'Nest can't resolve dependencies' error, what is the likely cause?

NestJS

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

@Injectable()
export class DataService {
  getData() {
    return 'data';
  }
}

@Module({
  providers: [DataService],
  // exports: [DataService], // This line is missing
})
export class DataModule {}

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

// In a controller inside AppModule
constructor(private dataService: DataService) {}

A DataService must be declared in AppModule providers to be injectable.

B DataService is not exported from DataModule, so it is not available for injection in AppModule.

C DataService should be marked as @Global() to be injectable.

D DataService requires a factory provider to be injectable.

💡 Hint

Check if the service is exported from the module that provides it.

Providers must be exported from a feature module to be available for injection in modules that import it.

❓ state_output

advanced

What is the value of a service property after importing multiple feature modules?

Consider two feature modules each providing a service with a counter property initialized to 0. If both modules are imported into AppModule and the services are injected separately, what are the counter values after incrementing each once?

NestJS

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

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

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

@Module({
  providers: [CounterService],
  exports: [CounterService],
})
export class ModuleB {}

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

// In a controller
constructor(
  private counterA: CounterService,
  private counterB: CounterService
) {}

someMethod() {
  this.counterA.increment();
  this.counterB.increment();
  return { a: this.counterA.counter, b: this.counterB.counter };
}

A { a: 1, b: 1 } because each module provides its own instance of CounterService.

B { a: 2, b: 2 } because CounterService is singleton across modules.

C { a: 1, b: 0 } because only counterA increments.

D { a: 0, b: 0 } because services are not instantiated.

💡 Hint

Think about how NestJS creates service instances per module.

Each module provides its own instance of CounterService, so increments affect separate counters.

🧠 Conceptual

expert

Which statement best describes the role of feature modules in NestJS?

Choose the most accurate description of feature modules in NestJS.

A Feature modules organize related components and services, encapsulating functionality to promote modularity and reusability.

B Feature modules are only used to lazy-load parts of the application and cannot export providers.

C Feature modules replace the root module and must contain all controllers and services.

D Feature modules automatically share all their providers globally without explicit exports.

💡 Hint

Consider how NestJS encourages modular design.

Feature modules group related code to keep the app organized and allow selective sharing of providers via exports.