Request body in NestJS - Step-by-Step Execution

Concept Flow - Request body

Client sends HTTP request

↓

NestJS Controller receives request

↓

@Body() decorator extracts body data

↓

Controller method uses extracted data

↓

Response sent back to client

The flow shows how NestJS extracts the request body using @Body() in a controller method to use the data.

Execution Sample

NestJS

import { Controller, Post, Body } from '@nestjs/common';

@Controller('users')
export class UsersController {
  @Post()
  createUser(@Body() body: any) {
    return body;
  }
}

This code defines a POST endpoint '/users' that receives JSON data in the request body and returns it.

Execution Table

Step	Action	Input	Body Extracted	Output
1	Client sends POST /users	{"name":"Alice"}	N/A	N/A
2	NestJS receives request	POST /users with body	N/A	N/A
3	@Body() extracts body	{"name":"Alice"}	{"name":"Alice"}	N/A
4	Controller method runs	{"name":"Alice"}	{"name":"Alice"}	{"name":"Alice"}
5	Response sent	N/A	N/A	{"name":"Alice"}

💡 Request handled and response sent with extracted body data.

Variable Tracker

Variable	Start	After Step 3	After Step 4	Final
body	undefined	{"name":"Alice"}	{"name":"Alice"}	{"name":"Alice"}

Key Moments - 2 Insights

Why do we use @Body() in the controller method?

The @Body() decorator tells NestJS to extract the JSON data sent in the request body so the method can use it, as shown in step 3 of the execution_table.

What happens if the client sends no body?

Then @Body() extracts undefined or an empty object, so the variable 'body' will be empty, which you can check before using it (not shown in this trace).

Visual Quiz - 3 Questions

Look at the execution_table, what is the value of 'body' after step 3?

A undefined

B {"name":"Alice"}

C null

D {}

💡 Hint

Check the 'Body Extracted' column at step 3 in the execution_table.

At which step does the controller method return the extracted body?

A Step 4

B Step 3

C Step 2

D Step 5

💡 Hint

Look at the 'Output' column in the execution_table to see when the body is returned.

If the client sends an empty body, how would the 'body' variable change in variable_tracker?

A It would cause an error and stop execution

B It would be the same as before step 3

C It would be undefined or empty object after step 3

D It would contain previous request data

💡 Hint

Refer to key_moments about empty body and variable_tracker initial values.

Concept Snapshot

NestJS Request Body Handling:
- Use @Body() decorator in controller method parameter.
- Extracts JSON data sent by client in request body.
- Works with POST, PUT, PATCH requests.
- Access extracted data as method argument.
- Return or process data as needed.

Full Transcript

In NestJS, when a client sends an HTTP request with a body, such as JSON data, the controller can access this data using the @Body() decorator. The flow starts with the client sending a POST request to an endpoint. NestJS receives the request and uses @Body() to extract the body content. The controller method then receives this extracted data as a parameter and can use it, for example, to return it back or save it. If the client sends no body, the extracted data will be undefined or empty. This process allows easy handling of request data in NestJS controllers.

Practice

1. In NestJS, which decorator is used to access the data sent in the request body?

easy

A. @Body()

B. @Param()

C. @Query()

D. @Headers()

Solution

1. Step 1: Understand the purpose of decorators in NestJS

   Decorators like @Body(), @Param(), @Query(), and @Headers() extract different parts of the request.

2. Step 2: Identify which decorator accesses the request body

   @Body() specifically extracts the data sent in the request body from the client.

3. Final Answer:

   @Body() -> Option A

4. Quick Check:

   Request body data = @Body() [OK]

Hint: Request body data always uses @Body() decorator [OK]

Common Mistakes:

• Using @Param() to get body data
• Confusing @Query() with @Body()
• Trying to access body data without any decorator

2. Which of the following is the correct way to type the request body in a NestJS controller method?

easy

A. create(@Body: any data) {}

B. create(@Body data: any) {}

C. create(@Body() data: any) {}

D. create(@Body data) {}

Solution

1. Step 1: Recall the syntax for decorators with typed parameters

   In NestJS, the decorator is followed by parentheses and the parameter is typed after the colon.

2. Step 2: Check each option's syntax

   create(@Body() data: any) {} correctly uses @Body() with typed parameter 'data: any'. Options B, C, and D have syntax errors or missing parentheses.

3. Final Answer:

   create(@Body() data: any) {} -> Option C

4. Quick Check:

   Correct decorator syntax = create(@Body() data: any) {} [OK]

Hint: Always use parentheses with @Body() and type after colon [OK]

Common Mistakes:

• Omitting parentheses after @Body
• Placing type before parameter name
• Not typing the parameter at all

3. Given this NestJS controller method, what will be the output if the client sends {"name": "Alice"} in the request body?

  @Post()
  create(@Body() data: { name: string }) {
    return `Hello, ${data.name}!`;
  }

medium

A. "Hello, null!"

B. "Hello, undefined!"

C. Error: data.name is not defined

D. "Hello, Alice!"

Solution

1. Step 1: Understand the method behavior with typed body

   The method expects an object with a 'name' string property and returns a greeting using that name.

2. Step 2: Analyze the input and output

   The client sends {"name": "Alice"}, so data.name is "Alice". The method returns "Hello, Alice!".

3. Final Answer:

   "Hello, Alice!" -> Option D

4. Quick Check:

   Input name "Alice" produces greeting "Hello, Alice!" [OK]

Hint: Match input keys to typed properties for correct output [OK]

Common Mistakes:

• Assuming undefined if typing is missing
• Expecting runtime error for missing type
• Confusing property names in the body

4. Identify the error in this NestJS controller method:

  @Post()
  create(@Body data: { age: number }) {
    return `Age is ${data.age}`;
  }

medium

A. Return statement syntax error

B. Missing parentheses after @Body decorator

C. Incorrect type for data parameter

D. Method should be named differently

Solution

1. Step 1: Check the decorator syntax

   @Body decorator requires parentheses even if empty, so it should be @Body()

2. Step 2: Verify other parts of the method

   The type and return statement are correct; only the decorator syntax is wrong.

3. Final Answer:

   Missing parentheses after @Body decorator -> Option B

4. Quick Check:

   @Body() needs parentheses [OK]

Hint: Always write @Body() with parentheses, even if empty [OK]

Common Mistakes:

• Omitting parentheses after @Body
• Misplacing type annotation
• Assuming method name causes error

5. You want to accept a request body with optional fields in NestJS. Which method signature correctly types the body to allow optional 'email' and required 'username' fields?

  @Post()
  create(???) {
    // method body
  }

hard

A. @Body() data: { username: string; email?: string }

B. @Body() data: { username?: string; email: string }

C. @Body() data: { username: string; email: string }

D. @Body() data: { username?: string; email?: string }

Solution

1. Step 1: Understand optional and required fields in TypeScript types

   A question mark (?) after a property name means it is optional; absence means required.

2. Step 2: Match the requirement to the type

   Username is required, so no '?'. Email is optional, so it has '?'. @Body() data: { username: string; email?: string } matches this.

3. Final Answer:

   @Body() data: { username: string; email?: string } -> Option A

4. Quick Check:

   Required username, optional email = @Body() data: { username: string; email?: string } [OK]

Hint: Use '?' after optional fields in type definitions [OK]

Common Mistakes:

• Marking required fields as optional
• Marking optional fields as required
• Forgetting to use @Body() decorator