@tdxvolt/volt-client-grpc 0.18.5 → 0.18.6

package/lib/index.cjs

@@ -13,8 +13,8 @@ var Protobuf = require('protobufjs');
 var camelCase = require('lodash.camelcase');
 var descriptor = require('protobufjs/ext/descriptor/index.js');
 var bent = require('bent');
-var jwt = require('jsonwebtoken');
 var uuid = require('uuid');
+var jwt = require('jsonwebtoken');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
@@ -4250,206 +4250,6 @@ class GRPCCall extends EventEmitter__default["default"] {
   }
 }
 
-/* eslint-disable no-use-before-define */
-
-const log$3 = debug__default["default"]("volt-client-grpc:volt-connection");
-
-function _cleanUp(immediateReconnect) {
-  this._connectionId = "";
-
-  if (this._pingTimer) {
-    clearTimeout(this._pingTimer);
-    this._pingTimer = 0;
-  }
-
-  if (this._pingTimeoutTimer) {
-    clearTimeout(this._pingTimeoutTimer);
-    this._pingTimeoutTimer = 0;
-  }
-
-  if (this._dying) {
-    clearTimeout(this._reconnectTimer);
-  } else if (immediateReconnect || (this._autoRetry && !this._reconnectTimer)) {
-    this._reconnectTimer = setTimeout(
-      () => {
-        this._reconnectTimer = 0;
-        _doConnect.call(this, this._helloPayload);
-      },
-      immediateReconnect ? 0 : this._reconnectInterval
-    );
-  }
-
-  if (this.call?.writable) {
-    this.call.end();
-  }
-}
-
-function _connectionTimeoutHandler() {
-  log$3("server timed out");
-  this.emit("connected", false);
-  _cleanUp.call(this);
-}
-
-function _doConnect(connectHello) {
-  this.call = new GRPCCall(this._voltClient, "Connect", "METHOD_TYPE_BIDI");
-
-  const grpcClient = this._voltClient.getVoltAPIClient();
-
-  // Notify the Volt of our ping interval. If the Volt doesn't receive a ping from us
-  // within this time, it will assume the connection is dead.
-  const defaultHello = {
-    ping_interval: this._pingInterval,
-    timestamp: Date.now()
-  };
-
-  const helloPayload = { ...connectHello } || {};
-
-  helloPayload.hello = { ...defaultHello, ...connectHello?.hello };
-
-  log$3("hello is %j", helloPayload);
-
-  this.call.on("error", (err) => {
-    log$3("error on connection stream [%s]", err.message);
-    _cleanUp.call(this);
-    this.emit("error", err);
-  });
-
-  this.call.on("data", (response) => {
-    switch (response.payload) {
-      case "ping": {
-        log$3("pinged");
-
-        // Received ping response from server => clear timeout.
-        if (this._pingTimeoutTimer) {
-          clearTimeout(this._pingTimeoutTimer);
-        }
-
-        this.emit("ping", response.ping.timestamp);
-        break;
-      }
-      case "acknowledge": {
-        if (!this._connectionId) {
-          this._connectionId = response.acknowledge.connection_id;
-
-          // Set the ping timeout interval to the value returned by the Volt. If we don't
-          // hear from the Volt in this time, we'll assume the connection is dead.
-          this._timeoutInterval = response.acknowledge.ping_interval;
-
-          log$3("connection id is %s", this._connectionId);
-          this.emit("connected", this._connectionId);
-
-          // Schedule the next ping.
-          _startPingTimer.call(this);
-        }
-        break;
-      }
-      case "invoke_request": {
-        log$3("received invoke request %s", response.invoke_request.invoke_id);
-        // Pause the call while we process the invoke request to avoid getting
-        // CANCELLED errors from grpc - we should perhaps leave this to the
-        // client to manage as it may be overkill in some cases.
-        this.call.pause();
-        try {
-          this.emit("invoke_request", response.invoke_request);
-        } catch (err) {
-          log$3("error processing invoke request [%s]", err.message);
-        } finally {
-          this.call.resume();
-        }
-        break;
-      }
-      case "evt": {
-        log$3("received event %s", Object.keys(response.evt)[0]);
-        this.emit("evt", response.evt);
-        break;
-      }
-      default:
-        log$3("unimplemented connect response payload: %s", response.payload);
-        break;
-    }
-  });
-
-  this.call.on("end", () => {
-    if (this._connectionId) {
-      this.emit("connected", false);
-    }
-    _cleanUp.call(this);
-  });
-
-  this.call.start(grpcClient, helloPayload);
-}
-
-function _startPingTimer() {
-  if (this._pingTimer) {
-    log$3("ping timer running");
-    return;
-  }
-
-  this._pingTimer = setTimeout(() => {
-    // Send next ping to server.
-    const request = { ping: { timestamp: Date.now() } };
-
-    log$3("pinging Volt");
-    this.call.write(request);
-
-    this._pingTimer = 0;
-
-    // Schedule a timeout if we don't hear back from the server.
-    if (this._pingTimeoutTimer) {
-      clearTimeout(this._pingTimeoutTimer);
-    }
-
-    this._pingTimeoutTimer = setTimeout(
-      _connectionTimeoutHandler.bind(this),
-      this._timeoutInterval
-    );
-
-    _startPingTimer.call(this);
-  }, this._pingInterval);
-}
-
-class VoltConnection extends EventEmitter__default["default"] {
-  constructor(voltClient, grpc) {
-    super();
-
-    const config = voltClient.config;
-    this._grpc = grpc;
-    this._autoRetry =
-      config.autoReconnect === undefined ? true : !!config.autoReconnect;
-    this._dying = false;
-    this._voltClient = voltClient;
-    this._pingTimer = 0;
-    this._pingTimeoutTimer = 0;
-    this._connectionId = "";
-    this._pingInterval = config.pingInterval || 10000;
-    this._reconnectInterval = config.reconnectInterval || 5000;
-    this._timeoutInterval = config.timeoutInterval || 60000;
-    this._helloPayload = undefined;
-  }
-
-  get connectionId() {
-    return this._connectionId;
-  }
-
-  connect(helloPayload, throwOnFail) {
-    this._helloPayload = helloPayload;
-    if (throwOnFail) {
-      return _doConnect.call(this, this._helloPayload);
-    } else {
-      return Promise.resolve(_cleanUp.call(this, true));
-    }
-  }
-
-  disconnect() {
-    this._dying = true;
-    _cleanUp.call(this);
-  }
-
-  send(request) {
-    this.call.write(request);
-  }
-}
-
 const {
   aesDecrypt,
   aesEncrypt,
@@ -4466,7 +4266,7 @@ const {
   x25519
 } = js.voltUtils;
 
-const log$2 = debug__default["default"]("volt-client-grpc:rpc-invocation");
+const log$3 = debug__default["default"]("volt-client-grpc:rpc-invocation");
 
 class RpcInvocation extends EventEmitter__default["default"] {
   #voltClient = null;
@@ -4520,7 +4320,7 @@ class RpcInvocation extends EventEmitter__default["default"] {
         this.#payload
       );
     } else {
-      log$2("unexpected: no method descriptor");
+      log$3("unexpected: no method descriptor");
       throw new Error(
         "no method descriptor - set this before accessing payload"
       );
@@ -4547,7 +4347,7 @@ class RpcInvocation extends EventEmitter__default["default"] {
     this.#token = jwt__default["default"].decode(token);
 
     if (!this.#token) {
-      log$2("failed to decode token %s", token || "null");
+      log$3("failed to decode token %s", token || "null");
       return Promise.reject(new Error("failed to decode token"));
     }
 
@@ -4608,7 +4408,7 @@ class RpcInvocation extends EventEmitter__default["default"] {
     if (!this.#derivedKey) {
       // We don't have the derived key yet, so we need to perform the key exchange.
       return this.#keyExchange(invoke_request.token).catch((err) => {
-        log$2("failure initialising invocation: %s", err.message);
+        log$3("failure initialising invocation: %s", err.message);
         return Promise.reject(err);
       });
     } else {
@@ -4693,16 +4493,16 @@ class RpcInvocation extends EventEmitter__default["default"] {
             );
             this.emit("payload", this);
           } else if (wrappedPayload.method_end) {
-            log$2("method_end received");
+            log$3("method_end received");
             if (!this.#endEmitted) {
               this.#endEmitted = true;
               this.emit("end", this);
             } else {
-              log$2("method_end: end already emitted");
+              log$3("method_end: end already emitted");
             }
           }
         } catch (err) {
-          log$2("JSON.parse failure parsing json_payload: %s", err.message);
+          log$3("JSON.parse failure parsing json_payload: %s", err.message);
           reject(err);
         }
 
@@ -4712,14 +4512,14 @@ class RpcInvocation extends EventEmitter__default["default"] {
           this.#endEmitted = true;
           this.emit("end", this);
         } else {
-          log$2("client_end: end already emitted");
+          log$3("client_end: end already emitted");
         }
       } else {
         // Do we need to support json_payload here?
         reject(new Error("No payload in invoke request"));
       }
     }).catch((err) => {
-      log$2("failure parsing payload: %s", err.message);
+      log$3("failure parsing payload: %s", err.message);
       return Promise.reject(err);
     });
   }
@@ -4807,6 +4607,206 @@ class RpcInvocation extends EventEmitter__default["default"] {
   }
 }
 
+/* eslint-disable no-use-before-define */
+
+const log$2 = debug__default["default"]("volt-client-grpc:volt-connection");
+
+function _cleanUp(immediateReconnect) {
+  this._connectionId = "";
+
+  if (this._pingTimer) {
+    clearTimeout(this._pingTimer);
+    this._pingTimer = 0;
+  }
+
+  if (this._pingTimeoutTimer) {
+    clearTimeout(this._pingTimeoutTimer);
+    this._pingTimeoutTimer = 0;
+  }
+
+  if (this._dying) {
+    clearTimeout(this._reconnectTimer);
+  } else if (immediateReconnect || (this._autoRetry && !this._reconnectTimer)) {
+    this._reconnectTimer = setTimeout(
+      () => {
+        this._reconnectTimer = 0;
+        _doConnect.call(this, this._helloPayload);
+      },
+      immediateReconnect ? 0 : this._reconnectInterval
+    );
+  }
+
+  if (this.call?.writable) {
+    this.call.end();
+  }
+}
+
+function _connectionTimeoutHandler() {
+  log$2("server timed out");
+  this.emit("connected", false);
+  _cleanUp.call(this);
+}
+
+function _doConnect(connectHello) {
+  this.call = new GRPCCall(this._voltClient, "Connect", "METHOD_TYPE_BIDI");
+
+  const grpcClient = this._voltClient.getVoltAPIClient();
+
+  // Notify the Volt of our ping interval. If the Volt doesn't receive a ping from us
+  // within this time, it will assume the connection is dead.
+  const defaultHello = {
+    ping_interval: this._pingInterval,
+    timestamp: Date.now()
+  };
+
+  const helloPayload = { ...connectHello } || {};
+
+  helloPayload.hello = { ...defaultHello, ...connectHello?.hello };
+
+  log$2("hello is %j", helloPayload);
+
+  this.call.on("error", (err) => {
+    log$2("error on connection stream [%s]", err.message);
+    _cleanUp.call(this);
+    this.emit("error", err);
+  });
+
+  this.call.on("data", (response) => {
+    switch (response.payload) {
+      case "ping": {
+        log$2("pinged");
+
+        // Received ping response from server => clear timeout.
+        if (this._pingTimeoutTimer) {
+          clearTimeout(this._pingTimeoutTimer);
+        }
+
+        this.emit("ping", response.ping.timestamp);
+        break;
+      }
+      case "acknowledge": {
+        if (!this._connectionId) {
+          this._connectionId = response.acknowledge.connection_id;
+
+          // Set the ping timeout interval to the value returned by the Volt. If we don't
+          // hear from the Volt in this time, we'll assume the connection is dead.
+          this._timeoutInterval = response.acknowledge.ping_interval;
+
+          log$2("connection id is %s", this._connectionId);
+          this.emit("connected", this._connectionId);
+
+          // Schedule the next ping.
+          _startPingTimer.call(this);
+        }
+        break;
+      }
+      case "invoke_request": {
+        log$2("received invoke request %s", response.invoke_request.invoke_id);
+        // Pause the call while we process the invoke request to avoid getting
+        // CANCELLED errors from grpc - we should perhaps leave this to the
+        // client to manage as it may be overkill in some cases.
+        this.call.pause();
+        try {
+          this.emit("invoke_request", response.invoke_request);
+        } catch (err) {
+          log$2("error processing invoke request [%s]", err.message);
+        } finally {
+          this.call.resume();
+        }
+        break;
+      }
+      case "evt": {
+        log$2("received event %s", Object.keys(response.evt)[0]);
+        this.emit("evt", response.evt);
+        break;
+      }
+      default:
+        log$2("unimplemented connect response payload: %s", response.payload);
+        break;
+    }
+  });
+
+  this.call.on("end", () => {
+    if (this._connectionId) {
+      this.emit("connected", false);
+    }
+    _cleanUp.call(this);
+  });
+
+  this.call.start(grpcClient, helloPayload);
+}
+
+function _startPingTimer() {
+  if (this._pingTimer) {
+    log$2("ping timer running");
+    return;
+  }
+
+  this._pingTimer = setTimeout(() => {
+    // Send next ping to server.
+    const request = { ping: { timestamp: Date.now() } };
+
+    log$2("pinging Volt");
+    this.call.write(request);
+
+    this._pingTimer = 0;
+
+    // Schedule a timeout if we don't hear back from the server.
+    if (this._pingTimeoutTimer) {
+      clearTimeout(this._pingTimeoutTimer);
+    }
+
+    this._pingTimeoutTimer = setTimeout(
+      _connectionTimeoutHandler.bind(this),
+      this._timeoutInterval
+    );
+
+    _startPingTimer.call(this);
+  }, this._pingInterval);
+}
+
+class VoltConnection extends EventEmitter__default["default"] {
+  constructor(voltClient, grpc) {
+    super();
+
+    const config = voltClient.config;
+    this._grpc = grpc;
+    this._autoRetry =
+      config.autoReconnect === undefined ? true : !!config.autoReconnect;
+    this._dying = false;
+    this._voltClient = voltClient;
+    this._pingTimer = 0;
+    this._pingTimeoutTimer = 0;
+    this._connectionId = "";
+    this._pingInterval = config.pingInterval || 10000;
+    this._reconnectInterval = config.reconnectInterval || 5000;
+    this._timeoutInterval = config.timeoutInterval || 60000;
+    this._helloPayload = undefined;
+  }
+
+  get connectionId() {
+    return this._connectionId;
+  }
+
+  connect(helloPayload, throwOnFail) {
+    this._helloPayload = helloPayload;
+    if (throwOnFail) {
+      return _doConnect.call(this, this._helloPayload);
+    } else {
+      return Promise.resolve(_cleanUp.call(this, true));
+    }
+  }
+
+  disconnect() {
+    this._dying = true;
+    _cleanUp.call(this);
+  }
+
+  send(request) {
+    this.call.write(request);
+  }
+}
+
 /* eslint-disable no-underscore-dangle */
 
 const { publicKeyToPem, removeCarriageReturn, signBase64 } = js.voltUtils;
@@ -5107,7 +5107,9 @@ function connectInternal(helloPayload) {
 
       if (rpcInvocation) {
         if (rpcInvocation.started) {
-          rpcInvocation.parsePayload(invoke_request);
+          rpcInvocation.parsePayload(invoke_request).catch((err) => {
+            log$1("invoke_request - error [%s]", err.message);
+          });
         } else {
           rpcInvocation
             .initialise(invoke_request)

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.18.5",
+  "version": "0.18.6",
   "description": "tdx Volt library for nodejs clients",
   "type": "module",
   "exports": {

package/src/volt-client-internal.js

@@ -1,20 +1,20 @@
 /* eslint-disable no-underscore-dangle */
+import { voltUtils as voltClientUtils } from "@tdxvolt/volt-client-web/js";
+import bent from "bent";
 import debug from "debug";
 import ip from "ip";
-import bent from "bent";
 import lodash from "lodash";
-import VoltConnection from "./volt-connection.js";
-import {
-  getServiceDescriptors,
-  getBuiltInServiceDescriptors
-} from "./proto-utils.js";
-import { createClient as createGrpcClient } from "./grpc-utils.js";
-import * as voltUtils from "./utils.js";
+import { v4 as generateId } from "uuid";
 import { constants } from "./constants.js";
 import GRPCCall from "./grpc-call.js";
+import { createClient as createGrpcClient } from "./grpc-utils.js";
+import {
+  getBuiltInServiceDescriptors,
+  getServiceDescriptors
+} from "./proto-utils.js";
 import RpcInvocation from "./rpc-invocation.js";
-import { v4 as generateId } from "uuid";
-import { voltUtils as voltClientUtils } from "@tdxvolt/volt-client-web/js";
+import * as voltUtils from "./utils.js";
+import VoltConnection from "./volt-connection.js";
 
 const { publicKeyToPem, removeCarriageReturn, signBase64 } = voltClientUtils;
 
@@ -314,7 +314,9 @@ export function connectInternal(helloPayload) {
 
       if (rpcInvocation) {
         if (rpcInvocation.started) {
-          rpcInvocation.parsePayload(invoke_request);
+          rpcInvocation.parsePayload(invoke_request).catch((err) => {
+            log("invoke_request - error [%s]", err.message);
+          });
         } else {
           rpcInvocation
             .initialise(invoke_request)