feat(classValidationResolver): add transform and validator options (#524)

BREAKING CHANGE: schema options now includes validator and transformer 

Before:
```ts
schemaOptions?: ValidatorOptions,
```

After:
```ts
schemaOptions?: {
    validator?: ValidatorOptions;
    transformer?: ClassTransformOptions;
  }
```

Author: jorisre

class-validator/src/__tests__/__snapshots__/class-validator.ts.snap

@@ -205,3 +205,38 @@ exports[`classValidatorResolver > should return all the errors from classValidat
   "values": {},
 }
 `;
+
+exports[`validate data with transformer option 1`] = `
+{
+  "errors": {
+    "random": {
+      "message": "All fields must be defined.",
+      "ref": undefined,
+      "type": "isDefined",
+      "types": {
+        "isDefined": "All fields must be defined.",
+        "isNumber": "Must be a number",
+        "max": "Cannot be greater than 255",
+        "min": "Cannot be lower than 0",
+      },
+    },
+  },
+  "values": {},
+}
+`;
+
+exports[`validate data with validator option 1`] = `
+{
+  "errors": {
+    "random": {
+      "message": "All fields must be defined.",
+      "ref": undefined,
+      "type": "isDefined",
+      "types": {
+        "isDefined": "All fields must be defined.",
+      },
+    },
+  },
+  "values": {},
+}
+`;

class-validator/src/__tests__/class-validator.ts

@@ -2,6 +2,8 @@
 import { classValidatorResolver } from '..';
 import { Schema, validData, fields, invalidData } from './__fixtures__/data';
 import * as classValidator from 'class-validator';
+import { Expose, Type } from 'class-transformer';
+import { IsDefined, IsNumber, Max, Min } from 'class-validator';
 
 const shouldUseNativeValidation = false;
 
@@ -85,3 +87,61 @@ describe('classValidatorResolver', () => {
     expect(result).toMatchSnapshot();
   });
 });
+
+it('validate data with transformer option', async () => {
+  class SchemaTest {
+    @Expose({ groups: ['find', 'create', 'update'] })
+    @Type(() => Number)
+    @IsDefined({
+      message: `All fields must be defined.`,
+      groups: ['publish'],
+    })
+    @IsNumber({}, { message: `Must be a number`, always: true })
+    @Min(0, { message: `Cannot be lower than 0`, always: true })
+    @Max(255, { message: `Cannot be greater than 255`, always: true })
+    random: number;
+  }
+
+  const result = await classValidatorResolver(
+    SchemaTest,
+    { transformer: { groups: ['update'] } },
+    {
+      mode: 'sync',
+    },
+  )(invalidData, undefined, {
+    fields,
+    criteriaMode: 'all',
+    shouldUseNativeValidation,
+  });
+
+  expect(result).toMatchSnapshot();
+});
+
+it('validate data with validator option', async () => {
+  class SchemaTest {
+    @Expose({ groups: ['find', 'create', 'update'] })
+    @Type(() => Number)
+    @IsDefined({
+      message: `All fields must be defined.`,
+      groups: ['publish'],
+    })
+    @IsNumber({}, { message: `Must be a number`, always: true })
+    @Min(0, { message: `Cannot be lower than 0`, always: true })
+    @Max(255, { message: `Cannot be greater than 255`, always: true })
+    random: number;
+  }
+
+  const result = await classValidatorResolver(
+    SchemaTest,
+    { validator: { stopAtFirstError: true } },
+    {
+      mode: 'sync',
+    },
+  )(invalidData, undefined, {
+    fields,
+    criteriaMode: 'all',
+    shouldUseNativeValidation,
+  });
+
+  expect(result).toMatchSnapshot();
+});

class-validator/src/class-validator.ts

@@ -37,11 +37,12 @@ const parseErrors = (
 export const classValidatorResolver: Resolver =
   (schema, schemaOptions = {}, resolverOptions = {}) =>
   async (values, _, options) => {
-    const user = plainToClass(schema, values);
+    const { transformer, validator } = schemaOptions;
+    const data = plainToClass(schema, values, transformer);
 
     const rawErrors = await (resolverOptions.mode === 'sync'
       ? validateSync
-      : validate)(user, schemaOptions);
+      : validate)(data, validator);
 
     if (rawErrors.length) {
       return {

class-validator/src/types.ts

@@ -1,15 +1,14 @@
-import {
-  FieldValues,
-  ResolverOptions,
-  ResolverResult,
-} from 'react-hook-form';
+import { FieldValues, ResolverOptions, ResolverResult } from 'react-hook-form';
 import { ValidatorOptions } from 'class-validator';
-import { ClassConstructor } from 'class-transformer';
+import { ClassConstructor, ClassTransformOptions } from 'class-transformer';
 
 export type Resolver = <T extends { [_: string]: any }>(
   schema: ClassConstructor<T>,
-  schemaOptions?: ValidatorOptions,
-  resolverOptions?: { mode?: 'async' | 'sync', rawValues?: boolean; },
+  schemaOptions?: {
+    validator?: ValidatorOptions;
+    transformer?: ClassTransformOptions;
+  },
+  resolverOptions?: { mode?: 'async' | 'sync'; rawValues?: boolean },
 ) => <TFieldValues extends FieldValues, TContext>(
   values: TFieldValues,
   context: TContext | undefined,