Response Transformation

{
  "id": 1,
  "name": "Anna"
}

{
  "data": [
    { "id": 1, "name": "Anna" }
  ]
}

{
  "data": {
    "id": 1,
    "name": "Anna"
  }
}

запит
  ↓
interceptor
  ↓
контролер
  ↓
Observable з результатом
  ↓
map(...)
  ↓
трансформована відповідь

intercept(
  context: ExecutionContext,
  next: CallHandler,
): Observable<unknown> {
  return next.handle().pipe(
    map((data) => ({
      data,
    })),
  );
}

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

export interface ApiResponse<T> {
  data: T;
}

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

NestInterceptor<T, ApiResponse<T>>

{
  data: T
}

import {
  Controller,
  Get,
  UseInterceptors,
} from '@nestjs/common';
import { TransformInterceptor } from './transform.interceptor';

interface User {
  id: number;
  name: string;
}

@Controller('users')
@UseInterceptors(TransformInterceptor)
export class UsersController {
  @Get()
  findAll(): User[] {
    return [
      { id: 1, name: 'Anna' },
      { id: 2, name: 'Oleh' },
    ];
  }

  @Get('first')
  findFirst(): User {
    return {
      id: 1,
      name: 'Anna',
    };
  }
}

[
  {
    "id": 1,
    "name": "Anna"
  },
  {
    "id": 2,
    "name": "Oleh"
  }
]

{
  "id": 1,
  "name": "Anna"
}

{
  "data": [
    {
      "id": 1,
      "name": "Anna"
    },
    {
      "id": 2,
      "name": "Oleh"
    }
  ]
}

{
  "data": {
    "id": 1,
    "name": "Anna"
  }
}

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

export interface ApiResponse<T> {
  data: T;
}

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

import {
  Controller,
  Get,
  UseInterceptors,
} from '@nestjs/common';
import { TransformInterceptor } from './transform.interceptor';

interface User {
  id: number;
  name: string;
}

@Controller('users')
@UseInterceptors(TransformInterceptor)
export class UsersController {
  @Get()
  findAll(): User[] {
    return [
      { id: 1, name: 'Anna' },
      { id: 2, name: 'Oleh' },
    ];
  }

  @Get(':id')
  findOne(): User {
    return {
      id: 1,
      name: 'Anna',
    };
  }
}

import { Module } from '@nestjs/common';
import { UsersController } from './users.controller';

@Module({
  controllers: [UsersController],
})
export class AppModule {}

GET /users

{
  "data": [
    {
      "id": 1,
      "name": "Anna"
    },
    {
      "id": 2,
      "name": "Oleh"
    }
  ]
}

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

async function bootstrap() {
  const app = await NestFactory.create(AppModule);

  app.useGlobalInterceptors(new TransformInterceptor());

  await app.listen(3000);
}

bootstrap();

import { Module } from '@nestjs/common';
import { APP_INTERCEPTOR } from '@nestjs/core';
import { UsersController } from './users.controller';
import { TransformInterceptor } from './transform.interceptor';

@Module({
  controllers: [UsersController],
  providers: [
    {
      provide: APP_INTERCEPTOR,
      useClass: TransformInterceptor,
    },
  ],
})
export class AppModule {}

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

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

{
  id: 1,
  name: 'Anna',
}

{
  "success": true,
  "data": {
    "id": 1,
    "name": "Anna"
  }
}

return [];

{
  "data": []
}

return null;

{
  "data": null
}

import {
  Controller,
  Get,
  NotFoundException,
} from '@nestjs/common';

@Controller('users')
export class UsersController {
  @Get('missing')
  findMissing() {
    throw new NotFoundException('Користувача не знайдено');
  }
}

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

return next.handle().pipe(
  map((data) => ({
    data,
  })),
);

return {
  data: users,
};

{
  "data": {
    "data": []
  }
}