Merge pull request #811 from xTCry/class-transform-options

Added class transform options

packages/crud-request/src/interfaces/parsed-request.interface.ts

@@ -1,10 +1,12 @@
 import { ObjectLiteral } from '@nestjsx/util';
+import { ClassTransformOptions } from 'class-transformer';
 import { QueryFields, QueryFilter, QueryJoin, QuerySort, SCondition } from '../types';
 
 export interface ParsedRequestParams {
   fields: QueryFields;
   paramsFilter: QueryFilter[];
   authPersist: ObjectLiteral;
+  classTransformOptions: ClassTransformOptions;
   search: SCondition;
   filter: QueryFilter[];
   or: QueryFilter[];

packages/crud-request/src/request-query.parser.ts

@@ -11,6 +11,7 @@ import {
   isNil,
   ObjectLiteral,
 } from '@nestjsx/util';
+import { ClassTransformOptions } from 'class-transformer';
 
 import { RequestQueryException } from './exceptions';
 import { ParamsOptions, ParsedRequestParams, RequestQueryBuilderOptions } from './interfaces';
@@ -42,6 +43,8 @@ export class RequestQueryParser implements ParsedRequestParams {
 
   public authPersist: ObjectLiteral = undefined;
 
+  public classTransformOptions: ClassTransformOptions = undefined;
+
   public search: SCondition;
 
   public filter: QueryFilter[] = [];
@@ -83,6 +86,7 @@ export class RequestQueryParser implements ParsedRequestParams {
       fields: this.fields,
       paramsFilter: this.paramsFilter,
       authPersist: this.authPersist,
+      classTransformOptions: this.classTransformOptions,
       search: this.search,
       filter: this.filter,
       or: this.or,
@@ -144,6 +148,10 @@ export class RequestQueryParser implements ParsedRequestParams {
     this.authPersist = persist || /* istanbul ignore next */ {};
   }
 
+  setClassTransformOptions(options: ClassTransformOptions = {}) {
+    this.classTransformOptions = options || /* istanbul ignore next */ {};
+  }
+
   convertFilterToSearch(filter: QueryFilter): SFields | SConditionAND {
     const isEmptyValue = {
       isnull: true,

packages/crud-request/test/request-query.parser.spec.ts

@@ -457,13 +457,27 @@ describe('#request-query', () => {
       });
     });
 
+    describe('#setClassTransformOptions', () => {
+      it('it should set classTransformOptions, 1', () => {
+        qp.setClassTransformOptions();
+        expect(qp.classTransformOptions).toMatchObject({});
+      });
+      it('it should set classTransformOptions, 2', () => {
+        const testOptions = { groups: ['TEST'] };
+        qp.setClassTransformOptions(testOptions);
+        const parsed = qp.getParsed();
+        expect(parsed.classTransformOptions).toMatchObject(testOptions);
+      });
+    });
+
     describe('#getParsed', () => {
       it('should return parsed params', () => {
         const expected: ParsedRequestParams = {
           fields: [],
           paramsFilter: [],
           search: undefined,
           authPersist: undefined,
+          classTransformOptions: undefined,
           filter: [],
           or: [],
           join: [],

packages/crud-typeorm/src/typeorm-crud.service.ts

@@ -169,7 +169,9 @@ export class TypeOrmCrudService<T> extends CrudService<T> {
     const toSave = !allowParamsOverride
       ? { ...found, ...dto, ...paramsFilters, ...req.parsed.authPersist }
       : { ...found, ...dto, ...req.parsed.authPersist };
-    const updated = await this.repo.save(plainToClass(this.entityType, toSave) as unknown as DeepPartial<T>);
+    const updated = await this.repo.save(
+      plainToClass(this.entityType, toSave, req.parsed.classTransformOptions) as unknown as DeepPartial<T>,
+    );
 
     if (returnShallow) {
       return updated;
@@ -209,7 +211,9 @@ export class TypeOrmCrudService<T> extends CrudService<T> {
           ...dto,
           ...req.parsed.authPersist,
         };
-    const replaced = await this.repo.save(plainToClass(this.entityType, toSave) as unknown as DeepPartial<T>);
+    const replaced = await this.repo.save(
+      plainToClass(this.entityType, toSave, req.parsed.classTransformOptions) as unknown as DeepPartial<T>,
+    );
 
     if (returnShallow) {
       return replaced;
@@ -233,7 +237,9 @@ export class TypeOrmCrudService<T> extends CrudService<T> {
   public async deleteOne(req: CrudRequest): Promise<void | T> {
     const { returnDeleted } = req.options.routes.deleteOneBase;
     const found = await this.getOneOrFail(req, returnDeleted);
-    const toReturn = returnDeleted ? plainToClass(this.entityType, { ...found }) : undefined;
+    const toReturn = returnDeleted
+      ? plainToClass(this.entityType, { ...found }, req.parsed.classTransformOptions)
+      : undefined;
     const deleted =
       req.options.query.softDelete === true
         ? await this.repo.softRemove(found as unknown as DeepPartial<T>)
@@ -421,7 +427,7 @@ export class TypeOrmCrudService<T> extends CrudService<T> {
 
     return dto instanceof this.entityType
       ? Object.assign(dto, parsed.authPersist)
-      : plainToClass(this.entityType, { ...dto, ...parsed.authPersist });
+      : plainToClass(this.entityType, { ...dto, ...parsed.authPersist }, parsed.classTransformOptions);
   }
 
   protected getAllowedColumns(columns: string[], options: QueryOptions): string[] {

packages/crud/src/crud/crud-routes.factory.ts

@@ -80,6 +80,12 @@ export class CrudRoutesFactory {
     if (isUndefined(this.options.auth.property)) {
       this.options.auth.property = CrudConfigService.config.auth.property;
     }
+    if (isUndefined(this.options.auth.groups)) {
+      this.options.auth.groups = CrudConfigService.config.auth.groups;
+    }
+    if (isUndefined(this.options.auth.classTransformOptions)) {
+      this.options.auth.classTransformOptions = CrudConfigService.config.auth.classTransformOptions;
+    }
 
     // merge query config
     const query = isObjectFull(this.options.query) ? this.options.query : {};

packages/crud/src/interceptors/crud-request.interceptor.ts

@@ -1,6 +1,7 @@
 import { BadRequestException, CallHandler, ExecutionContext, Injectable, NestInterceptor } from '@nestjs/common';
 import { RequestQueryException, RequestQueryParser, SCondition, QueryFilter } from '@nestjsx/crud-request';
 import { isNil, isFunction, isArrayFull, hasLength } from '@nestjsx/util';
+import { ClassTransformOptions } from 'class-transformer';
 
 import { PARSED_CRUD_REQUEST_KEY } from '../constants';
 import { CrudActions } from '../enums';
@@ -142,6 +143,16 @@ export class CrudRequestInterceptor extends CrudBaseInterceptor implements NestI
       if (isFunction(crudOptions.auth.persist)) {
         parser.setAuthPersist(crudOptions.auth.persist(userOrRequest));
       }
+
+      const options: ClassTransformOptions = {};
+      if (isFunction(crudOptions.auth.classTransformOptions)) {
+        Object.assign(options, crudOptions.auth.classTransformOptions(userOrRequest));
+      }
+
+      if (isFunction(crudOptions.auth.groups)) {
+        options.groups = crudOptions.auth.groups(userOrRequest);
+      }
+      parser.setClassTransformOptions(options);
     }
 
     return auth;

packages/crud/src/interceptors/crud-response.interceptor.ts

@@ -1,6 +1,6 @@
 import { CallHandler, ExecutionContext, Injectable, NestInterceptor } from '@nestjs/common';
 import { isFalse, isObject, isFunction } from '@nestjsx/util';
-import { classToPlain, classToPlainFromExist } from 'class-transformer';
+import { classToPlain, classToPlainFromExist, ClassTransformOptions } from 'class-transformer';
 import { Observable } from 'rxjs';
 import { map } from 'rxjs/operators';
 import { CrudActions } from '../enums';
@@ -27,31 +27,51 @@ export class CrudResponseInterceptor extends CrudBaseInterceptor implements Nest
     return next.handle().pipe(map((data) => this.serialize(context, data)));
   }
 
-  protected transform(dto: any, data: any) {
+  protected transform(dto: any, data: any, options: ClassTransformOptions) {
     if (!isObject(data) || isFalse(dto)) {
       return data;
     }
 
     if (!isFunction(dto)) {
-      return data.constructor !== Object ? classToPlain(data) : data;
+      return data.constructor !== Object ? classToPlain(data, options) : data;
     }
 
-    return data instanceof dto ? classToPlain(data) : classToPlain(classToPlainFromExist(data, new dto()));
+    return data instanceof dto
+      ? classToPlain(data, options)
+      : classToPlain(classToPlainFromExist(data, new dto()), options);
   }
 
   protected serialize(context: ExecutionContext, data: any): any {
+    const req = context.switchToHttp().getRequest();
     const { crudOptions, action } = this.getCrudInfo(context);
     const { serialize } = crudOptions;
     const dto = serialize[actionToDtoNameMap[action]];
     const isArray = Array.isArray(data);
 
+    const options: ClassTransformOptions = {};
+    /* istanbul ignore else */
+    if (isFunction(crudOptions.auth?.classTransformOptions)) {
+      const userOrRequest = crudOptions.auth.property ? req[crudOptions.auth.property] : req;
+      Object.assign(options, crudOptions.auth.classTransformOptions(userOrRequest));
+    }
+
+    /* istanbul ignore else */
+    if (isFunction(crudOptions.auth?.groups)) {
+      const userOrRequest = crudOptions.auth.property ? req[crudOptions.auth.property] : req;
+      options.groups = crudOptions.auth.groups(userOrRequest);
+    }
+
     switch (action) {
       case CrudActions.ReadAll:
-        return isArray ? (data as any[]).map((item) => this.transform(serialize.get, item)) : this.transform(dto, data);
+        return isArray
+          ? (data as any[]).map((item) => this.transform(serialize.get, item, options))
+          : this.transform(dto, data, options);
       case CrudActions.CreateMany:
-        return isArray ? (data as any[]).map((item) => this.transform(dto, item)) : this.transform(dto, data);
+        return isArray
+          ? (data as any[]).map((item) => this.transform(dto, item, options))
+          : this.transform(dto, data, options);
       default:
-        return this.transform(dto, data);
+        return this.transform(dto, data, options);
     }
   }
 }

packages/crud/src/interfaces/auth-options.interface.ts

@@ -1,12 +1,21 @@
 import { SCondition } from '@nestjsx/crud-request/lib/types/request-query.types';
 import { ObjectLiteral } from '@nestjsx/util';
+import { ClassTransformOptions } from 'class-transformer';
 
 export interface AuthGlobalOptions {
   property?: string;
+  /** Get options for the `classToPlain` function (response) */
+  classTransformOptions?: (req: any) => ClassTransformOptions;
+  /** Get `groups` value for the `classToPlain` function options (response) */
+  groups?: (req: any) => string[];
 }
 
 export interface AuthOptions {
   property?: string;
+  /** Get options for the `classToPlain` function (response) */
+  classTransformOptions?: (req: any) => ClassTransformOptions;
+  /** Get `groups` value for the `classToPlain` function options (response) */
+  groups?: (req: any) => string[];
   filter?: (req: any) => SCondition | void;
   or?: (req: any) => SCondition | void;
   persist?: (req: any) => ObjectLiteral;

packages/crud/test/crud-request.interceptor.spec.ts

@@ -1,11 +1,4 @@
-import {
-  Controller,
-  Get,
-  Param,
-  ParseIntPipe,
-  Query,
-  UseInterceptors,
-} from '@nestjs/common';
+import { Controller, Get, Param, ParseIntPipe, Query, UseInterceptors } from '@nestjs/common';
 import { NestApplication } from '@nestjs/core';
 import { Test } from '@nestjs/testing';
 import { RequestQueryBuilder } from '@nestjsx/crud-request';
@@ -61,10 +54,7 @@ describe('#crud', () => {
 
     @UseInterceptors(CrudRequestInterceptor)
     @Get('other2/:id/twoParams/:someParam')
-    async twoParams(
-      @ParsedRequest() req: CrudRequest,
-      @Param('someParam', ParseIntPipe) p: number,
-    ) {
+    async twoParams(@ParsedRequest() req: CrudRequest, @Param('someParam', ParseIntPipe) p: number) {
       return { filter: req.parsed.paramsFilter };
     }
   }
@@ -123,6 +113,23 @@ describe('#crud', () => {
     constructor(public service: TestService<TestModel>) {}
   }
 
+  @Crud({
+    model: { type: TestModel },
+  })
+  @CrudAuth({
+    groups: () => ['TEST_2'],
+    classTransformOptions: () => ({ groups: ['TEST_1'] }),
+  })
+  @Controller('test6')
+  class Test6Controller {
+    constructor(public service: TestService<TestModel>) {}
+
+    @Override('getManyBase')
+    get(@ParsedRequest() req: CrudRequest) {
+      return req;
+    }
+  }
+
   let $: supertest.SuperTest<supertest.Test>;
   let app: NestApplication;
 
@@ -135,6 +142,7 @@ describe('#crud', () => {
         Test3Controller,
         Test4Controller,
         Test5Controller,
+        Test6Controller,
       ],
     }).compile();
     app = module.createNestApplication();
@@ -158,8 +166,15 @@ describe('#crud', () => {
       const page = 2;
       const limit = 10;
       const fields = ['a', 'b', 'c'];
-      const sorts: any[][] = [['a', 'ASC'], ['b', 'DESC']];
-      const filters: any[][] = [['a', 'eq', 1], ['c', 'in', [1, 2, 3]], ['d', 'notnull']];
+      const sorts: any[][] = [
+        ['a', 'ASC'],
+        ['b', 'DESC'],
+      ];
+      const filters: any[][] = [
+        ['a', 'eq', 1],
+        ['c', 'in', [1, 2, 3]],
+        ['d', 'notnull'],
+      ];
 
       qb.setPage(page).setLimit(limit);
       qb.select(fields);
@@ -170,9 +185,7 @@ describe('#crud', () => {
         qb.setFilter({ field: f[0], operator: f[1], value: f[2] });
       }
 
-      const res = await $.get('/test/query')
-        .query(qb.query())
-        .expect(200);
+      const res = await $.get('/test/query').query(qb.query()).expect(200);
       expect(res.body.parsed).toHaveProperty('page', page);
       expect(res.body.parsed).toHaveProperty('limit', limit);
       expect(res.body.parsed).toHaveProperty('fields', fields);
@@ -190,9 +203,7 @@ describe('#crud', () => {
     });
 
     it('should others working', async () => {
-      const res = await $.get('/test/other')
-        .query({ page: 2, per_page: 11 })
-        .expect(200);
+      const res = await $.get('/test/other').query({ page: 2, per_page: 11 }).expect(200);
       expect(res.body.page).toBe(2);
     });
 
@@ -225,9 +236,7 @@ describe('#crud', () => {
     });
 
     it('should handle authorized request, 1', async () => {
-      const res = await $.post('/test3')
-        .send({})
-        .expect(201);
+      const res = await $.post('/test3').send({}).expect(201);
       const authPersist = { bar: false };
       const { parsed } = res.body;
       expect(parsed.authPersist).toMatchObject(authPersist);
@@ -241,19 +250,21 @@ describe('#crud', () => {
 
     it('should handle authorized request, 3', async () => {
       const query = qb.search({ name: 'test' }).query();
-      const res = await $.get('/test4')
-        .query(query)
-        .expect(200);
+      const res = await $.get('/test4').query(query).expect(200);
       const search = { $or: [{ id: 1 }, { $and: [{}, { name: 'test' }] }] };
       expect(res.body.parsed.search).toMatchObject(search);
     });
     it('should handle authorized request, 4', async () => {
       const query = qb.search({ name: 'test' }).query();
-      const res = await $.get('/test3')
-        .query(query)
-        .expect(200);
+      const res = await $.get('/test3').query(query).expect(200);
       const search = { $and: [{ user: 'test', buz: 1 }, { name: 'persist' }] };
       expect(res.body.parsed.search).toMatchObject(search);
     });
+
+    it('should handle classTransformOptions, 1', async () => {
+      const res = await $.get('/test6').expect(200);
+      const groups = ['TEST_2'];
+      expect(res.body.parsed.classTransformOptions.groups).toMatchObject(groups);
+    });
   });
 });