@tdxvolt/volt-client-grpc 0.1.2 → 0.11.0

package/src/volt-client-internal.js

@@ -82,19 +82,21 @@ export async function bindInternal() {
 	try {
 		// Check if we need to resolve a Relay volt.
 		if (
-			this._config?.relay?.discovery_url ||
-			typeof this._config?.relay === "string"
+			typeof this._voltConfig?.relay === "string" ||
+			this._voltConfig?.relay?.http_address
 		) {
-			const relayURL = this._config.relay?.discovery_url || this._config.relay;
+			const relayURL =
+				this._voltConfig.relay?.http_address || this._voltConfig.relay;
 			log("attempting to retrieve Relay information from %s", relayURL);
-			const voltConfig = await fetchVoltConfig.call(this, relayURL);
-			this._config.relay = voltConfig.volt;
-			this._config.relay.discovery_url = relayURL;
-			if (this._config.relay.ca_pem) {
+			this._voltConfig.relay = await fetchVoltConfig.call(
+				this,
+				`${relayURL}/discovery`,
+			);
+			if (this._voltConfig.relay.ca_pem) {
 				log(
 					"Auto-fetched Relay CA %s, remote address %s",
-					this._config.relay.ca_pem,
-					this._config.relay.address,
+					this._voltConfig.relay.ca_pem,
+					this._voltConfig.relay.address,
 				);
 			} else {
 				throw new Error("Unable to fetch Relay CA - cannot securely connect.");
@@ -256,8 +258,8 @@ export function getVoltAPIClientInternal() {
 			serviceAddress,
 			this._credential,
 			this.isRemote && !this.isVoltRelay,
-			this._config?.relay?.cloud_relay ? this._voltConfig.id : "",
-			this._config?.relay?.cloud_relay ? this._voltConfig.id : "",
+			this._config?.relay?.cloud ? this._voltConfig.id : "",
+			this._config?.relay?.cloud ? this._voltConfig.id : "",
 		);
 	}
 
@@ -265,53 +267,93 @@ export function getVoltAPIClientInternal() {
 }
 
 export function unaryCall(method, request) {
-	const grpcClient = this.getVoltAPIClient();
+	return new Promise((resolve, reject) => {
+		const grpcClient = this.getVoltAPIClient();
+
+		const call = new GRPCCall(this, method, "METHOD_TYPE_UNARY");
+
+		let response = null;
+
+		call.on("data", (payload) => {
+			// Cache the response and wait for `end`.
+			response = payload;
+		});
+
+		call.on("error", reject);
+
+		call.on("end", () => {
+			if (!response) {
+				return reject(new Error("no response received"));
+			}
+
+			// Convert non-OK status to a JS error.
+			if (response.status?.message) {
+				reject(new Error(response.status.message));
+			} else {
+				resolve(response);
+			}
+		});
 
-	const call = new GRPCCall(this, method, "METHOD_TYPE_UNARY");
-	call.start(grpcClient, request);
-	return call.wait();
+		call.start(grpcClient, request);
+	});
 }
 
-export async function fetchVoltConfig(disovery_url) {
-	const getJSON = bent("json");
-	const resolvedConfig = await getJSON(disovery_url);
-
-	const voltConfig = pick(
-		resolvedConfig,
-		"id",
-		"display_name",
-		"public_key",
-		"fingerprint",
-		"address",
-		"ca_pem",
-		"challenge_code",
-		"cloud_relay",
-	);
-
-	const relayConfig = pick(resolvedConfig, "relay");
-
-	return { volt: voltConfig, ...relayConfig };
+export async function fetchVoltConfig(discovery_url) {
+	try {
+		const getJSON = bent("json");
+		const fullVoltConfig = await getJSON(discovery_url);
+
+		if (!fullVoltConfig || typeof fullVoltConfig !== "object") {
+			throw new Error(`invalid config resolved from: ${discovery_url}`);
+		}
+
+		const voltConfig = pick(
+			fullVoltConfig,
+			"id",
+			"display_name",
+			"public_key",
+			"fingerprint",
+			"address",
+			"ca_pem",
+			"challenge_code",
+			"cloud",
+			"relay",
+		);
+
+		return voltConfig;
+	} catch (err) {
+		throw new Error(
+			`Failure loading config from ${discovery_url}: ${err.message}`,
+		);
+	}
 }
 
 export async function fetchVoltConfigFromDID(volt_did) {
-	const didResolution = voltUtils.getDIDResolutionURL(volt_did);
-	if (!didResolution) {
-		throw new Error(`Invalid Volt DID: ${volt_did}`);
-	}
+	try {
+		const didResolution = voltUtils.getDIDResolutionURL(volt_did);
+		if (!didResolution) {
+			throw new Error(`Invalid Volt DID: ${volt_did}`);
+		}
+
+		const getJSON = bent("json");
+		const didDocument = await getJSON(didResolution);
+		const voltConfigServices = findDIDDocumentService(
+			didDocument,
+			constants.didServiceType.voltConfig,
+		);
+		if (voltConfigServices.length !== 1) {
+			log(
+				"Unexpected number of Volt configuration endpoints found in DID document for %s, services found: %d",
+				volt_did,
+				voltConfigServices.length,
+			);
+		}
 
-	const getJSON = bent("json");
-	const didDocument = await getJSON(didResolution);
-	const voltConfigServices = findDIDDocumentService(
-		didDocument,
-		constants.didServiceType.voltConfig,
-	);
-	if (voltConfigServices.length !== 1) {
-		log(
-			"Unexpected number of Volt configuration endpoints found in DID document for %s, services found: %d",
-			volt_did,
-			voltConfigServices.length,
+		const serviceEndpoint = voltConfigServices[0].serviceEndpoint;
+		return await fetchVoltConfig.call(this, serviceEndpoint);
+	} catch (err) {
+		throw new Error(
+			`Failure fetching Volt config from DID document ${volt_did}: ${err.message}`,
 		);
 	}
-	const serviceEndpoint = voltConfigServices[0].serviceEndpoint;
-	return await fetchVoltConfig.call(this, serviceEndpoint);
 }

package/src/volt-client.js

@@ -101,32 +101,38 @@ export class VoltClient extends EventEmitter {
 			this._config = { ...configJSON, ...extras };
 
 			let voltDID = "";
-			let voltDiscovery = "";
+			let voltHttpAddress = "";
 			if (typeof this._config.volt === "string") {
 				if (this._config.volt.indexOf("did:") === 0) {
 					voltDID = this._config.volt;
 				} else {
-					voltDiscovery = this._config.volt;
+					voltHttpAddress = this._config.volt;
 				}
 			} else if (typeof this._config.volt !== "object") {
 				throw new Error("configuration is missing the 'volt' object");
 			} else {
 				voltDID = this._config.volt.did;
-				voltDiscovery = this._config.volt.discovery_url;
+				voltHttpAddress = this._config.volt.http_address;
 			}
 
 			if (voltDID) {
 				const didConfig = await fetchVoltConfigFromDID.call(this, voltDID);
-				this._config = { ...this._config, ...didConfig };
+				this._config = { ...this._config, volt: didConfig };
 				log("resolved config from DID: %s", JSON.stringify(didConfig, null, 2));
-			} else if (voltDiscovery) {
-				const discoConfig = await fetchVoltConfig.call(this, voltDiscovery);
-				this._config = { ...this._config, ...discoConfig };
+			} else if (voltHttpAddress) {
+				const discoConfig = await fetchVoltConfig.call(
+					this,
+					`${voltHttpAddress}/discovery`,
+				);
+				this._config = {
+					...this._config,
+					volt: { ...this._config.volt, ...discoConfig },
+				};
 			}
 
 			this._voltConfig = this._config.volt;
 			this._voltConfig.did = voltDID;
-			this._voltConfig.discovery_url = voltDiscovery;
+			this._voltConfig.http_address = voltHttpAddress;
 
 			if (!this._voltConfig.id || typeof this._voltConfig.id !== "string") {
 				throw new Error("'id' property is missing in Volt configuration");
@@ -256,7 +262,7 @@ export class VoltClient extends EventEmitter {
 	}
 
 	get isVoltRelay() {
-		return this.isRemote && !this._config?.relay.cloud_relay;
+		return this.isRemote && !this._config?.relay.cloud;
 	}
 
 	connect() {
@@ -277,7 +283,7 @@ export class VoltClient extends EventEmitter {
 	/**
 	 * Request resource access.
 	 * @param {*} targetResourceId
-	 * @param {*} accessType - see vault.proto for enum values.
+	 * @param {*} accessType - see volt.proto for values.
 	 */
 	async RequestAccessBlocking(
 		targetResourceId,
@@ -452,24 +458,19 @@ export class VoltClient extends EventEmitter {
 	DownloadFile(request) {
 		const grpcClient = this.getVoltAPIClient();
 
-		return new Promise((resolve, reject) => {
-			const meta = this._credential.getIdentityMetadata(
-				this._grpc,
-				this._voltConfig.id,
-				this.isRemote,
-			);
-			resolve(grpcClient.DownloadFile(request, meta.metadata));
-		}).catch((err) => {
-			log("error during %s [%s]", method, err.message);
-			return Promise.reject(err);
-		});
+		const downloadCall = new GRPCCall(
+			this,
+			"DownloadFile",
+			"METHOD_TYPE_SERVER_STREAM",
+		);
+		return downloadCall.start(grpcClient, request);
 	}
 
-	UploadFile(request, callback) {
+	UploadFile(request) {
 		const grpcClient = this.getVoltAPIClient();
 
 		const uploadCall = new GRPCCall(this, "UploadFile", "METHOD_TYPE_BIDI");
-		return uploadCall.start(grpcClient, request, callback);
+		return uploadCall.start(grpcClient, request);
 	}
 
 	/**
@@ -478,72 +479,72 @@ export class VoltClient extends EventEmitter {
 	 * @returns file buffer, base64 encoded
 	 */
 	DownloadFileSync(request) {
-		const grpcClient = this.getVoltAPIClient();
+		return new Promise((resolve, reject) => {
+			const grpcClient = this.getVoltAPIClient();
 
-		const blocks = [];
+			const blocks = [];
 
-		const call = new GRPCCall(
-			this,
-			"DownloadFile",
-			"METHOD_TYPE_SERVER_STREAM",
-		);
-		call.start(grpcClient, request, (err, response) => {
-			if (err) {
-				return call.reject(err);
-			}
+			const call = new GRPCCall(
+				this,
+				"DownloadFile",
+				"METHOD_TYPE_SERVER_STREAM",
+			);
 
-			switch (response.payload) {
-				case "block": {
-					blocks.push(response.block);
-					break;
-				}
-				case "status": {
-					if (response.status.message) {
-						return call.reject(new Error(response.status.message));
-					} else {
-						// Non-error response status => do nothing and wait for the stream to end.
+			call.on("data", (response) => {
+				switch (response.payload) {
+					case "block": {
+						blocks.push(response.block);
+						break;
 					}
-					break;
+					case "status": {
+						if (response.status.message) {
+							return call.reject(new Error(response.status.message));
+						} else {
+							// Non-error response status => do nothing and wait for the stream to end.
+						}
+						break;
+					}
+					default:
+						log("unrecognised response payload %s", response.payload);
+						break;
 				}
-				default:
-					log("unrecognised response payload %s", response.payload);
-					break;
-			}
-		});
+			});
 
-		return call
-			.wait()
-			.then(() => {
-				log("Download finished");
-				return { buffer: Buffer.concat(blocks).toString("base64") };
-			})
-			.catch((err) => {
+			call.on("error", (err) => {
 				log("error during DownloadFile [%s]", err.message);
-				return Promise.reject(err);
+				reject(err);
+			});
+
+			call.on("end", () => {
+				log("Download finished");
+				resolve({ buffer: Buffer.concat(blocks).toString("base64") });
 			});
+
+			call.start(grpcClient, request);
+		});
 	}
 
 	/**
 	 * SqliteDatabaseAPI
 	 */
-	SqlExecute(request, callback) {
+	SqlExecute(request) {
 		const grpcClient = this.getVoltAPIClient();
 
 		const subscribeCall = new GRPCCall(this, "Execute", "METHOD_TYPE_BIDI");
-		return subscribeCall.start(grpcClient, request, callback);
+		return subscribeCall.start(grpcClient, request);
 	}
 
 	/**
 	 * WireAPI
 	 */
-	PublishWire(request, callback) {
+	PublishWire(request) {
 		const grpcClient = this.getVoltAPIClient();
 
 		const publishCall = new GRPCCall(this, "PublishWire", "METHOD_TYPE_BIDI");
-		return publishCall.start(grpcClient, request, callback);
+		return publishCall.start(grpcClient, request);
 	}
 
-	SubscribeWire(request, callback) {
+	SubscribeWire(request) {
 		const grpcClient = this.getVoltAPIClient();
 
 		const subscribeCall = new GRPCCall(
@@ -551,6 +552,6 @@ export class VoltClient extends EventEmitter {
 			"SubscribeWire",
 			"METHOD_TYPE_BIDI",
 		);
-		return subscribeCall.start(grpcClient, request, callback);
+		return subscribeCall.start(grpcClient, request);
 	}
 }