Verify enum values within controller function

Question

Verify enum values within controller function

I am dealing with a query parameter in my REST API that should be restricted to specific values according to an enum type. I need to find a way to handle a "Bad Request" error if the client provides any value outside of this enum.

Here is what my enum looks like:

export enum Precision {
    S = 's',
    MS = 'ms',
    U = 'u',
    NS = 'ns',
}

This is how my controller function is structured:

  @Get(':deviceId/:datapoint/last')
  @ApiOkResponse()
  @ApiQuery({name: 'precision', enum: Precision})
  getLastMeasurement(
    @Param('deviceId') deviceId: string,
    @Param('datapoint') datapoint: string,
    @Query('precision') precision: Precision = Precision.S,
    @Res() response: Response,
  ) {
    console.log(precision);
    ....
    response.status(HttpStatus.OK).send(body);
  }

The issue I am facing is that the function currently allows for other values besides those defined in the enum (e.g., accepting 'f' as a query parameter value). While no error is returned to the client, I want to address this without having to include an if-else block at the beginning of each controller function.
I believe there must be a straightforward solution to enforcing enum validation directly in the query parameter and REST controller, but my searches online have mainly yielded results related to class validation in DTOs rather than this specific scenario.

Thank you for your time,
J

typescript rest nestjs

Answer 1

Answer №1

There are two issues to address in this code.

The first problem lies in the incorrect passing of the default value for the precision parameter. To rectify this, you should utilize the DefaultValuePipe as shown below:

getLastMeasurement(
  ... // other parameters
    @Query('precision', new DefaultValuePipe(Precision.S)) precision: Precision
  ) { 
  ... // perform actions
}

The second issue pertains to enum validation. NestJS offers only six types of validation pipes, none of which directly validate enums. Therefore, you will need to create a custom validation pipe specifically for handling enums.

There are two approaches you can take to tackle this problem:

Create a custom pipe tailored to validating your specific enum;
Develop a generic custom pipe capable of validating any enum.

Referring to the documentation at https://docs.nestjs.com/pipes#custom-pipes, the implementation would resemble:

Validation for a specific enum

import { BadRequestException, PipeTransform } from '@nestjs/common';
import { isDefined, isEnum } from 'class-validator';

export class PrecisionValidationPipe implements PipeTransform<string, Promise<Precision>> {

  transform(value: string): Promise<Precision> {
    if (isDefined(value) && isEnum(value, Precision)) {
      return Precision[value];
    } else {
      const errorMessage = `the value ${value} is not valid. See the acceptable values: ${Object.keys(
        Precision
      ).map(key => Precision[key])}`;
      throw new BadRequestException(errorMessage);
    }
  }
}

Subsequently, in your request, it would be implemented as follows:

  getLastMeasurement(
    @Query('precision', PrecisionValidationPipe, new DefaultValuePipe(Precision.S)) precision: Precision,
  ) {
    console.log(precision);
    ....
    response.status(HttpStatus.OK).send(body);
  }

Validation for any enum (preferred approach)

import { BadRequestException, Injectable, PipeTransform } from '@nestjs/common';
import { isDefined, isEnum } from 'class-validator';

@Injectable()
export class EnumValidationPipe implements PipeTransform<string, Promise<any>> {
  constructor(private enumEntity: any) {}
  transform(value: string): Promise<any> {
      if (isDefined(value) && isEnum(value, this.enumEntity)) {
        return this.enumEntity[value];
      } else {
        const errorMessage = `the value ${value} is not valid. See the acceptable values: ${Object.keys(this.enumEntity).map(key => this.enumEntity[key])}`;
        throw new BadRequestException(errorMessage);
      }
  }
}

Following that, in your request, it would be set up like so:

  getLastMeasurement(
    @Query('precision', new EnumValidationPipe(Precision), new DefaultValuePipe(Precision.S)) precision: Precision,
  ) {
    console.log(precision);
    ....
    response.status(HttpStatus.OK).send(body);
  }

Answer 2

There are two issues to address in this code.

The first problem lies in the incorrect passing of the default value for the precision parameter. To rectify this, you should utilize the DefaultValuePipe as shown below:

getLastMeasurement(
  ... // other parameters
    @Query('precision', new DefaultValuePipe(Precision.S)) precision: Precision
  ) { 
  ... // perform actions
}

The second issue pertains to enum validation. NestJS offers only six types of validation pipes, none of which directly validate enums. Therefore, you will need to create a custom validation pipe specifically for handling enums.

There are two approaches you can take to tackle this problem:

Create a custom pipe tailored to validating your specific enum;
Develop a generic custom pipe capable of validating any enum.

Referring to the documentation at https://docs.nestjs.com/pipes#custom-pipes, the implementation would resemble:

Validation for a specific enum

import { BadRequestException, PipeTransform } from '@nestjs/common';
import { isDefined, isEnum } from 'class-validator';

export class PrecisionValidationPipe implements PipeTransform<string, Promise<Precision>> {

  transform(value: string): Promise<Precision> {
    if (isDefined(value) && isEnum(value, Precision)) {
      return Precision[value];
    } else {
      const errorMessage = `the value ${value} is not valid. See the acceptable values: ${Object.keys(
        Precision
      ).map(key => Precision[key])}`;
      throw new BadRequestException(errorMessage);
    }
  }
}

Subsequently, in your request, it would be implemented as follows:

  getLastMeasurement(
    @Query('precision', PrecisionValidationPipe, new DefaultValuePipe(Precision.S)) precision: Precision,
  ) {
    console.log(precision);
    ....
    response.status(HttpStatus.OK).send(body);
  }

Validation for any enum (preferred approach)

import { BadRequestException, Injectable, PipeTransform } from '@nestjs/common';
import { isDefined, isEnum } from 'class-validator';

@Injectable()
export class EnumValidationPipe implements PipeTransform<string, Promise<any>> {
  constructor(private enumEntity: any) {}
  transform(value: string): Promise<any> {
      if (isDefined(value) && isEnum(value, this.enumEntity)) {
        return this.enumEntity[value];
      } else {
        const errorMessage = `the value ${value} is not valid. See the acceptable values: ${Object.keys(this.enumEntity).map(key => this.enumEntity[key])}`;
        throw new BadRequestException(errorMessage);
      }
  }
}

Following that, in your request, it would be set up like so:

  getLastMeasurement(
    @Query('precision', new EnumValidationPipe(Precision), new DefaultValuePipe(Precision.S)) precision: Precision,
  ) {
    console.log(precision);
    ....
    response.status(HttpStatus.OK).send(body);
  }

Answer 3

Answer №2

If you want to ensure that the expected values are being sent in for a class, consider creating a class similar to LastMeasurementQueryParams that utilizes the decorators provided by class-validator. You can then use NestJS's built-in ValidationPipe to validate and verify these values.

An implementation of such a class might resemble the following:

export class LastMeasurementQueryParams {

  @IsEnum(Precision)
  precision: Precision;
}

Your controller could be structured as follows:

@Get(':deviceId/:datapoint/last')
@ApiOkResponse()
@ApiQuery({name: 'precision', enum: Precision})
getLastMeasurement(
    @Param('deviceId') deviceId: string,
    @Param('datapoint') datapoint: string,
    @Query('precision') precision: LastMeasurementQueryParams = { precision: Precision.S },
    @Res() response: Response,
) {
    console.log(precision);
    // additional logic
    response.status(HttpStatus.OK).send(body);
}

Answer 4

If you want to ensure that the expected values are being sent in for a class, consider creating a class similar to LastMeasurementQueryParams that utilizes the decorators provided by class-validator. You can then use NestJS's built-in ValidationPipe to validate and verify these values.

An implementation of such a class might resemble the following:

export class LastMeasurementQueryParams {

  @IsEnum(Precision)
  precision: Precision;
}

Your controller could be structured as follows:

@Get(':deviceId/:datapoint/last')
@ApiOkResponse()
@ApiQuery({name: 'precision', enum: Precision})
getLastMeasurement(
    @Param('deviceId') deviceId: string,
    @Param('datapoint') datapoint: string,
    @Query('precision') precision: LastMeasurementQueryParams = { precision: Precision.S },
    @Res() response: Response,
) {
    console.log(precision);
    // additional logic
    response.status(HttpStatus.OK).send(body);
}

Answer 5

Answer №3

Fixed a bug in Raphael's response where the enum key was returned instead of the value.

Additionally, utilized the metadata parameter to display the field name in the error message and made the following change:

${Object.values(this.enumEntity)}

Here is the updated code for the validator:

@Injectable()
export class EnumValidationPipe implements PipeTransform<string, Promise<any>> {
  constructor(private enumEntity: any) {}
  transform(value: string, metadata: ArgumentMetadata): Promise<any> {
    if (isDefined(value) && isEnum(value, this.enumEntity)) {
      return Promise.resolve(value);
    } else {
      const errorMessage = `the value ${value} from field ${
        metadata.data
      } is not valid. Acceptable values: ${Object.values(this.enumEntity)}`;
      throw new BadRequestException(errorMessage);
    }
  }
}

Answer 6

Fixed a bug in Raphael's response where the enum key was returned instead of the value.

Additionally, utilized the metadata parameter to display the field name in the error message and made the following change:

${Object.values(this.enumEntity)}

Here is the updated code for the validator:

@Injectable()
export class EnumValidationPipe implements PipeTransform<string, Promise<any>> {
  constructor(private enumEntity: any) {}
  transform(value: string, metadata: ArgumentMetadata): Promise<any> {
    if (isDefined(value) && isEnum(value, this.enumEntity)) {
      return Promise.resolve(value);
    } else {
      const errorMessage = `the value ${value} from field ${
        metadata.data
      } is not valid. Acceptable values: ${Object.values(this.enumEntity)}`;
      throw new BadRequestException(errorMessage);
    }
  }
}

Verify enum values within controller function

Answer №1

Answer №2

Answer №3

Similar questions

What is the process to enable mandatory validation after a change in input in Angular 4?

Oops! A mistake was made by passing an incorrect argument to a color function. Make sure to provide a string representation of a color as the argument next time

Transforming an array of JSON items into a unified object using Angular

When working with TypeScript in Node, the module ""http"" does not have a default export available

Error: The function 'some' is not recognized in the rawData variable in REACT/ANTDESIGN

What is the best way to upload a file using a relative path in Playwright with TypeScript?

Encountering a compilation error due to a Typescript assignment

Encountering an issue when using npm to add a forked repository as a required package

Posting JSON data with null values in a Spring REST API

Developing a dynamic web application using Asp.Net Core integrated with React and material

Troubleshooting an Angular application in Intellij using Chrome on a Windows operating system

The presence of a constructor in a component disrupts the connection between React and Redux in

Is TypeScript failing to enforce generic constraints?

"Send the selected radio button options chosen by the user, with the values specified in a JSON format

Changing the title of your document and app bar in React Router when navigating pages

React Bootstrap Forms: The <Form.Control.Feedback> element is failing to display when the validation is set to false

What is the best way to assign the result of a promise to a variable?

What is the best way to incorporate node_module during the iOS build process in Ionic 2?

Sharing information with a service in Ionic and Angular

Unable to employ the inequality operator while querying a collection in AngularFire