How to describe validators for two possible types: array or string?
  • 14-May-2023
Lightrun Team
Author Lightrun Team
How to describe validators for two possible types: array or string?

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

Lightrun Team
Lightrun Team

Explanation of the problem

The problem at hand involves defining validators for two possible types: array or string. In the given scenario, there is a need to specify the appropriate validators for a private property named foo. The foo property can hold values of either boolean or string type. To ensure proper validation, decorators are utilized. However, it appears that the implementation of two decorators, namely @IsBoolean() and @IsString(), is not yielding the desired results.


Troubleshooting with the Lightrun Developer Observability Platform

Getting a sense of what’s actually happening inside a live application is a frustrating experience, one that relies mostly on querying and observing whatever logs were written during development.
Lightrun is a Developer Observability Platform, allowing developers to add telemetry to live applications in real-time, on-demand, and right from the IDE.

  • Instantly add logs to, set metrics in, and take snapshots of live applications
  • Insights delivered straight to your IDE or CLI
  • Works where you do: dev, QA, staging, CI/CD, and production

Start for free today

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

I. Custom Decorator for Type Validation

One suggested solution is to create a custom decorator that handles type validation for properties. This approach aims to simplify the process of validating multi-typed properties by providing a more centralized and flexible solution. The custom decorator, named IsType, allows specifying the desired types to validate against. It utilizes a typeValidator object that contains validation functions for different types, such as strings and integers. By applying the IsType decorator to a property, the validation process is triggered, and the value is checked against the specified types.

II. Benefits of Custom Decorator Approach

This proposed solution offers several advantages over complex logic within decorator definitions. By using the IsType decorator, the repetitive process of defining validation logic for each property is avoided. Changing the validation logic becomes easier as modifications can be made in a single location. This approach promotes code cleanliness and maintainability, especially when dealing with multiple properties that require similar validation.

III. Implementation and Usage

The provided code snippet demonstrates the implementation of the custom decorator and its usage. The IsType decorator is applied to a property named someValue within a class. The decorator accepts an array of desired types to validate against, such as “string” and “int”. The decorator registers a custom validator that checks if the value matches any of the specified types. In case of a validation failure, appropriate error messages are generated. This approach offers a straightforward and concise way to handle type validation for properties with multiple possible types.

Other popular problems with Class Validator

Problem: Inconsistent Validation Behavior

One common problem encountered with the Class Validator library is inconsistent validation behavior. This issue arises when the validation rules defined using decorators do not behave as expected. For example, certain validation rules might fail to trigger or produce incorrect validation results, leading to unexpected behavior in the application. This inconsistency can be frustrating and challenging to debug, especially when dealing with complex validation scenarios.


To address this problem, it is crucial to ensure that the Class Validator library is used correctly and that the decorators are applied accurately. Carefully review the documentation and guidelines provided by the library to understand the correct usage of decorators and their parameters. Additionally, ensure that the version of the Class Validator library being used is up to date, as newer versions often include bug fixes and improvements related to validation behavior. Thoroughly test the validation rules using various scenarios to verify their correctness and consistency.

Problem: Lack of Customization Options

Another limitation often faced when working with the Class Validator library is the lack of customization options. While the library provides a wide range of built-in validation decorators, there may be cases where more specific or custom validation rules are required. In such situations, the existing decorators might not be sufficient to meet the specific validation needs of the application, resulting in a limitation of functionality.


To overcome this limitation, consider extending the functionality of the Class Validator library by creating custom decorators or utilizing custom validation classes. By creating custom decorators, you can define validation rules tailored to the specific requirements of your application. Additionally, the library provides the option to create custom validation classes that encapsulate complex validation logic. This approach enables you to have finer control over the validation process and meet the customization needs of your application.

Problem: Performance Impact

When using the Class Validator library for validation in applications with a large number of entities or complex validation rules, performance can become a concern. The validation process might introduce overhead and impact the overall responsiveness of the application. This issue becomes more pronounced when performing bulk validations or when the validation logic involves computationally intensive operations.


To mitigate the performance impact, consider implementing optimization techniques while using the Class Validator library. Some approaches include minimizing unnecessary validation by selectively applying decorators to properties that require validation and optimizing the validation logic to reduce redundant checks. Additionally, leverage asynchronous validation options provided by the library to parallelize validation tasks and enhance performance in scenarios where multiple entities or properties need to be validated simultaneously.

A brief introduction to Class Validator

Class Validator is a powerful library utilized in TypeScript and JavaScript for performing data validation on classes and their properties. It provides decorators and validation functions that enable developers to define validation rules and constraints for their data models. With Class Validator, developers can easily enforce type validation, length validation, pattern matching, and custom validation logic. The library integrates seamlessly with frameworks like NestJS and TypeORM, making it a popular choice for building robust and reliable applications.

By leveraging decorators provided by Class Validator, developers can annotate class properties with validation rules, simplifying the validation process. The library supports a wide range of validation decorators, including @IsString(), @IsNumber(), @IsEmail(), and @MinLength(), among others. Additionally, developers can create custom validation decorators to suit their specific validation requirements. Class Validator also offers validation functions that can be used directly to validate data outside of class instances. These functions provide flexibility and allow for granular validation of individual data values. Overall, Class Validator empowers developers to ensure the integrity and correctness of their data models, enhancing the overall quality and reliability of their applications.


Most popular use cases for Class Validator

  1. Data Validation for Class Properties: Class Validator can be used to perform comprehensive data validation on class properties. By applying appropriate decorators such as @IsString(), @IsNumber(), or @IsEmail(), developers can enforce type validation on properties to ensure that they adhere to specific data types. Additionally, decorators like @MinLength(), @MaxLength(), or @Matches() enable developers to enforce length constraints and pattern matching on string values. These validation rules help to prevent invalid data from being assigned to class properties, maintaining data integrity throughout the application.
class User {
  name: string;

  email: string;
  1. Custom Validation Logic: Class Validator allows developers to define and apply custom validation logic to class properties. By creating custom validation decorators or using the @Validate() decorator, developers can specify their own validation functions to validate complex or specific business rules. This flexibility enables developers to enforce domain-specific validation constraints on class properties, ensuring that the data satisfies their application’s unique requirements.
class Order {
  quantity: number;

  @Validate((value, args) => value <= args.object.quantity)
  selectedQuantity: number;
  1. Data Validation Outside of Class Instances: In addition to validating class properties, Class Validator provides validation functions that can be used independently to validate data outside of class instances. These functions, such as validate() and validateSync(), can be utilized to validate raw data or data received from external sources, such as API requests. This allows developers to perform standalone data validation, independent of class instantiation, and ensures that data received from various sources meets the required validation criteria.
const data = {
  name: 'John Doe',
  email: 'invalid-email',

const errors = validateSync(data);
if (errors.length > 0) {
  // Handle validation errors

It’s Really not that Complicated.

You can actually understand what’s going on inside your live applications.

Try Lightrun’s Playground

Lets Talk!

Looking for more information about Lightrun and debugging?
We’d love to hear from you!
Drop us a line and we’ll get back to you shortly.

By submitting this form, I agree to Lightrun’s Privacy Policy and Terms of Use.