feat: Add support for environment variables for OFREP provider config… (#1450)

Signed-off-by: marcozabel <marco.zabel@dynatrace.com>

Author: marcozabel

libs/providers/flagd/src/lib/configuration.ts

@@ -197,7 +197,7 @@ function checkEnvVarResolverType() {
   );
 }
 
-const getEnvVarConfig = (): Partial<Config & FlagdGrpcConfig> => {
+function getEnvVarConfig(): Partial<Config & FlagdGrpcConfig> {
   let provider = undefined;
   if (
     process.env[ENV_VAR.FLAGD_RESOLVER] &&
@@ -269,7 +269,7 @@ const getEnvVarConfig = (): Partial<Config & FlagdGrpcConfig> => {
       retryGracePeriod: Number(process.env[ENV_VAR.FLAGD_RETRY_GRACE_PERIOD]),
     }),
   };
-};
+}
 
 export function getConfig(options: FlagdProviderOptions = {}): FlagdConfig & FlagdGrpcConfig {
   const envVarConfig = getEnvVarConfig();

libs/providers/go-feature-flag/src/lib/go-feature-flag-provider-options.spec.ts

@@ -0,0 +1,66 @@
+import type { GoFeatureFlagProviderOptions } from './go-feature-flag-provider-options';
+import { EvaluationType } from './model';
+
+describe('GoFeatureFlagProviderOptions', () => {
+  describe('Type checking for endpoint configuration', () => {
+    it('should allow endpoint for InProcess evaluation (default)', () => {
+      const options: GoFeatureFlagProviderOptions = {
+        endpoint: 'https://api.example.com',
+        evaluationType: EvaluationType.InProcess,
+      };
+
+      expect(options.endpoint).toBe('https://api.example.com');
+    });
+
+    it('should allow endpoint when using Remote evaluation', () => {
+      const options: GoFeatureFlagProviderOptions = {
+        endpoint: 'https://api.example.com',
+        evaluationType: EvaluationType.Remote,
+      };
+
+      expect(options.endpoint).toBe('https://api.example.com');
+    });
+
+    it('should allow omitting endpoint for evaluation type remote', () => {
+      const options: GoFeatureFlagProviderOptions = {
+        evaluationType: EvaluationType.Remote,
+      };
+
+      expect(options.endpoint).toBeUndefined();
+    });
+
+    it('should allow all base options with endpoint', () => {
+      const options: GoFeatureFlagProviderOptions = {
+        endpoint: 'https://api.example.com',
+        timeout: 5000,
+        flagChangePollingIntervalMs: 30000,
+        dataFlushInterval: 60000,
+        maxPendingEvents: 5000,
+        disableDataCollection: true,
+        apiKey: 'test-key',
+      };
+
+      expect(options.endpoint).toBe('https://api.example.com');
+      expect(options.timeout).toBe(5000);
+      expect(options.flagChangePollingIntervalMs).toBe(30000);
+      expect(options.dataFlushInterval).toBe(60000);
+      expect(options.maxPendingEvents).toBe(5000);
+      expect(options.disableDataCollection).toBe(true);
+      expect(options.apiKey).toBe('test-key');
+    });
+
+    it('should allow all base options without endpoint when evaluation type is remote', () => {
+      const options: GoFeatureFlagProviderOptions = {
+        timeout: 5000,
+        flagChangePollingIntervalMs: 30000,
+        disableDataCollection: false,
+        evaluationType: EvaluationType.Remote,
+      };
+
+      expect(options.endpoint).toBeUndefined();
+      expect(options.timeout).toBe(5000);
+      expect(options.flagChangePollingIntervalMs).toBe(30000);
+      expect(options.disableDataCollection).toBe(false);
+    });
+  });
+});

libs/providers/go-feature-flag/src/lib/go-feature-flag-provider-options.ts

@@ -1,18 +1,7 @@
 import type { EvaluationType, ExporterMetadata } from './model';
 import type { FetchAPI } from './helper/fetch-api';
 
-export interface GoFeatureFlagProviderOptions {
-  /**
-   * The endpoint of the GO Feature Flag relay-proxy.
-   */
-  endpoint: string;
-
-  /**
-   * The type of evaluation to use.
-   * @default EvaluationType.InProcess
-   */
-  evaluationType?: EvaluationType;
-
+export interface GoFeatureFlagProviderBaseOptions {
   /**
    * The timeout for HTTP requests in milliseconds.
    * @default 10000
@@ -67,3 +56,28 @@ export interface GoFeatureFlagProviderOptions {
    */
   wasmBinaryPath?: string;
 }
+
+/**
+ * The evaluation type remote does not require an endpoint, because it can be
+ * set by the environment variable OFREP_ENDPOINT.
+ */
+export type GoFeatureFlagProviderOptions = GoFeatureFlagProviderBaseOptions &
+  (
+    | {
+        /**
+         * The endpoint of the GO Feature Flag relay-proxy.
+         */
+        endpoint: string;
+
+        /**
+         * The type of evaluation to use.
+         * @default EvaluationType.InProcess
+         */
+        evaluationType?: Omit<EvaluationType, 'Remote'>;
+      }
+    | {
+        endpoint?: string;
+
+        evaluationType: EvaluationType.Remote;
+      }
+  );

libs/providers/go-feature-flag/src/lib/go-feature-flag-provider.test.ts

@@ -65,6 +65,28 @@ describe('GoFeatureFlagProvider', () => {
       expect(() => new GoFeatureFlagProvider(undefined as any)).toThrow('No options provided');
     });
 
+    it('should not throw InvalidOptionsException when EvaluationType is Remote', () => {
+      expect(
+        () =>
+          new GoFeatureFlagProvider({
+            evaluationType: EvaluationType.Remote,
+          }),
+      ).toThrow('The given OFREP URL "" is not a valid URL.');
+    });
+
+    it('should not throw exception when EvaluationType is Remote and env variable is set', () => {
+      process.env['OFREP_ENDPOINT'] = 'https://api.example.com';
+
+      expect(
+        () =>
+          new GoFeatureFlagProvider({
+            evaluationType: EvaluationType.Remote,
+          }),
+      ).not.toThrow();
+
+      delete process.env['OFREP_ENDPOINT'];
+    });
+
     it('should throw InvalidOptionsException when endpoint is null', () => {
       expect(
         () =>

libs/providers/go-feature-flag/src/lib/go-feature-flag-provider.ts

@@ -157,17 +157,19 @@ export class GoFeatureFlagProvider implements Provider, Tracking {
       throw new InvalidOptionsException('No options provided');
     }
 
-    if (!options.endpoint || options.endpoint.trim() === '') {
+    if ((!options.endpoint || options.endpoint.trim() === '') && options.evaluationType !== EvaluationType.Remote) {
       throw new InvalidOptionsException('endpoint is a mandatory field when initializing the provider');
     }
 
-    try {
-      const url = new URL(options.endpoint);
-      if (url.protocol !== 'http:' && url.protocol !== 'https:') {
+    if (options.evaluationType !== EvaluationType.Remote && options.endpoint !== undefined) {
+      try {
+        const url = new URL(options.endpoint);
+        if (url.protocol !== 'http:' && url.protocol !== 'https:') {
+          throw new InvalidOptionsException('endpoint must be a valid URL (http or https)');
+        }
+      } catch {
         throw new InvalidOptionsException('endpoint must be a valid URL (http or https)');
       }
-    } catch {
-      throw new InvalidOptionsException('endpoint must be a valid URL (http or https)');
     }
 
     if (options.flagChangePollingIntervalMs !== undefined && options.flagChangePollingIntervalMs <= 0) {

libs/providers/go-feature-flag/src/lib/service/api.ts

@@ -41,7 +41,7 @@ export class GoFeatureFlagApi {
       throw new InvalidOptionsException('Options cannot be null');
     }
 
-    this.endpoint = options.endpoint;
+    this.endpoint = options.endpoint!;
     this.timeout = options.timeout || 10000;
     this.apiKey = options.apiKey;
     this.fetchImplementation = options.fetchImplementation || isomorphicFetch();

libs/providers/ofrep/README.md

@@ -29,6 +29,26 @@ import { OFREPProvider } from '@openfeature/ofrep-provider';
 OpenFeature.setProvider(new OFREPProvider({ baseUrl: 'https://localhost:8080' }));
 ```
 
+### Environment Variables
+
+The provider supports environment variables for default configuration. These are used when options are not explicitly provided:
+
+| Environment Variable | Description                                         | Example                                      |
+| -------------------- | --------------------------------------------------- | -------------------------------------------- |
+| `OFREP_ENDPOINT`     | The endpoint of the GO Feature Flag relay-proxy     | `http://localhost:2321`                      |
+| `OFREP_TIMEOUT_MS`   | HTTP request timeout in milliseconds                | `5000`                                       |
+| `OFREP_HEADERS`      | Additional headers as comma-separated key=value pairs | `Authentication=Bearer 123,Content-Type=json` |
+
+#### Example using environment variables:
+
+```bash
+export OFREP_ENDPOINT=http://localhost:2321
+export OFREP_TIMEOUT_MS=5000
+export OFREP_HEADERS=Authentication=Bearer 123,Content-Type=json
+```
+
+**Note**: Explicitly provided options always take precedence over environment variables.
+
 ### HTTP headers
 
 The provider can use headers from either a static header map or a custom header factory.

libs/providers/ofrep/src/lib/configuration.spec.ts

@@ -0,0 +1,171 @@
+import type { OFREPProviderBaseOptions } from '@openfeature/ofrep-core';
+import { getConfig } from './configuration';
+
+describe('Configuration', () => {
+  const OLD_ENV = process.env;
+
+  beforeEach(() => {
+    jest.resetModules();
+    process.env = { ...OLD_ENV };
+  });
+
+  afterEach(() => {
+    process.env = OLD_ENV;
+  });
+
+  describe('getConfig', () => {
+    it('should return empty config when no options or env vars are provided', () => {
+      const config = getConfig();
+      expect(config).toEqual({
+        baseUrl: '',
+        headers: undefined,
+      });
+    });
+
+    it('should use environment variables as defaults', () => {
+      process.env['OFREP_ENDPOINT'] = 'https://api.example.com';
+      process.env['OFREP_TIMEOUT_MS'] = '5000';
+      process.env['OFREP_HEADERS'] = 'X-Custom-Header=value1,X-Another=value2';
+
+      const config = getConfig();
+
+      expect(config.baseUrl).toBe('https://api.example.com');
+      expect(config.timeoutMs).toBe(5000);
+      expect(config.headers).toStrictEqual([
+        ['x-custom-header', 'value1'],
+        ['x-another', 'value2'],
+      ]);
+    });
+
+    it('should override environment variables with provided options', () => {
+      process.env['OFREP_ENDPOINT'] = 'https://api.example.com';
+      process.env['OFREP_TIMEOUT_MS'] = '5000';
+
+      const options: OFREPProviderBaseOptions = {
+        baseUrl: 'https://override.example.com',
+        timeoutMs: 10000,
+      };
+
+      const config = getConfig(options);
+
+      expect(config.baseUrl).toBe('https://override.example.com');
+      expect(config.timeoutMs).toBe(10000);
+    });
+
+    it('should handle invalid timeoutMs value in environment variable', () => {
+      process.env['OFREP_TIMEOUT_MS'] = 'invalid';
+
+      const config = getConfig();
+
+      expect(config.timeoutMs).toBeUndefined();
+    });
+
+    it('should parse fully URL-encoded headers', () => {
+      // Encoded: "Authorization=Bearer token123,X-Custom=value with spaces"
+      process.env['OFREP_HEADERS'] = 'Authorization%3DBearer%20token123%2CX-Custom%3Dvalue%20with%20spaces';
+
+      const config = getConfig();
+
+      expect(config.headers).toStrictEqual([
+        ['authorization', 'Bearer token123'],
+        ['x-custom', 'value with spaces'],
+      ]);
+    });
+
+    it('should parse partially URL-encoded headers (commas not encoded)', () => {
+      // Only values are encoded, commas are not
+      process.env['OFREP_HEADERS'] = 'Authorization=Bearer%20token123,X-Custom=value%20with%20spaces';
+
+      const config = getConfig();
+
+      expect(config.headers).toStrictEqual([
+        ['authorization', 'Bearer token123'],
+        ['x-custom', 'value with spaces'],
+      ]);
+    });
+
+    it('should handle header values containing equals signs', () => {
+      process.env['OFREP_HEADERS'] = 'X-Signature=key=value=another,Authorization=Bearer token';
+
+      const config = getConfig();
+
+      expect(config.headers).toStrictEqual([
+        ['x-signature', 'key=value=another'],
+        ['authorization', 'Bearer token'],
+      ]);
+    });
+
+    it('should handle URL-encoded header values with equals signs', () => {
+      // Encoded: "X-Data=param1=value1&param2=value2"
+      process.env['OFREP_HEADERS'] = 'X-Data=param1%3Dvalue1%26param2%3Dvalue2';
+
+      const config = getConfig();
+
+      expect(config.headers).toStrictEqual([['x-data', 'param1=value1&param2=value2']]);
+    });
+
+    it('should skip malformed headers without equals sign and log warning', () => {
+      const consoleSpy = jest.spyOn(console, 'warn').mockImplementation();
+      process.env['OFREP_HEADERS'] = 'ValidHeader=value,InvalidHeader,AnotherValid=value2';
+
+      const config = getConfig();
+
+      expect(config.headers).toStrictEqual([
+        ['validheader', 'value'],
+        ['anothervalid', 'value2'],
+      ]);
+      expect(consoleSpy).toHaveBeenCalledWith('Skipping malformed header entry (missing equals sign): "InvalidHeader"');
+      consoleSpy.mockRestore();
+    });
+
+    it('should skip headers with empty keys and log warning', () => {
+      const consoleSpy = jest.spyOn(console, 'warn').mockImplementation();
+      process.env['OFREP_HEADERS'] = 'ValidHeader=value,=valueWithoutKey,AnotherValid=value2';
+
+      const config = getConfig();
+
+      expect(config.headers).toStrictEqual([
+        ['validheader', 'value'],
+        ['anothervalid', 'value2'],
+      ]);
+      expect(consoleSpy).toHaveBeenCalledWith('Skipping malformed header entry (missing key): "=valueWithoutKey"');
+      consoleSpy.mockRestore();
+    });
+
+    it('should skip headers with whitespace-only keys and log warning', () => {
+      const consoleSpy = jest.spyOn(console, 'warn').mockImplementation();
+      process.env['OFREP_HEADERS'] = 'ValidHeader=value,  =valueWithSpaceKey,AnotherValid=value2';
+
+      const config = getConfig();
+
+      expect(config.headers).toStrictEqual([
+        ['validheader', 'value'],
+        ['anothervalid', 'value2'],
+      ]);
+      expect(consoleSpy).toHaveBeenCalledWith('Skipping malformed header entry (missing key): "  =valueWithSpaceKey"');
+      consoleSpy.mockRestore();
+    });
+
+    it('should allow headers with empty values', () => {
+      process.env['OFREP_HEADERS'] = 'X-Empty=,X-Valid=value';
+
+      const config = getConfig();
+
+      expect(config.headers).toStrictEqual([
+        ['x-empty', ''],
+        ['x-valid', 'value'],
+      ]);
+    });
+
+    it('should trim whitespace from keys and values', () => {
+      process.env['OFREP_HEADERS'] = '  X-Header1  =  value1  ,  X-Header2  =  value2  ';
+
+      const config = getConfig();
+
+      expect(config.headers).toStrictEqual([
+        ['x-header1', 'value1'],
+        ['x-header2', 'value2'],
+      ]);
+    });
+  });
+});