@tdxvolt/volt-client-grpc 0.11.0 → 0.11.3

package/src/grpc-call.js

@@ -6,280 +6,281 @@ import { VoltCredential } from "./volt-credential.js";
 const log = debug("volt-client-grpc:grpc-call");
 
 function _prepareInvokeRequest(
-	request,
-	method,
-	methodType = "METHOD_TYPE_UNARY",
+  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,
-	};
+  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.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;
+  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.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;
+  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;
-	}
-
-	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);
-		}
-	}
+  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) {
+      // Allow callee to attach event handlers before we actually send the initial payload.
+      process.nextTick(() => 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);
+    }
+  }
 }