@tdxvolt/volt-client-grpc 0.18.0 → 0.18.2

package/src/volt-client.js

@@ -31,7 +31,6 @@ export class VoltClient extends EventEmitter {
     }
     this._grpc = grpc;
     this._cachedClient = null;
-    this._cachedRemoteClient = null;
     this._session = null;
     this._config = null;
     this._voltConfig = null;
@@ -56,12 +55,36 @@ export class VoltClient extends EventEmitter {
     return this._voltConfig;
   }
 
+  get connection() {
+    return this._voltConnection;
+  }
+
+  close() {
+    if (this._cachedClient) {
+      this._grpc.closeClient(this._cachedClient);
+      this._cachedClient = null;
+    }
+
+    for (let serviceKey in Object.keys(this._cachedService)) {
+      if (this._cachedService[serviceKey]) {
+        this._grpc.closeClient(this._cachedService[serviceKey]);
+      }
+    }
+
+    this._cachedService = {};
+  }
+
   /**
    * Initialises a binding and connection to the volt.
    * @param {string} [config] - the location of the Volt configuration file, or a configuration object
    * @param {object} [extras] - additional configuration properties
    */
-  async initialise(config, extras = {}) {
+  async initialise(
+    config,
+    extras = {},
+    ownDID = false,
+    didRegistryList = undefined
+  ) {
     try {
       if (!config) {
         throw new Error(
@@ -126,7 +149,15 @@ export class VoltClient extends EventEmitter {
       }
 
       if (voltDID) {
-        const didConfig = await fetchVoltConfigFromDID.call(this, voltDID);
+        const didConfig = await fetchVoltConfigFromDID.call(
+          this,
+          voltDID,
+          didRegistryList
+        );
+
+        // Remove the relay list from the DID config, as it would overwrite the relay in the supplied config.
+        delete didConfig.relay;
+
         this._config = { ...this._config, volt: didConfig };
         log("resolved config from DID: %s", JSON.stringify(didConfig, null, 2));
       } else if (voltHttpAddress && !this._config?.volt?.id) {
@@ -156,7 +187,7 @@ export class VoltClient extends EventEmitter {
 
       await this._credential.initialise();
 
-      if (!this.isRemote) {
+      if (!this.isRelayed) {
         // If we're not connecting via a Relay, we must have the address and CA.
         if (
           !this._voltConfig.address ||
@@ -179,15 +210,15 @@ export class VoltClient extends EventEmitter {
       } else {
         // No certificate present in the cache yet => we need to authenticate.
         try {
-          isBound = await authenticateInternal.call(this);
+          isBound = await authenticateInternal.call(this, false, ownDID);
         } catch (bindErr) {
           if (bindErr.message === "invalid arguments") {
             // This is usually the result of a missing challenge signature or credential.
             log(
               "failure authenticating on Volt - did you supply a challenge code or verified credential?"
             );
-            throw bindErr;
           }
+          throw bindErr;
         }
       }
 
@@ -196,7 +227,7 @@ export class VoltClient extends EventEmitter {
         throw new Error("Volt authentication failed");
       } else {
         // Perist the configuration.
-        this._config = this._credential.saveCache();
+        this._credential.saveCache();
       }
 
       return Promise.resolve(this._config);
@@ -247,7 +278,7 @@ export class VoltClient extends EventEmitter {
       });
     }
 
-    if (this.isRemote) {
+    if (this.isRelayed) {
       if (!this._voltConfig?.relay?.address) {
         throw new Error(
           "Remote connection enabled but no Relay address - have you called start()?"
@@ -274,14 +305,10 @@ export class VoltClient extends EventEmitter {
     }
   }
 
-  get isRemote() {
+  get isRelayed() {
     return !!(this._voltConfig?.relay && this._voltConfig.id);
   }
 
-  get isVoltRelay() {
-    return this.isRemote && !this._voltConfig?.relay.cloud;
-  }
-
   connect(helloPayload) {
     return connectInternal.call(this, helloPayload);
   }
@@ -613,6 +640,9 @@ export class VoltClient extends EventEmitter {
    */
   SqlExecuteJSON(request) {
     return new Promise((resolve, reject) => {
+      if (!request.start) {
+        request = { start: request };
+      }
       const call = this.SqlExecute(request);
 
       let header;

package/src/volt-connection.js

@@ -96,8 +96,18 @@ function _doConnect(connectHello) {
         break;
       }
       case "invoke_request": {
-        log("received invoke request");
-        this.emit("invoke_request", response.invoke_request);
+        log("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("error processing invoke request [%s]", err.message);
+        } finally {
+          this.call.resume();
+        }
         break;
       }
       case "evt": {
@@ -169,6 +179,10 @@ export default class VoltConnection extends EventEmitter {
     this._helloPayload = undefined;
   }
 
+  get connectionId() {
+    return this._connectionId;
+  }
+
   connect(helloPayload, throwOnFail) {
     this._helloPayload = helloPayload;
     if (throwOnFail) {

package/src/volt-credential.js

@@ -52,7 +52,7 @@ export class VoltCredential {
         this._cryptoCache.ca = this._voltConfig.ca_pem;
       }
 
-      // Extract Volt public key (used for encrypting Relay payloads).
+      // Extract Volt public key.
       this._voltPublicKey = this._voltConfig.public_key;
 
       const voltKey = keyFromPem(this._voltPublicKey).publicKey;
@@ -92,6 +92,10 @@ export class VoltCredential {
     return this._voltFingerprint;
   }
 
+  get key() {
+    return this.getKey();
+  }
+
   getKey() {
     const key = keyFromPem(this._cryptoCache.key);
     return key;
@@ -107,7 +111,7 @@ export class VoltCredential {
       return Promise.resolve(this.getKey());
     } else {
       log("creating key");
-      this._cryptoCache.key = createSigningKey();
+      this._cryptoCache.key = JSON.parse(createSigningKey()).private_pem;
       const key = keyFromPem(this._cryptoCache.key);
       log("successfully created key");
       return Promise.resolve(key);