@tdxvolt/volt-client-grpc 0.1.2 → 0.11.1

package/package.json

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

package/protobuf/tdx/volt_api/data/v1/sqlite.proto

@@ -3,19 +3,19 @@ syntax = "proto3";
 package tdx.volt_api.data.v1;
 
 // Just reflect SQLite types for now.
-enum ColumnType {
-  COLUMN_TYPE_UNKNOWN = 0;
-  COLUMN_TYPE_TEXT = 1;
-  COLUMN_TYPE_INTEGER = 2;
-  COLUMN_TYPE_REAL = 3;
-  COLUMN_TYPE_BLOB = 4;
-  COLUMN_TYPE_NULL = 5;
+enum DataType {
+  DATA_TYPE_UNKNOWN = 0;
+  DATA_TYPE_TEXT = 1;
+  DATA_TYPE_INTEGER = 2;
+  DATA_TYPE_REAL = 3;
+  DATA_TYPE_BLOB = 4;
+  DATA_TYPE_NULL = 5;
 }
 
 message Column {
   string name = 1;
   string description = 2;
-  ColumnType type = 3;
+  DataType type = 3;
 }
 
 message Schema {
@@ -25,12 +25,12 @@ message Schema {
 }
 
 message Variant {
-  ColumnType type = 1;
   oneof data {
-    string text = 2;
-    int64 integer = 3;
-    double real = 4;
-    bytes blob = 5;
+    string text = 1;
+    int64 integer = 2;
+    double real = 3;
+    bytes blob = 4;
+    bool null = 5;
   }
 }
 

package/protobuf/tdx/volt_api/volt/v1/volt.proto

@@ -82,6 +82,9 @@ message ProxyConnection {
 
   // Set to indicate the Volt API itself is not automatically exposed to the connection.
   bool disable_volt_api = 9;
+
+  // Optional challenge that can be presented in the bind phase when initialising the connection.
+  string challenge = 10;
 }
 
 enum SecureMode {

package/protobuf/tdx/volt_api/volt/v1/wire_api.proto

@@ -14,7 +14,7 @@ service WireAPI {
   rpc SubscribeWire(stream SubscribeWireRequest) returns (stream SubscribeWireResponse);
 }
 
-// Because the publish RPC is client-streaming, the policy will not be checked until the first message arrives. This can mean that the `PublishWire` call appears to succeed but then fails after the first attempt to publish a message.
+// Because the publish RPC is streaming, the policy will not be checked until the first message arrives. This can mean that the `PublishWire` call appears to succeed but then fails after the first attempt to publish a message.
 // To avoid this, clients can immediately send a message with the `wire_id` set and no `chunk` set. This will establish that the correct permissions are in place and fail fast if not.
 message PublishWireRequest {
   // Only necessary in the first payload.

package/src/constants.js

@@ -1,75 +1,75 @@
 // eslint-disable-next-line import/prefer-default-export
 export const constants = {
-	authTokenName: "tdx-token",
-	collectionOperation: {
-		add: "ADD",
-		remove: "REMOVE",
-		update: "UPDATE",
-	},
-	crypto: {
-		subjectDefaults: [
-			{
-				name: "countryName",
-				value: "GB",
-			},
-			{
-				name: "localityName",
-				value: "Southampton",
-			},
-			{
-				name: "organizationName",
-				value: "nquiringminds Ltd",
-			},
-		],
-		userIdOID: "0.9.2342.19200300.100.1.1",
-	},
-	defaultDIDHostName: "cloud.tdxvolt.com",
-	didServiceType: {
-		voltConfig: "tdx-volt-config",
-	},
-	identityType: {
-		did: "did",
-		volt: "volt",
-	},
-	onlineStatus: {
-		offline: "offline",
-		online: "online",
-		unknown: "unknown",
-	},
-	publicKeyPrefix: "-----BEGIN PUBLIC KEY-----",
-	privateKeyPrefix: "-----BEGIN RSA PRIVATE KEY-----",
-	privateEncryptedKeyPrefix: "-----BEGIN ENCRYPTED PRIVATE KEY-----",
-	resource: {
-		identity: "ident",
-		identityView: "ident-view",
-		proxy: "proxy",
-		proxyView: "proxy-view",
-		vc: "vc",
-		vcView: "vc-view",
-	},
-	voltStatus: {
-		pending: "",
-		online: "online",
-		offline: "offline",
-		deleted: "deleted",
-		revoked: "revoked",
-	},
-	/**
-	 * These top-level service types should map to a protobuf definition
-	 * in @tdxvolt/volt-proto.
-	 */
-	serviceType: {
-		fileAPI: "tdx.volt_api.volt.v1.FileAPI",
-		sqliteServerAPI: "tdx.volt_api.data.v1.SqliteServerAPI",
-		sqliteDatabaseAPI: "tdx.volt_api.data.v1.SqliteDatabaseAPI",
-		ssiAPI: "tdx.volt_api.ssi.v1.SsiAPI",
-		relayAPI: "tdx.volt_api.relay.v1.RelayAPI",
-		voltAPI: "tdx.volt_api.volt.v1.VoltAPI",
-		wireAPI: "tdx.volt_api.volt.v1.WireAPI",
-	},
-	tunnelInvokeMethod: "/tdx.volt_api.volt.v1.VoltAPI/Invoke",
-	tunnelPingInterval: 10000,
-	tunnelPingTimeout: 2500,
-	tunnelReconnectAfter: 30000,
-	tunnelTimeoutInterval: 10000 * 2, // This must always be greater than `tunnelPingInterval`.
+  authTokenName: "tdx-token",
+  collectionOperation: {
+    add: "ADD",
+    remove: "REMOVE",
+    update: "UPDATE",
+  },
+  crypto: {
+    subjectDefaults: [
+      {
+        name: "countryName",
+        value: "GB",
+      },
+      {
+        name: "localityName",
+        value: "Southampton",
+      },
+      {
+        name: "organizationName",
+        value: "nquiringminds Ltd",
+      },
+    ],
+    userIdOID: "0.9.2342.19200300.100.1.1",
+  },
+  defaultDIDHostName: "cloud.tdxvolt.com",
+  didServiceType: {
+    voltConfig: "tdx-volt-config",
+  },
+  identityType: {
+    did: "did",
+    volt: "volt",
+  },
+  onlineStatus: {
+    offline: "offline",
+    online: "online",
+    unknown: "unknown",
+  },
+  publicKeyPrefix: "-----BEGIN PUBLIC KEY-----",
+  privateKeyPrefix: "-----BEGIN RSA PRIVATE KEY-----",
+  privateEncryptedKeyPrefix: "-----BEGIN ENCRYPTED PRIVATE KEY-----",
+  resource: {
+    identity: "ident",
+    identityView: "ident-view",
+    proxy: "proxy",
+    proxyView: "proxy-view",
+    vc: "vc",
+    vcView: "vc-view",
+  },
+  voltStatus: {
+    pending: "",
+    online: "online",
+    offline: "offline",
+    deleted: "deleted",
+    revoked: "revoked",
+  },
+  /**
+   * These top-level service types should map to a protobuf definition
+   * in @tdxvolt/volt-proto.
+   */
+  serviceType: {
+    fileAPI: "tdx.volt_api.volt.v1.FileAPI",
+    sqliteServerAPI: "tdx.volt_api.data.v1.SqliteServerAPI",
+    sqliteDatabaseAPI: "tdx.volt_api.data.v1.SqliteDatabaseAPI",
+    ssiAPI: "tdx.volt_api.ssi.v1.SsiAPI",
+    relayAPI: "tdx.volt_api.relay.v1.RelayAPI",
+    voltAPI: "tdx.volt_api.volt.v1.VoltAPI",
+    wireAPI: "tdx.volt_api.volt.v1.WireAPI",
+  },
+  tunnelInvokeMethod: "/tdx.volt_api.volt.v1.VoltAPI/Invoke",
+  tunnelPingInterval: 10000,
+  tunnelPingTimeout: 2500,
+  tunnelReconnectAfter: 30000,
+  tunnelTimeoutInterval: 10000 * 2, // This must always be greater than `tunnelPingInterval`.
 };

package/src/grpc-call.js

@@ -1,15 +1,19 @@
 /* eslint-disable no-underscore-dangle */
 import debug from "debug";
 import EventEmitter from "events";
-import {VoltCredential} from "./volt-credential.js";
+import { VoltCredential } from "./volt-credential.js";
 
 const log = debug("volt-client-grpc:grpc-call");
 
-function _prepareInvokeRequest(request, method, methodType = "METHOD_TYPE_UNARY") {
+function _prepareInvokeRequest(
+  request,
+  method,
+  methodType = "METHOD_TYPE_UNARY",
+) {
   const meta = this._voltClient.credential.getIdentityMetadata(
     this._voltClient.grpc,
     this._voltClient.voltConfig.id,
-    this._voltClient.isRemote
+    this._voltClient.isRemote,
   );
   let invokeRequest;
   let callMethod = method;
@@ -38,7 +42,7 @@ function _prepareInvokeRequest(request, method, methodType = "METHOD_TYPE_UNARY"
     const invokePayload = VoltCredential.aesEncrypt(
       tunnelMethod.responseSerialize(tunnelResp),
       meta.sharedKey.key,
-      meta.sharedKey.iv
+      meta.sharedKey.iv,
     );
 
     log("target volt is %s", this._voltClient.credential.voltFingerprint);
@@ -50,8 +54,13 @@ function _prepareInvokeRequest(request, method, methodType = "METHOD_TYPE_UNARY"
 
     callMethod = "Invoke";
   } else if (this._voltClient.isRemote && meta.sharedKey.key) {
-    const requestPayload = this._grpcClient[method].requestSerializeOriginal(request);
-    invokeRequest = VoltCredential.aesEncrypt(requestPayload, meta.sharedKey.key, meta.sharedKey.iv);
+    const requestPayload =
+      this._grpcClient[method].requestSerializeOriginal(request);
+    invokeRequest = VoltCredential.aesEncrypt(
+      requestPayload,
+      meta.sharedKey.key,
+      meta.sharedKey.iv,
+    );
   } else {
     invokeRequest = request;
   }
@@ -68,7 +77,8 @@ function _preparePayloadRequest(request, invokeInfo) {
   let payloadRequest;
 
   if (this._voltClient.isVoltRelay) {
-    const requestPayload = this._grpcClient[invokeInfo.methodName].requestSerialize(request);
+    const requestPayload =
+      this._grpcClient[invokeInfo.methodName].requestSerialize(request);
     const tunnelMethod = this._grpcClient.Tunnel;
 
     const tunnelResp = {
@@ -80,18 +90,19 @@ function _preparePayloadRequest(request, invokeInfo) {
     const invokePayload = VoltCredential.aesEncrypt(
       tunnelMethod.responseSerialize(tunnelResp),
       invokeInfo.meta.sharedKey.key,
-      invokeInfo.meta.sharedKey.iv
+      invokeInfo.meta.sharedKey.iv,
     );
 
     payloadRequest = {
       payload: invokePayload,
     };
   } else if (this._voltClient.isRemote && invokeInfo.meta.sharedKey.key) {
-    const requestPayload = this._grpcClient[invokeInfo.methodName].requestSerializeOriginal(request);
+    const requestPayload =
+      this._grpcClient[invokeInfo.methodName].requestSerializeOriginal(request);
     payloadRequest = VoltCredential.aesEncrypt(
       requestPayload,
       invokeInfo.meta.sharedKey.key,
-      invokeInfo.meta.sharedKey.iv
+      invokeInfo.meta.sharedKey.iv,
     );
   } else {
     payloadRequest = request;
@@ -105,11 +116,17 @@ function _parseResponse(method, meta, response) {
 
   if (this._voltClient.isVoltRelay) {
     if (response.payload) {
-      const decryptedPayload = VoltCredential.aesDecrypt(response.payload, meta.sharedKey.key, meta.sharedKey.iv);
+      const decryptedPayload = VoltCredential.aesDecrypt(
+        response.payload,
+        meta.sharedKey.key,
+        meta.sharedKey.iv,
+      );
       const tunnelMethod = this._grpcClient.Tunnel;
       const responsePayload = tunnelMethod.requestDeserialize(decryptedPayload);
       if (responsePayload.payload === "method_payload") {
-        invokeResponse.payload = this._grpcClient[method].responseDeserialize(responsePayload.method_payload.payload);
+        invokeResponse.payload = this._grpcClient[method].responseDeserialize(
+          responsePayload.method_payload.payload,
+        );
       } else if (responsePayload.payload === "method_end") {
         invokeResponse = responsePayload.method_end;
       } else {
@@ -121,18 +138,28 @@ function _parseResponse(method, meta, response) {
         "Tunnel status received: %s, code %d, description: %s",
         response.status.message,
         response.status.code,
-        response.status.description || "n/a"
+        response.status.description || "n/a",
       );
-      invokeResponse = {ended: true, error: `Error in tunnel: ${response.status.message}`};
+      invokeResponse = {
+        ended: true,
+        error: `Error in tunnel: ${response.status.message}`,
+      };
     } else {
       invokeResponse.methodId = response.invoke_id;
       log("started method %d for %s", invokeResponse.methodId, method);
     }
   } else if (this._voltClient.isRemote && meta.sharedKey.key) {
-    const decryptedPayload = VoltCredential.aesDecrypt(response, meta.sharedKey.key, meta.sharedKey.iv);
-    invokeResponse = {payload: this._grpcClient[method].responseDeserializeOriginal(decryptedPayload)};
+    const decryptedPayload = VoltCredential.aesDecrypt(
+      response,
+      meta.sharedKey.key,
+      meta.sharedKey.iv,
+    );
+    invokeResponse = {
+      payload:
+        this._grpcClient[method].responseDeserializeOriginal(decryptedPayload),
+    };
   } else {
-    invokeResponse = {payload: response};
+    invokeResponse = { payload: response };
   }
 
   return invokeResponse;
@@ -145,92 +172,79 @@ export default class GRPCCall extends EventEmitter {
     this._methodType = methodType;
     this._call = null;
     this._voltClient = voltClient;
-    this._lastResponse = null;
-    this._promise = null;
-    this._reject = null;
   }
 
-  reject(err) {
-    if (this._reject) {
-      this._reject(err);
+  start(grpcClient, request) {
+    this._grpcClient = grpcClient;
+
+    this._initialRequest = _prepareInvokeRequest.call(
+      this,
+      request,
+      this._methodName,
+      this._methodType,
+    );
+
+    if (!this._grpcClient[this._initialRequest.method]) {
+      return reject(
+        new Error(`method not found: '${this._initialRequest.method}'`),
+      );
     }
-  }
 
-  wait() {
-    return this._promise;
-  }
+    this._call = this._grpcClient[this._initialRequest.method](
+      this._initialRequest.meta.metadata,
+    );
 
-  start(grpcClient, request, responseCB) {
-    this._promise = new Promise((resolve, reject) => {
-      this._grpcClient = grpcClient;
-      this._reject = reject;
-
-      const callbackIntercept = (err, response) => {
-        log("received callback for method %s", this._methodName);
-        if (err) {
-          reject(err);
-        } else if (response) {
-          this._lastResponse = response;
-          if (responseCB) {
-            responseCB(err, response);
+    this._call.on("data", (streamResponse) => {
+      try {
+        const parsedResponse = _parseResponse.call(
+          this,
+          this._methodName,
+          this._initialRequest.meta,
+          streamResponse,
+        );
+        if (parsedResponse.payload) {
+          this.emit("data", parsedResponse.payload);
+        } else if (parsedResponse.ended) {
+          if (parsedResponse.error) {
+            this.emit("error", new Error(parsedResponse.error));
+          } else {
+            // Not sure this is necessary - we should receive "end" from grpc soon...
+            this.emit("end");
           }
         } else {
-          this.end();
-          resolve(this._lastResponse);
+          log("method id is %s", parsedResponse.methodId);
         }
-      };
+      } catch (err) {
+        log("failure processing connect response: %s", err.message);
+        this.emit("error", err);
+      }
+    });
 
-      this._initialRequest = _prepareInvokeRequest.call(this, request, this._methodName, this._methodType);
+    this._call.on("error", (err) => {
+      log("ERROR - intercepted stream error %s", err.message);
+      this.emit("error", err);
+    });
 
-      if (!this._grpcClient[this._initialRequest.method]) {
-        return reject(new Error(`method not found: '${this._initialRequest.method}'`));
-      }
+    this._call.on("finish", () => {
+      // The read side has ended (i.e. we called end()).
+      log("finished call %s", this._methodName);
+      this.emit("finish");
+    });
 
-      this._call = this._grpcClient[this._initialRequest.method](this._initialRequest.meta.metadata, callbackIntercept);
-
-      this._call.on("data", (streamResponse) => {
-        try {
-          const parsedResponse = _parseResponse.call(this, this._methodName, this._initialRequest.meta, streamResponse);
-          if (parsedResponse.payload) {
-            callbackIntercept(null, parsedResponse.payload);
-          } else if (parsedResponse.ended) {
-            if (parsedResponse.error) {
-              callbackIntercept(new Error(parsedResponse.error), null);
-            } else {
-              callbackIntercept(null, null);
-            }
-          } else {
-            log("method id is %s", parsedResponse.methodId);
-          }
-        } catch (err) {
-          log("failure processing connect response: %s", err.message);
-          this.emit("error", err);
-        }
-      });
-
-      this._call.on("error", (err) => {
-        log("ERROR - intercepted stream error %s", err.message);
-        callbackIntercept(err, null);
-      });
-
-      this._call.on("finish", () => {
-        // The read side has ended (i.e. we called end()).
-        log("finished call %s", this._methodName);
-        this.emit("finish");
-      });
-
-      this._call.on("end", () => {
-        // The remote peer ended the stream.
-        log("ended call %s, method id: %s", this._methodName, this._initialRequest.methodId || "n/a - not tunnelling");
-        this.emit("end");
-        callbackIntercept(null, null);
-      });
-
-      if (this._initialRequest.request) {
-        this._call.write(this._initialRequest.request);
-      }
+    this._call.on("end", () => {
+      // The remote peer ended the stream.
+      log(
+        "ended call %s, method id: %s",
+        this._methodName,
+        this._initialRequest.methodId || "n/a - not tunnelling",
+      );
+      this.emit("end");
     });
 
+    if (this._initialRequest.request) {
+      this._call.write(this._initialRequest.request);
+    }
+
     return this;
   }
 
@@ -251,10 +265,19 @@ export default class GRPCCall extends EventEmitter {
       log("ERROR - call not initialised");
       throw new Error("call not initialised");
     } else if (this._initialRequest) {
-      const payloadRequest = _preparePayloadRequest.call(this, request, this._initialRequest);
+      const payloadRequest = _preparePayloadRequest.call(
+        this,
+        request,
+        this._initialRequest,
+      );
       return this._call.write(payloadRequest);
     } else {
-      this._initialRequest = _prepareInvokeRequest.call(this, request, this._methodName, this._methodType);
+      this._initialRequest = _prepareInvokeRequest.call(
+        this,
+        request,
+        this._methodName,
+        this._methodType,
+      );
 
       return this._call.write(this._initialRequest.request);
     }