- response packing by JSON Rpc specification

- fixed unit tests

Author: goce-h4

src/client-proxy.ts

@@ -6,6 +6,9 @@ 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.');
   }
@@ -26,19 +29,26 @@ export class JSONRPCClient extends ClientProxy {
   }
   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" })
-              .then(res => Promise.resolve(res))
+              .post(url, {
+                method: namespace + "." + prop.toString(),
+                params,
+                jsonrpc: "2.0",
+                id: ++id
+              })
+              .then(res => Promise.resolve({ jsonrpc, result: res, id }))
               .catch(err => {
                 const { code, message, data } = err.response.data;
                 let resp = { code, message, data };
 
-                return Promise.resolve(resp);
+                return Promise.resolve({ jsonrpc, error: resp, id });
               });
           };
         }

src/index.spec.ts

@@ -10,6 +10,8 @@ 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({
@@ -21,61 +23,32 @@ describe("json-rpc-e2e", () => {
       port: 8080
     });
 
-    app = moduleRef.createNestMicroservice({ strategy: server });
-    await new Promise(resolve => app.listen(resolve));
-  });
+    client = new JSONRPCClient("http://localhost:8080/rpc/v1");
 
-  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"
-      });
-  });
+    service = client.getService<TestService>("test");
 
-  it(`should throw an error on /rpc/v1/ test.testError (POST)`, () => {
-    const errorObj = {
-      message: "RPC EXCEPTION",
-      code: 403,
-      data: {
-        fromService: "Test Service",
-        params: { data: "hi" }
-      }
-    };
-    return request(server.server)
-      .post("/rpc/v1")
-      .send({ method: "test.testError", params: { data: "hi" } })
-      .expect(403)
-      .expect(errorObj);
+    app = moduleRef.createNestMicroservice({ strategy: server });
+    await new Promise(resolve => app.listen(resolve));
   });
 
   it(`should make and RPC call with the JSONRPCClient`, () => {
-    console.log("Testing RPC CLient");
-    const client = new JSONRPCClient("http://localhost:8080/rpc/v1");
-    const service = client.getService<TestService>("test");
-
     return service
       .invokeClientService({ data: "hi" })
-      .then(res => expect(res.data).toStrictEqual({ data: "hi" }));
+      .then(res => expect(res.result.data).toStrictEqual({ data: "hi" }));
   });
 
   it(`should return an error from JSONRPCClient call`, () => {
-    console.log("Testing RPC CLient");
-    const client = new JSONRPCClient("http://localhost:8080/rpc/v1");
-    const service = client.getService<TestService>("test");
-
     const errorObj = {
       message: "RPC EXCEPTION",
       code: 403,
       data: {
         fromService: "Test Service",
         params: { data: "hi" }
-      }
+      },
+      id: 2
     };
 
-    return service.testError({ data: "hi" }).then(res => expect(res).toStrictEqual(errorObj));
+    return service.testError({ data: "hi" }).then(res => expect(res.error).toStrictEqual(errorObj));
   });
 
   afterAll(async () => {

src/index.ts

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

src/test-handler.ts

@@ -81,7 +81,7 @@ export class TestService implements ITestClientService {
   @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 });
   }
@@ -96,6 +96,7 @@ export class TestService implements ITestClientService {
 }
 
 export interface ITestClientService {
+  invoke(params: any): any;
   invokeClientService(params: any): any;
-  testError(params: any): any;
+  testError(params: any): Promise<any>;
 }