Merge pull request #9 from hfour/goce/H4C-247_јson-rpc-client

H4C-247: JSON RPC Client implementation

Author: spion

package.json

@@ -17,8 +17,9 @@
     "@nestjs/common": "^6.11.11",
     "@nestjs/core": "^6.11.11",
     "@nestjs/microservices": "^6.11.11",
-    "reflect-metadata": "^0.1.13",
-    "express": "^4.17.1"
+    "axios": "^0.19.2",
+    "express": "^4.17.1",
+    "reflect-metadata": "^0.1.13"
   },
   "devDependencies": {
     "@nestjs/testing": "^6.11.11",
@@ -28,11 +29,11 @@
     "@types/supertest": "^2.0.7",
     "jest": "^25.1.0",
     "prettier": "^1.15.3",
+    "rxjs": "^6.0.0",
     "supertest": "^4.0.2",
     "ts-jest": "25.2.1",
     "ts-node": "8.6.2",
-    "typescript": "3.8.3",
-    "rxjs": "^6.0.0"
+    "typescript": "3.8.3"
   },
   "jest": {
     "moduleFileExtensions": [

src/client-proxy.ts

@@ -0,0 +1,65 @@
+import { ClientProxy } from "@nestjs/microservices";
+import axios from "axios";
+import { resolve } from "dns";
+import { CodedRpcException } from ".";
+
+export class JSONRPCClient extends ClientProxy {
+  constructor(private readonly url: string) {
+    super();
+  }
+  private counter: number = 0;
+  private jsonrpc: string = "2.0";
+
+  connect(): Promise<any> {
+    throw new Error('The "connect()" method is not supported in JSONRPC mode.');
+  }
+  close() {
+    return Promise.resolve();
+  }
+  /**
+   * Method is unsupported for JSONRPC
+   */
+  protected publish(packet: any, callback: (packet: any) => any): any {
+    throw new Error("Method is not supported in JSONRPC mode.");
+  }
+  /**
+   * Method is unsupported for JSONRPC
+   */
+  protected async dispatchEvent(packet: any): Promise<any> {
+    throw new Error("Method is not supported in JSONRPC mode.");
+  }
+  getService<SvcInterface>(namespace: string): ServiceClient<SvcInterface> {
+    let url = this.url;
+    let id = ++this.counter;
+    let jsonrpc = this.jsonrpc;
+    return new Proxy(
+      {},
+      {
+        get(obj, prop) {
+          return function(params: any) {
+            return axios
+              .post(url, {
+                method: namespace + "." + prop.toString(),
+                params,
+                jsonrpc: "2.0",
+                id
+              })
+              .then(res => ({ jsonrpc, result: res, id }))
+              .catch(err => {
+                const { code, message, data } = err.response.data;
+
+                throw new CodedRpcException(message, code, data);
+              });
+          };
+        }
+      }
+    ) as ServiceClient<SvcInterface>;
+  }
+}
+export type ServiceClient<Service> = {
+  [MethodName in keyof Service]: Service[MethodName] extends (params: any) => Promise<any>
+    ? Service[MethodName]
+    : Service[MethodName] extends (params: infer Params) => infer ReturnType
+    ? (params: Params) => Promise<ReturnType>
+    : never;
+};

src/index.spec.ts

@@ -1,14 +1,17 @@
 import * as request from "supertest";
 
 import { Test } from "@nestjs/testing";
-import { INestMicroservice } from "@nestjs/common";
+import { INestMicroservice, ServiceUnavailableException } from "@nestjs/common";
 
 import { TestService } from "./test-handler";
-import { JSONRPCServer } from ".";
+import { JSONRPCServer, CodedRpcException } from ".";
+import { JSONRPCClient } from "./client-proxy";
 
 describe("json-rpc-e2e", () => {
   let app: INestMicroservice;
   let server: JSONRPCServer;
+  let client: JSONRPCClient;
+  let service: TestService;
 
   beforeAll(async () => {
     let moduleRef = await Test.createTestingModule({
@@ -20,34 +23,30 @@ describe("json-rpc-e2e", () => {
       port: 8080
     });
 
+    client = new JSONRPCClient("http://localhost:8080/rpc/v1");
+
+    service = client.getService<TestService>("test");
+
     app = moduleRef.createNestMicroservice({ strategy: server });
     await new Promise(resolve => app.listen(resolve));
   });
 
-  it(`/rpc/v1/ test.invoke (POST)`, () => {
-    return request(server.server)
-      .post("/rpc/v1")
-      .send({ method: "test.invoke", params: { data: "hi" } })
-      .expect(200)
-      .expect({
-        data: "hi"
-      });
+  it(`should make and RPC call with the JSONRPCClient`, () => {
+    return service
+      .invokeClientService({ data: "hi" })
+      .then(res => expect(res.result.data).toStrictEqual({ data: "hi" }));
   });
 
-  it(`should throw an error on /rpc/v1/ test.testError (POST)`, () => {
-    const errorObj = {
-      message: "RPC EXCEPTION",
-      code: 403,
-      data: {
+  it(`should return an error and check error data from JSONRPCClient call`, async () => {
+    const expectedCodedException = expect.objectContaining(
+      new CodedRpcException("RPC EXCEPTION", 403, {
         fromService: "Test Service",
         params: { data: "hi" }
-      }
-    };
-    return request(server.server)
-      .post("/rpc/v1")
-      .send({ method: "test.testError", params: { data: "hi" } })
-      .expect(403)
-      .expect(errorObj);
+      })
+    );
+
+    const resp = service.testError({ data: "hi" });
+    return expect(resp).rejects.toThrowError(expectedCodedException);
   });
 
   afterAll(async () => {

src/index.ts

@@ -62,6 +62,7 @@ export class JSONRPCServer extends Server implements CustomTransportStrategy {
       // let handlers = this.getHandlers();
 
       let handler = this.getHandlerByPattern(req.body.method);
+
       if (handler == null) {
         return res.status(404).json({ error: "Not Found" });
       }

src/test-handler.ts

@@ -64,7 +64,7 @@ class TestGuard implements CanActivate {
 @JSONRpcService({
   namespace: "test"
 })
-export class TestService {
+export class TestService implements ITestClientService {
   constructor() {
     DecorationsState.serviceConstructorCount = DecorationsState.serviceConstructorCount + 1;
     console.log("TestService count now at", DecorationsState.serviceConstructorCount);
@@ -81,8 +81,22 @@ export class TestService {
   @UsePipes(TestPipe)
   @UseInterceptors(TestInterceptor)
   @UseGuards(TestGuard)
-  public async testError(params: any) {
+  public async testError(params: any): Promise<any> {
     // construct the error object with some data inside
     throw new CodedRpcException("RPC EXCEPTION", 403, { fromService: "Test Service", params });
   }
+
+  @UsePipes(TestPipe)
+  @UseInterceptors(TestInterceptor)
+  @UseGuards(TestGuard)
+  public async invokeClientService(params: any) {
+    console.log("Invoke Client Service WAS called");
+    return params;
+  }
+}
+
+export interface ITestClientService {
+  invoke(params: any): any;
+  invokeClientService(params: any): any;
+  testError(params: any): Promise<any>;
 }

yarn.lock

@@ -722,7 +722,7 @@ aws4@^1.8.0:
   resolved "https://registry.yarnpkg.com/aws4/-/aws4-1.9.1.tgz#7e33d8f7d449b3f673cd72deb9abdc552dbe528e"
   integrity sha512-wMHVg2EOHaMRxbzgFJ9gtjOOCrI80OHLG14rxi28XwOW8ux6IiEbRCGGGqCtdAIg4FQCbW20k9RsT4y3gJlFug==
 
-[email protected]:
+[email protected], axios@^0.19.2:
   version "0.19.2"
   resolved "https://registry.yarnpkg.com/axios/-/axios-0.19.2.tgz#3ea36c5d8818d0d5f8a8a97a6d36b86cdc00cb27"
   integrity sha512-fjgm5MvRHLhx+osE2xoekY70AhARk3a6hkN+3Io1jc00jtquGvxYlKlsFUhmUET0V5te6CcZI7lcv2Ym61mjHA==