NestJS：如何将复杂Entity转换为Dto并排除嵌套属性

Great question—you're actually on the right track with class-transformer's @Exclude and @Expose decorators; the issue is likely that you're referencing your original Entity classes in your DTO instead of nested DTO classes, and missing key configuration to enable recursive transformation. Let's break down the fix step by step:

1. Define Nested DTO Classes #

First, create dedicated DTOs for each nested Entity type, applying @Exclude to the fields you want to remove. Make sure your top-level DTO references these nested DTOs instead of the original Entity classes:

import { Exclude, Type } from 'class-transformer';

// Top-level DTO
export class AdvisoryResultDto {
  public id: string;
  public userId: string;
  // Reference your CalculationOutput DTO (define this similarly for your complex structure)
  @Type(() => CalculationOutputDto)
  public results: CalculationOutputDto[];
  // Reference the nested ItemDto instead of the original Item Entity
  @Type(() => ItemDto)
  public item: ItemDto;
}

// Nested Item DTO
export class ItemDto {
  @Exclude() // Exclude the `privat` field entirely
  public privat: PrivateDto;
  // Reference the nested StateDto
  @Type(() => StateDto)
  public state: StateDto;
  public combined: number;
}

// Nested State DTO
export class StateDto {
  public numberA: number;
  @Exclude() // Exclude the `numberB` field
  public numberB: number;
  public numberC: number;
  public numberD: number;
}

// Define your CalculationOutputDto to match your complex Entity structure
// Apply @Exclude/@Expose and @Type decorators for its nested fields as needed
export class CalculationOutputDto {
  // Your complex nested field definitions here
}

2. Configure the Transformation Interceptor #

Make sure your custom interceptor uses classToPlain with the excludeExtraneousValues option enabled. This tells class-transformer to respect your @Exclude/@Expose decorators across all nested levels:

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

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

3. Register the Interceptor #

Register the interceptor either globally (in your root module) or on specific controllers/routes:

Global Registration #

import { Module } from '@nestjs/common';
import { APP_INTERCEPTOR } from '@nestjs/core';
import { EntityToDtoInterceptor } from './interceptors/entity-to-dto.interceptor';

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

Controller/Route Registration #

import { Controller, Get, UseInterceptors } from '@nestjs/common';
import { EntityToDtoInterceptor } from './interceptors/entity-to-dto.interceptor';

@Controller('results')
@UseInterceptors(EntityToDtoInterceptor)
export class ResultsController {
  @Get()
  getResults(): AdvisoryResultDto {
    // Return your ResultEntity instance here—it will be transformed automatically
    return new ResultEntity('1', 'user123');
  }
}

Why Your Original Approach Didn't Work #

The key issue was that you were referencing the original Item Entity class in your AdvisoryResultDto instead of a dedicated ItemDto. class-transformer only applies decorators to the classes you explicitly reference in your DTO structure. By swapping to nested DTOs and using the @Type decorator to specify nested types, you enable recursive transformation that respects your @Exclude rules at every level.

Alternative: Manual Transformation with @Transform (For Simple Cases) #

If you only need to exclude a few nested fields and don't want to define full nested DTOs, you can use the @Transform decorator to modify the nested object directly. This is less scalable for complex structures but works for quick fixes:

import { Transform } from 'class-transformer';

export class AdvisoryResultDto {
  public id: string;
  public userId: string;
  public results: CalculationOutputDto[];
  @Transform(({ value }) => {
    // Remove `privat` from Item and `numberB` from State
    const { privat, ...itemWithoutPrivat } = value;
    itemWithoutPrivat.state = { ...itemWithoutPrivat.state, numberB: undefined };
    return itemWithoutPrivat;
  })
  public item: Item;
}

For your complex CalculationOutput structure, though, defining nested DTOs is far more maintainable and scalable.

内容的提问来源于stack exchange，提问作者Manuel Wolf