How to describe validators for two possible types: array or string?

How to describe validators for two possible types: array or string?

Two decorators seems not working.

@IsBoolean()
@IsString()
private readonly foo: boolean | string;

[NoNameProvided]

How about a signature like:

@IsType(Array<(val: any) => boolean>)

@IsType([
 val => typeof val == 'string',
 val => typeof val == 'boolean',
])
private readonly foo: boolean | string;

[ZBAGI]

@NoNameProvided Personally i’m against complex logic in decorator definitions. Imagine having repeat those val => typeof val == 'string' in every property you want to validate. It quickly gets messy. Especially when you will need to change the logic of validating - then you will need to look for all references and change them one by one.

I suggest you to implement similar solution to the one i posted here. Or if it’s common to validate multi-typed properties in your project, you can use custom decorator factory to specify which type you want to validate.

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


const typeValidator = {
    "string": function (value: any, args: ValidationArguments) {
        const validator = new Validator();
        return validator.isString(value);
    },
    "int": function (value: any, args: ValidationArguments) {
        const validator = new Validator();
        return validator.isInt(value);
    }
// Add more here
};

export function IsType(types: (keyof (typeof typeValidator))[], validationOptions?: ValidationOptions) {
    return function (object: Object, propertyName: string) {
        registerDecorator({
            name: "wrongType",
            target: object.constructor,
            propertyName: propertyName,
            options: validationOptions,
            validator: {
                validate(value: any, args: ValidationArguments) {
                    return types.some(v => typeValidator[v](value, args));
                },
                defaultMessage(validationArguments?: ValidationArguments) {
                    const lastType = types.pop();
                    if (types.length == 0)
                        return `Has to be ${lastType}`;
                    return `Can only be ${types.join(", ")} or ${lastType}.`;
                }
            }
        });
    };
}

And then usage is very simple and clean:

class example {
    @IsType(["string", "int"])
    public someValue: number | string;
}