Response transformation in NestJS - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What is the output of this interceptor?

Given the following NestJS interceptor that transforms the response by adding a status field, what will the client receive?

NestJS

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

@Injectable()
export class StatusInterceptor implements NestInterceptor {
  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
    return next.handle().pipe(
      map(data => ({ status: 'success', data }))
    );
  }
}

// Controller method returns: { message: 'Hello' }

A {"data":{"message":"Hello"}}

B {"message":"Hello","status":"success"}

C {"status":"success","data":{"message":"Hello"}}

D {"status":"success"}

💡 Hint

Think about how the map operator wraps the original data.

The interceptor uses map to wrap the original response inside an object with a status field and a data field containing the original response. So the client receives an object with status and data keys.

📝 Syntax

intermediate

Which option correctly applies a global response interceptor in NestJS?

Choose the correct way to apply a global interceptor that transforms all responses.

NestJS

import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';
import { TransformInterceptor } from './transform.interceptor';

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  // Apply global interceptor here
  await app.listen(3000);
}
bootstrap();

A app.useGlobalInterceptors(new TransformInterceptor());

B app.useGlobalInterceptor(new TransformInterceptor());

C app.useGlobalFilters(new TransformInterceptor());

D app.useInterceptor(new TransformInterceptor());

💡 Hint

Check the exact method name for applying global interceptors in NestJS.

The correct method to apply a global interceptor is useGlobalInterceptors (note the plural). Other options are either misspelled or refer to filters, not interceptors.

🔧 Debug

advanced

Why does this interceptor not transform the response?

Consider this interceptor code. Why does the client receive the original response without transformation?

NestJS

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

@Injectable()
export class NoTransformInterceptor implements NestInterceptor {
  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
    return next.handle().pipe(
      map(data => ({ transformed: true, data }))
    );
  }
}

A The interceptor should use tap instead of map to transform data.

B The interceptor does not return the observable from next.handle(), so the pipeline is broken.

C The map operator is not imported, so it causes a runtime error.

D The interceptor must call next.handle() inside a try-catch block.

💡 Hint

Check if the observable is returned properly.

The interceptor must return the observable from next.handle().pipe(...). Here, the return statement is missing, so the transformation never happens and the original response is sent.

❓ state_output

advanced

What is the final response after applying this interceptor and controller?

Given this controller and interceptor, what will the client receive?

NestJS

import { Controller, Get, UseInterceptors } from '@nestjs/common';
import { map } from 'rxjs/operators';

@Controller('test')
@UseInterceptors(class {
  intercept(context, next) {
    return next.handle().pipe(map(data => ({ modified: true, ...data })));
  }
})
export class TestController {
  @Get()
  getData() {
    return { message: 'Hi' };
  }
}

A {"modified":true,"message":"Hi"}

B {"message":"Hi","modified":true}

C {"message":"Hi"}

D {"modified":true,"data":{"message":"Hi"}}

💡 Hint

Remember how the spread operator works inside the map function.

The interceptor spreads the original data inside a new object with modified: true. So the final object has keys modified and message at the same level.

🧠 Conceptual

expert

Which statement about NestJS response transformation is TRUE?

Choose the correct statement about how response transformation works in NestJS.

A Response transformation is only possible using middleware before the request reaches the controller.

B Response transformation requires modifying the controller method's return type directly.

C Global filters are the recommended way to transform all responses in NestJS.

D Interceptors can modify the response stream by transforming the observable returned by the handler.

💡 Hint

Think about the role of interceptors versus filters and middleware.

Interceptors wrap the handler's observable and can transform the response stream. Filters handle exceptions, and middleware runs before controllers but does not transform responses directly.