refactor(@nestjs/common): rename the ValidationPipe properties

adopt the class-validator naming scheme

Author: fwoelffel

src/common/pipes/validation.pipe.ts

@@ -1,4 +1,4 @@
-import { validate } from 'class-validator';
+import { validate, ValidatorOptions } from 'class-validator';
 import { classToPlain, plainToClass } from 'class-transformer';
 import { PipeTransform } from '../interfaces/pipe-transform.interface';
 import { ArgumentMetadata, BadRequestException } from '../index';
@@ -7,21 +7,21 @@ import { Pipe } from './../decorators/core/component.decorator';
 
 export interface ValidationPipeOptions {
   transform?: boolean;
-  strip?: boolean;
-  reject?: boolean;
+  whitelist?: boolean;
+  forbidNonWhitelisted?: boolean;
 }
 
 @Pipe()
 export class ValidationPipe implements PipeTransform<any> {
 
-  private shouldTransform: boolean;
-  private shouldStrip: boolean;
-  private shouldReject: boolean;
+  private returnTransformed: boolean;
+
+  private validatorOptions: ValidatorOptions = {};
 
   constructor(options?: ValidationPipeOptions) {
-    this.shouldTransform = (options && 'transform' in options) ? options.transform : true;
-    this.shouldStrip = options && (options.strip || options.reject);
-    this.shouldReject = options && options.reject;
+    this.returnTransformed = (options && 'transform' in options) ? options.transform : true;
+    this.validatorOptions.whitelist = options && (options.whitelist || options.forbidNonWhitelisted);
+    this.validatorOptions.forbidNonWhitelisted = options && options.forbidNonWhitelisted;
   }
 
   public async transform(value, metadata: ArgumentMetadata) {
@@ -30,12 +30,12 @@ export class ValidationPipe implements PipeTransform<any> {
       return value;
     }
     const entity = plainToClass(metatype, value);
-    const errors = await validate(entity, { whitelist: this.shouldStrip, forbidNonWhitelisted: this.shouldReject });
+    const errors = await validate(entity, this.validatorOptions);
     if (errors.length > 0) {
       throw new BadRequestException(errors);
     }
-    return this.shouldTransform ? entity
-      : this.shouldStrip ? classToPlain(entity)
+    return this.returnTransformed ? entity
+      : this.validatorOptions.whitelist ? classToPlain(entity)
       : value;
   }
 

src/common/test/pipes/validation.pipe.spec.ts

@@ -49,15 +49,15 @@ describe('ValidationPipe', () => {
       });
       describe('when validation strips', () => {
         it('should return a TestModel without extra properties', async () => {
-          target = new ValidationPipe({strip: true});
+          target = new ValidationPipe({whitelist: true});
           const testObj = { prop1: 'value1', prop2: 'value2', prop3: 'value3'};
           expect(await target.transform(testObj, metadata)).to.be.instanceOf(TestModel);
           expect(await target.transform(testObj, metadata)).to.not.have.property('prop3');
         });
       });
       describe('when validation rejects', () => {
         it('should throw an error', () => {
-          target = new ValidationPipe({reject: true});
+          target = new ValidationPipe({forbidNonWhitelisted: true});
           const testObj = { prop1: 'value1', prop2: 'value2', prop3: 'value3' };
           expect(target.transform(testObj, metadata)).to.be.rejected;
         });
@@ -66,15 +66,15 @@ describe('ValidationPipe', () => {
     describe('when validation does\'t transform', () => {
       describe('when validation strips', () => {
         it('should return a plain object without extra properties', async () => {
-          target = new ValidationPipe({transform: false, strip: true});
+          target = new ValidationPipe({transform: false, whitelist: true});
           const testObj = { prop1: 'value1', prop2: 'value2', prop3: 'value3'};
           expect(await target.transform(testObj, metadata)).to.not.be.instanceOf(TestModel);
           expect(await target.transform(testObj, metadata)).to.not.have.property('prop3');
         });
       });
       describe('when validation rejects', () => {
         it('should throw an error', () => {
-          target = new ValidationPipe({transform: false, reject: true});
+          target = new ValidationPipe({transform: false, forbidNonWhitelisted: true});
           const testObj = { prop1: 'value1', prop2: 'value2', prop3: 'value3' };
           expect(target.transform(testObj, metadata)).to.be.rejected;
         });