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.

Practice

1. What is the main purpose of dependency injection in NestJS?

easy

A. To automatically provide required services to classes

B. To manually create instances of services inside components

C. To write all code inside a single file

D. To avoid using classes and use only functions

Solution

1. Step 1: Understand dependency injection concept

   Dependency injection means NestJS automatically gives the needed services to classes without manual creation.

2. Step 2: Compare options with this concept

   Only To automatically provide required services to classes describes automatic service provision, others describe manual or unrelated actions.

3. Final Answer:

   To automatically provide required services to classes -> Option A

4. Quick Check:

   Dependency injection = automatic service provision [OK]

Hint: Dependency injection means NestJS gives services automatically [OK]

Common Mistakes:

• Thinking you must create service instances manually
• Confusing dependency injection with code organization only
• Believing dependency injection removes classes

2. Which decorator marks a class as injectable for NestJS dependency injection?

easy

A. @Module()

B. @Controller()

C. @Injectable()

D. @Service()

Solution

1. Step 1: Recall NestJS decorators for DI

   Classes that can be injected must be marked with @Injectable() decorator.

2. Step 2: Check each option

   @Controller is for controllers, @Module for modules, @Service is not a NestJS decorator.

3. Final Answer:

   @Injectable() -> Option C

4. Quick Check:

   @Injectable() marks injectable classes [OK]

Hint: Use @Injectable() to mark services for injection [OK]

Common Mistakes:

• Using @Controller or @Module instead of @Injectable
• Assuming @Service is a valid NestJS decorator
• Forgetting to add any decorator

3. Given this code snippet, what will be the output when appService.getMessage() is called?

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

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

export class AppController {
  constructor(private readonly appService: AppService) {}

  showMessage() {
    return this.appService.getMessage();
  }
}

medium

A. Error: AppService not provided

B. 'Hello from AppService'

C. undefined

D. 'Hello from AppController'

Solution

1. Step 1: Understand injection in constructor

   AppController receives AppService instance via constructor injection because AppService is marked @Injectable.

2. Step 2: Trace method call

   showMessage calls appService.getMessage(), which returns 'Hello from AppService'.

3. Final Answer:

   'Hello from AppService' -> Option B

4. Quick Check:

   Injected service method returns message [OK]

Hint: Injected service methods return their defined values [OK]

Common Mistakes:

• Assuming injection fails without @Module setup
• Expecting AppController message instead
• Confusing method return values

4. Identify the error in this NestJS service injection code:

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

export class UserService {
  getUser() {
    return 'User data';
  }
}

@Injectable()
export class UserController {
  constructor(private readonly userService: UserService) {}

  fetchUser() {
    return this.userService.getUser();
  }
}

medium

A. UserService is missing @Injectable() decorator

B. UserController should not have a constructor

C. fetchUser method should be async

D. userService property should be public

Solution

1. Step 1: Check decorators on injectable classes

   UserService is injected into UserController but lacks @Injectable(), so NestJS cannot inject it.

2. Step 2: Verify other options

   Constructor in controller is valid, fetchUser need not be async, and private readonly is correct for injection.

3. Final Answer:

   UserService is missing @Injectable() decorator -> Option A

4. Quick Check:

   Injectable classes must have @Injectable() [OK]

Hint: Injectable services must have @Injectable() decorator [OK]

Common Mistakes:

• Forgetting @Injectable on services
• Thinking constructor is invalid in controllers
• Assuming async is required for injected methods

5. You want to inject two different services, LoggerService and ConfigService, into a controller. Which is the correct way to do this in NestJS?

hard

A. Inject only one service and import the other directly

B. Create instances manually inside the controller constructor

C. Use @Injectable() on the controller and call services statically

D. Use constructor injection with both services as parameters marked private readonly

Solution

1. Step 1: Recall how to inject multiple services

   In NestJS, multiple services are injected by listing them as constructor parameters with access modifiers like private readonly.

2. Step 2: Evaluate options

   Use constructor injection with both services as parameters marked private readonly correctly uses constructor injection. Create instances manually inside the controller constructor manually creates instances, breaking DI. Use @Injectable() on the controller and call services statically misuses @Injectable on controller and static calls. Inject only one service and import the other directly injects only one service, which is incomplete.

3. Final Answer:

   Use constructor injection with both services as parameters marked private readonly -> Option D

4. Quick Check:

   Multiple services injected via constructor parameters [OK]

Hint: Inject multiple services by listing them in constructor [OK]

Common Mistakes:

• Manually creating service instances inside controllers
• Using static calls instead of injection
• Injecting only one service when multiple are needed