如何基于外部requiredFields数组实现class-validator动态类验证？

针对你需要根据外部动态获取的requiredFields数组来控制字段必填性的需求，以下是三种可落地的实现方案，适配不同场景：

方案1：自定义动态必填装饰器（静态配置场景） #

如果requiredFields是系统全局配置、可提前从数据库加载后再定义验证类的场景，可以通过自定义装饰器工厂函数实现：

import { registerDecorator, ValidationOptions, ValidationArguments } from 'class-validator';

// 自定义动态必填装饰器
export function IsDynamicallyRequired(requiredFields: string[], validationOptions?: ValidationOptions) {
  return function (object: Object, propertyName: string) {
    registerDecorator({
      name: 'isDynamicallyRequired',
      target: object.constructor,
      propertyName: propertyName,
      options: validationOptions,
      validator: {
        validate(value: any, args: ValidationArguments) {
          // 若当前字段在必填列表中，则检查非空；否则直接通过
          if (requiredFields.includes(args.property)) {
            return value !== undefined && value !== null && value.trim() !== '';
          }
          return true;
        },
        defaultMessage(args: ValidationArguments) {
          return `${args.property} 为必填字段`;
        },
      },
    });
  };
}

// 使用示例：先从数据库加载必填字段列表
const requiredFields = ['name', 'motherName']; // 模拟DB查询结果

class PersonType {
  @IsDynamicallyRequired(requiredFields, { message: '姓名不能为空' })
  name: string;

  @IsDynamicallyRequired(requiredFields)
  motherName: string;

  email: string;
}

局限性：装饰器在类定义阶段执行，若requiredFields是后续动态变化的（比如每次请求规则不同），该方案不适用。

方案2：运行时手动校验（动态场景） #

如果requiredFields每次验证都可能变化（比如不同用户自定义不同必填项），可以在基础验证后手动补充动态规则校验：

import { validate, ValidationError } from 'class-validator';

class PersonType {
  name: string;
  motherName: string;
  email: string;
}

async function validatePerson(person: PersonType, requiredFields: string[]): Promise<ValidationError[]> {
  // 先执行class-validator的基础字段验证（如格式校验等）
  const baseErrors = await validate(person);

  // 手动检查动态必填字段
  const dynamicErrors: ValidationError[] = [];
  for (const field of requiredFields) {
    const value = person[field as keyof PersonType];
    if (value === undefined || value === null || value.trim() === '') {
      dynamicErrors.push({
        property: field,
        constraints: {
          isNotEmpty: `${field} 为必填字段`,
        },
      });
    }
  }

  // 合并两类错误返回
  return [...baseErrors, ...dynamicErrors];
}

// 使用示例
const person = { name: '', email: 'test@example.com' };
const requiredFields = ['name', 'motherName']; // 从数据库动态获取
const errors = await validatePerson(person as PersonType, requiredFields);
if (errors.length > 0) {
  // 处理验证错误逻辑
}

优势：完全动态，每次验证可传入不同的requiredFields，不受类定义阶段限制，适配高频变化的规则场景。

方案3：验证组（Groups）动态切换（固定字段场景） #

如果字段固定，仅需动态切换哪些字段必填，可以利用class-validator的验证组特性：

import { IsNotEmpty, validate } from 'class-validator';

class PersonType {
  @IsNotEmpty({ groups: ['name_required'] })
  name: string;

  @IsNotEmpty({ groups: ['motherName_required'] })
  motherName: string;

  @IsNotEmpty({ groups: ['email_required'] })
  email: string;
}

// 根据必填字段列表生成对应的验证组
function getValidationGroups(requiredFields: string[]): string[] {
  return requiredFields.map(field => `${field}_required`);
}

// 使用示例
const person = { name: '', motherName: 'Smith' };
const requiredFields = ['name', 'motherName'];
const groups = getValidationGroups(requiredFields);
const errors = await validate(person, { groups });

适用场景：字段集合固定，仅需动态启用不同字段的必填规则，代码结构更规整。

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