@tdxvolt/volt-client-grpc 0.11.0 → 0.11.3

package/src/grpc-utils.js

@@ -6,77 +6,77 @@ import { createSecureContextOptions } from "./utils.js";
 const { forEach, isEmpty } = lodash;
 
 const serialiseNOP = (arg) => {
-	return arg;
+  return arg;
 };
 
 export function createClient(
-	grpc,
-	serviceDescriptors,
-	address,
-	credentials,
-	noSerialise,
-	voltId,
-	serviceId,
+  grpc,
+  serviceDescriptors,
+  address,
+  credentials,
+  noSerialise,
+  voltId,
+  serviceId,
 ) {
-	let grpcCredentials;
-	if (credentials) {
-		const ca = credentials.config?.relay?.ca_pem || credentials.cache.ca;
-		const cert = credentials.cache.cloud_cert || credentials.cache.cert;
-		const { key } = credentials.cache;
-
-		if (key && cert) {
-			const cryyptoOptions = { ca, cert, key };
-			const tlsOptions = createSecureContextOptions(cryyptoOptions);
-			grpcCredentials = grpc.credentials.createSsl(
-				tlsOptions.ca,
-				tlsOptions.key,
-				tlsOptions.cert,
-			);
-		} else {
-			// Cache has no private key, this implies we are connecting without supplying a client certificate.
-			// Simply connect using the CA certificate.
-			grpcCredentials = grpc.credentials.createSsl(Buffer.from(ca));
-		}
-	} else {
-		grpcCredentials = grpc.credentials.createInsecure();
-	}
-
-	// Force all methods to appear bi-directional, since we manually handle the call flow (see grpc-call.js).
-	forEach(serviceDescriptors, (method) => {
-		method.requestStream = true;
-		method.responseStream = true;
-	});
-
-	if (noSerialise || voltId) {
-		if (voltId && !serviceId) {
-			// We must have a service identifier id when tunnelling in order to be able to route the rpc.
-			throw new Error("createClient - no serviceId given");
-		}
-		forEach(serviceDescriptors, (method) => {
-			if (voltId) {
-				// Prepend the resource id to the method path if tunnelling.
-				if (voltId === serviceId) {
-					method.path = `/${voltId}${method.path}`;
-				} else {
-					method.path = `/${voltId}/${serviceId}${method.path}`;
-				}
-			}
-			if (noSerialise) {
-				// Save original serialisation methods so we can encrypt/decrypt in the tunnel.
-				method.requestSerializeOriginal = method.requestSerialize;
-				method.responseDeserializeOriginal = method.responseDeserialize;
-
-				// Replace default serialisation with NOP, since when tunnelling we encrypt the payload
-				// before sending it to the channel, so we want it to be treated as a pure byte array (pass-through).
-				method.requestSerialize = serialiseNOP;
-				method.responseDeserialize = serialiseNOP;
-			}
-		});
-	}
-
-	const SubClass = grpc.makeGenericClientConstructor(serviceDescriptors);
-
-	return new SubClass(address, grpcCredentials);
+  let grpcCredentials;
+  if (credentials) {
+    const ca = credentials.config?.relay?.ca_pem || credentials.cache.ca;
+    const cert = credentials.cache.cloud_cert || credentials.cache.cert;
+    const { key } = credentials.cache;
+
+    if (key && cert) {
+      const cryyptoOptions = { ca, cert, key };
+      const tlsOptions = createSecureContextOptions(cryyptoOptions);
+      grpcCredentials = grpc.credentials.createSsl(
+        tlsOptions.ca,
+        tlsOptions.key,
+        tlsOptions.cert,
+      );
+    } else {
+      // Cache has no private key, this implies we are connecting without supplying a client certificate.
+      // Simply connect using the CA certificate.
+      grpcCredentials = grpc.credentials.createSsl(Buffer.from(ca));
+    }
+  } else {
+    grpcCredentials = grpc.credentials.createInsecure();
+  }
+
+  // Force all methods to appear bi-directional, since we manually handle the call flow (see grpc-call.js).
+  forEach(serviceDescriptors, (method) => {
+    method.requestStream = true;
+    method.responseStream = true;
+  });
+
+  if (noSerialise || voltId) {
+    if (voltId && !serviceId) {
+      // We must have a service identifier id when tunnelling in order to be able to route the rpc.
+      throw new Error("createClient - no serviceId given");
+    }
+    forEach(serviceDescriptors, (method) => {
+      if (voltId) {
+        // Prepend the resource id to the method path if tunnelling.
+        if (voltId === serviceId) {
+          method.path = `/${voltId}${method.path}`;
+        } else {
+          method.path = `/${voltId}/${serviceId}${method.path}`;
+        }
+      }
+      if (noSerialise) {
+        // Save original serialisation methods so we can encrypt/decrypt in the tunnel.
+        method.requestSerializeOriginal = method.requestSerialize;
+        method.responseDeserializeOriginal = method.responseDeserialize;
+
+        // Replace default serialisation with NOP, since when tunnelling we encrypt the payload
+        // before sending it to the channel, so we want it to be treated as a pure byte array (pass-through).
+        method.requestSerialize = serialiseNOP;
+        method.responseDeserialize = serialiseNOP;
+      }
+    });
+  }
+
+  const SubClass = grpc.makeGenericClientConstructor(serviceDescriptors);
+
+  return new SubClass(address, grpcCredentials);
 }
 
 /**
@@ -84,150 +84,150 @@ export function createClient(
  * @param {*} api
  */
 const grpcWrap = (api) => {
-	const grpcRoutes = {};
-
-	// Don't bother trying to wrap class constructors.
-	const ignoreMethods = ["constructor"];
-
-	// Support class instances and PoJos
-	const isClass = api.constructor !== Object;
-	const iterate = Object.getOwnPropertyNames(
-		isClass ? api.constructor.prototype : api,
-	);
-
-	// Wrap each method on the api.
-	forEach(iterate, (name) => {
-		if (!ignoreMethods.includes(name)) {
-			const method = api[name];
-			grpcRoutes[name] = (call, callback) => {
-				// Execute the method in the context of the api.
-				const resultPromise = method.call(api, call.request, call);
-
-				// Enforce promise results.
-				if (!(resultPromise?.then && resultPromise?.catch)) {
-					throw new Error(
-						`implementation methods must return a Promise [${name}]`,
-					);
-				}
-
-				resultPromise
-					.then((response) => {
-						if (callback) {
-							callback(null, response);
-						}
-					})
-					.catch((err) => {
-						if (callback) {
-							callback(err);
-						} else {
-							// TODO - verify this => how to send error to stream clients?
-							// Destroy stream on error.
-							call.destroy(err);
-						}
-					});
-			};
-		}
-	});
-
-	return grpcRoutes;
+  const grpcRoutes = {};
+
+  // Don't bother trying to wrap class constructors.
+  const ignoreMethods = ["constructor"];
+
+  // Support class instances and PoJos
+  const isClass = api.constructor !== Object;
+  const iterate = Object.getOwnPropertyNames(
+    isClass ? api.constructor.prototype : api,
+  );
+
+  // Wrap each method on the api.
+  forEach(iterate, (name) => {
+    if (!ignoreMethods.includes(name)) {
+      const method = api[name];
+      grpcRoutes[name] = (call, callback) => {
+        // Execute the method in the context of the api.
+        const resultPromise = method.call(api, call.request, call);
+
+        // Enforce promise results.
+        if (!(resultPromise?.then && resultPromise?.catch)) {
+          throw new Error(
+            `implementation methods must return a Promise [${name}]`,
+          );
+        }
+
+        resultPromise
+          .then((response) => {
+            if (callback) {
+              callback(null, response);
+            }
+          })
+          .catch((err) => {
+            if (callback) {
+              callback(err);
+            } else {
+              // TODO - verify this => how to send error to stream clients?
+              // Destroy stream on error.
+              call.destroy(err);
+            }
+          });
+      };
+    }
+  });
+
+  return grpcRoutes;
 };
 
 class GrpcServer {
-	constructor(options) {
-		const { grpc, serviceDescriptors, routes, tlsOptions, requireClientCert } =
-			options;
-		this._grpc = grpc;
-		this._server = new this._grpc.Server({
-			"grpc.keepalive_time_ms": 500,
-			"grpc.keepalive_timeout_ms": 5000,
-			"grpc.http2.max_pings_without_data": 0,
-			"grpc.keepalive_permit_without_calls": 1,
-			"grpc.http2.min_ping_interval_without_data_ms": 250,
-			"grpc.http2.max_ping_strikes": 0,
-		});
-
-		if (tlsOptions) {
-			const caList = [];
-			const certChains = [];
-			[].concat(tlsOptions).forEach((tlsOption) => {
-				caList.push(tlsOption.ca);
-				certChains.push({
-					private_key: tlsOption.key,
-					cert_chain: tlsOption.cert,
-				});
-			});
-
-			// Create credentials from the volt CA and our own pub/priv key.
-			this._credentials = grpc.ServerCredentials.createSsl(
-				// The root CAs we trust when verifying client certificates.
-				Buffer.concat(caList),
-				// The certificate chain(s) we present to the client.
-				certChains,
-				// Flag indicating if we insist on a client certificate.
-				requireClientCert,
-			);
-		} else {
-			this._credentials = grpc.ServerCredentials.createInsecure();
-		}
-
-		if (serviceDescriptors && !isEmpty(routes)) {
-			// Enforce decoupling of the service implementation.
-			const router = grpcWrap(routes);
-			this._server.addService(serviceDescriptors, router);
-		}
-	}
-
-	close(force = false) {
-		return new Promise((resolve) => {
-			if (force) {
-				resolve(this._server.forceShutdown());
-			} else {
-				this._server.tryShutdown(resolve);
-			}
-		});
-	}
-
-	listen(address) {
-		return new Promise((resolve, reject) => {
-			// If no port is specified, grpc will return the port number assigned.
-			this._server.bindAsync(address, this._credentials, (err, port) => {
-				if (err) {
-					reject(err);
-				} else {
-					this._port = port;
-					this._server.start();
-					resolve(port);
-				}
-			});
-		});
-	}
-
-	get server() {
-		return this._server;
-	}
-
-	get port() {
-		return this._port;
-	}
+  constructor(options) {
+    const { grpc, serviceDescriptors, routes, tlsOptions, requireClientCert } =
+      options;
+    this._grpc = grpc;
+    this._server = new this._grpc.Server({
+      "grpc.keepalive_time_ms": 500,
+      "grpc.keepalive_timeout_ms": 5000,
+      "grpc.http2.max_pings_without_data": 0,
+      "grpc.keepalive_permit_without_calls": 1,
+      "grpc.http2.min_ping_interval_without_data_ms": 250,
+      "grpc.http2.max_ping_strikes": 0,
+    });
+
+    if (tlsOptions) {
+      const caList = [];
+      const certChains = [];
+      [].concat(tlsOptions).forEach((tlsOption) => {
+        caList.push(tlsOption.ca);
+        certChains.push({
+          private_key: tlsOption.key,
+          cert_chain: tlsOption.cert,
+        });
+      });
+
+      // Create credentials from the volt CA and our own pub/priv key.
+      this._credentials = grpc.ServerCredentials.createSsl(
+        // The root CAs we trust when verifying client certificates.
+        Buffer.concat(caList),
+        // The certificate chain(s) we present to the client.
+        certChains,
+        // Flag indicating if we insist on a client certificate.
+        requireClientCert,
+      );
+    } else {
+      this._credentials = grpc.ServerCredentials.createInsecure();
+    }
+
+    if (serviceDescriptors && !isEmpty(routes)) {
+      // Enforce decoupling of the service implementation.
+      const router = grpcWrap(routes);
+      this._server.addService(serviceDescriptors, router);
+    }
+  }
+
+  close(force = false) {
+    return new Promise((resolve) => {
+      if (force) {
+        resolve(this._server.forceShutdown());
+      } else {
+        this._server.tryShutdown(resolve);
+      }
+    });
+  }
+
+  listen(address) {
+    return new Promise((resolve, reject) => {
+      // If no port is specified, grpc will return the port number assigned.
+      this._server.bindAsync(address, this._credentials, (err, port) => {
+        if (err) {
+          reject(err);
+        } else {
+          this._port = port;
+          this._server.start();
+          resolve(port);
+        }
+      });
+    });
+  }
+
+  get server() {
+    return this._server;
+  }
+
+  get port() {
+    return this._port;
+  }
 }
 
 export function createServer(
-	grpc,
-	serviceDescriptors,
-	routes,
-	cryptoCache,
-	requireClientCert,
+  grpc,
+  serviceDescriptors,
+  routes,
+  cryptoCache,
+  requireClientCert,
 ) {
-	let tlsOptions;
-	if (cryptoCache) {
-		tlsOptions = createSecureContextOptions(cryptoCache);
-	}
-	const serverArgs = {
-		grpc,
-		serviceDescriptors,
-		routes,
-		tlsOptions,
-		requireClientCert,
-	};
-	return new GrpcServer(serverArgs);
+  let tlsOptions;
+  if (cryptoCache) {
+    tlsOptions = createSecureContextOptions(cryptoCache);
+  }
+  const serverArgs = {
+    grpc,
+    serviceDescriptors,
+    routes,
+    tlsOptions,
+    requireClientCert,
+  };
+  return new GrpcServer(serverArgs);
 }

package/src/proto-utils.js

@@ -9,90 +9,90 @@ const __dirname = dirname(fileURLToPath(import.meta.url));
 const defaultProtoPath = join(__dirname, "../protobuf");
 
 const defaultLoaderOptions = {
-	keepCase: true,
-	longs: String,
-	enums: String,
-	defaults: true,
-	oneofs: true,
-	includeDirs: [defaultProtoPath],
+  keepCase: true,
+  longs: String,
+  enums: String,
+  defaults: true,
+  oneofs: true,
+  includeDirs: [defaultProtoPath],
 };
 
 const getProtoDescriptors = (grpc, protoPath, opts) => {
-	const definition = protoLoader.loadSync(
-		protoPath,
-		opts || defaultLoaderOptions,
-	);
-	const descriptors = grpc.loadPackageDefinition(definition);
-	return descriptors;
+  const definition = protoLoader.loadSync(
+    protoPath,
+    opts || defaultLoaderOptions,
+  );
+  const descriptors = grpc.loadPackageDefinition(definition);
+  return descriptors;
 };
 
 const getProtoService = (descriptors, servicePath) => {
-	const serviceDef = getProp(descriptors, servicePath);
-	if (serviceDef?.service) {
-		return serviceDef.service;
-	} else {
-		return null;
-	}
+  const serviceDef = getProp(descriptors, servicePath);
+  if (serviceDef?.service) {
+    return serviceDef.service;
+  } else {
+    return null;
+  }
 };
 
 function getServiceDescriptorsFromPath(
-	grpc,
-	protoPath,
-	servicePackageName,
-	opts,
+  grpc,
+  protoPath,
+  servicePackageName,
+  opts,
 ) {
-	let serviceDescriptors;
-	const descriptors = getProtoDescriptors(grpc, protoPath, opts);
-	if (descriptors) {
-		serviceDescriptors = getProtoService(descriptors, servicePackageName);
-	}
+  let serviceDescriptors;
+  const descriptors = getProtoDescriptors(grpc, protoPath, opts);
+  if (descriptors) {
+    serviceDescriptors = getProtoService(descriptors, servicePackageName);
+  }
 
-	return serviceDescriptors;
+  return serviceDescriptors;
 }
 
 function getServiceDescriptors(grpc, servicePackageName, opts) {
-	// Extract the package components of the service proto package. The package name should be of the
-	// fully qualified proto path, e.g. tdx.volt_api.webcam.v1.WebcamControlAPI.
-	const protoServiceComponents = servicePackageName.split(".");
+  // Extract the package components of the service proto package. The package name should be of the
+  // fully qualified proto path, e.g. tdx.volt_api.webcam.v1.WebcamControlAPI.
+  const protoServiceComponents = servicePackageName.split(".");
 
-	// The service name is the last component of the path.
-	const protoServiceName = protoServiceComponents.pop();
+  // The service name is the last component of the path.
+  const protoServiceName = protoServiceComponents.pop();
 
-	// The actual file name should match the snake case of the service name.
-	const protoFileName = `${snakeCase(protoServiceName).toLowerCase()}.proto`;
+  // The actual file name should match the snake case of the service name.
+  const protoFileName = `${snakeCase(protoServiceName).toLowerCase()}.proto`;
 
-	// The path to the proto file should match each component of the package name.
-	const protoPath = join(
-		defaultProtoPath,
-		...protoServiceComponents,
-		protoFileName,
-	);
+  // The path to the proto file should match each component of the package name.
+  const protoPath = join(
+    defaultProtoPath,
+    ...protoServiceComponents,
+    protoFileName,
+  );
 
-	let serviceDescriptors;
-	const descriptors = getProtoDescriptors(grpc, protoPath, opts);
-	if (descriptors) {
-		serviceDescriptors = getProtoService(descriptors, servicePackageName);
-	}
+  let serviceDescriptors;
+  const descriptors = getProtoDescriptors(grpc, protoPath, opts);
+  if (descriptors) {
+    serviceDescriptors = getProtoService(descriptors, servicePackageName);
+  }
 
-	return serviceDescriptors;
+  return serviceDescriptors;
 }
 
 function getProtoDescriptorMethods(protoDescriptor) {
-	const methods = [];
-	Object.keys(protoDescriptor).forEach((methodName) => {
-		const method = protoDescriptor[methodName];
-		methods.push({
-			path: method.path,
-			client_streaming: method.requestStream,
-			server_streaming: method.responseStream,
-		});
-	});
-	return methods;
+  const methods = [];
+  Object.keys(protoDescriptor).forEach((methodName) => {
+    const method = protoDescriptor[methodName];
+    methods.push({
+      path: method.path,
+      client_streaming: method.requestStream,
+      server_streaming: method.responseStream,
+    });
+  });
+  return methods;
 }
 
 export {
-	getServiceDescriptors,
-	getProtoDescriptors,
-	getProtoDescriptorMethods,
-	getServiceDescriptorsFromPath,
+  getServiceDescriptors,
+  getProtoDescriptors,
+  getProtoDescriptorMethods,
+  getServiceDescriptorsFromPath,
 };