feature(common) add class serializer interceptor

Author: kamilmysliwiec

packages/common/interfaces/external/class-transform-options.interface.ts

@@ -0,0 +1,41 @@
+/**
+ * Options to be passed during transformation.
+ * @see https://github.com/typestack/class-transformer
+ */
+export interface ClassTransformOptions {
+  /**
+   * Exclusion strategy. By default exposeAll is used, which means that it will expose all properties are transformed
+   * by default.
+   */
+  strategy?: 'excludeAll' | 'exposeAll';
+  /**
+   * Only properties with given groups gonna be transformed.
+   */
+  groups?: string[];
+  /**
+   * Only properties with "since" > version < "until" gonna be transformed.
+   */
+  version?: number;
+  /**
+   * Excludes properties with the given prefixes. For example, if you mark your private properties with "_" and "__"
+   * you can set this option's value to ["_", "__"] and all private properties will be skipped.
+   * This works only for "exposeAll" strategy.
+   */
+  excludePrefixes?: string[];
+  /**
+   * If set to true then class transformer will ignore all @Expose and @Exclude decorators and what inside them.
+   * This option is useful if you want to kinda clone your object but do not apply decorators affects.
+   */
+  ignoreDecorators?: boolean;
+  /**
+   * Target maps allows to set a Types of the transforming object without using @Type decorator.
+   * This is useful when you are transforming external classes, or if you already have type metadata for
+   * objects and you don't want to set it up again.
+   */
+  targetMaps?: any[];
+  /**
+   * If set to true then class transformer will perform a circular check. (circular check is turned off by default)
+   * This option is useful when you know for sure that your types might have a circular dependency.
+   */
+  enableCircularCheck?: boolean;
+}

packages/common/serializer/class-serializer.constants.ts

@@ -0,0 +1 @@
+export const CLASS_SERIALIZER_OPTIONS = 'class_serializer:options';

packages/common/serializer/class-serializer.interceptors.ts

@@ -0,0 +1,76 @@
+import { ExecutionContext, Injectable, NestInterceptor } from '@nestjs/common';
+import { Observable } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { Inject } from '../decorators/core';
+import { ClassTransformOptions } from '../interfaces/external/class-transform-options.interface';
+import { loadPackage } from '../utils/load-package.util';
+import { isObject } from '../utils/shared.utils';
+import { CLASS_SERIALIZER_OPTIONS } from './class-serializer.constants';
+
+let classTransformer: any = {};
+
+export interface PlainLiteralObject {
+  [key: string]: any;
+}
+
+// NOTE (external)
+// We need to deduplicate them here due to the circular dependency
+// between core and common packages
+const REFLECTOR = 'Reflector';
+
+@Injectable()
+export class ClassSerializerInterceptor implements NestInterceptor {
+  constructor(@Inject(REFLECTOR) private readonly reflector: any) {
+    const loadPkg = pkg => loadPackage(pkg, 'ClassSerializerInterceptor');
+    classTransformer = loadPkg('class-transformer');
+  }
+
+  intercept(
+    context: ExecutionContext,
+    call$: Observable<any>,
+  ): Observable<any> {
+    const options = this.getContextOptions(context);
+    return call$.pipe(
+      map((res: PlainLiteralObject | Array<PlainLiteralObject>) =>
+        this.serialize(res, options),
+      ),
+    );
+  }
+
+  serialize(
+    response: PlainLiteralObject | Array<PlainLiteralObject>,
+    options: ClassTransformOptions,
+  ): PlainLiteralObject | PlainLiteralObject[] {
+    const isArray = Array.isArray(response);
+    if (!isObject(response) && !isArray) {
+      return response;
+    }
+    return isArray
+      ? (response as PlainLiteralObject[]).map(item =>
+          this.transformToPlain(item, options),
+        )
+      : this.transformToPlain(response, options);
+  }
+
+  transformToPlain(
+    plainOrClass,
+    options: ClassTransformOptions,
+  ): PlainLiteralObject {
+    return plainOrClass && plainOrClass.constructor !== Object
+      ? classTransformer.classToPlain(plainOrClass, options)
+      : plainOrClass;
+  }
+
+  private getContextOptions(
+    context: ExecutionContext,
+  ): ClassTransformOptions | undefined {
+    return (
+      this.reflectSerializeMetadata(context.getHandler()) ||
+      this.reflectSerializeMetadata(context.getClass())
+    );
+  }
+
+  private reflectSerializeMetadata(obj): ClassTransformOptions | undefined {
+    return this.reflector.get(CLASS_SERIALIZER_OPTIONS, obj);
+  }
+}

packages/common/serializer/decorators/index.ts

@@ -0,0 +1 @@
+export * from './serialize-options.decorator';

packages/common/serializer/decorators/serialize-options.decorator.ts

@@ -0,0 +1,6 @@
+import { ReflectMetadata } from '../../decorators';
+import { ClassTransformOptions } from '../../interfaces/external/class-transform-options.interface';
+import { CLASS_SERIALIZER_OPTIONS } from '../class-serializer.constants';
+
+export const SerializeOptions = (options: ClassTransformOptions) =>
+  ReflectMetadata(CLASS_SERIALIZER_OPTIONS, options);

packages/common/serializer/index.ts

@@ -0,0 +1,2 @@
+export * from './class-serializer.interceptors';
+export * from './decorators';