@tdxvolt/volt-client-grpc 0.1.1 → 0.11.0

package/src/grpc-call.js

@@ -1,258 +1,285 @@
 /* eslint-disable no-underscore-dangle */
 import debug from "debug";
 import EventEmitter from "events";
-import {VoltCrypto} from "./volt-crypto.js";
+import { VoltCredential } from "./volt-credential.js";
 
 const log = debug("volt-client-grpc:grpc-call");
 
-function _prepareInvokeRequest(request, method, methodType = "METHOD_TYPE_UNARY") {
-  const meta = this._voltClient.crypto.getIdentityMetadata(
-    this._voltClient.grpc,
-    this._voltClient.options.id,
-    this._voltClient.isRemote
-  );
-  let invokeRequest;
-  let callMethod = method;
-
-  if (this._voltClient.isVoltTunnel) {
-    let requestPayload;
-    if (request) {
-      requestPayload = this._grpcClient[method].requestSerialize(request);
-    } else if (request !== null) {
-      log("****************LOOKOUT****************** - empty request");
-    } else {
-      log("explicit empty request payload");
-    }
-
-    const tunnelMethod = this._grpcClient.Tunnel;
-
-    const tunnelResp = {
-      method_invoke: {
-        method_name: this._grpcClient[method].path,
-        method_type: methodType,
-        token: meta.token,
-        request: requestPayload,
-      },
-    };
-
-    const invokePayload = VoltCrypto.aesEncrypt(
-      tunnelMethod.responseSerialize(tunnelResp),
-      meta.sharedKey.key,
-      meta.sharedKey.iv
-    );
-
-    log("target volt is %s", this._voltClient.crypto.voltFingerprint);
-
-    invokeRequest = {
-      identity_fingerprint: this._voltClient.crypto.voltFingerprint,
-      payload: invokePayload,
-    };
-
-    callMethod = "Invoke";
-  } else if (this._voltClient.isRemote && meta.sharedKey.key) {
-    const requestPayload = this._grpcClient[method].requestSerializeOriginal(request);
-    invokeRequest = VoltCrypto.aesEncrypt(requestPayload, meta.sharedKey.key, meta.sharedKey.iv);
-  } else {
-    invokeRequest = request;
-  }
-
-  return {
-    meta,
-    method: callMethod,
-    methodName: method,
-    request: invokeRequest,
-  };
+function _prepareInvokeRequest(
+	request,
+	method,
+	methodType = "METHOD_TYPE_UNARY",
+) {
+	const meta = this._voltClient.credential.getIdentityMetadata(
+		this._voltClient.grpc,
+		this._voltClient.voltConfig.id,
+		this._voltClient.isRemote,
+	);
+	let invokeRequest;
+	let callMethod = method;
+
+	if (this._voltClient.isVoltRelay) {
+		let requestPayload;
+		if (request) {
+			requestPayload = this._grpcClient[method].requestSerialize(request);
+		} else if (request !== null) {
+			log("****************LOOKOUT****************** - empty request");
+		} else {
+			log("explicit empty request payload");
+		}
+
+		const tunnelMethod = this._grpcClient.Tunnel;
+
+		const tunnelResp = {
+			method_invoke: {
+				method_name: this._grpcClient[method].path,
+				method_type: methodType,
+				token: meta.token,
+				request: requestPayload,
+			},
+		};
+
+		const invokePayload = VoltCredential.aesEncrypt(
+			tunnelMethod.responseSerialize(tunnelResp),
+			meta.sharedKey.key,
+			meta.sharedKey.iv,
+		);
+
+		log("target volt is %s", this._voltClient.credential.voltFingerprint);
+
+		invokeRequest = {
+			identity_fingerprint: this._voltClient.credential.voltFingerprint,
+			payload: invokePayload,
+		};
+
+		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,
+		);
+	} else {
+		invokeRequest = request;
+	}
+
+	return {
+		meta,
+		method: callMethod,
+		methodName: method,
+		request: invokeRequest,
+	};
 }
 
 function _preparePayloadRequest(request, invokeInfo) {
-  let payloadRequest;
-
-  if (this._voltClient.isVoltTunnel) {
-    const requestPayload = this._grpcClient[invokeInfo.methodName].requestSerialize(request);
-    const tunnelMethod = this._grpcClient.Tunnel;
-
-    const tunnelResp = {
-      method_payload: {
-        payload: requestPayload,
-      },
-    };
-
-    const invokePayload = VoltCrypto.aesEncrypt(
-      tunnelMethod.responseSerialize(tunnelResp),
-      invokeInfo.meta.sharedKey.key,
-      invokeInfo.meta.sharedKey.iv
-    );
-
-    payloadRequest = {
-      payload: invokePayload,
-    };
-  } else if (this._voltClient.isRemote && invokeInfo.meta.sharedKey.key) {
-    const requestPayload = this._grpcClient[invokeInfo.methodName].requestSerializeOriginal(request);
-    payloadRequest = VoltCrypto.aesEncrypt(requestPayload, invokeInfo.meta.sharedKey.key, invokeInfo.meta.sharedKey.iv);
-  } else {
-    payloadRequest = request;
-  }
-
-  return payloadRequest;
+	let payloadRequest;
+
+	if (this._voltClient.isVoltRelay) {
+		const requestPayload =
+			this._grpcClient[invokeInfo.methodName].requestSerialize(request);
+		const tunnelMethod = this._grpcClient.Tunnel;
+
+		const tunnelResp = {
+			method_payload: {
+				payload: requestPayload,
+			},
+		};
+
+		const invokePayload = VoltCredential.aesEncrypt(
+			tunnelMethod.responseSerialize(tunnelResp),
+			invokeInfo.meta.sharedKey.key,
+			invokeInfo.meta.sharedKey.iv,
+		);
+
+		payloadRequest = {
+			payload: invokePayload,
+		};
+	} else if (this._voltClient.isRemote && invokeInfo.meta.sharedKey.key) {
+		const requestPayload =
+			this._grpcClient[invokeInfo.methodName].requestSerializeOriginal(request);
+		payloadRequest = VoltCredential.aesEncrypt(
+			requestPayload,
+			invokeInfo.meta.sharedKey.key,
+			invokeInfo.meta.sharedKey.iv,
+		);
+	} else {
+		payloadRequest = request;
+	}
+
+	return payloadRequest;
 }
 
 function _parseResponse(method, meta, response) {
-  let invokeResponse = {};
-
-  if (this._voltClient.isVoltTunnel) {
-    if (response.payload) {
-      const decryptedPayload = VoltCrypto.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);
-      } else if (responsePayload.payload === "method_end") {
-        invokeResponse = responsePayload.method_end;
-      } else {
-        log("unexpected tunnel payload type: %s", responsePayload.payload);
-      }
-    } else if (response.status && response.status.message) {
-      // There's been an error in the tunnel.
-      log(
-        "Tunnel status received: %s, code %d, description: %s",
-        response.status.message,
-        response.status.code,
-        response.status.description || "n/a"
-      );
-      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 = VoltCrypto.aesDecrypt(response, meta.sharedKey.key, meta.sharedKey.iv);
-    invokeResponse = {payload: this._grpcClient[method].responseDeserializeOriginal(decryptedPayload)};
-  } else {
-    invokeResponse = {payload: response};
-  }
-
-  return invokeResponse;
+	let invokeResponse = {};
+
+	if (this._voltClient.isVoltRelay) {
+		if (response.payload) {
+			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,
+				);
+			} else if (responsePayload.payload === "method_end") {
+				invokeResponse = responsePayload.method_end;
+			} else {
+				log("unexpected tunnel payload type: %s", responsePayload.payload);
+			}
+		} else if (response.status?.message) {
+			// There's been an error in the tunnel.
+			log(
+				"Tunnel status received: %s, code %d, description: %s",
+				response.status.message,
+				response.status.code,
+				response.status.description || "n/a",
+			);
+			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),
+		};
+	} else {
+		invokeResponse = { payload: response };
+	}
+
+	return invokeResponse;
 }
 
 export default class GRPCCall extends EventEmitter {
-  constructor(voltClient, methodName, methodType) {
-    super();
-    this._methodName = methodName;
-    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);
-    }
-  }
-
-  wait() {
-    return this._promise;
-  }
-
-  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);
-          }
-        } else {
-          this.end();
-          resolve(this._lastResponse);
-        }
-      };
-
-      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}'`));
-      }
-
-      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);
-      }
-    });
-
-    return this;
-  }
-
-  end() {
-    if (!this._call) {
-      throw new Error("call not initialised");
-    } else {
-      return this._call.end();
-    }
-  }
-
-  get writable() {
-    return this._call && this._call.writable;
-  }
-
-  write(request) {
-    if (!this._call) {
-      log("ERROR - call not initialised");
-      throw new Error("call not initialised");
-    } else if (!this._initialRequest) {
-      this._initialRequest = _prepareInvokeRequest.call(this, request, this._methodName, this._methodType);
-
-      return this._call.write(this._initialRequest.request);
-    } else {
-      const payloadRequest = _preparePayloadRequest.call(this, request, this._initialRequest);
-      return this._call.write(payloadRequest);
-    }
-  }
+	constructor(voltClient, methodName, methodType) {
+		super();
+		this._methodName = methodName;
+		this._methodType = methodType;
+		this._call = null;
+		this._voltClient = voltClient;
+	}
+
+	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}'`),
+			);
+		}
+
+		this._call = this._grpcClient[this._initialRequest.method](
+			this._initialRequest.meta.metadata,
+		);
+
+		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 {
+					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);
+			this.emit("error", err);
+		});
+
+		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");
+		});
+
+		if (this._initialRequest.request) {
+			this._call.write(this._initialRequest.request);
+		}
+
+		return this;
+	}
+
+	end() {
+		if (this._call) {
+			return this._call.end();
+		} else {
+			throw new Error("call not initialised");
+		}
+	}
+
+	get writable() {
+		return this._call?.writable;
+	}
+
+	write(request) {
+		if (!this._call) {
+			log("ERROR - call not initialised");
+			throw new Error("call not initialised");
+		} else if (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,
+			);
+
+			return this._call.write(this._initialRequest.request);
+		}
+	}
 }