@tdxvolt/volt-client-grpc 0.18.4 → 0.18.6

package/lib/index.cjs

@@ -12,10 +12,9 @@ var path = require('path');
 var Protobuf = require('protobufjs');
 var camelCase = require('lodash.camelcase');
 var descriptor = require('protobufjs/ext/descriptor/index.js');
-var IdempotencyLevel = require('@grpc/proto-loader');
 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 }; }
 
@@ -28,7 +27,6 @@ var path__default = /*#__PURE__*/_interopDefaultLegacy(path);
 var Protobuf__default = /*#__PURE__*/_interopDefaultLegacy(Protobuf);
 var camelCase__default = /*#__PURE__*/_interopDefaultLegacy(camelCase);
 var descriptor__default = /*#__PURE__*/_interopDefaultLegacy(descriptor);
-var IdempotencyLevel__default = /*#__PURE__*/_interopDefaultLegacy(IdempotencyLevel);
 var bent__default = /*#__PURE__*/_interopDefaultLegacy(bent);
 var jwt__default = /*#__PURE__*/_interopDefaultLegacy(jwt);
 
@@ -362,7 +360,7 @@ const {
   publicKeyToPem: publicKeyToPem$2
 } = js.voltUtils;
 
-const log$6 = debug__default["default"]("volt-client-grpc:volt-credential");
+const log$5 = debug__default["default"]("volt-client-grpc:volt-credential");
 
 class VoltCredential {
   constructor(config, configPath) {
@@ -456,13 +454,13 @@ class VoltCredential {
   createKey() {
     if (this._cryptoCache.key) {
       // Already have key data in the cache in pem format => create fully-formed pki instances.
-      log$6("createKey - key already exists");
+      log$5("createKey - key already exists");
       return Promise.resolve(this.getKey());
     } else {
-      log$6("creating key");
+      log$5("creating key");
       this._cryptoCache.key = JSON.parse(createSigningKey()).private_pem;
       const key = keyFromPem$2(this._cryptoCache.key);
-      log$6("successfully created key");
+      log$5("successfully created key");
       return Promise.resolve(key);
     }
   }
@@ -479,7 +477,7 @@ class VoltCredential {
         return this._cryptoCache;
       })
       .catch((err) => {
-        log$6("failure initialising crypto [%s]", err.message);
+        log$5("failure initialising crypto [%s]", err.message);
         return Promise.reject(err);
       });
   }
@@ -544,6 +542,8 @@ class VoltCredential {
  *
  */
 
+const IDEMPOTENCY_UNKNOWN = "IDEMPOTENCY_UNKNOWN";
+
 const descriptorOptions = {
   longs: String,
   enums: String,
@@ -619,7 +619,7 @@ function mapMethodOptions(options) {
     },
     {
       deprecated: false,
-      idempotency_level: IdempotencyLevel__default["default"].IDEMPOTENCY_UNKNOWN,
+      idempotency_level: IDEMPOTENCY_UNKNOWN,
       uninterpreted_option: []
     }
   );
@@ -3693,7 +3693,7 @@ message SubscribeWireResponse {
 `;
 const voltProtos = [sqlite, sqlite_database_api, sqlite_server_api, proxy_api, relay_api, sync, discovery_api, file, file_api, remote, spark_api, ssi, ssi_api, status, terminal_api, volt, volt_api, wire_api];
 
-const log$5 = debug__default["default"]("volt-client-grpc:proto-utils");
+debug__default["default"]("volt-client-grpc:proto-utils");
 
 const voltServices = [
   constants.serviceType.voltAPI,
@@ -3718,7 +3718,6 @@ function getServiceDescriptors(service) {
   let root = new Protobuf__default["default"].Root();
   for (let protoFile of service.service_description.proto_file) {
     Protobuf__default["default"].parse(protoFile.protobuf, root, defaultLoaderOptions);
-    log$5("parsed proto file %s", protoFile.file_path);
   }
 
   // Create a package definition from the root object.
@@ -4251,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,
@@ -4467,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;
@@ -4521,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"
       );
@@ -4548,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"));
     }
 
@@ -4609,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 {
@@ -4694,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);
         }
 
@@ -4713,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);
     });
   }
@@ -4808,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;
@@ -5108,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.4",
+  "version": "0.18.6",
   "description": "tdx Volt library for nodejs clients",
   "type": "module",
   "exports": {
@@ -37,7 +37,6 @@
   "author": "toby.ealden@gmail.com",
   "license": "ISC",
   "dependencies": {
-    "@grpc/proto-loader": "^0.7.13",
     "@tdxvolt/volt-client-web": "^0.18.1",
     "bent": "^7.3.12",
     "builtin-modules": "^3.3.0",

package/src/proto-package-definition.js

@@ -17,7 +17,8 @@
 import camelCase from "lodash.camelcase";
 import Protobuf from "protobufjs";
 import descriptor from "protobufjs/ext/descriptor/index.js";
-import IdempotencyLevel from "@grpc/proto-loader";
+
+const IDEMPOTENCY_UNKNOWN = "IDEMPOTENCY_UNKNOWN";
 
 const descriptorOptions = {
   longs: String,
@@ -94,7 +95,7 @@ function mapMethodOptions(options) {
     },
     {
       deprecated: false,
-      idempotency_level: IdempotencyLevel.IDEMPOTENCY_UNKNOWN,
+      idempotency_level: IDEMPOTENCY_UNKNOWN,
       uninterpreted_option: []
     }
   );

package/src/proto-utils.js

@@ -29,7 +29,6 @@ function getServiceDescriptors(service) {
   let root = new protobuf.Root();
   for (let protoFile of service.service_description.proto_file) {
     protobuf.parse(protoFile.protobuf, root, defaultLoaderOptions);
-    log("parsed proto file %s", protoFile.file_path);
   }
 
   // Create a package definition from the root object.

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)