Response transformation in NestJS - Performance & Optimization

Performance: Response transformation

MEDIUM IMPACT

This affects how fast the server sends the final data to the client and how much processing happens before the response is sent.

Transforming API response data before sending to client

NestJS

import { Injectable, NestInterceptor, ExecutionContext, CallHandler } from '@nestjs/common';
import { map } from 'rxjs/operators';

@Injectable()
export class LightTransformInterceptor implements NestInterceptor {
  intercept(context: ExecutionContext, next: CallHandler) {
    return next.handle().pipe(
      map(data => ({ ...data, value: data.value + 1 })),
    );
  }
}

Lightweight transformation avoids blocking event loop and sends response faster.

📈 Performance GainReduces response delay to under 10 ms, improving LCP.

Transforming API response data before sending to client

NestJS

import { Injectable, NestInterceptor, ExecutionContext, CallHandler } from '@nestjs/common';
import { map } from 'rxjs/operators';

@Injectable()
export class HeavyTransformInterceptor implements NestInterceptor {
  intercept(context: ExecutionContext, next: CallHandler) {
    return next.handle().pipe(
      map(data => {
        // Heavy synchronous transformation
        for (let i = 0; i < 1000000; i++) {
          data.value += i;
        }
        return data;
      }),
    );
  }
}

Heavy synchronous processing blocks the event loop delaying response sending.

📉 Performance CostBlocks server response for 100+ ms depending on data size, increasing LCP.

Performance Comparison

Pattern	Server Processing	Response Delay	Impact on LCP	Verdict
Heavy synchronous transformation	High CPU usage	100+ ms delay	Significant LCP increase	[X] Bad
Lightweight transformation	Minimal CPU usage	Under 10 ms delay	Minimal LCP impact	[OK] Good

Rendering Pipeline

Response transformation happens on the server before the browser receives data. Heavy transformations delay the server sending the response, which delays the browser's rendering start.

→Server Processing

→Network Transfer

→Browser Rendering Start

⚠️ BottleneckServer Processing (heavy synchronous transformations)

Core Web Vital Affected

LCP

This affects how fast the server sends the final data to the client and how much processing happens before the response is sent.

Optimization Tips

1Avoid heavy synchronous processing in response interceptors.

2Keep transformations simple and fast to reduce server response time.

3Use DevTools Network tab to monitor server response delays.

Performance Quiz - 3 Questions

What is the main performance risk of heavy synchronous response transformations in NestJS?

A They block the event loop, delaying server response.

B They increase client-side rendering time.

C They reduce network bandwidth.

D They cause layout shifts in the browser.

DevTools: Network

How to check: Open DevTools, go to Network tab, reload page, select API response, check 'Waiting (TTFB)' time.

What to look for: Long 'Waiting' time indicates server delay due to heavy response transformation.

Practice

1. What is the main purpose of response transformation in NestJS?

easy

A. To modify data before sending it to the client

B. To handle database connections

C. To manage user authentication

D. To log server errors

Solution

1. Step 1: Understand response transformation concept

   Response transformation means changing the data before it is sent to the user.

2. Step 2: Identify the correct purpose in NestJS context

   In NestJS, response transformation is used to modify or format the response data.

3. Final Answer:

   To modify data before sending it to the client -> Option A

4. Quick Check:

   Response transformation = modify data before sending [OK]

Hint: Response transformation changes output data before sending [OK]

Common Mistakes:

• Confusing response transformation with authentication
• Thinking it manages database connections
• Assuming it logs errors

2. Which of the following is the correct way to apply a response transformation interceptor in NestJS?

easy

A. controller.transform(TransformInterceptor)

B. @UseInterceptors(new TransformInterceptor())

C. app.use(TransformInterceptor)

D. @Injectable(TransformInterceptor)

Solution

1. Step 1: Recall NestJS interceptor usage

   Interceptors are applied using the @UseInterceptors decorator on controllers or methods.

2. Step 2: Match correct syntax

   The correct syntax is @UseInterceptors(new InterceptorClass()).

3. Final Answer:

   @UseInterceptors(new TransformInterceptor()) -> Option B

4. Quick Check:

   Use @UseInterceptors with new instance [OK]

Hint: Use @UseInterceptors with new interceptor instance [OK]

Common Mistakes:

• Using @Injectable instead of @UseInterceptors
• Calling interceptor as a method on controller
• Trying to use app.use for interceptors

3. Given this interceptor code snippet, what will be the transformed response?

intercept(context, next) {
  return next.handle().pipe(map(data => ({ result: data }))); 
}

medium

A. { data: originalData }

B. originalData

C. { result: originalData }

D. An error will occur

Solution

1. Step 1: Understand the interceptor's map function

   The map operator wraps the original data inside an object with key 'result'.

2. Step 2: Predict the transformed output

   The response will be an object: { result: originalData }.

3. Final Answer:

   { result: originalData } -> Option C

4. Quick Check:

   map wraps data in { result: ... } [OK]

Hint: map operator wraps data in new object key [OK]

Common Mistakes:

• Assuming original data is unchanged
• Confusing key name as 'data' instead of 'result'
• Expecting an error from this code

4. What is wrong with this interceptor code that tries to transform the response?

intercept(context, next) {
  next.handle().pipe(map(data => data.trim()));
}

medium

A. next.handle() should not be called

B. map operator cannot be used inside intercept

C. trim() is not a valid method on data

D. Missing return statement for the observable

Solution

1. Step 1: Check interceptor return value

   Interceptors must return the observable from next.handle().pipe(...).

2. Step 2: Identify missing return

   The code calls next.handle().pipe(...) but does not return it, so the response is undefined.

3. Final Answer:

   Missing return statement for the observable -> Option D

4. Quick Check:

   Always return next.handle().pipe(...) [OK]

Hint: Always return the observable from intercept method [OK]

Common Mistakes:

• Forgetting to return the observable
• Assuming map cannot be used in intercept
• Misusing trim() on non-string data

5. You want to hide the user's password field from all API responses using response transformation. Which approach is best in NestJS?

hard

A. Create an interceptor that maps the response and deletes the password field

B. Modify the database schema to exclude password

C. Use a middleware to filter out password from requests

D. Send password as null in the controller methods

Solution

1. Step 1: Understand response transformation goal

   We want to remove sensitive info from outgoing responses, not database or requests.

2. Step 2: Choose best NestJS method

   Interceptors can transform responses globally, ideal for removing password fields before sending.

3. Step 3: Evaluate other options

   Modifying DB schema or middleware won't affect response data; setting password null in controllers is repetitive.

4. Final Answer:

   Create an interceptor that maps the response and deletes the password field -> Option A

5. Quick Check:

   Use interceptor to hide sensitive response data [OK]

Hint: Use interceptor to remove sensitive fields from responses [OK]

Common Mistakes:

• Trying to filter password in middleware (affects requests)
• Changing database schema instead of response
• Manually nulling password in every controller