Dependency injection basics in NestJS - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What is the output of this NestJS service injection?

Consider the following NestJS service and controller. What will be logged when the controller method is called?

NestJS

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

@Injectable()
export class GreetingService {
  getGreeting() {
    return 'Hello, NestJS!';
  }
}

@Controller()
export class GreetingController {
  constructor(private readonly greetingService: GreetingService) {}

  @Get()
  greet() {
    console.log(this.greetingService.getGreeting());
    return this.greetingService.getGreeting();
  }
}

A "Hello, NestJS!" is logged and returned

B "undefined" is logged and returned

C "null" is logged and returned

D A runtime error occurs because GreetingService is not injected

💡 Hint

Think about how NestJS injects services marked with @Injectable() into controllers.

The GreetingService is marked with @Injectable(), so NestJS can inject it into the controller's constructor. The greet method calls getGreeting() which returns the string Hello, NestJS!. This string is logged and returned.

📝 Syntax

intermediate

Which option correctly injects a service in NestJS?

You want to inject a service named AuthService into a controller. Which constructor syntax is correct?

A constructor(private readonly authService: AuthService) {}

B constructor(public readonly authService: AuthService) {}

C constructor(private authService: AuthService) {}

D constructor(authService: AuthService) {}

💡 Hint

Remember to use access modifiers and readonly for best practice.

In NestJS, to inject a service via constructor, you must use an access modifier like private or public. Using private readonly is a common best practice to prevent reassignment. Option A uses private readonly which is correct.

🔧 Debug

advanced

Why does this NestJS service injection fail at runtime?

Given this code, why does NestJS throw a runtime error about missing provider for LoggerService?

NestJS

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

@Injectable()
export class LoggerService {
  log(message: string) {
    console.log(message);
  }
}

@Controller()
export class AppController {
  constructor(private readonly loggerService: LoggerService) {}

  someMethod() {
    this.loggerService.log('Test');
  }
}

A AppController is not decorated with @Controller()

B LoggerService is missing the @Injectable() decorator

C LoggerService is not listed in the module's providers array

D LoggerService method log() is not public

💡 Hint

Check if the service is registered in the module where the controller is declared.

Even though LoggerService is marked with @Injectable(), NestJS needs it to be registered in the module's providers array to inject it. If it's missing there, NestJS throws a runtime error about missing provider.

❓ state_output

advanced

What is the value of the injected service property after module initialization?

In this NestJS module, what will be the value of this.configService.apiKey inside AppService after the app starts?

NestJS

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

@Injectable()
export class ConfigService {
  apiKey = '12345';
}

@Injectable()
export class AppService {
  constructor(public readonly configService: ConfigService) {}

  getApiKey() {
    return this.configService.apiKey;
  }
}

@Module({
  providers: [ConfigService, AppService],
  exports: [AppService]
})
export class AppModule {}

A undefined

B "12345"

C null

D Throws a runtime error

💡 Hint

Check how ConfigService is injected and its property initialized.

The ConfigService has a property apiKey initialized to '12345'. It is injected into AppService correctly via constructor. So, calling getApiKey() returns '12345'.

🧠 Conceptual

expert

Which statement best describes NestJS dependency injection scope behavior?

In NestJS, what happens when a service is provided with scope: Scope.REQUEST compared to the default singleton scope?

A The service instance is shared globally across all requests

B The service is instantiated once per controller instance

C The service is instantiated once per module import

D A new instance of the service is created for each incoming request

💡 Hint

Think about how request-scoped services differ from singleton services.

By default, NestJS services are singletons, meaning one instance is shared globally. When a service is marked with scope: Scope.REQUEST, NestJS creates a new instance of that service for every incoming HTTP request, isolating state per request.