Created PipesModelParser

Author: adammfrank

package.json

@@ -24,6 +24,8 @@
     "@nestjs/microservices": "^4.0.0",
     "@nestjs/testing": "^4.0.0",
     "@nestjs/websockets": "^4.0.0",
+    "class-transformer": "^0.1.8",
+    "class-validator": "^0.7.3",
     "cli-color": "^1.1.0",
     "engine.io-client": "^3.1.1",
     "express": "^4.16.2",

src/core/pipes/pipes-model-parser.ts

@@ -0,0 +1,30 @@
+import { HttpException } from "@nestjs/core";
+import {
+  PipeTransform,
+  Pipe,
+  ArgumentMetadata,
+  HttpStatus
+} from "@nestjs/common";
+import { validate } from "class-validator";
+import { plainToClass } from "class-transformer";
+
+@Pipe()
+export class PipesModelParser implements PipeTransform<any> {
+  async transform(value, metadata: ArgumentMetadata) {
+    const { metatype } = metadata;
+    if (!metatype || !this.toValidate(metatype)) {
+      return value;
+    }
+    const entity = plainToClass(metatype, value);
+    const errors = await validate(entity);
+    if (errors.length > 0) {
+      throw new HttpException("Validation failed", HttpStatus.BAD_REQUEST);
+    }
+    return entity;
+  }
+
+  private toValidate(metatype): boolean {
+    const types = [String, Boolean, Number, Array, Object];
+    return !types.find(type => metatype === type);
+  }
+}

src/core/test/pipes/pipes-model-parser.spec.ts

@@ -0,0 +1,39 @@
+import * as sinon from "sinon";
+import { expect } from "chai";
+import { PipesModelParser } from "./../../pipes/pipes-model-parser";
+import { ArgumentMetadata } from "@nestjs/common";
+
+class TestModel {
+  constructor(public prop1: string, public prop2: number) {}
+}
+
+describe("PipesModelParser", () => {
+  let target: PipesModelParser;
+  let testModel;
+  beforeEach(() => {
+    target = new PipesModelParser();
+  });
+  describe("transform", () => {
+    describe("when metadata is empty or undefined", () => {
+      it("should return the value unchanged", async () => {
+        const testObj = { prop1: "value1", prop2: "value2" };
+        expect(await target.transform(testObj, {} as any)).to.equal(testObj);
+        expect(await target.transform(testObj, {} as any)).to.not.be.instanceOf(
+          TestModel
+        );
+      });
+    });
+    describe("when metadata contains a class", () => {
+      const metadata: ArgumentMetadata = {
+        type: "body",
+        metatype: TestModel,
+        data: ""
+      };
+      it("should return an instance of the class", async () => {
+        const testObj = { prop1: "value1", prop2: "value2" };
+        const result = await target.transform(testObj, metadata);
+        expect(result).to.be.instanceOf(TestModel);
+      });
+    });
+  });
+});