feature(common): add transformOptions to ValidationPipeOptions

allows plainToClass to expose class properties to defined groups as per issue nestjs#1374

Author: FionaLovett

packages/common/pipes/validation.pipe.ts

@@ -6,13 +6,15 @@ import {
   ValidationError,
 } from '../index';
 import { ValidatorOptions } from '../interfaces/external/validator-options.interface';
+import { ClassTransformOptions } from '../interfaces/external/class-transform-options.interface';
 import { PipeTransform } from '../interfaces/features/pipe-transform.interface';
 import { loadPackage } from '../utils/load-package.util';
 import { isNil } from '../utils/shared.utils';
 
 export interface ValidationPipeOptions extends ValidatorOptions {
   transform?: boolean;
   disableErrorMessages?: boolean;
+  transformOptions?: ClassTransformOptions;
   exceptionFactory?: (errors: ValidationError[]) => any;
 }
 
@@ -24,13 +26,20 @@ export class ValidationPipe implements PipeTransform<any> {
   protected isTransformEnabled: boolean;
   protected isDetailedOutputDisabled?: boolean;
   protected validatorOptions: ValidatorOptions;
+  protected transformOptions: ClassTransformOptions;
   protected exceptionFactory: (errors: ValidationError[]) => any;
 
   constructor(@Optional() options?: ValidationPipeOptions) {
     options = options || {};
-    const { transform, disableErrorMessages, ...validatorOptions } = options;
+    const {
+      transform,
+      disableErrorMessages,
+      transformOptions,
+      ...validatorOptions
+    } = options;
     this.isTransformEnabled = !!transform;
     this.validatorOptions = validatorOptions;
+    this.transformOptions = transformOptions;
     this.isDetailedOutputDisabled = disableErrorMessages;
     this.exceptionFactory =
       options.exceptionFactory ||
@@ -52,6 +61,7 @@ export class ValidationPipe implements PipeTransform<any> {
     const entity = classTransformer.plainToClass(
       metatype,
       this.toEmptyIfNil(value),
+      this.transformOptions,
     );
     const errors = await classValidator.validate(entity, this.validatorOptions);
     if (errors.length > 0) {
@@ -60,8 +70,8 @@ export class ValidationPipe implements PipeTransform<any> {
     return this.isTransformEnabled
       ? entity
       : Object.keys(this.validatorOptions).length > 0
-      ? classTransformer.classToPlain(entity)
-      : value;
+        ? classTransformer.classToPlain(entity, this.transformOptions)
+        : value;
   }
 
   private toValidate(metadata: ArgumentMetadata): boolean {

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

@@ -3,12 +3,22 @@ import { expect } from 'chai';
 import { ArgumentMetadata } from '../../interfaces';
 import { IsString } from 'class-validator';
 import { ValidationPipe } from '../../pipes/validation.pipe';
+import { Exclude, Expose } from 'class-transformer';
 
+@Exclude()
 class TestModel {
   constructor() {}
-  @IsString() public prop1: string;
+  @Expose()
+  @IsString()
+  public prop1: string;
 
-  @IsString() public prop2: string;
+  @Expose()
+  @IsString()
+  public prop2: string;
+
+  @Expose({ groups: ['internal'] })
+  @IsString()
+  public propInternal: string;
 }
 
 describe('ValidationPipe', () => {
@@ -68,6 +78,36 @@ describe('ValidationPipe', () => {
           expect(target.transform(testObj, metadata)).to.eventually.throw;
         });
       });
+      describe('when transformation is internal', () => {
+        it('should return a TestModel with internal property', async () => {
+          target = new ValidationPipe({
+            transformOptions: { groups: ['internal'] },
+          });
+          const testObj = {
+            prop1: 'value1',
+            prop2: 'value2',
+            propInternal: 'value3',
+          };
+          expect(await target.transform(testObj, metadata)).to.have.property(
+            'propInternal',
+          );
+        });
+      });
+      describe('when transformation is external', () => {
+        it('should return a TestModel without internal property', async () => {
+          target = new ValidationPipe({
+            transformOptions: { groups: ['external'] },
+          });
+          const testObj = {
+            prop1: 'value1',
+            prop2: 'value2',
+            propInternal: 'value3',
+          };
+          expect(
+            await target.transform(testObj, metadata),
+          ).to.not.have.property('propInternal');
+        });
+      });
     });
     describe("when validation doesn't transform", () => {
       describe('when validation strips', () => {