Response handling in NestJS - Step-by-Step Execution

Concept Flow - Response handling

Receive HTTP Request

↓

Controller Method Called

↓

Process Request Logic

↓

Prepare Response Data

↓

Send Response to Client

↓

Client Receives Response

This flow shows how NestJS handles an HTTP request by calling a controller, processing logic, preparing data, and sending the response back to the client.

Execution Sample

NestJS

import { Controller, Get, Res } from '@nestjs/common';
import { Response } from 'express';

@Controller('hello')
export class HelloController {
  @Get()
  getHello(@Res() res: Response) {
    res.status(200).json({ message: 'Hello World' });
  }
}

This code defines a NestJS controller that sends a JSON response with status 200 and a message when the /hello route is requested.

Execution Table

Step	Action	Input/State	Output/State Change	Notes
1	Receive HTTP GET /hello	Request received	Controller method getHello called	NestJS routes request to controller
2	Call getHello method	No parameters except response object	Prepare response with status 200 and JSON body	Uses Express Response object
3	Execute res.status(200).json(...)	Response object	HTTP response sent with status 200 and JSON { message: 'Hello World' }	Response sent to client
4	Client receives response	HTTP 200 with JSON body	Client can read message 'Hello World'	End of request-response cycle

💡 Response sent to client, request handling complete

Variable Tracker

Variable	Start	After Step 2	After Step 3	Final
res	Express Response object	Response status set to 200	Response body set to JSON { message: 'Hello World' }	Response sent to client

Key Moments - 2 Insights

Why do we use @Res() to get the response object instead of just returning data?

Using @Res() gives full control over the response, like setting status codes and headers manually, as shown in step 2 and 3 of the execution_table.

What happens if we forget to call res.status(...).json(...) inside the controller?

The client will not receive a response and the request will hang, because the response is never sent. This is clear from step 3 where sending the response ends the cycle.

Visual Quiz - 3 Questions

Look at the execution table, what is the response status code set at step 3?

A 500

B 404

C 200

D 302

💡 Hint

Check the 'Output/State Change' column at step 3 in the execution_table.

At which step is the controller method getHello called?

A Step 1

B Step 2

C Step 3

D Step 4

💡 Hint

Look at the 'Action' column to find when getHello is executed.

If we remove @Res() and just return { message: 'Hello World' }, what changes in the response handling?

A NestJS automatically sends JSON with status 200

B Response status must be set manually

C Response will not be sent

D Client receives plain text instead of JSON

💡 Hint

Consider how NestJS handles return values when @Res() is not used.

Concept Snapshot

NestJS Response Handling:
- Use @Res() to access Express response object
- Call res.status(code).json(data) to send JSON with status
- Without @Res(), return value is auto-sent as JSON with status 200
- Response ends request cycle
- Control response headers and status manually with @Res()

Full Transcript

In NestJS, when a client sends an HTTP request, the framework routes it to the matching controller method. Inside the method, you can use the @Res() decorator to get the Express response object. This lets you set the HTTP status code and send JSON data manually using res.status(200).json({ message: 'Hello World' }). This sends the response back to the client and ends the request cycle. If you do not use @Res(), you can simply return an object and NestJS will automatically send it as JSON with status 200. The execution table shows each step from receiving the request, calling the controller, preparing the response, and sending it. The variable tracker shows how the response object changes as status and body are set. Key moments clarify why @Res() is used and what happens if the response is not sent. The quiz tests understanding of status codes, method calls, and automatic response sending.

Practice

1. In NestJS, what is the primary purpose of using the @Res() decorator in a controller method?

easy

A. To define a route path for the controller method

B. To inject a service into the controller

C. To access and customize the HTTP response object directly

D. To automatically serialize the response data

Solution

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

   The @Res() decorator gives direct access to the HTTP response object, allowing full control over the response.

2. Step 2: Differentiate from other decorators

   Other decorators like @Inject() inject services, and route decorators define paths, but @Res() is specifically for response handling.

3. Final Answer:

   To access and customize the HTTP response object directly -> Option C

4. Quick Check:

   @Res() = direct response control [OK]

Hint: Remember: @Res() means direct response access [OK]

Common Mistakes:

• Confusing @Res() with service injection
• Thinking @Res() defines routes
• Assuming @Res() auto-serializes data

2. Which of the following is the correct way to set a 201 status code and send a JSON response using @Res() in NestJS?

easy

A. res.status(201).json({ message: 'Created' });

B. res.sendStatus(201).json({ message: 'Created' });

C. res.json(201, { message: 'Created' });

D. res.statusCode(201).send({ message: 'Created' });

Solution

1. Step 1: Recall Express response methods

   In NestJS, @Res() uses Express response methods. The correct way to set status and send JSON is res.status(201).json(...).

2. Step 2: Identify incorrect method usage

   sendStatus sends status and ends response, so chaining .json() is invalid. res.json(201, ...) and res.statusCode(201) are not valid Express methods.

3. Final Answer:

   res.status(201).json({ message: 'Created' }); -> Option A

4. Quick Check:

   Set status then json = res.status(201).json(...) [OK]

Hint: Use res.status(code).json(data) to set status and send JSON [OK]

Common Mistakes:

• Using sendStatus then chaining json
• Passing status code as first json argument
• Using non-existent statusCode method

3. Given the following NestJS controller method, what will be the HTTP status code and response body sent to the client?

async getData(@Res() res) {
  const data = { id: 1, name: 'NestJS' };
  return res.status(202).json(data);
}

medium

A. Status 202 with body { id: 1, name: 'NestJS' }

B. Status 200 with body { id: 1, name: 'NestJS' }

C. Status 202 with empty body

D. Status 500 with error message

Solution

1. Step 1: Analyze response status setting

   The method calls res.status(202), so the HTTP status code will be 202 (Accepted).

2. Step 2: Analyze response body sent

   The method sends JSON data { id: 1, name: 'NestJS' } with .json(data), so the body will contain this object.

3. Final Answer:

   Status 202 with body { id: 1, name: 'NestJS' } -> Option A

4. Quick Check:

   Status 202 + JSON data = Status 202 with body { id: 1, name: 'NestJS' } [OK]

Hint: res.status(code).json(data) sets status and sends data [OK]

Common Mistakes:

• Assuming default 200 status instead of 202
• Thinking body is empty when using json()
• Confusing status codes with error codes

4. Identify the error in the following NestJS controller method that uses @Res():

async sendResponse(@Res() res) {
  res.json({ message: 'Hello' });
  res.status(200);
}

medium

A. res.status must be called before returning from method

B. Missing await keyword before res.json

C. res.json should be replaced with res.sendStatus

D. Calling res.status after res.json causes no effect

Solution

1. Step 1: Understand Express response flow

   Calling res.json() sends the response immediately and ends it.

2. Step 2: Analyze order of method calls

   Calling res.status(200) after res.json() has no effect because response is already sent.

3. Final Answer:

   Calling res.status after res.json causes no effect -> Option D

4. Quick Check:

   Set status before sending response [OK]

Hint: Always set status before sending response [OK]

Common Mistakes:

• Calling res.status after res.json
• Thinking res.json needs await
• Confusing res.sendStatus with res.json

5. You want to create a NestJS controller method that returns a 404 status with a JSON error message if a user is not found, but returns the user data with status 200 if found. Which code snippet correctly implements this response handling?

hard

A. async getUser(@Res() res, @Param('id') id: string) {
const user = await this.userService.findById(id);
if (!user) {
res.json({ error: 'User not found' }).status(404);
} else {
res.json(user).status(200);
}
}

B. async getUser(@Res() res, @Param('id') id: string) {
const user = await this.userService.findById(id);
if (!user) {
return res.status(404).json({ error: 'User not found' });
}
return res.status(200).json(user);
}

C. async getUser(@Res() res, @Param('id') id: string) {
const user = await this.userService.findById(id);
if (!user) {
res.json({ error: 'User not found' });
res.status(404);
} else {
res.json(user);
res.status(200);
}
}

D. async getUser(@Res() res, @Param('id') id: string) {
const user = await this.userService.findById(id);
if (!user) {
res.sendStatus(404);
} else {
res.json(user);
}
}

Solution

1. Step 1: Check correct chaining of status and json

   async getUser(@Res() res, @Param('id') id: string) { const user = await this.userService.findById(id); if (!user) { return res.status(404).json({ error: 'User not found' }); } return res.status(200).json(user); } correctly calls res.status(404).json(...) and res.status(200).json(...), chaining status and JSON response properly.

2. Step 2: Identify errors in other options

   async getUser(@Res() res, @Param('id') id: string) { const user = await this.userService.findById(id); if (!user) { res.json({ error: 'User not found' }).status(404); } else { res.json(user).status(200); } } calls res.json() before res.status(), which does not set status correctly. async getUser(@Res() res, @Param('id') id: string) { const user = await this.userService.findById(id); if (!user) { res.json({ error: 'User not found' }); res.status(404); } else { res.json(user); res.status(200); } } calls res.json() before res.status(), which does not set status correctly. async getUser(@Res() res, @Param('id') id: string) { const user = await this.userService.findById(id); if (!user) { res.sendStatus(404); } else { res.json(user); } } uses res.sendStatus(404) which sends response immediately but does not send JSON error message.

3. Final Answer:

   correctly sets status and sends JSON error or data -> Option B

4. Quick Check:

   Chain status and json for correct response [OK]

Hint: Chain res.status(code).json(data) for clear responses [OK]

Common Mistakes:

• Calling res.json before res.status
• Using res.sendStatus without JSON body
• Separating status and json calls without chaining