Service creation in NestJS - Step-by-Step Execution

Concept Flow - Service creation

Define Service Class

↓

Add @Injectable() Decorator

↓

Implement Service Methods

↓

Register Service in Module

↓

Inject Service into Controller or Other Providers

↓

Use Service Methods in Application

This flow shows how to create a service in NestJS: define a class, mark it injectable, add methods, register it in a module, then inject and use it.

Execution Sample

NestJS

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

@Injectable()
export class CatsService {
  private cats = [];
  findAll() { return this.cats; }
}

Defines a CatsService with an injectable decorator and a method to return all cats.

Execution Table

Step	Action	Evaluation	Result
1	Define CatsService class	Class created	CatsService class exists with empty cats array
2	Add @Injectable() decorator	Marks class as injectable	NestJS can inject CatsService
3	Implement findAll() method	Method returns cats array	Method ready to return [] initially
4	Register CatsService in module providers	Module knows CatsService	Service available for injection
5	Inject CatsService in controller	Controller receives service instance	Can call findAll() from controller
6	Call findAll() method	Returns current cats array	Returns [] initially
7	Add cat to cats array (not shown in code)	cats array updated	cats array now has new cat
8	Call findAll() again	Returns updated cats array	Returns array with added cat
9	Exit	Service ready and usable	Execution ends

💡 Service class created, injectable, registered, injected, and methods callable; ready for use in app.

Variable Tracker

Variable	Start	After Step 3	After Step 7	Final
cats	[]	[]	[{name: 'Fluffy'}]	[{name: 'Fluffy'}]

Key Moments - 3 Insights

Why do we need the @Injectable() decorator on the service class?

Without @Injectable(), NestJS cannot inject the service into other classes. See execution_table step 2 where adding @Injectable() marks the class injectable.

How does the service get used inside a controller?

The service is registered in the module and then injected into the controller constructor (step 5). This allows calling service methods like findAll() (step 6).

What happens if we don't register the service in the module providers?

NestJS won't know about the service and injection will fail. See step 4 where registration makes the service available.

Visual Quiz - 3 Questions

Look at the execution table, what is the value of 'cats' after step 3?

A undefined

B []

C [{name: 'Fluffy'}]

D null

💡 Hint

Check variable_tracker column 'After Step 3' for 'cats' value.

At which step does NestJS mark the service as injectable?

A Step 2

B Step 1

C Step 4

D Step 5

💡 Hint

See execution_table step 2 description about @Injectable() decorator.

If we skip registering the service in the module, what will happen?

A Service will still inject correctly

B Service methods won't work but injection succeeds

C Injection will fail because NestJS doesn't know the service

D Service will be registered automatically

💡 Hint

Refer to key_moments answer about module registration and execution_table step 4.

Concept Snapshot

NestJS Service Creation:
- Define a class for your service
- Add @Injectable() decorator to make it injectable
- Implement service methods inside the class
- Register the service in the module's providers array
- Inject the service into controllers or other providers
- Use service methods to share logic across app

Full Transcript

To create a service in NestJS, first define a class that will hold your logic. Add the @Injectable() decorator so NestJS knows it can inject this service elsewhere. Inside the class, add methods like findAll() to perform tasks. Next, register this service in the module's providers array so NestJS can manage it. Then, inject the service into controllers or other providers by adding it to their constructor. Finally, call the service methods from those classes to reuse logic. This process helps keep your app organized and modular.

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