Validation pipe example

Author: spion

package.json

@@ -29,6 +29,8 @@
     "@types/jest": "^25.1.4",
     "@types/node": "^13.9.0",
     "@types/supertest": "^2.0.7",
+    "class-transformer": "^0.3.2",
+    "class-validator": "^0.13.1",
     "jest": "^25.1.0",
     "prettier": "^1.15.3",
     "rxjs": "^6.0.0",

src/index.spec.ts

@@ -1,4 +1,4 @@
-import * as request from 'supertest';
+import * as request from "supertest";
 
 import { Test } from "@nestjs/testing";
 import { INestApplication, INestMicroservice } from "@nestjs/common";
@@ -15,7 +15,7 @@ describe("json-rpc-e2e", () => {
   let service: ITestClientService;
   let unauthorizedService: ITestClientService;
 
-  describe('standalone', () => {
+  describe("standalone", () => {
     beforeAll(async () => {
       let moduleRef = await Test.createTestingModule({
         controllers: [TestService]
@@ -45,6 +45,10 @@ describe("json-rpc-e2e", () => {
       expect(res).toStrictEqual({ test: "hi" });
     });
 
+    it(`should throw if sends an invalid DTO`, async () => {
+      let res = service.invokeClientService({ test: "" });
+      await expect(res).rejects.toThrow("hi");
+    });
     it(`should fail to make a request with an unauthorized JsonRpcClient`, async () => {
       let result = unauthorizedService.invokeClientService({ test: "hi" });
       await expect(result).rejects.toThrowError("Forbidden resource");
@@ -61,7 +65,10 @@ describe("json-rpc-e2e", () => {
     });
 
     it(`should fail to invoke unexposed methods`, async () => {
-      const expectedCodedException = new CodedRpcException("Method not found: test.notExposed", 404);
+      const expectedCodedException = new CodedRpcException(
+        "Method not found: test.notExposed",
+        404
+      );
       const resp = service.notExposed({ test: "data" });
       await expect(resp).rejects.toThrowError(expectedCodedException);
     });
@@ -83,17 +90,17 @@ describe("json-rpc-e2e", () => {
     });
   });
 
-  describe('hybrid', () => {
+  describe("hybrid", () => {
     beforeAll(async () => {
       let moduleRef = await Test.createTestingModule({
         controllers: [TestService]
       }).compile();
-    
+
       app = moduleRef.createNestApplication();
 
       server = new JsonRpcServer({
-        path: '/rpc',
-        adapter: app.getHttpAdapter(),
+        path: "/rpc",
+        adapter: app.getHttpAdapter()
       });
 
       app.connectMicroservice({ strategy: server });
@@ -102,46 +109,46 @@ describe("json-rpc-e2e", () => {
       await app.init();
     });
 
-    it('should invoke RPC methods on incoming HTTP requests', async () => {
+    it("should invoke RPC methods on incoming HTTP requests", async () => {
       await request(app.getHttpServer())
-        .post('/rpc')
-        .set('Authorization', 'Bearer xyz')
+        .post("/rpc")
+        .set("Authorization", "Bearer xyz")
         .send({
-          jsonrpc: '2.0',
-          method: 'test.invokeClientService',
-          id: '1',
+          jsonrpc: "2.0",
+          method: "test.invokeClientService",
+          id: "1",
           params: {
-            test: 'hi',
-          },
+            test: "hi"
+          }
         })
         .expect({
-          jsonrpc: '2.0',
-          id: '1',
-          result: { test: 'hi' }
+          jsonrpc: "2.0",
+          id: "1",
+          result: { test: "hi" }
         });
     });
 
-    it('should wrap json-rpc errors in http 200', async () => {
+    it("should wrap json-rpc errors in http 200", async () => {
       await request(app.getHttpServer())
-      .post('/rpc')
-      .set('Authorization', 'Bearer xyz')
-      .send({
-        jsonrpc: '2.0',
-        method: 'test.notExposed',
-        id: '1',
-        params: {
-          test: 'hi',
-        },
-      })
-      .expect({
-        jsonrpc: '2.0',
-        id: '1',
-        error: { 
-          code: 404, 
-          data: {}, 
-          message: 'Method not found: test.notExposed',
-        }
-      });
+        .post("/rpc")
+        .set("Authorization", "Bearer xyz")
+        .send({
+          jsonrpc: "2.0",
+          method: "test.notExposed",
+          id: "1",
+          params: {
+            test: "hi"
+          }
+        })
+        .expect({
+          jsonrpc: "2.0",
+          id: "1",
+          error: {
+            code: 404,
+            data: {},
+            message: "Method not found: test.notExposed"
+          }
+        });
     });
   });
 });

src/test-handler.ts

@@ -10,10 +10,12 @@ import {
   UseInterceptors,
   UseGuards,
   Scope,
-  Inject
+  ValidationPipe
 } from "@nestjs/common";
 import { Ctx } from "@nestjs/microservices";
 
+import { IsNotEmpty } from "class-validator";
+
 import { CodedRpcException, JsonRpcContext, RpcController, RpcMethod, RpcService } from ".";
 
 const initialModuleState = {
@@ -83,6 +85,11 @@ class TestGuard implements CanActivate {
 
 type IRpcTestService = RpcController<ITestClientService>;
 
+export class TestDto {
+  @IsNotEmpty()
+  test!: string;
+}
+
 @RpcService({
   namespace: "test"
 })
@@ -92,14 +99,6 @@ export class TestService implements IRpcTestService {
     DecorationsState.serviceConstructorCount = DecorationsState.serviceConstructorCount + 1;
   }
 
-  @UsePipes(TestPipe)
-  @UseInterceptors(TestInterceptor)
-  @UseGuards(TestGuard)
-  @RpcMethod()
-  public async invoke(params: { test: string }) {
-    return Promise.resolve(params);
-  }
-
   @UsePipes(TestPipe)
   @UseInterceptors(TestInterceptor)
   @UseGuards(TestGuard)
@@ -110,10 +109,11 @@ export class TestService implements IRpcTestService {
   }
 
   @UsePipes(TestPipe)
+  @UsePipes(ValidationPipe)
   @UseInterceptors(TestInterceptor)
   @UseGuards(TestGuard)
   @RpcMethod()
-  public async invokeClientService(params: { test: string }) {
+  public async invokeClientService(params: TestDto) {
     return Promise.resolve(params);
   }
 
@@ -131,7 +131,6 @@ export class TestService implements IRpcTestService {
 }
 
 export interface ITestClientService {
-  invoke(params: { test: string }): Promise<{ test: string }>;
   invokeClientService(params: { test: string }): Promise<{ test: string }>;
   testError(params: { errorTest: string }): Promise<void>;
   injectContext(params: {}): Promise<{ key: string | undefined }>;