export interface ValidationOptions {
  /**
   * Indicates that an object is to be considered a plain record.
   * 
   * For an object-valued property marked as plain, the object the property holds may neither
   * be specifically class-typed nor validated, but all of the child values of said object MUST be.
   * Effectively, this declares a "plain record", which will be validated the same way any other 
   * JavaScript collection does (Array, Map, Set, etc).
   * The default is `false`; that is, an object-value must be an instance of a class.
   */
  plain?: boolean;
}

export class ValidationExecutor {

  // Not changed
  // ...

  private nestedValidations(value: any, metadatas: ValidationMetadata[], errors: ValidationError[]): void {
      // Not changed
      // ...

      // At line 346
      if (value instanceof Array || value instanceof Set || value instanceof Map) {
        // Not changed
        //  ...
      } else if (value instanceof Object) {
        if (metadata.validationOptions.plain) {
          // Here, we do essentially what would be done with a Map-typed property
          Object.values(value).forEach((subValue: any, index: any) => {
            this.performValidations(value, subValue, index.toString(), [], metadatas, errors);
          });
        } else {
          const targetSchema = typeof metadata.target === 'string' ? metadata.target : metadata.target.name;
          this.execute(value, targetSchema, errors);
        }
      } else {
        // Not changed
        //  ...
      }
    });
  }

import {
    ValidatorConstraint,
    ValidatorConstraintInterface,
    validate,
    ValidationArguments,
    ValidationError,
} from 'class-validator';
import {
    ClassConstructor,
    plainToClass,
} from 'class-transformer';

@ValidatorConstraint({ async: true })
export class RecordValidator<T extends Record<string, unknown>> implements ValidatorConstraintInterface {
    validationErrors: ValidationError[][] = [];

    async validate(record: Record<string, T>, validationArguments: ValidationArguments) {
        const ClassTransformer = validationArguments.constraints?.[0] as ClassConstructor<T>;

        if (!ClassTransformer) {
            return false;
        }

        const values = Object.values(record);

        this.validationErrors = await Promise.all(values.map((value) => {
            const transformedValue = plainToClass(ClassTransformer, value);

            return validate(transformedValue);
        }));

        return this.validationErrors.every((validationError) => isEmpty(validationError));
    }

    defaultMessage() {
        return this.validationErrors.map(
            (errors) => errors.reduce(
                (acc, error) => error.constraints ? [...acc, ...Object.values(error.constraints)] : acc,
                [],
            ).join(', '),
        ).join(', ');
    }
}

class  ButtonDto {
    @IsString()
    id: sting;

    @IsOptional()
    @IsString()
    name?: string;
}

export class SomeDto {
    @Validate(RecordValidator, [ButtonDto])
    buttons: Record<string, ButtonDto>;
}