Typescript class validator that validates based on varying data types

Question

Typescript class validator that validates based on varying data types

Currently, I am utilizing TypeORM and seeking ways to dynamically set the validation fields based on the value of another field. Let me illustrate this using my DTO model:

import { IsString, IsOptional, IsNumber, IsEnum, IsObject, IsBoolean, ValidateNested } from 'class-validator';

export enum AttributeTypes {
    DATE = 'DATE',
    TIME = 'TIME',
    NUMBERS = 'NUMBERS',
}

export class BaseValidation {
    @IsOptional()
    @IsBoolean()
    required: boolean;
}

export class modelCreate {
    @IsOptional()
    @IsNumber()
    id: number;

    @IsOptional()
    @IsString()
    label: string;

    @IsOptional()
    @IsEnum(AttributeTypes)
    type: AttributeTypes;

    @IsOptional()
    @IsObject()
    @ValidateNested()
    validation: BaseValidation;
}

An issue arises with the validation field within modelCreate as it can vary in structure and properties when stored in the database:

validation: {
   required: true,
   text: 2
}

or may appear like this:

   validation: {
       required: false,
       number: 1,
       maxNumber: 10
    }

This variability is dependent on the type property within modelCreate. For example, if the type is 'TIME', the desired validation would be:

BaseValidation {
    @IsBoolean()
     required: true,
    @IsString()
    text: 2
}

Conversely, if the type is 'NUMBERS', the expected validation format changes to:

  BaseValidation {
           @IsBoolean()
           required: boolean,
           @IsNumber()
           number: number,
           @IsNumber()
           maxNumber: number
        }

The main query revolves around how to switch between different classes in the validation field based on the value of the type field within class validator, and whether such a functionality is feasible.

typescript typeorm class-validator

Answer 1

Answer №1

To achieve this, it is necessary to create two separate classes for handling strings and numbers respectively. Next, update the type to

validation: StringBaseValidation | NumberBaseValidation;

. This will allow the class-validator to differentiate between the two cases.

If the data is being retrieved from a request, you should use

@Type((obj) => obj.writeConditionToDetectString ? StringBaseValidation : NumberBaseValidation)

to assist the library in identifying the correct type of data coming from the request.

Answer 2

To achieve this, it is necessary to create two separate classes for handling strings and numbers respectively. Next, update the type to

validation: StringBaseValidation | NumberBaseValidation;

. This will allow the class-validator to differentiate between the two cases.

If the data is being retrieved from a request, you should use

@Type((obj) => obj.writeConditionToDetectString ? StringBaseValidation : NumberBaseValidation)

to assist the library in identifying the correct type of data coming from the request.

Answer 3

Answer №2

Ensure you have a distinct field to facilitate the class-transformer in recognizing the type for casting and utilizing in validation. This can also be applied to nested array objects by using the "required" field.

For instance, if the value of the property required is true, then utilize class A; otherwise, if it is false, use class B.
In the discriminator property, define a field that distinguishes between different polymorphic forms of nested objects. The subTypes.[].value represents the class used in validation, while subTypes.[].name signifies the value expected by the discriminator field to match the corresponding class specified in subTypes.[].name.

import { Type } from 'class-transformer';
import { IsBoolean, IsNumber, IsString, ValidateNested } from 'class-validator';

class Discriminator {
  @IsBoolean()
  required: boolean;
}

class A extends Discriminator {  
  @IsString()
  text: string;
}

class B extends Discriminator {  
  @IsNumber()
  number: number;

  @IsNumber()
  maxNumber: number
}

export class C {

  // Other fields...

  @ValidateNested()
  @Type(() => Discriminator, {
    discriminator: {
      property: 'required',
      subTypes: [
        { value: A, name: true as unknown as string },
        { value: B, name: false  as unknown as string },
      ],
    },
    keepDiscriminatorProperty: true,
  })
  validation: A | B;
}

Update your controller to reflect these changes:

@Controller()
export class AppController {
  @Post()
  public example(
    @Body(new ValidationPipe({ transform: true }))
    body: C,
  ) {
    return body;
  }
}

You can now make requests as follows:

curl --location 'localhost:3000/' \
--header 'Content-Type: application/json' \
--data '{
  "validation": {
    "required": true,
    "text": "Some text..."
  } 
}'

If you adjust the second element of the required property to false, an error will occur:

{
- "required": true,
+ "required": false,
  "text": "Some text..."
}

{
  "statusCode": 400,
  "message": [
    "validation.number must be a number conforming to the specified constraints",
    "validation.maxNumber must be a number conforming to the specified constraints"
  ],
  "error": "Bad Request"
}

References: https://github.com/typestack/class-transformer#providing-more-than-one-type-option

Answer 4

Ensure you have a distinct field to facilitate the class-transformer in recognizing the type for casting and utilizing in validation. This can also be applied to nested array objects by using the "required" field.

For instance, if the value of the property required is true, then utilize class A; otherwise, if it is false, use class B.
In the discriminator property, define a field that distinguishes between different polymorphic forms of nested objects. The subTypes.[].value represents the class used in validation, while subTypes.[].name signifies the value expected by the discriminator field to match the corresponding class specified in subTypes.[].name.

import { Type } from 'class-transformer';
import { IsBoolean, IsNumber, IsString, ValidateNested } from 'class-validator';

class Discriminator {
  @IsBoolean()
  required: boolean;
}

class A extends Discriminator {  
  @IsString()
  text: string;
}

class B extends Discriminator {  
  @IsNumber()
  number: number;

  @IsNumber()
  maxNumber: number
}

export class C {

  // Other fields...

  @ValidateNested()
  @Type(() => Discriminator, {
    discriminator: {
      property: 'required',
      subTypes: [
        { value: A, name: true as unknown as string },
        { value: B, name: false  as unknown as string },
      ],
    },
    keepDiscriminatorProperty: true,
  })
  validation: A | B;
}

Update your controller to reflect these changes:

@Controller()
export class AppController {
  @Post()
  public example(
    @Body(new ValidationPipe({ transform: true }))
    body: C,
  ) {
    return body;
  }
}

You can now make requests as follows:

curl --location 'localhost:3000/' \
--header 'Content-Type: application/json' \
--data '{
  "validation": {
    "required": true,
    "text": "Some text..."
  } 
}'

If you adjust the second element of the required property to false, an error will occur:

{
- "required": true,
+ "required": false,
  "text": "Some text..."
}

{
  "statusCode": 400,
  "message": [
    "validation.number must be a number conforming to the specified constraints",
    "validation.maxNumber must be a number conforming to the specified constraints"
  ],
  "error": "Bad Request"
}

References: https://github.com/typestack/class-transformer#providing-more-than-one-type-option

Typescript class validator that validates based on varying data types

Answer №1

Answer №2

Similar questions

Challenges faced with Angular 4 TypeScript destructuring implementation

Incorporating a CSS Module into a conditional statement

Ionic 4 - Best practices for handling asynchronous data with multiple observables

Is there a way to customize the language used for the months and days on the DatePicker

Is it possible to escape the code within the setup block using the Vue-Composition API?

What is the method to make a String bold when sending it through a messaging service?

Defining the signature of an unnamed function in TypeScript

resolved after a new promise returned nothing (console.log will output undefined)

What is the best method for transforming an object into an interface without prior knowledge of the keys

Remove the array stored in the local storage of an Ionic 2 application

The 'void' data type must be equipped with a '[Symbol.iterator]()' function that produces an iterator

Setting key-value pairs in TypeScript objects explained

Refreshing Angular 2 routes when parameters are updated

Check if a string contains only special characters and no letters within them using regular expressions

Show the login form and accompanying controls in the center of the screen with Angular 6

What is the reason for the distinction between {[x: string]: this} and Record<string, this> in TypeScript class member definitions?

Presenting information on the user interface

Type of Data for Material UI's Selection Component

Transfer the export to a different file and update all the files that import it accordingly

Angular fails to combine values within routerLink