Service creation in NestJS - Mini Project: Build & Apply

Service Creation in NestJS

📖 Scenario: You are building a simple NestJS application to manage a list of books in a library. You want to create a service that will hold the data and provide methods to access it.

🎯 Goal: Create a NestJS service called BooksService that stores a list of books and provides a method to get all books.

📋 What You'll Learn

Create a service class named BooksService

Add a private array property called books with three book titles as strings

Add a method called getAllBooks() that returns the books array

Export the service class properly

💡 Why This Matters

🌍 Real World

Services in NestJS hold business logic and data. Creating a service to manage books is like having a librarian who knows all the books and can share that info when asked.

💼 Career

Understanding how to create and use services is essential for backend development with NestJS, a popular framework for building scalable server applications.

1

Create the BooksService class with a books array

Create a class called BooksService and inside it, create a private property called books that is an array containing these exact strings: 'The Hobbit', '1984', 'Brave New World'.

NestJS

class BooksService {
  // Create a private books array with the given book titles
  // Your code here
}

Hint

Remember to use private books = [...] inside the class.

2

Add the getAllBooks method

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

NestJS

class BooksService {
  private books = ['The Hobbit', '1984', 'Brave New World'];

  // Add getAllBooks method that returns books array
  // Your code here
}

Hint

The method should return this.books.

3

Add the @Injectable decorator

Import Injectable from @nestjs/common and add the @Injectable() decorator above the BooksService class.

NestJS

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

// Add @Injectable decorator here
class BooksService {
  private books = ['The Hobbit', '1984', 'Brave New World'];

  getAllBooks() {
    return this.books;
  }
}

Hint

Use @Injectable() just before the class declaration.

4

Export the BooksService class

Add an export statement to export the BooksService class so it can be used in other parts of the application.

NestJS

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

@Injectable()
// Export the BooksService class
// Your code here
class BooksService {
  private books = ['The Hobbit', '1984', 'Brave New World'];

  getAllBooks() {
    return this.books;
  }
}

Hint

Use export class BooksService instead of just class BooksService.

Practice

1.

What is the main purpose of creating a service in a NestJS application?

easy

A. To handle HTTP requests directly

B. To style the user interface

C. To define database schemas

D. To hold the business logic separate from controllers

Solution

1. Step 1: Understand the role of services in NestJS

   Services are designed to contain business logic, keeping controllers clean and focused on handling requests.

2. Step 2: Differentiate services from controllers and other parts

   Controllers handle HTTP requests, schemas define data structure, and styling is unrelated to services.

3. Final Answer:

   To hold the business logic separate from controllers -> Option D

4. Quick Check:

   Service purpose = business logic separation [OK]

Hint: Services = business logic holders, not request handlers [OK]

Common Mistakes:

• Confusing services with controllers
• Thinking services handle HTTP requests
• Assuming services define database schemas

2.

Which decorator is used to make a class injectable as a service in NestJS?

easy

A. @Injectable()

B. @Module()

C. @Controller()

D. @Service()

Solution

1. Step 1: Identify the decorator for service injection

   In NestJS, @Injectable() marks a class as a provider that can be injected.

2. Step 2: Differentiate from other decorators

   @Controller() is for controllers, @Module() for modules, and @Service() does not exist in NestJS.

3. Final Answer:

   @Injectable() -> Option A

4. Quick Check:

   Service decorator = @Injectable() [OK]

Hint: Remember: Injectable means ready to inject [OK]

Common Mistakes:

• Using @Controller() instead of @Injectable()
• Confusing @Module() with service decorator
• Assuming @Service() exists in NestJS

3.

Given the following service code, what will be the output when getHello() is called?

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

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

medium

A. "Hello, NestJS!"

B. undefined

C. Error: Method not found

D. "Hello World!"

Solution

1. Step 1: Analyze the getHello method

   The method returns the string 'Hello, NestJS!'.

2. Step 2: Determine the output of calling getHello()

   Calling getHello() returns exactly the string defined, no errors or undefined.

3. Final Answer:

   "Hello, NestJS!" -> Option A

4. Quick Check:

   Method return = "Hello, NestJS!" [OK]

Hint: Read method return value carefully [OK]

Common Mistakes:

• Assuming method returns undefined
• Confusing output with error messages
• Mixing up string content

4.

Identify the error in this service code snippet:

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

@Injectable()
export class MathService {
  add(a: number, b: number) {
    return a + b
  }
}

medium

A. Missing parentheses in method declaration

B. Missing return type annotation for add method

C. No error, code is correct

D. Missing semicolon after return statement

Solution

1. Step 1: Check syntax correctness

   The method add correctly takes two numbers and returns their sum. Semicolons are optional in TypeScript.

2. Step 2: Verify method declaration and return type

   Return type annotation is optional; TypeScript infers it. Parentheses are present and correct.

3. Final Answer:

   No error, code is correct -> Option C

4. Quick Check:

   Code syntax = correct [OK]

Hint: Semicolons optional; return types inferred [OK]

Common Mistakes:

• Thinking semicolons are mandatory
• Expecting explicit return type always
• Misreading method syntax

5.

You want to create a service that provides a list of users and inject it into a controller. Which of the following is the correct way to create and inject the service?

1. Create service with @Injectable()
2. Define a method getUsers() returning an array
3. Inject service in controller constructor
4. Use service method inside controller method

hard

A. Create service without @Injectable(), inject with @Inject() decorator

B. Create service with @Injectable(), inject via constructor parameter

C. Create service with @Controller(), inject via property decorator

D. Create service with @Module(), inject manually inside methods

Solution

1. Step 1: Create service with @Injectable()

   This decorator makes the service injectable and reusable.

2. Step 2: Inject service via constructor parameter in controller

   Constructor injection is the NestJS standard for dependency injection.

3. Step 3: Use service methods inside controller methods

   This keeps code modular and clean.

4. Final Answer:

   Create service with @Injectable(), inject via constructor parameter -> Option B

5. Quick Check:

   Service injection = @Injectable() + constructor [OK]

Hint: Use @Injectable() and constructor injection [OK]

Common Mistakes:

• Omitting @Injectable() on service
• Using @Controller() on service
• Injecting service incorrectly with property decorators