feat: upgrade grpc-js to 1.1.7 (#102)

Karl Ranna · web-flow · commit 8a95c69c006b · 2020-09-25T14:19:13.000+03:00
diff --git a/package-lock.json b/package-lock.json
diff --git a/package.json b/package.json
@@ -50,7 +50,7 @@
     "typescript": "3.9.3"
   },
   "dependencies": {
-    "@grpc/grpc-js": "1.0.4",
+    "@grpc/grpc-js": "1.1.7",
     "axios": "0.19.2",
     "axios-debug-log": "0.7.0",
     "bignumber.js": "9.0.0",
diff --git a/src/opendex/swap-success.ts b/src/opendex/swap-success.ts
@@ -4,7 +4,6 @@ import { Config } from '../config';
 import { RETRY_INTERVAL } from '../constants';
 import { XudClient } from '../proto/xudrpc_grpc_pb';
 import { SwapSuccess } from '../proto/xudrpc_pb';
-import { parseGrpcError } from './xud/parse-error';
 import { SubscribeSwapsParams } from './xud/subscribe-swaps';
 
 type GetOpenDEXswapSuccessParams = {
@@ -32,7 +31,7 @@ const getOpenDEXswapSuccess$ = ({
   ] = partition(
     getXudClient$(config).pipe(
       mergeMap(client => {
-        return subscribeXudSwaps$({ client, config, parseGrpcError });
+        return subscribeXudSwaps$({ client, config });
       }),
       share()
     ),
diff --git a/src/opendex/xud/balance.ts b/src/opendex/xud/balance.ts
@@ -2,7 +2,6 @@ import { Observable } from 'rxjs';
 import { XudClient } from '../../proto/xudrpc_grpc_pb';
 import { GetBalanceRequest, GetBalanceResponse } from '../../proto/xudrpc_pb';
 import { processResponse } from './process-response';
-import { parseGrpcError } from './parse-error';
 
 const getXudBalance$ = (client: XudClient): Observable<GetBalanceResponse> => {
   const request = new GetBalanceRequest();
@@ -11,7 +10,6 @@ const getXudBalance$ = (client: XudClient): Observable<GetBalanceResponse> => {
       request,
       processResponse({
         subscriber,
-        parseGrpcError,
       })
     );
   });
diff --git a/src/opendex/xud/create-order.ts b/src/opendex/xud/create-order.ts
@@ -6,7 +6,6 @@ import { PlaceOrderRequest, PlaceOrderResponse } from '../../proto/xudrpc_pb';
 import { satsToCoinsStr } from '../../utils';
 import { OpenDEXorder } from '../orders';
 import { processResponse } from './process-response';
-import { parseGrpcError } from './parse-error';
 
 type CreateXudOrderParams = OpenDEXorder & {
   logger: Logger;
@@ -52,7 +51,6 @@ const createXudOrder$ = ({
         request,
         processResponse({
           subscriber,
-          parseGrpcError,
         })
       );
     }).pipe(
diff --git a/src/opendex/xud/list-orders.ts b/src/opendex/xud/list-orders.ts
@@ -3,7 +3,6 @@ import { XudClient } from '../../proto/xudrpc_grpc_pb';
 import { ListOrdersRequest, ListOrdersResponse } from '../../proto/xudrpc_pb';
 import { processResponse } from './process-response';
 import { map } from 'rxjs/operators';
-import { parseGrpcError } from './parse-error';
 
 type ListXudOrdersResponse = {
   client: XudClient;
@@ -19,7 +18,6 @@ const listXudOrders$ = (
       request,
       processResponse({
         subscriber,
-        parseGrpcError,
       })
     );
   });
diff --git a/src/opendex/xud/parse-error.spec.ts b/src/opendex/xud/parse-error.spec.ts
diff --git a/src/opendex/xud/parse-error.ts b/src/opendex/xud/parse-error.ts
diff --git a/src/opendex/xud/process-response.spec.ts b/src/opendex/xud/process-response.spec.ts
@@ -9,11 +9,9 @@ describe('processResponse', () => {
   test('success', done => {
     expect.assertions(1);
     const nextValue = 'next';
-    const parseGrpcError = jest.fn().mockReturnValue('error');
     const source$ = new Observable(subscriber => {
       processResponse({
         subscriber,
-        parseGrpcError,
       })(null, nextValue);
     });
     source$.subscribe({
@@ -25,23 +23,18 @@ describe('processResponse', () => {
   });
 
   test('error', done => {
-    expect.assertions(3);
+    expect.assertions(1);
     const errorValue = ('errorValue' as unknown) as ServiceError;
-    const parsedError = 'parsedError';
-    const parseGrpcError = jest.fn().mockReturnValue(parsedError);
     const source$ = new Observable(subscriber => {
       processResponse({
-        parseGrpcError,
         subscriber,
       })(errorValue, null);
     });
     source$.subscribe({
       error: errorMsg => {
-        expect(errorMsg).toEqual(parsedError);
+        expect(errorMsg).toEqual(errorValue);
         done();
       },
     });
-    expect(parseGrpcError).toHaveBeenCalledWith(errorValue);
-    expect(parseGrpcError).toHaveBeenCalledTimes(1);
   });
 });
diff --git a/src/opendex/xud/process-response.ts b/src/opendex/xud/process-response.ts
@@ -1,20 +1,14 @@
 import { ServiceError } from '@grpc/grpc-js';
 import { Subscriber } from 'rxjs';
-import { ParseGrpcErrorResponse } from './parse-error';
 
 type ProcessResponseParams = {
   subscriber: Subscriber<unknown>;
-  parseGrpcError: (error: ServiceError) => ParseGrpcErrorResponse;
 };
 
-const processResponse = ({
-  subscriber,
-  parseGrpcError,
-}: ProcessResponseParams) => {
+const processResponse = ({ subscriber }: ProcessResponseParams) => {
   return (error: ServiceError | null, response: any) => {
     if (error) {
-      const parsedError = parseGrpcError(error);
-      parsedError && subscriber.error(parsedError);
+      subscriber.error(error);
     } else {
       subscriber.next(response);
     }
diff --git a/src/opendex/xud/remove-order.ts b/src/opendex/xud/remove-order.ts
@@ -3,7 +3,6 @@ import { take } from 'rxjs/operators';
 import { XudClient } from '../../proto/xudrpc_grpc_pb';
 import { RemoveOrderRequest, RemoveOrderResponse } from '../../proto/xudrpc_pb';
 import { processResponse } from './process-response';
-import { parseGrpcError } from './parse-error';
 
 type RemoveXudOrderParams = {
   client: XudClient;
@@ -21,7 +20,6 @@ const removeXudOrder$ = ({
       request,
       processResponse({
         subscriber,
-        parseGrpcError,
       })
     );
   }).pipe(take(1));
diff --git a/src/opendex/xud/subscribe-swaps.spec.ts b/src/opendex/xud/subscribe-swaps.spec.ts
@@ -44,11 +44,9 @@ describe('subscribeXudSwaps$', () => {
 
   test('success', done => {
     expect.assertions(8);
-    const parseGrpcError = () => null;
     const swapsSubscription$ = subscribeXudSwaps$({
       client,
       config,
-      parseGrpcError,
     });
     swapsSubscription$.subscribe({
       next: actualSuccessValue => {
@@ -73,49 +71,24 @@ describe('subscribeXudSwaps$', () => {
     };
     mockSwapSubscription.emit('data', swapSuccessOtherTradingPair);
     mockSwapSubscription.emit('end');
-    // cleanup function of subscribeXudSwaps$ uses
-    // setImmediate to work around NodeJS core crashing
-    // so we'll have to use setTimeout here
-    setTimeout(() => {
-      expect(offSwapSubscriptionSpy).toHaveBeenCalledTimes(3);
-      expect(cancelSwapSubscriptionSpy).toHaveBeenCalledTimes(1);
-      done();
-    }, 50);
+    expect(offSwapSubscriptionSpy).toHaveBeenCalledTimes(3);
+    expect(cancelSwapSubscriptionSpy).toHaveBeenCalledTimes(1);
+    done();
   });
 
-  test('parseError returns null will not emit error', () => {
-    expect.assertions(2);
-    const swapError = 'swapError';
-    const parseGrpcError = jest.fn().mockReturnValue(null);
+  test('will emit error', done => {
+    expect.assertions(1);
+    const swapError = 'swapError HELLO';
     const swapsSubscription$ = subscribeXudSwaps$({
       client,
       config,
-      parseGrpcError,
-    });
-    swapsSubscription$.subscribe(() => {});
-    mockSwapSubscription.emit('error', swapError);
-    expect(parseGrpcError).toHaveBeenCalledWith(swapError);
-    expect(parseGrpcError).toHaveBeenCalledTimes(1);
-  });
-
-  test('will parse error and emit', done => {
-    expect.assertions(3);
-    const swapError = 'swapError';
-    const parsedError = 'parsedError';
-    const parseGrpcError = jest.fn().mockReturnValue(parsedError);
-    const swapsSubscription$ = subscribeXudSwaps$({
-      client,
-      config,
-      parseGrpcError,
     });
     swapsSubscription$.subscribe({
       error: actualError => {
-        expect(actualError).toEqual(parsedError);
+        expect(actualError).toEqual(swapError);
         done();
       },
     });
     mockSwapSubscription.emit('error', swapError);
-    expect(parseGrpcError).toHaveBeenCalledWith(swapError);
-    expect(parseGrpcError).toHaveBeenCalledTimes(1);
   });
 });
diff --git a/src/opendex/xud/subscribe-swaps.ts b/src/opendex/xud/subscribe-swaps.ts
@@ -2,19 +2,16 @@ import { Observable } from 'rxjs';
 import { Config } from '../../config';
 import { XudClient } from '../../proto/xudrpc_grpc_pb';
 import { SubscribeSwapsRequest, SwapSuccess } from '../../proto/xudrpc_pb';
-import { ParseGrpcErrorResponse } from './parse-error';
 import { ServiceError } from '@grpc/grpc-js';
 
 type SubscribeSwapsParams = {
   client: XudClient;
   config: Config;
-  parseGrpcError: (error: ServiceError) => ParseGrpcErrorResponse;
 };
 
 const subscribeXudSwaps$ = ({
   client,
   config,
-  parseGrpcError,
 }: SubscribeSwapsParams): Observable<SwapSuccess> => {
   const request = new SubscribeSwapsRequest();
   request.setIncludeTaker(true);
@@ -29,24 +26,20 @@ const subscribeXudSwaps$ = ({
     };
     swapsSubscription.on('data', onData);
     const onError = (error: ServiceError) => {
-      const parsedError = parseGrpcError(error);
-      parsedError && subscriber.error(parsedError);
+      subscriber.error(error);
     };
     swapsSubscription.on('error', onError);
     const onEnd = () => {
       subscriber.complete();
     };
     swapsSubscription.on('end', onEnd);
     return () => {
-      const cleanup = () => {
-        swapsSubscription.cancel();
-        swapsSubscription.off('data', onData);
-        swapsSubscription.off('error', onError);
-        swapsSubscription.off('end', onEnd);
-      };
-      // using setImmediate to prevent NodeJS core crashing with:
-      // Assertion `(current_nghttp2_memory_) >= (previous_size)' failed
-      setImmediate(cleanup);
+      // ignore the error that cancel() will emit
+      swapsSubscription.on('error', () => {});
+      swapsSubscription.cancel();
+      swapsSubscription.off('error', onError);
+      swapsSubscription.off('end', onEnd);
+      swapsSubscription.off('data', onData);
     };
   });
   return subscribeSwaps$ as Observable<SwapSuccess>;
diff --git a/src/opendex/xud/trading-limits.ts b/src/opendex/xud/trading-limits.ts
@@ -5,7 +5,6 @@ import {
   TradingLimitsResponse,
 } from '../../proto/xudrpc_pb';
 import { processResponse } from './process-response';
-import { parseGrpcError } from './parse-error';
 
 const getXudTradingLimits$ = (
   client: XudClient
@@ -16,7 +15,6 @@ const getXudTradingLimits$ = (
       request,
       processResponse({
         subscriber,
-        parseGrpcError,
       })
     );
   });
