@tdxvolt/volt-client-grpc 0.14.61 → 0.15.0

package/src/volt-client.js

@@ -10,7 +10,8 @@ import {
   fetchVoltConfig,
   fetchVoltConfigFromDID,
   getVoltAPIClientInternal,
-  unaryCall,
+  unaryCallInternal,
+  streamingCallInternal
 } from "./volt-client-internal.js";
 import fs from "fs";
 import GRPCCall from "./grpc-call.js";
@@ -35,6 +36,8 @@ export class VoltClient extends EventEmitter {
     this._config = null;
     this._voltConfig = null;
     this._voltConnection = null;
+    this._cachedService = {};
+    this._activeRPC = {};
   }
 
   get config() {
@@ -61,7 +64,7 @@ export class VoltClient extends EventEmitter {
     try {
       if (!config) {
         throw new Error(
-          "configPath argument is required to be a non-empty string",
+          "configPath argument is required to be a non-empty string"
         );
       }
 
@@ -72,13 +75,13 @@ export class VoltClient extends EventEmitter {
         log("Attempt to load config from file %s", configPath);
         try {
           const configContents = await readFile(
-            new URL(configPath, import.meta.url),
+            new URL(configPath, import.meta.url)
           );
           configJSON = JSON.parse(configContents);
         } catch (err) {
           log("failure loading config file %s [%s]", configPath, err.message);
           throw new Error(
-            `failed to load configuration - check JSON format in ${configPath}`,
+            `failed to load configuration - check JSON format in ${configPath}`
           );
         }
       } else if (typeof config === "object") {
@@ -119,14 +122,14 @@ export class VoltClient extends EventEmitter {
         const didConfig = await fetchVoltConfigFromDID.call(this, voltDID);
         this._config = { ...this._config, volt: didConfig };
         log("resolved config from DID: %s", JSON.stringify(didConfig, null, 2));
-      } else if (voltHttpAddress) {
+      } else if (voltHttpAddress && !this._config?.volt?.id) {
         const discoConfig = await fetchVoltConfig.call(
           this,
-          `${voltHttpAddress}/discovery`,
+          `${voltHttpAddress}/discovery`
         );
         this._config = {
           ...this._config,
-          volt: { ...this._config.volt, ...discoConfig },
+          volt: { ...this._config.volt, ...discoConfig }
         };
       }
 
@@ -170,7 +173,7 @@ export class VoltClient extends EventEmitter {
           if (bindErr.message === "invalid arguments") {
             // This is usually the result of a missing challenge signature or credential.
             log(
-              "failure binding to Volt - did you supply a challenge code or verified credential?",
+              "failure binding to Volt - did you supply a challenge code or verified credential?"
             );
             throw bindErr;
           }
@@ -233,7 +236,7 @@ export class VoltClient extends EventEmitter {
     if (this.isRemote) {
       if (!this._voltConfig?.relay?.address) {
         throw new Error(
-          "Remote connection enabled but no Relay address - have you called start()?",
+          "Remote connection enabled but no Relay address - have you called start()?"
         );
       }
 
@@ -245,14 +248,14 @@ export class VoltClient extends EventEmitter {
         this._credential,
         false,
         service.volt_id,
-        service.id,
+        service.id
       );
     } else {
       return createGrpcClient(
         this._grpc,
         serviceDescriptors,
         service.service_description.address,
-        this._credential,
+        this._credential
       );
     }
   }
@@ -280,6 +283,40 @@ export class VoltClient extends EventEmitter {
     return getVoltAPIClientInternal.call(this);
   }
 
+  unaryCall(method, request, service) {
+    return unaryCallInternal.call(this, method, request, service);
+  }
+
+  bidiStreamingCall(method, request, service) {
+    return streamingCallInternal.call(
+      this,
+      "METHOD_TYPE_BIDI",
+      method,
+      request,
+      service
+    );
+  }
+
+  clientStreamingCall(method, request, service) {
+    return streamingCallInternal.call(
+      this,
+      "METHOD_TYPE_CLIENT_STREAM",
+      method,
+      request,
+      service
+    );
+  }
+
+  serverStreamingCall(method, request, service) {
+    return streamingCallInternal.call(
+      this,
+      "METHOD_TYPE_SERVER_STREAM",
+      method,
+      request,
+      service
+    );
+  }
+
   /**
    * Request resource access.
    * @param {*} targetResourceId
@@ -287,12 +324,12 @@ export class VoltClient extends EventEmitter {
    */
   async RequestAccessBlocking(
     targetResourceId,
-    accessType = "VOLT_ACCESS_READ",
+    accessType = "VOLT_ACCESS_READ"
   ) {
     try {
       const accessRequest = {
         access: accessType,
-        resource_id: targetResourceId,
+        resource_id: targetResourceId
       };
 
       // This will block while the request is pending.
@@ -324,47 +361,47 @@ export class VoltClient extends EventEmitter {
    */
 
   CanAccessResource(request) {
-    return unaryCall.call(this, "CanAccessResource", request);
+    return unaryCallInternal.call(this, "CanAccessResource", request);
   }
 
   DeleteResource(request) {
-    return unaryCall.call(this, "DeleteResource", request);
+    return unaryCallInternal.call(this, "DeleteResource", request);
   }
 
   DiscoverServices(request) {
-    return unaryCall.call(this, "DiscoverServices", request);
+    return unaryCallInternal.call(this, "DiscoverServices", request);
   }
 
   GetResource(request) {
-    return unaryCall.call(this, "GetResource", request);
+    return unaryCallInternal.call(this, "GetResource", request);
   }
 
   GetResources(request) {
-    return unaryCall.call(this, "GetResources", request);
+    return unaryCallInternal.call(this, "GetResources", request);
   }
 
   GetResourceAncestors(request) {
-    return unaryCall.call(this, "GetResourceAncestors", request);
+    return unaryCallInternal.call(this, "GetResourceAncestors", request);
   }
 
   GetResourceDescendants(request) {
-    return unaryCall.call(this, "GetResourceDescendants", request);
+    return unaryCallInternal.call(this, "GetResourceDescendants", request);
   }
 
   RequestAccess(request) {
-    return unaryCall.call(this, "RequestAccess", request);
+    return unaryCallInternal.call(this, "RequestAccess", request);
   }
 
   SaveResource(request) {
-    return unaryCall.call(this, "SaveResource", request);
+    return unaryCallInternal.call(this, "SaveResource", request);
   }
 
   SaveResourceAttribute(request) {
-    return unaryCall.call(this, "SaveResourceAttribute", request);
+    return unaryCallInternal.call(this, "SaveResourceAttribute", request);
   }
 
   SetServiceStatus(request) {
-    return unaryCall.call(this, "SetServiceStatus", request);
+    return unaryCallInternal.call(this, "SetServiceStatus", request);
   }
 
   /**
@@ -372,82 +409,82 @@ export class VoltClient extends EventEmitter {
    */
 
   Bind(request) {
-    return unaryCall.call(this, "Bind", request);
+    return unaryCallInternal.call(this, "Bind", request);
   }
 
   DeleteAccess(request) {
-    return unaryCall.call(this, "DeleteAccess", request);
+    return unaryCallInternal.call(this, "DeleteAccess", request);
   }
 
   DeleteVolt(request) {
-    return unaryCall.call(this, "DeleteVolt", request);
+    return unaryCallInternal.call(this, "DeleteVolt", request);
   }
 
   GetAccess(request) {
-    return unaryCall.call(this, "GetAccess", request);
+    return unaryCallInternal.call(this, "GetAccess", request);
   }
 
   GetBindings(request) {
-    return unaryCall.call(this, "GetBindings", request);
+    return unaryCallInternal.call(this, "GetBindings", request);
   }
 
   GetIdentities(request) {
-    return unaryCall.call(this, "GetIdentities", request);
+    return unaryCallInternal.call(this, "GetIdentities", request);
   }
 
   GetIdentity(request) {
-    return unaryCall.call(this, "GetIdentity", request);
+    return unaryCallInternal.call(this, "GetIdentity", request);
   }
 
   GetIdentityToken(request) {
-    return unaryCall.call(this, "GetIdentityToken", request);
+    return unaryCallInternal.call(this, "GetIdentityToken", request);
   }
 
   GetPolicy(request) {
-    return unaryCall.call(this, "GetPolicy", request);
+    return unaryCallInternal.call(this, "GetPolicy", request);
   }
 
   GetSettings(request) {
-    return unaryCall.call(this, "GetSettings", request);
+    return unaryCallInternal.call(this, "GetSettings", request);
   }
 
   SaveAccess(request) {
-    return unaryCall.call(this, "SaveAccess", request);
+    return unaryCallInternal.call(this, "SaveAccess", request);
   }
 
   SaveCloudConnection(request) {
-    return unaryCall.call(this, "SaveCloudConnection", request);
+    return unaryCallInternal.call(this, "SaveCloudConnection", request);
   }
 
   SaveIdentity(request) {
-    return unaryCall.call(this, "SaveIdentity", request);
+    return unaryCallInternal.call(this, "SaveIdentity", request);
   }
 
   SaveSettings(request) {
-    return unaryCall.call(this, "SaveSettings", request);
+    return unaryCallInternal.call(this, "SaveSettings", request);
   }
 
   SetAccessRequestDecision(request) {
-    return unaryCall.call(this, "SetAccessRequestDecision", request);
+    return unaryCallInternal.call(this, "SetAccessRequestDecision", request);
   }
 
   SetBindingDecision(request) {
-    return unaryCall.call(this, "SetBindingDecision", request);
+    return unaryCallInternal.call(this, "SetBindingDecision", request);
   }
 
   Shutdown(request) {
-    return unaryCall.call(this, "Shutdown", request);
+    return unaryCallInternal.call(this, "Shutdown", request);
   }
 
   SignVerify(request) {
-    return unaryCall.call(this, "SignVerify", request);
+    return unaryCallInternal.call(this, "SignVerify", request);
   }
 
   /**
    * FileAPI
    */
   GetFileDescendants(request) {
-    return unaryCall.call(this, "GetFileDescendants", request);
+    return unaryCallInternal.call(this, "GetFileDescendants", request);
   }
 
   /**
@@ -461,11 +498,19 @@ export class VoltClient extends EventEmitter {
     const downloadCall = new GRPCCall(
       this,
       "DownloadFile",
-      "METHOD_TYPE_SERVER_STREAM",
+      "METHOD_TYPE_SERVER_STREAM"
     );
     return downloadCall.start(grpcClient, request);
   }
 
+  GetFileContent(request) {
+    return unaryCallInternal.call(this, "GetFileContent", request);
+  }
+
+  SetFileContent(request) {
+    return unaryCallInternal.call(this, "SetFileContent", request);
+  }
+
   UploadFile(request) {
     const grpcClient = this.getVoltAPIClient();
 
@@ -487,7 +532,7 @@ export class VoltClient extends EventEmitter {
       const call = new GRPCCall(
         this,
         "DownloadFile",
-        "METHOD_TYPE_SERVER_STREAM",
+        "METHOD_TYPE_SERVER_STREAM"
       );
 
       call.on("data", (response) => {
@@ -527,6 +572,10 @@ export class VoltClient extends EventEmitter {
   /**
    * SqliteDatabaseAPI
    */
+  BulkUpdate(request) {
+    return unaryCallInternal.call(this, "BulkUpdate", request);
+  }
+
   SqlExecute(request) {
     const grpcClient = this.getVoltAPIClient();
 
@@ -610,7 +659,7 @@ export class VoltClient extends EventEmitter {
     const subscribeCall = new GRPCCall(
       this,
       "SubscribeWire",
-      "METHOD_TYPE_BIDI",
+      "METHOD_TYPE_BIDI"
     );
     return subscribeCall.start(grpcClient, request);
   }

package/src/volt-connection.js

@@ -28,7 +28,7 @@ function _cleanUp(immediateReconnect) {
         this._reconnectTimer = 0;
         _doConnect.call(this, this._helloPayload);
       },
-      immediateReconnect ? 0 : this._reconnectInterval,
+      immediateReconnect ? 0 : this._reconnectInterval
     );
   }
 
@@ -49,10 +49,10 @@ function _doConnect(connectHello) {
   const grpcClient = this._voltClient.getVoltAPIClient();
 
   let helloPayload = connectHello;
-  if (!connectHello) {
+  if (!helloPayload) {
     log("defaulting hello payload");
     helloPayload = {
-      hello: {},
+      hello: {}
     };
   }
 
@@ -74,6 +74,8 @@ function _doConnect(connectHello) {
 
         // Schedule the next ping.
         _startPingTimer.call(this);
+
+        this.emit("ping", response.ping.timestamp);
         break;
       }
       case "acknowledge": {
@@ -84,8 +86,13 @@ function _doConnect(connectHello) {
         }
         break;
       }
+      case "invoke_request": {
+        log("received invoke request");
+        this.emit("invoke_request", response.invoke_request);
+        break;
+      }
       case "evt": {
-        log("received event %s", response.evt.event_type);
+        log("received event %s", Object.keys(response.evt)[0]);
         this.emit("evt", response.evt);
         break;
       }
@@ -129,7 +136,7 @@ function _startPingTimer() {
 
     this._pingTimeoutTimer = setTimeout(
       _connectionTimeoutHandler.bind(this),
-      this._timeoutInterval,
+      this._timeoutInterval
     );
   }, this._pingInterval);
 }
@@ -166,4 +173,8 @@ export default class VoltConnection extends EventEmitter {
     this._dying = true;
     _cleanUp.call(this);
   }
+
+  send(request) {
+    this.call.write(request);
+  }
 }

package/src/volt-credential.js

@@ -36,7 +36,7 @@ export class VoltCredential {
       // Need to unencrypt the private key.
       const decrypted = pki.decryptRsaPrivateKey(
         this._cryptoCache.key,
-        config.p,
+        config.p
       );
       if (!decrypted) {
         throw new Error("failed to decrypt key - check passphrase");
@@ -56,7 +56,7 @@ export class VoltCredential {
       // Extract Volt public key (used for encrypting Relay payloads).
       this._voltPublicKey = forge.pki.publicKeyToPem(voltCert.publicKey);
       this._voltFingerprint = voltUtils.createPublicKeyFingerprint(
-        this._voltPublicKey,
+        this._voltPublicKey
       );
     }
   }
@@ -73,6 +73,10 @@ export class VoltCredential {
     return this._cryptoCache.client_id;
   }
 
+  get voltPublicKey() {
+    return this._voltPublicKey;
+  }
+
   get publicKey() {
     return pki.publicKeyToPem(this.getKey().publicKey);
   }
@@ -97,19 +101,17 @@ export class VoltCredential {
       return Promise.resolve(this.getKey());
     } else {
       log("creating key");
-      return new Promise((resolve, reject) => {
-        pki.rsa.generateKeyPair({ bits: 2048, workers: -1 }, (err, keypair) => {
-          if (err) {
-            log("failure creating key [%s]", err.message);
-            reject(err);
-          } else {
-            log("successfully created key");
-            const pem = pki.privateKeyToPem(keypair.privateKey);
-            this._cryptoCache.key = pem;
-            resolve(keypair);
-          }
+      return voltUtils
+        .createRSAKey()
+        .then((keyInfo) => {
+          log("successfully created key");
+          this._cryptoCache.key = keyInfo.pem;
+          return keyInfo.keypair;
+        })
+        .catch((err) => {
+          log("failure creating key [%s]", err.message);
+          return Promise.reject(err);
         });
-      });
     }
   }
 
@@ -140,7 +142,7 @@ export class VoltCredential {
    * @param {*} tunnelling flag indicating if the token is required for a tunnelled connection
    * @param {*} ttl time to live in seconds (default to 1 minute)
    */
-  getIdentityToken(audience, tunnelling = false, ttl = 60) {
+  getIdentityToken(audience, publicKey, tunnelling = false, ttl = 60) {
     if (!this._cryptoCache.key) {
       throw new Error("crypto cache invalid");
     }
@@ -157,7 +159,7 @@ export class VoltCredential {
       aud: audience,
       iat: Math.floor(Date.now() / 1000) - ttl,
       exp: Math.floor(Date.now() / 1000) + ttl,
-      sub: this._cryptoCache.client_id,
+      sub: this._cryptoCache.client_id
     };
 
     let sharedKey;
@@ -166,23 +168,20 @@ export class VoltCredential {
       sharedKey = VoltCredential.aesCreateKey();
 
       // Encrypt the key details using the target Volt public key and include this in the JWT payload.
-      payload.sk = VoltCredential.rsaEncrypt(
-        this._voltPublicKey,
-        sharedKey.key,
-      );
-      payload.iv = VoltCredential.rsaEncrypt(this._voltPublicKey, sharedKey.iv);
+      payload.sk = VoltCredential.rsaEncrypt(publicKey, sharedKey.key);
+      payload.iv = VoltCredential.rsaEncrypt(publicKey, sharedKey.iv);
     }
 
     // Sign synchronously.
     const token = jwt.sign(payload, this._cryptoCache.key, {
       algorithm: rs256Algorithm,
-      keyid: base58Key,
+      keyid: base58Key
     });
 
     // Return the token along with any encryption key details.
     return {
       token,
-      sharedKey,
+      sharedKey
     };
   }
 
@@ -195,11 +194,12 @@ export class VoltCredential {
    * @param {*} ttl
    * @returns
    */
-  getIdentityMetadata(grpc, audience, tunnelling = false, ttl = 60) {
+  getIdentityMetadata(grpc, audience, publicKey, tunnelling = false, ttl = 60) {
     const identityToken = this.getIdentityToken(
       audience || this._voltConfig.id,
+      publicKey,
       tunnelling,
-      ttl,
+      ttl
     );
     const metadata = new grpc.Metadata();
     metadata.add(constants.authTokenName, identityToken.token);
@@ -214,7 +214,7 @@ export class VoltCredential {
         const privateKey = pki.privateKeyFromPem(this._cryptoCache.key);
         clone.credential.key = pki.encryptRsaPrivateKey(
           privateKey,
-          this._config.p,
+          this._config.p
         );
       }
       fs.writeFileSync(this._configPath, JSON.stringify(clone, null, 2));
@@ -243,4 +243,10 @@ export class VoltCredential {
   static rsaEncrypt(key, buffer) {
     return crypto.publicEncrypt(key, buffer).toString("base64");
   }
+
+  static rsaDecrypt(key, buffer) {
+    const keyObj = crypto.createPrivateKey(key);
+    const cipher = Buffer.from(buffer, "base64");
+    return Buffer.from(crypto.privateDecrypt(keyObj, cipher));
+  }
 }