@tdxvolt/volt-client-grpc 0.14.61 → 0.14.134

package/src/volt-client-internal.js

@@ -5,11 +5,17 @@ import bent from "bent";
 import forge from "node-forge";
 import lodash from "lodash";
 import VoltConnection from "./volt-connection.js";
-import { getServiceDescriptors } from "./proto-utils.js";
+import { join } from "path";
+import {
+  createServiceProtobufFiles,
+  getServiceDescriptors,
+  getServiceDescriptorsFromPath,
+} from "./proto-utils.js";
 import { createClient as createGrpcClient } from "./grpc-utils.js";
 import * as voltUtils from "./utils.js";
 import { constants } from "./constants.js";
 import GRPCCall from "./grpc-call.js";
+import RpcInvocation from "./rpc-invocation.js";
 
 const { pki } = forge;
 const { filter, pick } = lodash;
@@ -27,46 +33,48 @@ const voltServices = [
 
 function issueBind(bindRequest, ttl) {
   // eslint-disable-next-line no-use-before-define
-  return unaryCall.call(this, "Bind", bindRequest).then((bindResponse) => {
-    log("got binding request response %j", bindResponse);
-    if (bindResponse.status?.code) {
-      log("error in bind response: %s", bindResponse.status.message);
-      return Promise.reject(new Error(bindResponse.status.message));
-    } else {
-      switch (bindResponse.decision) {
-        case "POLICY_DECISION_PERMIT": {
-          //
-          // The request status is permit => cache the bind response info.
-          //
-
-          // This is the certificate assigned to us by the volt.
-          this._credential.cache.cert = bindResponse.cert;
-
-          // This is the signing CA used by the volt.
-          this._credential.cache.ca = bindResponse.chain;
-
-          // Identity resource id is assigned by the volt.
-          this._credential.cache.client_id = bindResponse.identity_id;
-          this._credential.saveCache();
-          break;
-        }
-        case "POLICY_DECISION_DENY": {
-          log(">>>>>>>>>>>>>>> access request is DENIED <<<<<<<<<<<<<<<<<<<");
-          break;
-        }
-        case "POLICY_DECISION_PROMPT":
-        case "POLICY_DECISION_PENDING": {
-          log("access pending approval - waiting...");
-          break;
+  return unaryCallInternal
+    .call(this, "Bind", bindRequest)
+    .then((bindResponse) => {
+      log("got binding request response %j", bindResponse);
+      if (bindResponse.status?.code) {
+        log("error in bind response: %s", bindResponse.status.message);
+        return Promise.reject(new Error(bindResponse.status.message));
+      } else {
+        switch (bindResponse.decision) {
+          case "POLICY_DECISION_PERMIT": {
+            //
+            // The request status is permit => cache the bind response info.
+            //
+
+            // This is the certificate assigned to us by the volt.
+            this._credential.cache.cert = bindResponse.cert;
+
+            // This is the signing CA used by the volt.
+            this._credential.cache.ca = bindResponse.chain;
+
+            // Identity resource id is assigned by the volt.
+            this._credential.cache.client_id = bindResponse.identity_id;
+            this._credential.saveCache();
+            break;
+          }
+          case "POLICY_DECISION_DENY": {
+            log(">>>>>>>>>>>>>>> access request is DENIED <<<<<<<<<<<<<<<<<<<");
+            break;
+          }
+          case "POLICY_DECISION_PROMPT":
+          case "POLICY_DECISION_PENDING": {
+            log("access pending approval - waiting...");
+            break;
+          }
+          default:
+            log("ignoring unknown bind descision %s", bindResponse.status);
+            break;
         }
-        default:
-          log("ignoring unknown bind descision %s", bindResponse.status);
-          break;
       }
-    }
 
-    return bindResponse.decision;
-  });
+      return bindResponse.decision;
+    });
 }
 
 function findDIDDocumentService(document, serviceType) {
@@ -233,6 +241,30 @@ export function connectInternal(helloPayload) {
       this.emit("evt", evt);
     });
 
+    this._voltConnection.on("invoke_request", (invoke_request) => {
+      const invokeId = invoke_request.invoke_id;
+      if (this._activeRPC[invokeId]) {
+        this._activeRPC[invokeId].parsePayload(invoke_request);
+      } else {
+        const rpcInvocation = new RpcInvocation(this, this._voltConnection);
+
+        rpcInvocation.on("end", () => {
+          log("removing active RPC [%s]", invokeId);
+          this._activeRPC[invokeId] = undefined;
+        });
+
+        rpcInvocation
+          .initialise(invoke_request)
+          .then(() => {
+            this._activeRPC[invokeId] = rpcInvocation;
+            this.emit("invoke_request", rpcInvocation);
+          })
+          .catch((err) => {
+            log("invoke_request - error [%s]", err.message);
+          });
+      }
+    });
+
     return this._voltConnection.connect(helloPayload);
   } catch (err) {
     log("connect - error [%s]", err.message);
@@ -266,11 +298,62 @@ export function getVoltAPIClientInternal() {
   return this._cachedClient;
 }
 
-export function unaryCall(method, request) {
-  return new Promise((resolve, reject) => {
-    const grpcClient = this.getVoltAPIClient();
+export function getAPIClientInternal(service) {
+  if (!this._cachedService[service.id]) {
+    const isRelayedService =
+      service.service_description.host_type === "SERVICE_HOST_TYPE_RELAYED";
+
+    const serviceAddress = this.isRemote
+      ? this._voltConfig.relay.address
+      : service.service_description.host_address;
+
+    createServiceProtobufFiles(service, "./service-proto");
+
+    log("creating API service client on %s", serviceAddress);
+    let serviceDescriptors = {};
+    const fullProtoPath = join(process.cwd(), "./service-proto");
+    for (let api of service.service_description.service_api) {
+      const packageDescriptors = getServiceDescriptorsFromPath(
+        this._grpc,
+        fullProtoPath,
+        api,
+      );
+      serviceDescriptors = { ...serviceDescriptors, ...packageDescriptors };
+    }
+
+    this._cachedService[service.id] = createGrpcClient(
+      this._grpc,
+      serviceDescriptors,
+      serviceAddress,
+      this._credential,
+      this.isRemote && !this.isVoltRelay,
+      this._voltConfig?.relay?.cloud ? this._voltConfig.id : "",
+      this._voltConfig?.relay?.cloud ? this._voltConfig.id : "",
+    );
+  }
+
+  return this._cachedService[service.id];
+}
 
-    const call = new GRPCCall(this, method, "METHOD_TYPE_UNARY");
+export function getServiceClient(service) {
+  let grpcClient;
+  if (
+    service &&
+    service?.service_description.host_type !== "SERVICE_HOST_TYPE_BUILTIN"
+  ) {
+    grpcClient = getAPIClientInternal.call(this, service);
+  } else {
+    grpcClient = getVoltAPIClientInternal.call(this);
+  }
+
+  return grpcClient;
+}
+
+export function unaryCallInternal(method, request, service) {
+  const grpcClient = getServiceClient.call(this, service);
+
+  return new Promise((resolve, reject) => {
+    const call = new GRPCCall(this, method, "METHOD_TYPE_UNARY", service);
 
     let response = null;
 
@@ -298,6 +381,16 @@ export function unaryCall(method, request) {
   });
 }
 
+export function streamingCallInternal(methodType, method, request, service) {
+  const grpcClient = getServiceClient.call(this, service);
+
+  const call = new GRPCCall(this, method, methodType, service);
+
+  call.start(grpcClient, request);
+
+  return call;
+}
+
 export async function fetchVoltConfig(discovery_url) {
   try {
     const getJSON = bent("json");

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() {
@@ -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
@@ -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);
   }
 
   /**
@@ -527,6 +564,10 @@ export class VoltClient extends EventEmitter {
   /**
    * SqliteDatabaseAPI
    */
+  BulkUpdate(request) {
+    return unaryCallInternal.call(this, "BulkUpdate", request);
+  }
+
   SqlExecute(request) {
     const grpcClient = this.getVoltAPIClient();
 

package/src/volt-connection.js

@@ -84,6 +84,11 @@ 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);
         this.emit("evt", response.evt);
@@ -166,4 +171,8 @@ export default class VoltConnection extends EventEmitter {
     this._dying = true;
     _cleanUp.call(this);
   }
+
+  send(request) {
+    this.call.write(request);
+  }
 }

package/src/volt-credential.js

@@ -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);
   }
@@ -140,7 +144,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");
     }
@@ -166,11 +170,8 @@ 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.
@@ -195,9 +196,10 @@ 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,
     );
@@ -243,4 +245,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));
+  }
 }