如何在NestJS+TypeORM中排除User实体敏感属性返回给前端？

现有基于NestJS+TypeORM的用户列表API，当前会直接返回包含password、accessToken等敏感字段的UserEntity全量数据，需要实现类似Laravel Resource的字段过滤功能，以下是三种常用实现方案：

方案一：TypeORM 查询构建器（从数据库层面过滤） #

直接在查询时只选择需要返回的字段，避免查询敏感字段，性能最优。修改user.service.ts的findAll方法：

@Injectable()
export class UserService {
    public constructor(@InjectRepository(UserEntity) private userRepository: Repository<UserEntity>) {}

    public async findAll(): Promise<Partial<UserEntity>[]> {
        return await this.userRepository
            .createQueryBuilder('user')
            .select([
                'user.id',
                'user.name',
                'user.email',
                'user.age',
                'user.lastActive',
                'user.createdAt',
                'user.updatedAt'
            ])
            .getMany();
    }
}

优点：数据库只查询必要字段，减少数据传输量；缺点：如果需要不同场景返回不同字段，需要写多个查询方法。

方案二：DTO + Class-Transformer（类似Laravel Resource） #

创建一个数据传输对象（DTO）定义允许返回的字段，通过class-transformer将实体转换为DTO，实现字段过滤。

步骤1：创建user-response.dto.ts #

import { Expose } from 'class-transformer';

export class UserResponseDto {
    @Expose()
    id: number;

    @Expose()
    name: string;

    @Expose()
    email: string;

    @Expose()
    age: number;

    @Expose()
    lastActive: string;

    @Expose()
    createdAt: Date;

    @Expose()
    updatedAt: Date;
}

步骤2：修改控制器，转换实体为DTO #

import { plainToInstance } from 'class-transformer';
import { UserResponseDto } from './user-response.dto';

@Controller("user")
export class UserController {
    constructor(private readonly userService: UserService) {}

    @Get()
    public async getUsers(): Promise<UserResponseDto[]> {
        const users = await this.userService.findAll();
        return plainToInstance(UserResponseDto, users, { excludeExtraneousValues: true });
    }
}

优点：统一管理返回格式，支持多场景复用不同DTO；缺点：需要先查询全量实体再转换，数据量稍大，但代码更易维护，符合NestJS的DTO规范。

方案三：自定义序列化拦截器（全局/批量处理） #

如果多个接口都需要字段过滤，可以自定义拦截器配合DTO使用，减少重复代码。

步骤1：创建serialize.interceptor.ts #

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

@Injectable()
export class SerializeInterceptor implements NestInterceptor {
    constructor(private readonly dto: any) {}

    intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
        return next.handle().pipe(
            map((data: any) => {
                return plainToInstance(this.dto, data, { excludeExtraneousValues: true });
            })
        );
    }
}

步骤2：在控制器上使用拦截器 #

import { UseInterceptors } from '@nestjs/common';
import { SerializeInterceptor } from '../interceptors/serialize.interceptor';
import { UserResponseDto } from './user-response.dto';

@Controller("user")
@UseInterceptors(new SerializeInterceptor(UserResponseDto))
export class UserController {
    constructor(private readonly userService: UserService) {}

    @Get()
    public getUsers(): Promise<UserEntity[]> {
        return this.userService.findAll();
    }
}

优点：一次配置，多个接口复用；缺点：需要额外创建拦截器文件，适合多接口统一格式的场景。

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