Request body in NestJS - Performance & Optimization

Performance: Request body

MEDIUM IMPACT

How the server processes incoming data affects response time and overall user experience.

Handling incoming JSON data in a NestJS controller

NestJS

import { Controller, Post, Body } from '@nestjs/common';
@Controller('users')
export class UserController {
  @Post()
  createUser(@Body() data: CreateUserDto) {
    // process validated data
  }
}

Uses NestJS built-in body parser and validation pipes, reducing CPU overhead and improving error handling.

📈 Performance GainNon-blocking parsing with validation, reducing response time and improving server throughput.

Handling incoming JSON data in a NestJS controller

NestJS

import { Controller, Post, Req } from '@nestjs/common';
@Controller('users')
export class UserController {
  @Post()
  createUser(@Req() request) {
    const data = JSON.parse(request.body);
    // process data
  }
}

Manually parsing JSON from rawBody bypasses NestJS built-in body parsers and validation, causing extra CPU work and potential errors.

📉 Performance CostBlocks event loop during JSON.parse, increasing response time and risking server slowdowns under load.

Performance Comparison

Pattern	CPU Usage	Event Loop Blocking	Error Handling	Verdict
Manual JSON.parse in controller	High	Blocks event loop	Poor	[X] Bad
NestJS @Body with validation pipes	Low	Non-blocking	Good	[OK] Good

Rendering Pipeline

Request body parsing happens on the server before response generation, impacting server processing time and thus interaction responsiveness.

→Server Request Parsing

→Validation

→Response Generation

⚠️ BottleneckSynchronous JSON parsing and manual validation can block the event loop.

Core Web Vital Affected

INP

How the server processes incoming data affects response time and overall user experience.

Optimization Tips

1Avoid manual JSON parsing in controllers; use NestJS @Body decorator.

2Use validation pipes to catch errors early and reduce processing overhead.

3Keep request body size minimal to reduce parsing time and server load.

Performance Quiz - 3 Questions

What is a performance risk of manually parsing JSON request bodies in NestJS controllers?

A It automatically validates data, improving speed.

B It reduces server CPU usage by offloading parsing.

C It blocks the event loop during parsing, increasing response time.

D It caches parsed data for faster reuse.

DevTools: Network and Performance panels

How to check: Use Network panel to inspect request payload size and timing; use Performance panel to profile server response time and event loop delays.

What to look for: Look for long server processing times and event loop blocking indicators to identify inefficient request body handling.

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