NestJS中如何通过Interceptor动态设置控制器方法的SerializeOptions

下面提供两种可行的实现方案，无需依赖外部链接，直接基于NestJS和class-transformer的核心能力实现：

方法一：自定义拦截器手动处理序列化 #

这种方式绕过静态元数据限制，直接在拦截器中调用class-transformer的序列化方法，动态传入角色对应的分组。

1. 创建自定义拦截器 #

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 DynamicSerializeInterceptor implements NestInterceptor {
  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
    // 从请求中获取用户角色
    const role = context.switchToHttp().getRequest().user?.role;
    // 从元数据中读取控制器方法指定的DTO类型
    const handler = context.getHandler();
    const dtoType = Reflect.getMetadata('serializer:dto', handler);

    return next.handle().pipe(
      map(data => {
        // 无DTO或角色时直接返回原始数据
        if (!dtoType || !role) return data;
        // 动态应用角色分组完成序列化
        return plainToInstance(dtoType, data, {
          groups: [role],
          excludeExtraneousValues: true // 仅保留DTO中@Expose标记的字段
        });
      }),
    );
  }
}

2. 创建装饰器标记DTO #

import { SetMetadata } from '@nestjs/common';

// 自定义装饰器，用于指定控制器方法返回的DTO类型
export const SerializeDto = (dto: any) => SetMetadata('serializer:dto', dto);

3. 在控制器中使用 #

import { Get, Controller } from '@nestjs/common';
import { SerializeDto } from './serialize-dto.decorator';
import { UserDto } from './user.dto';

@Controller('users')
export class UsersController {
  @Get()
  @SerializeDto(UserDto)
  async getUser() {
    return { id: 1, name: 'John Doe', adminNotes: '仅管理员可见' };
  }
}

4. 定义带分组的DTO #

import { Expose } from 'class-transformer';

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

  @Expose()
  name: string;

  // 仅admin角色能看到该字段
  @Expose({ groups: ['admin'] })
  adminNotes: string;
}

方法二：动态修改默认序列化元数据 #

这种方式复用Nest默认的ClassSerializerInterceptor，通过临时修改控制器方法的元数据实现动态分组，请求结束后恢复原元数据避免并发冲突。

1. 创建动态元数据拦截器 #

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

@Injectable()
export class DynamicRoleSerializeInterceptor implements NestInterceptor {
  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
    const role = context.switchToHttp().getRequest().user?.role;
    const handler = context.getHandler();

    // 保存原始序列化配置
    const originalOptions = Reflect.getMetadata('class_serializer:options', handler) || {};
    // 动态更新元数据，添加角色分组
    Reflect.setMetadata('class_serializer:options', {
      ...originalOptions,
      groups: [role],
    }, handler);

    return next.handle().pipe(
      // 请求完成后恢复原始元数据，防止影响后续请求
      finalize(() => {
        Reflect.setMetadata('class_serializer:options', originalOptions, handler);
      }),
    );
  }
}

2. 配置拦截器执行顺序 #

确保自定义拦截器在默认ClassSerializerInterceptor之前执行，这样默认拦截器能读取到修改后的元数据：

import { Module } from '@nestjs/common';
import { APP_INTERCEPTOR } from '@nestjs/core';
import { DynamicRoleSerializeInterceptor } from './dynamic-role-serialize.interceptor';
import { ClassSerializerInterceptor } from '@nestjs/common';

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

3. 结合静态序列化配置（可选） #

如果需要保留静态序列化选项，可搭配@SerializeOptions使用：

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

@Controller('users')
@SerializeOptions({ excludeExtraneousValues: true })
export class UsersController {
  @Get()
  async getUser() {
    return { id: 1, name: 'John Doe', adminNotes: '仅管理员可见' };
  }
}

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