Parse controller method argument into Entity

Hello! I think a much needed feature is to automatically parse Controller method arguments into the appropriate Entity. This is very easy to do using a pipe, but I think it is worth making its own example, or even an npm package, so that it can be plugged in effortlessly.

import { HttpException } from '@nestjs/core';
import { PipeTransform, Pipe, ArgumentMetadata, HttpStatus } from '@nestjs/common';
import { validate } from 'class-validator';
import { plainToClass } from 'class-transformer';

@Pipe()
export default class EntityParserPipe implements PipeTransform<any> {
    async transform(value, metadata: ArgumentMetadata) {
      const { metatype } = metadata;
      if (!metatype || !this.toValidate(metatype)) {
          return value;
      }
      const entity = plainToClass(metatype, value);
      const errors = await validate(entity);
      if (errors.length > 0) {
          throw new HttpException('Validation failed', HttpStatus.BAD_REQUEST);
      }
      return entity;
    }

    private toValidate(metatype): boolean {
      const types = [String, Boolean, Number, Array, Object];
      return !types.find((type) => metatype === type);
    }
}

This is what I’m using, and you’ll notice its almost exactly the same as the validation example from the pipe tutorial. Therefore, I don’t want to post this on npm and claim credit. Could I commit it to the core repo? Again, I know this is an easy feature to implement by hand, but I think it should be available out of the box because it is so handy, and expected.

[kamilmysliwiec]

Hi @adammfrank, This pipe depends on the two 3rd party packages. That’s the reason why I don’t think it’s a good idea to make it a part of the core package, but I’m wondering about the new @nestjs/utils package. It might contain useful interceptors / guards as well as pipes (for example ParseXPipe / ValidationPipe) 🙂

[icepeng]

ModelParserPipe is useful in this case:

import { IsInt, IsNumberString, IsPositive, Min } from 'class-validator';
import { Type } from 'class-transformer';

export class PhotoQuery {
  @Type(() => Number)
  @IsInt()
  @Min(0)
  readonly skip: number;

  @Type(() => Number)
  @IsInt()
  @IsPositive()
  readonly take: number;
}

Query is always parsed as string, so it is hard to validate with class-validator package. And you can validate and sanitize model with just one class definition.