Confirm that the array includes all unique objects that have the specified properties and values

Question

Confirm that the array includes all unique objects that have the specified properties and values

I have been searching through the class-validators samples and documentation, but I have not been able to find the specific validation that I require.

Within my code, I have an array of object literals that each contain unique properties and values.

const comboItems = [{itemType: 'Entree'}, {itemType: 'Side'}, {itemType: 'Beverage'}];

My goal is to validate the following criteria for the comboItems array: it must not be empty, it must contain a minimum and maximum of 3 objects, and it must include one object with itemType === 'Entree', another with itemType === 'Side', and a third with itemType === 'Beverage'.

Below is the class I have created, which does not provide the correct validation:

import {validate, ArrayContains, ArrayNotEmpty, ArrayMinSize, ArrayMaxSize} from 'class-validator';
import { plainToClass } from 'class-transformer';

export class MealMenuItem {
    @ArrayContains([{itemType: 'Entree'}, {itemType: 'Side'}, {itemType: 'Beverage'}])
    @ArrayNotEmpty()
    @ArrayMinSize(3)
    @ArrayMaxSize(3)
    comboItems: any[];
}

const mealMenuItemData: any = {comboItems: [{itemType: 'Entree'}, {itemType: 'Side'}, {itemType: 'Beverage'}]};

const mealMenuItemDataClassInstance = plainToClass(MealMenuItem, mealMenuItemData as MealMenuItem)

validate(mealMenuItemDataClassInstance).then(errors => {
    if (errors.length > 0) 
        console.log('validation failed. errors: ', JSON.stringify(errors));
    else 
        console.log('validation succeed');
});

If anyone can offer assistance, I would greatly appreciate it!

typescript class-validator

Answer 1

Answer №1

The method of the ArrayContains decorator is designed solely to validate primitive types, as indicated by this snippet from the class-validator module:

export function arrayContains(array: unknown, values: any[]): boolean {
  if (!(array instanceof Array)) return false;

  // Returns false for object items
  return values.every(value => array.indexOf(value) !== -1);
}

View source code

To enhance validation for your itemType field, you can create a custom decorator like so:

import {
    validate,
    ArrayMinSize,
    ArrayMaxSize,
    registerDecorator,
    ValidationOptions,
    ValidationArguments
} from 'class-validator';
import { plainToClass } from 'class-transformer';

function ContainSequenceOf(property: string, validationOptions?: ValidationOptions & { containThese: string[] }) {
    return function (object: Object, propertyName: string) {
        registerDecorator({
            name: 'containSequenceOf',
            target: object.constructor,
            propertyName: propertyName,
            constraints: [property],
            options: validationOptions,
            validator: {
                validate(value: any, args: ValidationArguments) {
                    const [relatedPropertyName] = args.constraints;
                    return value.every((item, i) => {
                        return item[relatedPropertyName] === validationOptions?.containThese[i]
                    })
                },
            },
        });
    };
}
export class MealMenuItem {
    @ContainSequenceOf('itemType', {
        message: "Is Not Valid!",
        containThese: ['Entree', 'Side', 'Beverage']
    })
    @ArrayMinSize(3)
    @ArrayMaxSize(3)
    comboItems: any[];
}

const mealMenuItemData: any = {comboItems: [{ itemType: 'Entree' }, { itemType: 'Side' }, { itemType: 'Beverage' }]};
const mealMenuItemDataClassInstance = plainToClass(MealMenuItem, mealMenuItemData as MealMenuItem)

validate(mealMenuItemDataClassInstance).then(errors => {
    if (errors.length > 0) 
        console.log('Validation failed. Errors: ', JSON.stringify(errors));
    else 
        console.log('Validation successful');
});

Answer 2

The method of the ArrayContains decorator is designed solely to validate primitive types, as indicated by this snippet from the class-validator module:

export function arrayContains(array: unknown, values: any[]): boolean {
  if (!(array instanceof Array)) return false;

  // Returns false for object items
  return values.every(value => array.indexOf(value) !== -1);
}

View source code

To enhance validation for your itemType field, you can create a custom decorator like so:

import {
    validate,
    ArrayMinSize,
    ArrayMaxSize,
    registerDecorator,
    ValidationOptions,
    ValidationArguments
} from 'class-validator';
import { plainToClass } from 'class-transformer';

function ContainSequenceOf(property: string, validationOptions?: ValidationOptions & { containThese: string[] }) {
    return function (object: Object, propertyName: string) {
        registerDecorator({
            name: 'containSequenceOf',
            target: object.constructor,
            propertyName: propertyName,
            constraints: [property],
            options: validationOptions,
            validator: {
                validate(value: any, args: ValidationArguments) {
                    const [relatedPropertyName] = args.constraints;
                    return value.every((item, i) => {
                        return item[relatedPropertyName] === validationOptions?.containThese[i]
                    })
                },
            },
        });
    };
}
export class MealMenuItem {
    @ContainSequenceOf('itemType', {
        message: "Is Not Valid!",
        containThese: ['Entree', 'Side', 'Beverage']
    })
    @ArrayMinSize(3)
    @ArrayMaxSize(3)
    comboItems: any[];
}

const mealMenuItemData: any = {comboItems: [{ itemType: 'Entree' }, { itemType: 'Side' }, { itemType: 'Beverage' }]};
const mealMenuItemDataClassInstance = plainToClass(MealMenuItem, mealMenuItemData as MealMenuItem)

validate(mealMenuItemDataClassInstance).then(errors => {
    if (errors.length > 0) 
        console.log('Validation failed. Errors: ', JSON.stringify(errors));
    else 
        console.log('Validation successful');
});

Confirm that the array includes all unique objects that have the specified properties and values

Answer №1

Similar questions

What is the best way to create props that can accommodate three distinct types of functions in TypeScript?

Enhance the Next.js higher-order authentication component by including extra data in the return

In Typescript, what is the antonym of "Choose"?

Utilize the expert capabilities within #dateHeaderTemplate in the Angular component schedule by Syncfusion

What is the best way to change the name of an imported variable currently named `await` to avoid conflicting with other variables?

The initial function is executed only after the second function has completed, as it relies on the

Caution: Ensuring that every child item in a list possesses a distinct "key" prop is crucial when working with React in TypeScript

A guide on utilizing portals in Next.js to move a child element beyond its direct parent container

In TypeScript, combining the numbers 0 and 1 results in the value 01

Using arrow functions in Typescript e6 allows for the utilization of Array.groupBy

Creating a Loading Sign with a Button Component in React

What is the best way to automatically refresh an observable every 30 seconds?

How can I confine a non-UMD module that has been imported in Webpack and Typescript to just one file?

Is it possible to retrieve 2 arguments within a function in a non-sequential manner?

How to create a boolean observable that emits hot values with switchMap?

Creating an interface or type in Typescript with a nested object property that uses keys from the same interface

Nextjs 14 experiences full page loading due to the presence of multiple root layouts

Capturing a webpage through Record RTC integration with Angular

Angular 6: Sending Back HTTP Headers

TS - deduce the specific type of a key value without receiving a union type