Dependency injection basics in NestJS - Mini Project: Build & Apply

Dependency injection basics

📖 Scenario: You are building a simple NestJS service that provides a greeting message. You want to use dependency injection to keep your code clean and testable.

🎯 Goal: Create a NestJS service called GreetingService that returns a greeting message. Then inject this service into a controller called GreetingController to return the greeting when a GET request is made.

📋 What You'll Learn

Create a service class named GreetingService with a method getGreeting() that returns the string 'Hello, NestJS!'.

Create a controller class named GreetingController.

Inject GreetingService into GreetingController using constructor injection.

Add a GET route /greet in GreetingController that returns the greeting from GreetingService.

💡 Why This Matters

🌍 Real World

Dependency injection helps keep code modular and testable by letting NestJS manage service creation and sharing.

💼 Career

Understanding dependency injection is essential for building scalable and maintainable backend applications with NestJS.

1

Create the GreetingService

Create a class called GreetingService with a method getGreeting() that returns the string 'Hello, NestJS!'.

NestJS

# Create the GreetingService class with getGreeting method
# Your code here

Hint

Use the @Injectable() decorator to make the service injectable.

2

Create the GreetingController

Create a class called GreetingController and add the @Controller('greet') decorator to it.

NestJS

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

# Create the GreetingController class with @Controller('greet') decorator
# Your code here

Hint

Use the @Controller('greet') decorator to define the route prefix.

3

Inject GreetingService into GreetingController

Add a constructor to GreetingController that injects GreetingService as a private readonly property named greetingService.

NestJS

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

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

@Controller('greet')
export class GreetingController {
  # Add constructor to inject GreetingService
  # Your code here
}

Hint

Use constructor injection with private readonly greetingService: GreetingService.

4

Add GET route to return greeting

Add a method called getGreeting() in GreetingController decorated with @Get() that returns the result of this.greetingService.getGreeting().

NestJS

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

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

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

  # Add a GET route method getGreeting() that returns greetingService.getGreeting()
  # Your code here
}

Hint

Use the @Get() decorator to define the GET route handler.

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