ci(nestjs-json-rpc-sdk): fix test and create e2e

Author: klerick

apps/json-api-server-e2e/src/json-api/json-rpc/run-json-rpc.spec.ts

@@ -0,0 +1,102 @@
+import { INestApplication } from '@nestjs/common';
+import {
+  ResultRpcFactoryPromise,
+  ErrorCodeType,
+  RpcError,
+} from '@klerick/nestjs-json-rpc-sdk';
+
+import { creatRpcSdk, MapperRpc, run } from '../utils/run-ppplication';
+
+let app: INestApplication;
+
+beforeAll(async () => {
+  app = await run();
+});
+
+afterAll(async () => {
+  await app.close();
+});
+
+describe('Run json rpc:', () => {
+  let rpc: ResultRpcFactoryPromise<MapperRpc>['rpc'];
+  let rpcBatch: ResultRpcFactoryPromise<MapperRpc>['rpcBatch'];
+  let rpcForBatch: ResultRpcFactoryPromise<MapperRpc>['rpcForBatch'];
+  beforeEach(() => {
+    ({ rpc, rpcBatch, rpcForBatch } = creatRpcSdk());
+  });
+
+  describe('Should be correct response', () => {
+    it('Should be call one method', async () => {
+      const input = 1;
+      const result = await rpc.RpcService.someMethode(input);
+      expect(result).toBe(input);
+    });
+
+    it('Should be correct response batch', async () => {
+      const input = 1;
+      const input2 = {
+        a: 1,
+        b: 2,
+      };
+      const call1 = rpcForBatch.RpcService.someMethode(input);
+      const call2 = rpcForBatch.RpcService.methodeWithObjectParams(input2);
+
+      const [result1, result2] = await rpcBatch(call1, call2);
+      expect(result1).toBe(input);
+      if ('error' in result2) {
+        throw Error('Return error');
+      }
+      expect(result2.d).toEqual(`${input2.a}`);
+      expect(result2.c).toEqual(`${input2.b}`);
+    });
+  });
+
+  describe('Check error', () => {
+    it('Should throw an error ' + ErrorCodeType.MethodNotFound, async () => {
+      const input = 1;
+      expect.assertions(6);
+      try {
+        // @ts-ignore
+        await rpc.IncorrectService.incorrectMethode(input);
+      } catch (e) {
+        expect(e).toBeInstanceOf(RpcError);
+        expect((e as RpcError).code).toBe(-32601);
+        expect((e as RpcError).message).toBe(ErrorCodeType.MethodNotFound);
+      }
+      try {
+        // @ts-ignore
+        await rpc.RpcService.incorrectMethode(input);
+      } catch (e) {
+        expect(e).toBeInstanceOf(RpcError);
+        expect((e as RpcError).code).toBe(-32601);
+        expect((e as RpcError).message).toBe(ErrorCodeType.MethodNotFound);
+      }
+    });
+
+    it('Should throw an error ' + ErrorCodeType.InvalidParams, async () => {
+      const input = 'llll';
+      expect.assertions(3);
+      try {
+        // @ts-ignore
+        await rpc.RpcService.someMethode(input);
+      } catch (e) {
+        expect(e).toBeInstanceOf(RpcError);
+        expect((e as RpcError).code).toBe(-32602);
+        expect((e as RpcError).message).toBe(ErrorCodeType.InvalidParams);
+      }
+    });
+
+    it('Should throw an error ' + ErrorCodeType.ServerError, async () => {
+      const input = 5;
+      expect.assertions(4);
+      try {
+        await rpc.RpcService.someMethode(input);
+      } catch (e) {
+        expect(e).toBeInstanceOf(RpcError);
+        expect((e as RpcError).code).toBe(-32099);
+        expect((e as RpcError).message).toBe(ErrorCodeType.ServerError);
+        expect((e as RpcError).data.title).toBe('Custom Error');
+      }
+    });
+  });
+});

apps/json-api-server-e2e/src/json-api/utils/run-ppplication.ts

@@ -1,13 +1,19 @@
 import { Test } from '@nestjs/testing';
 import { INestApplication } from '@nestjs/common';
-import { NestFactory } from '@nestjs/core';
 import { adapterForAxios, JsonApiJs } from 'json-api-nestjs-sdk';
+import {
+  RpcFactory,
+  axiosTransportFactory,
+  RpcConfig,
+} from '@klerick/nestjs-json-rpc-sdk';
+import { RpcService } from '@nestjs-json-api/type-for-rpc';
 import axios from 'axios';
 import { Logger } from 'nestjs-pino';
 
 import { AppModule } from '../../../../json-api-server/src/app/app.module';
 
 import { JsonConfig } from '../../../../../libs/json-api/json-api-nestjs-sdk/src/lib/types';
+import { TransportType } from '@klerick/nestjs-json-rpc-sdk';
 
 export const axiosAdapter = adapterForAxios(axios);
 let saveApp: INestApplication;
@@ -45,3 +51,19 @@ export const creatSdk = (config: Partial<JsonConfig> = {}) =>
     },
     true
   );
+
+export type MapperRpc = {
+  RpcService: RpcService;
+};
+
+export const creatRpcSdk = (config: Partial<RpcConfig> = {}) =>
+  RpcFactory<MapperRpc>(
+    {
+      ...config,
+      rpcHost: `http://localhost:${port}`,
+      rpcPath: `${globalPrefix}/rpc`,
+      transport: TransportType.HTTP,
+      httpAgentFactory: axiosTransportFactory(axios),
+    },
+    true
+  );

apps/json-api-server/src/app/rpc/rpc.module.ts

@@ -1,5 +1,6 @@
 import { Module } from '@nestjs/common';
 import { NestjsJsonRpcModule, TransportType } from '@klerick/nestjs-json-rpc';
+import { RpcService } from './service/rpc.service';
 
 @Module({
   imports: [
@@ -8,6 +9,6 @@ import { NestjsJsonRpcModule, TransportType } from '@klerick/nestjs-json-rpc';
       transport: TransportType.HTTP,
     }),
   ],
-  // providers: [ContestRpc, ParseIntArrayPipe, LineUpSchemaPipe],
+  providers: [RpcService],
 })
 export class RpcModule {}

apps/json-api-server/src/app/rpc/service/rpc.service.ts

@@ -0,0 +1,31 @@
+import {
+  InputType,
+  OutputType,
+  RpcService as IRpcService,
+} from '@nestjs-json-api/type-for-rpc';
+
+import {
+  createErrorCustomError,
+  RpcHandler,
+  RpcParamsPipe,
+} from '@klerick/nestjs-json-rpc';
+import { ParseIntPipe } from '@nestjs/common';
+
+@RpcHandler()
+export class RpcService implements IRpcService {
+  methodeWithObjectParams(a: InputType): Promise<OutputType> {
+    return Promise.resolve({
+      d: `${a.a}`,
+      c: `${a.b}`,
+    });
+  }
+
+  someMethode(@RpcParamsPipe(ParseIntPipe) firstArg: number): Promise<number> {
+    if (firstArg === 5) throw createErrorCustomError(-32099, 'Custom Error');
+    return Promise.resolve(firstArg);
+  }
+
+  someOtherMethode(firstArg: number, secondArgument: number): Promise<string> {
+    return Promise.resolve('');
+  }
+}

libs/json-rpc/nestjs-json-rpc-sdk/src/index.ts

@@ -1 +1,7 @@
-export * from './lib/nestjs-json-rpc-sdk';
+export {
+  axiosTransportFactory,
+  RpcFactory,
+  ResultRpcFactoryPromise,
+  ResultRpcFactory,
+} from './lib/factory';
+export { RpcConfig, TransportType, ErrorCodeType, RpcError } from './lib/types';

libs/json-rpc/nestjs-json-rpc-sdk/src/lib/factory/rpc.factory.ts

@@ -2,11 +2,11 @@ import { RpcConfig, RpcReturnList, RpcBatch, RpcBatchPromise } from '../types';
 import { transportFactory } from './transport.factory';
 import { RpcBatchFactory, rpcProxy, RpcBatchFactoryPromise } from '../utils';
 
-type ResultRpcFactory<T extends object> = {
+export type ResultRpcFactory<T extends object> = {
   rpc: RpcReturnList<T, false>;
   rpcBatch: RpcBatch;
 };
-type ResultRpcFactoryPromise<T extends object> = {
+export type ResultRpcFactoryPromise<T extends object> = {
   rpc: RpcReturnList<T, true>;
   rpcForBatch: RpcReturnList<T, false>;
   rpcBatch: RpcBatchPromise;
@@ -30,7 +30,7 @@ export function RpcFactory<T extends object>(
 
   if (usePromise) {
     rpc = rpcProxy<RpcReturnList<T, true>>(transport, usePromise);
-    rpcForBatch = rpcProxy<RpcReturnList<T, false>>(transport, usePromise);
+    rpcForBatch = rpcProxy<RpcReturnList<T, false>>(transport, false);
     return { rpc, rpcForBatch, rpcBatch: RpcBatchFactoryPromise(transport) };
   } else {
     rpc = rpcProxy<RpcReturnList<T, false>>(transport, usePromise);

libs/json-rpc/nestjs-json-rpc-sdk/src/lib/json-rpc-angular.ts

@@ -1,5 +1,4 @@
 import {
-  Component,
   inject,
   InjectionToken,
   ModuleWithProviders,

libs/json-rpc/nestjs-json-rpc-sdk/src/lib/nestjs-json-rpc-sdk.spec.ts

@@ -58,17 +58,17 @@ describe('rpc-batch', () => {
 
   it('RpcBatchFactoryPromise', async () => {
     const transport = jest.fn().mockImplementationOnce((data) => {
-      expect(data.map((i: any) => i.id)).toEqual([1, 2, 3]);
+      expect(data.map((i: any) => i.id)).toEqual([4, 5, 6]);
       const errorObj = {
         error: {
           message: 'ErrroMsg',
           code: 1,
         },
-        id: 3,
+        id: 6,
       };
       return of(
         data.map((i: any) => {
-          if (i.id === 3) {
+          if (i.id === 6) {
             return errorObj;
           } else {
             return {
@@ -100,7 +100,6 @@ describe('rpc-batch', () => {
     ) as any;
 
     const [r3, r1, r2] = await rpcBatch(call3, call1, call2);
-
     expect(r3).toBeInstanceOf(RpcError);
     expect(r2).toEqual(call2.arg);
     expect(r1).toEqual(call1.arg);

libs/json-rpc/nestjs-json-rpc-sdk/src/lib/nestjs-json-rpc-sdk.ts

@@ -4,4 +4,7 @@ export {
   fromRpcErrorToRpcErrorObject,
   createError,
   RpcError,
+  createErrorCustomError,
 } from './lib/utils';
+
+export { RpcHandler, RpcParamsPipe } from './lib/decorators';

libs/json-rpc/nestjs-json-rpc-sdk/src/lib/utils/rpc-batch.spec.ts

@@ -25,7 +25,7 @@ import {
   MAP_HANDLER,
 } from '../../../constants';
 import { IterateFactory } from '../../../providers';
-import { RpcErrorObject } from '../../../types/error-payloade';
+import { RpcErrorObject } from '../../../types';
 
 type toString<T> = T extends string ? T : never;
 
@@ -84,7 +84,7 @@ export class HandlerService {
       }
       return result;
     } else {
-      return this.callRpc(data, 1);
+      return this.callRpc(data, data.id);
     }
   }
 
@@ -99,6 +99,7 @@ export class HandlerService {
         id,
       };
     } catch (e) {
+      console.log(e);
       if (e instanceof RpcError) {
         return fromRpcErrorToRpcErrorObject(e, id);
       }
@@ -182,9 +183,17 @@ export class HandlerService {
       if (pipe) {
         pipe = await this.getPipeByType(pipe);
       }
+      let metatype: ArgumentMetadata = {
+        type: 'custom',
+        data: '',
+        metatype: undefined,
+      };
+      if (paramsType && paramsType[index]) {
+        metatype = paramsType[index];
+      }
       return {
         pipe,
-        metatype: paramsType[index],
+        metatype,
         params,
         index,
       };
@@ -204,8 +213,8 @@ export class HandlerService {
       } catch (e) {
         throw createError(
           e instanceof BadRequestException
-            ? ErrorCodeType.InvalidRequest
-            : ErrorCodeType.ServerError,
+            ? ErrorCodeType.InvalidParams
+            : ErrorCodeType.InternalError,
           (e as Error).message,
           `Argument: #${index}`
         );

libs/json-rpc/nestjs-json-rpc/src/index.ts

@@ -1,5 +1,6 @@
 import { ErrorCode } from '../constants';
 import { RpcErrorData, RpcErrorObject } from '../types/error-payloade';
+import { ErrorCodeType } from '../types';
 
 export class RpcError extends Error {
   id: number | null = null;
@@ -12,11 +13,10 @@ export class RpcError extends Error {
   }
 }
 
-export function createError(
-  type: keyof typeof ErrorCode,
+function getErrorData(
   title?: string,
   description?: string
-): RpcError {
+): undefined | RpcErrorData {
   let data: undefined | RpcErrorData = undefined;
   if (title) {
     data = { title };
@@ -25,8 +25,32 @@ export function createError(
   if (title && description) {
     data = { title, description };
   }
+  return data;
+}
 
-  return new RpcError(type, ErrorCode[type], data);
+export function createErrorCustomError(
+  code: number,
+  title?: string,
+  description?: string
+): RpcError {
+  const absCode = Math.abs(code);
+  let resultCode = 3200;
+  if (code < 0 && absCode > 3200 && absCode <= 32099) {
+    resultCode = code;
+  }
+
+  return new RpcError(
+    ErrorCodeType.ServerError,
+    resultCode,
+    getErrorData(title, description)
+  );
+}
+export function createError(
+  type: keyof typeof ErrorCode,
+  title?: string,
+  description?: string
+): RpcError {
+  return new RpcError(type, ErrorCode[type], getErrorData(title, description));
 }
 
 export function fromRpcErrorToRpcErrorObject(