question: can we perform a oneOf validation?

[manan]

Description

How to perform a oneOf validation of a nested object i.e., child object is either of TypeA or TypeB? This seems like a very common use case, is there an out-of-the-box solution for this? I understand that this problem is concerning class-transformer more than it is class-validator..

Is there an example of a generic @OneOf()decorator? Any ideas on how to work with class-transformer and class-validator together to make this happen?

Reproduction

class TypeA {

    @IsString()
    public foo;
}

class TypeB {

    @IsString()
    public bar;
}

class Parent {

    @IsObject()
    @ValidateNested()
    @Type((): Function => TypeA)  // ???
    public child: TypeA | TypeB;
}

Environment

• nodejs: 8.11.2
• browser
• framework/library

class-validator version: 0.12.2

[hood]

You could write a custom validator, passing the an array of types to check your property against. If there's a match, you validate the field

[ibraah88]

+1

[ibraah88]

@mehtamanan can you try this ?

import {
  registerDecorator,
  ValidationOptions,
  ValidatorConstraint,
  ValidatorConstraintInterface,
  ValidationArguments,
} from 'class-validator';
import { activitiesList } from '../activitiesList';

@ValidatorConstraint({ async: true })
export class OneOfConstraint implements ValidatorConstraintInterface {
  validate(activities: any, args: ValidationArguments) {
   return Array.isArray(activities)
      ? activities.every(item => activitiesList.includes(item))
      : false;
  }
}

export function OneOf(validationOptions?: ValidationOptions) {
  return function(object: Object, propertyName: string) {
    registerDecorator({
      target: object.constructor,
      propertyName: propertyName,
      options: validationOptions,
      constraints: [],
      validator: OneOfConstraint,
    });
  };
}

---

and to use it in your DTO

...
import { activities } from '../activities';
...

  @IsArray()
  @IsNotEmpty()
  @OneOf({
    message: `activities must be in: ${activities}`,
  })
  activities: string[];

[BoKKeR]

how does activitiesList look like? @isdiop

[BoKKeR]

my use case is:

class booleanField {
  @IsString({ message: errors.notString })
  name: string

  @IsString({ message: errors.notString })
  type: string

  @IsString({ message: errors.notString })
  key: string
}

class numberField {
  @IsString({ message: errors.notString })
  name: string

  @IsString({ message: errors.notString })
  type: string

  @IsString({ message: errors.notString })
  key: string
}

export const fieldArray = [booleanField, numberField]

class Categories {
  @IsString({ message: errors.notString })
  name: string

  @IsString({ message: errors.notString })
  type: string

  @IsString({ message: errors.notString })
  key: string

  @IsArray()
  @OneOf({ message: `must be part of ${fieldArray}` })
  fields
}

I imported fieldArray and placed it in instead of activitiesList. It never turns true with this object.

"categories": [
        {
            "username": "aaaa",
            "id": "string",
            "name": "string",
            "type": "string",
            "key": "string",
            "fields": [
                {
                    "name": "test",
                    "type": "test",
                    "key": "test"
                }
            ]
        }
    ]

[ibraah88]

hi @BoKKeR sorry for the late,

ActivitiesList look like :

export enum ActivitiesList {
  'aa-aa' = 'AA AA',
  'bb-bb' = 'BB BB',
  'cc-cc' = "CC CC"
}

export const ActivitiesKeys = Object.keys(ActivitiesList);

[rmolinamir]

Try this decorator, and feel free to adapt to your needs:

import { ClassConstructor, plainToInstance, Type } from 'class-transformer';
import { registerDecorator, validateSync } from 'class-validator';

export function OneOf(
  types: Exclude<Parameters<typeof Type>[0], undefined>[]
): PropertyDecorator {
  return function (target: Object, propertyName: PropertyKey) {
    registerDecorator({
      name: 'wrongType',
      target: target.constructor,
      propertyName: propertyName.toString(),
      options: {},
      validator: {
        validate(arg: object | Array<object>) {
          let objects: Array<object>;

          if (Array.isArray(arg)) objects = arg;
          else objects = [arg];

          for (const somethingToTransform of objects) {
            const isValid = types.some((t) => {
              const classType = t() as ClassConstructor<object>;

              let object: object;

              if (typeof somethingToTransform === 'string') {
                object = JSON.parse(somethingToTransform);
              } else if (
                somethingToTransform != null &&
                typeof somethingToTransform === 'object'
              ) {
                object = somethingToTransform;
              } else {
                throw new Error(
                  'Incorrect object param type! Only string or objects are allowed.'
                );
              }

              const instance = plainToInstance(classType, object, undefined);

              try {
                const errors = validateSync(instance);

                if (errors.length) return false;
                else return true;
              } catch (error) {
                return false;
              }
            });

            if (!isValid) return false;
          }

          return true;
        },
        defaultMessage() {
          if (types.length === 0) {
            return '';
          } else if (types.length === 1) {
            const type = types[0]();
            return `Has to be of type ${type.name}.`;
          } else {
            const lastType = types.pop()!();
            return `Can only be of types ${types
              .map((t) => {
                const type = t();
                return type.name;
              })
              .join(', ')}, or ${lastType.name}.`;
          }
        }
      }
    });
  };
}

Usage:

class ImportNotifier {
  @IsArray()
  @ArrayMinSize(1)
  @ValidateNested({ each: true })
  @OneOf([() => S3Uri, () => HttpUri])
  public notifications!: (S3Uri | HttpUri)[];
}

[NoNameProvided]

As for the original question, yes this is more a question to class-transformer and not class-validator.

Closing this as answered by others.

If the issue still persists, you may open a new Q&A in the discussions tab and someone from the community may be able to help.

[github-actions]

This issue has been automatically locked since there has not been any recent activity after it was closed. Please open a new issue for related bugs.