feat: Support for the DAPR_HTTP_ENDPOINT and DAPR_GRPC_ENDPOINT environment variables. Adds support for DAPR_API_TOKEN to gRPC client

.gitignore

@@ -1,5 +1,5 @@
 ### vscode ###
-.vscode/*
+.vscode
 !.vscode/settings.json
 !.vscode/tasks.json
 !.vscode/launch.json
@@ -144,4 +144,11 @@ temp/
 build/
 
 # version file is auto-generated
-src/version.ts
+src/version.ts
+
+# OSX
+/.DS_Store
+
+# JetBrains
+/.idea
+

src/implementation/Client/GRPCClient/GRPCClient.ts

@@ -28,15 +28,18 @@
   private readonly client: GrpcDaprClient;
   private readonly clientCredentials: grpc.ChannelCredentials;
   private readonly logger: Logger;
+  public readonly grpcClientOptions: Partial<grpc.ClientOptions>;
 
   constructor(options: DaprClientOptions) {
     this.options = options;
     this.clientCredentials = this.generateCredentials();
+    this.grpcClientOptions = this.generateChannelOptions();
+
     this.logger = new Logger("GRPCClient", "GRPCClient", options.logger);
     this.isInitialized = false;
 
     this.logger.info(`Opening connection to ${this.options.daprHost}:${this.options.daprPort}`);
-    this.client = this.generateClient(this.options.daprHost, this.options.daprPort, this.clientCredentials);
+    this.client = this.generateClient(this.options.daprHost, this.options.daprPort);
   }
 
   async getClient(requiresInitialization = true): Promise<GrpcDaprClient> {
@@ -52,8 +55,20 @@
     return this.clientCredentials;
   }
 
-  private generateChannelOptions(): Record<string, string | number> {
-    const options: Record<string, string | number> = {};
+  getGrpcClientOptions(): grpc.ClientOptions {
+    return this.grpcClientOptions;
+  }
+
+  private generateCredentials(): grpc.ChannelCredentials {
+    if (this.options.daprHost.startsWith("https")) {
+      return grpc.ChannelCredentials.createSsl();
+    }
+    return grpc.ChannelCredentials.createInsecure();
+  }
+
+  private generateChannelOptions(): Partial<grpc.ClientOptions> {
+    // const options: Record<string, string | number> = {};
+    let options: Partial<grpc.ClientOptions> = {};
 
     // See: GRPC_ARG_MAX_SEND_MESSAGE_LENGTH, it is in bytes
     // https://grpc.github.io/grpc/core/group__grpc__arg__keys.html#ga813f94f9ac3174571dd712c96cdbbdc1
@@ -67,20 +82,48 @@
     // Add user agent
     options["grpc.primary_user_agent"] = "dapr-sdk-js/v" + SDK_VERSION;
 
+    // Add interceptors if we have an API token
+    if (this.options.daprApiToken !== "") {
+      options = {
+        interceptors: [this.generateInterceptors()],
+        ...options,
+      };
+    }
+
     return options;
   }
 
-  private generateClient(host: string, port: string, credentials: grpc.ChannelCredentials): GrpcDaprClient {
-    const options = this.generateChannelOptions();
-    const client = new GrpcDaprClient(`${host}:${port}`, credentials, options);
+  private generateClient(host: string, port: string): GrpcDaprClient {
+    return new GrpcDaprClient(
+      GRPCClient.getEndpoint(host, port),
+      this.getClientCredentials(),
+      this.getGrpcClientOptions(),
+    );
+  }
 
-    return client;
+  // The grpc client doesn't allow http:// or https:// for grpc connections,
+  // so we need to remove it, if it exists
+  static getEndpoint(host: string, port: string): string {
+    let endpoint = `${host}:${port}`;
+    const parts = endpoint.split("://");
+    if (parts.length > 1 && parts[0].startsWith("http")) {
+      endpoint = parts[1];
+    }
+
+    return endpoint;
   }
 
-  // @todo: look into making secure credentials
-  private generateCredentials(): grpc.ChannelCredentials {
-    const credsChannel = grpc.ChannelCredentials.createInsecure();
-    return credsChannel;
+  private generateInterceptors(): (options: any, nextCall: any) => grpc.InterceptingCall {
+    return (options: any, nextCall: any) => {
+      return new grpc.InterceptingCall(nextCall(options), {
+        start: (metadata, listener, next) => {
+          if (metadata.get("dapr-api-token").length == 0) {
+            metadata.add("dapr-api-token", this.options.daprApiToken as grpc.MetadataValue);
+          }
+          next(metadata, listener);
+        },
+      });
+    };
   }
 
   setIsInitialized(isInitialized: boolean): void {

src/implementation/Client/GRPCClient/GRPCClientProxy.ts

@@ -60,7 +60,11 @@
       this.grpcClientOptions.interceptors = [];
     }
 
-    this.grpcClientOptions.interceptors = [...this.generateInterceptors(), ...this.grpcClientOptions.interceptors];
+    this.grpcClientOptions.interceptors = [
+      ...this.generateInterceptors(),
+      ...(this.grpcClient.grpcClientOptions.interceptors ?? []),
+      ...this.grpcClientOptions.interceptors,
+    ];
 
     const clientCustom = new this.clsProxy(
       `${this.grpcClient.options.daprHost}:${this.grpcClient.options.daprPort}`,

src/utils/Client.util.ts

@@ -263,9 +263,30 @@
   defaultLoggerOptions: LoggerOptions | undefined,
 ): DaprClientOptions {
   const clientCommunicationProtocol = clientoptions?.communicationProtocol ?? defaultCommunicationProtocol;
+
+  // We decide the host/port/endpoint here
+  let daprEndpoint = "";
+  if (clientCommunicationProtocol == CommunicationProtocolEnum.HTTP) {
+    daprEndpoint = Settings.getDefaultHttpEndpoint();
+  } else if (clientCommunicationProtocol == CommunicationProtocolEnum.GRPC) {
+    daprEndpoint = Settings.getDefaultGrpcEndpoint();
+  }
+
+  let host = Settings.getDefaultHost();
+  let port = Settings.getDefaultPort(clientCommunicationProtocol);
+
+  if (clientoptions?.daprHost || clientoptions?.daprPort) {
+    host = clientoptions?.daprHost ?? host;
+    port = clientoptions?.daprPort ?? port;
+  } else if (daprEndpoint != "") {
+    const [scheme, fqdn, p] = parseEndpoint(daprEndpoint);
+    host = `${scheme}://${fqdn}`;
+    port = p.toString();
+  }
+
   return {
-    daprHost: clientoptions?.daprHost ?? Settings.getDefaultHost(),
-    daprPort: clientoptions?.daprPort ?? Settings.getDefaultPort(clientCommunicationProtocol),
+    daprHost: host,
+    daprPort: port,
     communicationProtocol: clientCommunicationProtocol,
     isKeepAlive: clientoptions?.isKeepAlive,
     logger: clientoptions?.logger ?? defaultLoggerOptions,
@@ -274,3 +295,79 @@
     maxBodySizeMb: clientoptions?.maxBodySizeMb,
   };
 }
+
+/**
+ * Scheme, fqdn and port
+ */
+type EndpointTuple = [string, string, number];
+
+/**
+ * Parses an endpoint to scheme, fqdn and port
+ * Examples:
+ *  - http://localhost:3500 -> [http, localhost, 3500]
+ *  - localhost:3500 -> [http, localhost, 3500]
+ *  - :3500 -> [http, localhost, 3500]
+ *  - localhost -> [http, localhost, 80]
+ *  - https://localhost:3500 -> [https, localhost, 3500]
+ *  - [::1]:3500 -> [http, ::1, 3500]
+ *  - [::1] -> [http, ::1, 80]
+ *  - http://[2001:db8:1f70::999:de8:7648:6e8]:5000 -> [http, 2001:db8:1f70::999:de8:7648:6e8, 5000]
+ * @throws Error if the port is not a number
+ * @throws Error if the address is invalid
+ * @param address Endpoint address
+ * @returns EndpointTuple (scheme, fqdn, port)
+ */
+export function parseEndpoint(address: string): EndpointTuple {
+  let scheme = "http";
+  let fqdn = "localhost";
+  let port = 80;
+  let addr = address;
+
+  const addrList = address.split("://");
+
+  if (addrList.length === 2) {
+    // A scheme was explicitly specified
+    scheme = addrList[0];
+    if (scheme === "https") {
+      port = 443;
+    }
+    addr = addrList[1];
+  }
+
+  const addrParts = addr.split(":");
+  if (addrParts.length === 2) {
+    // A port was explicitly specified
+    if (addrParts[0].length > 0) {
+      fqdn = addrParts[0];
+    }
+    // Account for Endpoints of the type http://localhost:3500/v1.0/invoke
+    const portParts = addrParts[1].split("/");
+    port = parseInt(portParts[0], 10);
+  } else if (addrParts.length === 1) {
+    // No port was specified
+    // Account for Endpoints of the type :3500/v1.0/invoke
+    const fqdnParts = addrParts[0].split("/");
+    fqdn = fqdnParts[0];
+  } else {
+    // IPv6 address
+    const ipv6Parts = addr.split("]:");
+    if (ipv6Parts.length === 2) {
+      // A port was explicitly specified
+      fqdn = ipv6Parts[0].replace("[", "");
+      const portParts = ipv6Parts[1].split("/");
+      port = parseInt(portParts[0], 10);
+    } else if (ipv6Parts.length === 1) {
+      // No port was specified
+      const fqdnParts = ipv6Parts[0].split("/");
+      fqdn = fqdnParts[0].replace("[", "").replace("]", "");
+    } else {
+      throw new Error(`Invalid address: ${address}`);
+    }
+  }
+
+  if (isNaN(port)) {
+    throw new Error(`Invalid port: ${port}`);
+  }
+
+  return [scheme, fqdn, port];
+}

src/utils/Settings.util.ts

@@ -20,6 +20,8 @@
   private static readonly defaultHttpPort: string = "3500";
   private static readonly defaultGrpcAppPort: string = "50000";
   private static readonly defaultGrpcPort: string = "50001";
+  private static readonly defaultHttpEndpoint: string = "";
+  private static readonly defaultGrpcEndpoint: string = "";
   private static readonly defaultCommunicationProtocol: CommunicationProtocolEnum = CommunicationProtocolEnum.HTTP;
   private static readonly defaultKeepAlive: boolean = true;
   private static readonly defaultStateGetBulkParallelism: number = 10;
@@ -85,6 +87,22 @@
     return process.env.APP_PORT ?? Settings.defaultGrpcAppPort;
   }
 
+  static getDefaultHttpEndpoint(): string {
+    if (process.env.DAPR_HTTP_ENDPOINT && process.env.DAPR_HTTP_ENDPOINT !== "") {
+      return process.env.DAPR_HTTP_ENDPOINT as string;
+    } else {
+      return Settings.defaultHttpEndpoint;
+    }
+  }
+
+  static getDefaultGrpcEndpoint(): string {
+    if (process.env.DAPR_GRPC_ENDPOINT && process.env.DAPR_GRPC_ENDPOINT !== "") {
+      return process.env.DAPR_GRPC_ENDPOINT as string;
+    } else {
+      return Settings.defaultGrpcEndpoint;
+    }
+  }
+
   /**
    * Gets the default port that the application is listening on.
    * @param communicationProtocolEnum communication protocol