Use environment variables to initialize client and server

src/implementation/Client/DaprClient.ts

@@ -33,6 +33,7 @@ import HTTPClient from './HTTPClient/HTTPClient';
 
 import CommunicationProtocolEnum from '../../enum/CommunicationProtocol.enum';
 import { DaprClientOptions } from '../../types/DaprClientOptions';
+import { Settings } from '../../utils/Settings.util';
 
 export default class DaprClient {
   readonly daprHost: string;
@@ -52,15 +53,15 @@ export default class DaprClient {
   readonly actor: IClientActorBuilder;
 
   constructor(
-    daprHost: string
-    , daprPort: string
+    daprHost?: string
+    , daprPort?: string
     , communicationProtocol: CommunicationProtocolEnum = CommunicationProtocolEnum.HTTP
     , options: DaprClientOptions = {
       isKeepAlive: true
     }
   ) {
-    this.daprHost = daprHost;
-    this.daprPort = daprPort;
+    this.daprHost = daprHost ?? Settings.getDefaultHost();
+    this.daprPort = daprPort ?? Settings.getDefaultPort(communicationProtocol);
     this.communicationProtocol = communicationProtocol;
     this.options = options;
 

src/implementation/Client/GRPCClient/GRPCClient.ts

@@ -4,19 +4,22 @@ import { DaprClient } from "../../../proto/dapr/proto/runtime/v1/dapr_grpc_pb"
 import IClient from "../../../interfaces/Client/IClient";
 import CommunicationProtocolEnum from "../../../enum/CommunicationProtocol.enum";
 import { DaprClientOptions } from "../../../types/DaprClientOptions";
+import { Settings } from '../../../utils/Settings.util';
 
 export default class GRPCClient implements IClient {
-  private isInitialized: boolean;
   private readonly client: DaprClient;
   private readonly clientCredentials: grpc.ChannelCredentials;
   private readonly clientHost: string;
   private readonly clientPort: string;
   private readonly options: DaprClientOptions;
 
-  constructor(host = "127.0.0.1", port = "50050", options: DaprClientOptions = {
-    isKeepAlive: true
-  }) {
-    this.isInitialized = true;
+  constructor(
+    host = Settings.getDefaultHost()
+    , port = Settings.getDefaultGrpcPort()
+    , options: DaprClientOptions = {
+      isKeepAlive: true
+    }
+  ) {
     this.clientHost = host;
     this.clientPort = port;
     this.clientCredentials = ChannelCredentials.createInsecure();

src/implementation/Client/HTTPClient/HTTPClient.ts

@@ -4,9 +4,9 @@ import IClient from "../../../interfaces/Client/IClient";
 import http from "http";
 import https from "https";
 import { DaprClientOptions } from "../../../types/DaprClientOptions";
+import { Settings } from '../../../utils/Settings.util';
 
 export default class HTTPClient implements IClient {
-  private readonly isInitialized: boolean;
   private client: typeof fetch;
   private readonly clientHost: string;
   private readonly clientPort: string;
@@ -16,10 +16,13 @@ export default class HTTPClient implements IClient {
   private readonly httpAgent;
   private readonly httpsAgent;
 
-  constructor(host = "127.0.0.1", port = "50050", options: DaprClientOptions = {
-    isKeepAlive: true
-  }) {
-    this.isInitialized = true;
+  constructor(
+    host = Settings.getDefaultHost()
+    , port = Settings.getDefaultHttpPort()
+    , options: DaprClientOptions = {
+      isKeepAlive: true
+    }
+  ) {
     this.clientHost = host;
     this.clientPort = port;
     this.options = options;

src/implementation/Server/DaprServer.ts

@@ -18,6 +18,7 @@ import HTTPServerInvoker from './HTTPServer/invoker';
 import HTTPServerActor from './HTTPServer/actor';
 import { DaprClientOptions } from '../../types/DaprClientOptions';
 import { DaprClient } from '../..';
+import { Settings } from '../../utils/Settings.util';
 
 export default class DaprServer {
   // App details
@@ -35,19 +36,19 @@ export default class DaprServer {
   readonly client: DaprClient;
 
   constructor(
-    serverHost = "127.0.0.1"
-    , serverPort: string = process.env.DAPR_SERVER_PORT || "50050"
-    , daprHost = "127.0.0.1"
-    , daprPort = "50051"
+    serverHost?: string
+    , serverPort?: string
+    , daprHost?: string
+    , daprPort?: string
     , communicationProtocol: CommunicationProtocolEnum = CommunicationProtocolEnum.HTTP
     , clientOptions: DaprClientOptions = {
       isKeepAlive: true
     }
   ) {
-    this.serverHost = serverHost;
-    this.serverPort = serverPort;
-    this.daprHost = daprHost;
-    this.daprPort = daprPort;
+    this.serverHost = serverHost ?? Settings.getDefaultHost();
+    this.serverPort = serverPort ?? Settings.getDefaultAppPort(communicationProtocol);
+    this.daprHost = daprHost ?? Settings.getDefaultHost();
+    this.daprPort = daprPort ?? Settings.getDefaultPort(communicationProtocol);
 
     // Create a client to interface with the sidecar from the server side
     this.client = new DaprClient(daprHost, daprPort, communicationProtocol, clientOptions);

src/utils/Settings.util.ts

@@ -0,0 +1,57 @@
+import CommunicationProtocolEnum from "../enum/CommunicationProtocol.enum";
+
+export class Settings {
+    private static readonly defaultHost: string = "127.0.0.1";
+    private static readonly defaultHttpAppPort: string = "3000";
+    private static readonly defaultHttpPort: string = "3500";
+    private static readonly defaultGrpcAppPort: string = "50000";
+    private static readonly defaultGrpcPort: string = "50001";
+
+    static getDefaultHost(): string {
+        return Settings.defaultHost;
+    }
+
+    static getDefaultHttpPort(): string {
+        return process.env.DAPR_HTTP_PORT ?? Settings.defaultHttpPort;
+    }
+
+    static getDefaultGrpcPort(): string {
+        return process.env.DAPR_GRPC_PORT ?? Settings.defaultGrpcPort;
+    }
+
+    /**
+     * Gets the default port that the Dapr sidecar is listening to.
+     * @param communicationProtocolEnum communication protocol
+     * @returns port number
+     */
+    static getDefaultPort(communicationProtocolEnum: CommunicationProtocolEnum): string {
+        switch (communicationProtocolEnum) {
+            case CommunicationProtocolEnum.GRPC:
+                return this.getDefaultGrpcPort();
+            default:
+                return this.getDefaultHttpPort();
+        }
+    }
+
+    static getDefaultHttpAppPort(): string {
+        return process.env.APP_PORT ?? Settings.defaultHttpAppPort;
+    }
+
+    static getDefaultGrpcAppPort(): string {
+        return process.env.APP_PORT ?? Settings.defaultGrpcAppPort;
+    }
+
+    /**
+     * Gets the default port that the application is listening on.
+     * @param communicationProtocolEnum communication protocol
+     * @returns port number
+     */
+    static getDefaultAppPort(communicationProtocolEnum: CommunicationProtocolEnum): string {
+        switch (communicationProtocolEnum) {
+            case CommunicationProtocolEnum.GRPC:
+                return this.getDefaultGrpcAppPort();        
+            default:
+                return this.getDefaultHttpAppPort();
+        }
+    }
+}

test/unit/utils/Settings.util.test.ts

@@ -0,0 +1,25 @@
+import { CommunicationProtocolEnum } from "../../../src";
+import { Settings } from "../../../src/utils/Settings.util";
+
+describe('Settings', () => {
+    describe('getDefaultPort returns the correct default when', () => {
+        it('communication protocol is GRPC', () => {
+            expect(Settings.getDefaultPort(CommunicationProtocolEnum.GRPC))
+                .toEqual(Settings.getDefaultGrpcPort())
+        });
+        it('communication protocol is HTTP', () => {
+            expect(Settings.getDefaultPort(CommunicationProtocolEnum.HTTP))
+                .toEqual(Settings.getDefaultHttpPort())
+        });
+    });
+    describe('getDefaultAppPort returns the correct default when', () => {
+        it('communication protocol is GRPC', () => {
+            expect(Settings.getDefaultAppPort(CommunicationProtocolEnum.GRPC))
+                .toEqual(Settings.getDefaultGrpcAppPort())
+        });
+        it('communication protocol is HTTP', () => {
+            expect(Settings.getDefaultAppPort(CommunicationProtocolEnum.HTTP))
+                .toEqual(Settings.getDefaultHttpAppPort())
+        });
+    });
+})