Injectable decorator in NestJS - Mini Project: Build & Apply

Using the Injectable Decorator in NestJS

📖 Scenario: You are building a simple NestJS service to manage a list of books in a library. You want to make this service available for other parts of your application by marking it as injectable.

🎯 Goal: Create a NestJS service class called BooksService and use the @Injectable() decorator to make it injectable in other parts of the app.

📋 What You'll Learn

Create a class named BooksService

Use the @Injectable() decorator from @nestjs/common

Define a property books as an array of strings with these exact values: '1984', 'Brave New World', 'Fahrenheit 451'

Add a method getBooks() that returns the books array

💡 Why This Matters

🌍 Real World

Services in NestJS are used to hold business logic and data. Marking them with @Injectable() allows NestJS to manage their lifecycle and inject them where needed.

💼 Career

Understanding how to create injectable services is essential for building scalable and maintainable backend applications with NestJS, a popular Node.js framework.

1

Create the BooksService class with a books array

Create a class called BooksService with a property books that is an array containing the strings '1984', 'Brave New World', and 'Fahrenheit 451'.

NestJS

# Your code here

Hint

Start by writing export class BooksService {} and inside it add books = ['1984', 'Brave New World', 'Fahrenheit 451'];

2

Import the Injectable decorator

Add an import statement to import Injectable from @nestjs/common at the top of the file.

NestJS

// Add import for Injectable from '@nestjs/common'

export class BooksService {
  books = ['1984', 'Brave New World', 'Fahrenheit 451'];
}

Hint

Write import { Injectable } from '@nestjs/common'; at the top of your file.

3

Add the @Injectable() decorator to BooksService

Add the @Injectable() decorator exactly above the BooksService class declaration.

NestJS

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

// Add @Injectable() decorator here
export class BooksService {
  books = ['1984', 'Brave New World', 'Fahrenheit 451'];
}

Hint

Place @Injectable() right before export class BooksService.

4

Add a getBooks() method to return the books array

Inside the BooksService class, add a method called getBooks() that returns the books array.

NestJS

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

@Injectable()
export class BooksService {
  books = ['1984', 'Brave New World', 'Fahrenheit 451'];

  // Add getBooks() method here
}

Hint

Write a method getBooks() that returns this.books.

Practice

1. What is the main purpose of the @Injectable() decorator in NestJS?

easy

A. To style components with CSS

B. To define a route handler in a controller

C. To create a database connection automatically

D. To mark a class so NestJS can manage it for dependency injection

Solution

1. Step 1: Understand the role of @Injectable()

   This decorator tells NestJS that the class can be injected as a dependency, making it reusable and manageable by the framework.

2. Step 2: Differentiate from other decorators

   Other decorators like @Controller() or database decorators serve different purposes, not dependency injection.

3. Final Answer:

   To mark a class so NestJS can manage it for dependency injection -> Option D

4. Quick Check:

   @Injectable() = marks class for DI [OK]

Hint: Remember: @Injectable() means NestJS manages the class [OK]

Common Mistakes:

• Confusing @Injectable() with @Controller()
• Thinking it creates routes or database connections
• Assuming it styles components

2. Which of the following is the correct syntax to make a service class injectable in NestJS?

easy

A. function Injectable() { return class MyService {} }

B. class MyService {}

C. @Injectable() class MyService {}

D. @Injectable class MyService {}

Solution

1. Step 1: Recall correct decorator syntax

   In NestJS, decorators are functions called with parentheses, so @Injectable() is correct.

2. Step 2: Check each option

   class MyService {} lacks the decorator. function Injectable() { return class MyService {} } is invalid syntax. @Injectable class MyService {} misses parentheses after @Injectable.

3. Final Answer:

   @Injectable() class MyService {} -> Option C

4. Quick Check:

   Decorator syntax requires parentheses () [OK]

Hint: Always use parentheses with decorators like @Injectable() [OK]

Common Mistakes:

• Omitting parentheses after @Injectable
• Trying to use @Injectable without decorator syntax
• Confusing class and function syntax

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

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

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

const appService = new AppService();
console.log(appService.getMessage());

medium

A. Hello from AppService

B. undefined

C. Error: AppService is not injectable

D. null

Solution

1. Step 1: Understand @Injectable() effect on class instantiation

   The @Injectable() decorator marks the class for NestJS DI but does not change normal instantiation behavior.

2. Step 2: Analyze the code execution

   The code creates an instance manually and calls getMessage(), which returns the string as expected.

3. Final Answer:

   Hello from AppService -> Option A

4. Quick Check:

   Manual instantiation still works; method returns string [OK]

Hint: Manual new works; decorator doesn't block normal class use [OK]

Common Mistakes:

• Assuming decorator breaks manual instantiation
• Expecting an error without NestJS container
• Thinking method returns undefined

4. Identify the error in this NestJS service code:

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

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

medium

A. Missing parentheses after @Injectable decorator

B. Class name should be lowercase

C. Method getUser must be async

D. Missing export keyword

Solution

1. Step 1: Check decorator syntax

   The @Injectable decorator must be called with parentheses: @Injectable().

2. Step 2: Verify other code parts

   Class name casing is correct by convention. Method need not be async. Export keyword is present.

3. Final Answer:

   Missing parentheses after @Injectable decorator -> Option A

4. Quick Check:

   Decorator requires () to work properly [OK]

Hint: Always add () after decorators like @Injectable() [OK]

Common Mistakes:

• Forgetting parentheses after decorator
• Thinking method must be async
• Confusing export keyword presence

5. You want to create a reusable logging service in NestJS that other services can inject. Which of the following is the best way to define it?

hard

A. Create a class without @Injectable() and instantiate it manually everywhere

B. Use @Injectable() on the logging class and inject it where needed

C. Define logging functions in a plain JavaScript object and export it

D. Use @Controller() decorator on the logging class

Solution

1. Step 1: Understand dependency injection benefits

   Using @Injectable() allows NestJS to manage the logging service lifecycle and inject it automatically where needed.

2. Step 2: Evaluate options for reusability and testability

   Manual instantiation loses DI benefits. Plain objects lack lifecycle and DI. @Controller() is for routing, not services.

3. Final Answer:

   Use @Injectable() on the logging class and inject it where needed -> Option B

4. Quick Check:

   Injectable services = reusable and testable [OK]

Hint: Always use @Injectable() for reusable NestJS services [OK]

Common Mistakes:

• Skipping @Injectable() and instantiating manually
• Using @Controller() for services
• Using plain objects without DI benefits