Merge branch 'main' into release-please--branches--main--components--ofrep-provider

Author: lukas-reining

libs/providers/flagd/package.json

@@ -7,7 +7,7 @@
     "current-version": "echo $npm_package_version"
   },
   "peerDependencies": {
-    "@grpc/grpc-js": "~1.8.0 || ~1.9.0 || ~1.10.0 || ~1.11.0 || ~1.12.0 || ~1.13.0",
+    "@grpc/grpc-js": "~1.8.0 || ~1.9.0 || ~1.10.0 || ~1.11.0 || ~1.12.0 || ~1.13.0 || ~1.14.0",
     "@openfeature/server-sdk": "^1.17.0"
   },
   "dependencies": {

libs/providers/flagd/src/e2e/constants.ts

@@ -1,19 +1,6 @@
 import { getGherkinTestPath } from '@openfeature/flagd-core';
 
-export const FLAGD_NAME = 'flagd';
 export const UNSTABLE_CLIENT_NAME = 'unstable';
 export const UNAVAILABLE_CLIENT_NAME = 'unavailable';
 
 export const GHERKIN_FLAGD = getGherkinTestPath('*.feature');
-export const CONNECTION_FEATURE = getGherkinTestPath('connection.feature');
-export const CONTEXT_ENRICHMENT_FEATURE = getGherkinTestPath('contextEnrichment.feature');
-export const EVALUATION_FEATURE = getGherkinTestPath('evaluation.feature');
-export const EVENTS_FEATURE = getGherkinTestPath('events.feature');
-export const METADATA_FEATURE = getGherkinTestPath('metadata.feature');
-export const RPC_CACHING_FEATURE = getGherkinTestPath('rpc-caching.feature');
-export const SELECTOR_FEATURE = getGherkinTestPath('selector.feature');
-export const TARGETING_FEATURE = getGherkinTestPath('targeting.feature');
-export const GHERKIN_EVALUATION_FEATURE = getGherkinTestPath(
-  'evaluation.feature',
-  'spec/specification/assets/gherkin/',
-);

libs/providers/flagd/src/e2e/step-definitions/providerSteps.ts

@@ -1,3 +1,4 @@
+import { ProviderStatus } from '@openfeature/server-sdk';
 import { OpenFeature } from '@openfeature/server-sdk';
 import { FlagdContainer } from '../tests/flagdContainer';
 import type { State, Steps } from './state';
@@ -6,7 +7,7 @@ import type { FlagdProviderOptions } from '../../lib/configuration';
 
 export const providerSteps: Steps =
   (state: State) =>
-  ({ given, when, then }) => {
+  ({ given, when, then, and }) => {
     const container: FlagdContainer = FlagdContainer.build();
     beforeAll(async () => {
       console.log('Setting flagd provider...');
@@ -33,26 +34,29 @@ export const providerSteps: Steps =
       const flagdOptions: FlagdProviderOptions = {
         resolverType: state.resolverType,
         deadlineMs: 2000,
+        ...state.config,
+        ...state.options,
       };
+
       let type = 'default';
       switch (providerType) {
-        default:
-          flagdOptions['port'] = container.getPort(state.resolverType);
-          if (state?.options?.['selector']) {
-            flagdOptions['selector'] = state?.options?.['selector'] as string;
-          }
-          break;
         case 'unavailable':
           flagdOptions['port'] = 9999;
           break;
         case 'ssl':
           // TODO: modify this to support ssl
           flagdOptions['port'] = container.getPort(state.resolverType);
-          if (state?.config?.selector) {
-            flagdOptions['selector'] = state.config.selector;
-          }
           type = 'ssl';
           break;
+        case 'stable':
+          flagdOptions['port'] = container.getPort(state.resolverType);
+          break;
+        case 'syncpayload':
+          flagdOptions['port'] = container.getPort(state.resolverType);
+          type = 'sync-payload';
+          break;
+        default:
+          throw new Error('unknown provider type: ' + providerType);
       }
 
       await fetch('http://' + container.getLaunchpadUrl() + '/start?config=' + type);
@@ -67,6 +71,21 @@ export const providerSteps: Steps =
       state.providerType = providerType;
     });
 
+    function mapProviderState(state: string): ProviderStatus {
+      const mappedState = state.toUpperCase().replace('-', '_');
+      const status = Object.values(ProviderStatus).find((s) => s === mappedState);
+
+      if (!status) {
+        throw new Error(`Unknown provider status: ${state}`);
+      }
+
+      return status;
+    }
+
+    then(/^the client should be in (.*) state/, (providerState: string) => {
+      expect(state.client?.providerStatus).toBe(mapProviderState(providerState));
+    });
+
     when(/^the connection is lost for (\d+)s$/, async (time) => {
       console.log('stopping flagd');
       await fetch('http://' + container.getLaunchpadUrl() + '/restart?seconds=' + time);

libs/providers/flagd/src/e2e/step-definitions/utils.ts

@@ -19,6 +19,8 @@ export function mapValueToType(value: string, type: string): any {
       return value.toLowerCase() as ResolverType;
     case 'CacheType':
       return value as CacheOption;
+    case 'StringList':
+      return value.split(',').map((item) => item.trim());
     case 'Object':
       if (value == 'null') {
         return undefined;

libs/providers/flagd/src/e2e/tests/in-process.spec.ts

@@ -22,7 +22,7 @@ describe('in-process', () => {
       // remove filters as we add support for features
       // see: https://github.com/open-feature/js-sdk-contrib/issues/1096 and child issues
       tagFilter:
-        '@in-process and not @targetURI and not @customCert and not @events and not @sync and not @grace and not @metadata and not @contextEnrichment',
+        '@in-process and not @targetURI and not @forbidden and not @customCert and not @events and not @sync and not @grace and not @metadata and not @unixsocket',
       scenarioNameTemplate: (vars) => {
         return `${vars.scenarioTitle} (${vars.scenarioTags.join(',')} ${vars.featureTags.join(',')})`;
       },

libs/providers/flagd/src/e2e/tests/rpc.spec.ts

@@ -23,7 +23,7 @@ describe('rpc', () => {
       tagFilter:
         // remove filters as we add support for features
         // see: https://github.com/open-feature/js-sdk-contrib/issues/1096 and child issues
-        '@rpc and not @targetURI and not @customCert and not @events and not @stream and not @grace and not @metadata and not @contextEnrichment and not @caching',
+        '@rpc and not @targetURI and not @customCert and not @forbidden and not @events and not @stream and not @grace and not @metadata and not @caching and not @unixsocket',
       scenarioNameTemplate: (vars) => {
         return `${vars.scenarioTitle} (${vars.scenarioTags.join(',')} ${vars.featureTags.join(',')})`;
       },

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

@@ -0,0 +1,13 @@
+import type { Hook, EvaluationContext, BeforeHookContext, HookHints } from '@openfeature/server-sdk';
+
+export class SyncMetadataHook implements Hook {
+  enrichedContext: () => EvaluationContext;
+
+  constructor(enrichedContext: () => EvaluationContext) {
+    this.enrichedContext = enrichedContext;
+  }
+
+  public before(hookContext: BeforeHookContext, hookHints?: HookHints): EvaluationContext {
+    return this.enrichedContext();
+  }
+}

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

@@ -1,6 +1,7 @@
 import type { Config, FlagdProviderOptions } from './configuration';
 import { getConfig } from './configuration';
 import { DEFAULT_MAX_CACHE_SIZE } from './constants';
+import type { EvaluationContext } from '@openfeature/server-sdk';
 
 describe('Configuration', () => {
   const OLD_ENV = process.env;
@@ -20,6 +21,7 @@ describe('Configuration', () => {
       resolverType: 'rpc',
       selector: '',
       deadlineMs: 500,
+      contextEnricher: expect.any(Function),
     });
   });
 
@@ -46,22 +48,53 @@ describe('Configuration', () => {
     process.env['FLAGD_OFFLINE_FLAG_SOURCE_PATH'] = offlineFlagSourcePath;
     process.env['FLAGD_DEFAULT_AUTHORITY'] = defaultAuthority;
 
-    expect(getConfig()).toStrictEqual({
-      host,
-      port,
-      tls,
-      socketPath,
-      maxCacheSize,
-      cache,
-      resolverType,
-      selector,
-      offlineFlagSourcePath,
-      defaultAuthority,
-      deadlineMs: 500,
-    });
+    expect(getConfig()).toEqual(
+      expect.objectContaining({
+        host,
+        port,
+        tls,
+        socketPath,
+        maxCacheSize,
+        cache,
+        resolverType,
+        selector,
+        offlineFlagSourcePath,
+        defaultAuthority,
+        deadlineMs: 500,
+      }),
+    );
+  });
+
+  it('should override context enricher', () => {
+    const contextEnricher = (syncContext: EvaluationContext | null): EvaluationContext => {
+      return { ...syncContext, extraKey: 'extraValue' };
+    };
+
+    expect(getConfig({ contextEnricher }).contextEnricher({})).toEqual({ extraKey: 'extraValue' });
+  });
+
+  it('should return identity function', () => {
+    expect(getConfig().contextEnricher({})).toStrictEqual({});
+  });
+
+  it('should use flagd sync port over flagd port environment option', () => {
+    const port = 8080;
+    const syncPort = 9090;
+
+    process.env['FLAGD_PORT'] = `${port}`;
+    process.env['FLAGD_SYNC_PORT'] = `${syncPort}`;
+
+    expect(getConfig()).toStrictEqual(
+      expect.objectContaining({
+        port: syncPort,
+      }),
+    );
   });
 
   it('should use incoming options over defaults and environment variable', () => {
+    const contextEnricher = (syncContext: EvaluationContext | null): EvaluationContext => {
+      return { ...syncContext, extraKey: 'extraValue' };
+    };
     const options: FlagdProviderOptions = {
       host: 'test',
       port: 3000,
@@ -72,10 +105,12 @@ describe('Configuration', () => {
       selector: '',
       defaultAuthority: '',
       deadlineMs: 500,
+      contextEnricher: contextEnricher,
     };
 
     process.env['FLAGD_HOST'] = 'override';
     process.env['FLAGD_PORT'] = '8080';
+    process.env['FLAGD_SYNC_PORT'] = '9090';
     process.env['FLAGD_TLS'] = 'false';
     process.env['FLAGD_DEFAULT_AUTHORITY'] = 'test-authority-override';
 
@@ -87,6 +122,11 @@ describe('Configuration', () => {
     expect(getConfig()).toStrictEqual(expect.objectContaining({ port: 8013 }));
   });
 
+  it('should ignore an invalid sync port set as an environment variable', () => {
+    process.env['FLAGD_SYNC_PORT'] = 'invalid number';
+    expect(getConfig()).toStrictEqual(expect.objectContaining({ port: 8013 }));
+  });
+
   describe('port handling', () => {
     describe('for "in-process" evaluation', () => {
       const resolverType = 'in-process';

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

@@ -1,4 +1,5 @@
 import { DEFAULT_MAX_CACHE_SIZE } from './constants';
+import type { EvaluationContext } from '@openfeature/server-sdk';
 
 export type CacheOption = 'lru' | 'disabled';
 export type ResolverType = 'rpc' | 'in-process';
@@ -83,24 +84,39 @@ export interface Config {
   defaultAuthority?: string;
 }
 
-export type FlagdProviderOptions = Partial<Config>;
+interface FlagdConfig extends Config {
+  /**
+   * Function providing an EvaluationContext to mix into every evaluation.
+   * The syncContext from the SyncFlagsResponse
+   * (https://buf.build/open-feature/flagd/docs/main:flagd.sync.v1#flagd.sync.v1.SyncFlagsResponse),
+   * represented as a {@link dev.openfeature.sdk.Structure}, is passed as an argument.
+   *
+   * This function runs every time the provider (re)connects, and its result is cached and used in every evaluation.
+   * By default, the entire sync response (as a JSON Object) is used.
+   */
+  contextEnricher: (syncContext: EvaluationContext | null) => EvaluationContext;
+}
+
+export type FlagdProviderOptions = Partial<FlagdConfig>;
 
-const DEFAULT_CONFIG: Omit<Config, 'port' | 'resolverType'> = {
+const DEFAULT_CONFIG: Omit<FlagdConfig, 'port' | 'resolverType'> = {
   deadlineMs: 500,
   host: 'localhost',
   tls: false,
   selector: '',
   cache: 'lru',
   maxCacheSize: DEFAULT_MAX_CACHE_SIZE,
+  contextEnricher: (syncContext: EvaluationContext | null) => syncContext ?? {},
 };
 
-const DEFAULT_RPC_CONFIG: Config = { ...DEFAULT_CONFIG, resolverType: 'rpc', port: 8013 };
+const DEFAULT_RPC_CONFIG: FlagdConfig = { ...DEFAULT_CONFIG, resolverType: 'rpc', port: 8013 };
 
-const DEFAULT_IN_PROCESS_CONFIG: Config = { ...DEFAULT_CONFIG, resolverType: 'in-process', port: 8015 };
+const DEFAULT_IN_PROCESS_CONFIG: FlagdConfig = { ...DEFAULT_CONFIG, resolverType: 'in-process', port: 8015 };
 
 enum ENV_VAR {
   FLAGD_HOST = 'FLAGD_HOST',
   FLAGD_PORT = 'FLAGD_PORT',
+  FLAGD_SYNC_PORT = 'FLAGD_SYNC_PORT',
   FLAGD_DEADLINE_MS = 'FLAGD_DEADLINE_MS',
   FLAGD_TLS = 'FLAGD_TLS',
   FLAGD_SOCKET_PATH = 'FLAGD_SOCKET_PATH',
@@ -137,6 +153,9 @@ const getEnvVarConfig = (): Partial<Config> => {
     ...(Number(process.env[ENV_VAR.FLAGD_PORT]) && {
       port: Number(process.env[ENV_VAR.FLAGD_PORT]),
     }),
+    ...(Number(process.env[ENV_VAR.FLAGD_SYNC_PORT]) && {
+      port: Number(process.env[ENV_VAR.FLAGD_SYNC_PORT]),
+    }),
     ...(Number(process.env[ENV_VAR.FLAGD_DEADLINE_MS]) && {
       deadlineMs: Number(process.env[ENV_VAR.FLAGD_DEADLINE_MS]),
     }),
@@ -167,7 +186,7 @@ const getEnvVarConfig = (): Partial<Config> => {
   };
 };
 
-export function getConfig(options: FlagdProviderOptions = {}) {
+export function getConfig(options: FlagdProviderOptions = {}): FlagdConfig {
   const envVarConfig = getEnvVarConfig();
   const defaultConfig =
     options.resolverType == 'in-process' || envVarConfig.resolverType == 'in-process'

libs/providers/flagd/src/lib/flagd-provider.ts

@@ -5,14 +5,18 @@ import { getConfig } from './configuration';
 import { GRPCService } from './service/grpc/grpc-service';
 import type { Service } from './service/service';
 import { InProcessService } from './service/in-process/in-process-service';
+import type { Hook } from '@openfeature/server-sdk';
+import { SyncMetadataHook } from './SyncMetadataHook';
 
 export class FlagdProvider implements Provider {
   metadata = {
     name: 'flagd',
   };
 
+  readonly hooks?: Hook[];
   readonly runsOn = 'server';
   readonly events = new OpenFeatureEventEmitter();
+  private syncContext: EvaluationContext | null = null;
 
   private readonly _service: Service;
 
@@ -30,11 +34,27 @@ export class FlagdProvider implements Provider {
   ) {
     const config = getConfig(options);
 
-    this._service = service
-      ? service
-      : config.resolverType === 'in-process'
-        ? new InProcessService(config, undefined, logger)
-        : new GRPCService(config, undefined, logger);
+    if (service === undefined) {
+      if (config.resolverType === 'in-process') {
+        this._service = new InProcessService(config, this.setSyncContext.bind(this), undefined, logger);
+
+        if (config?.offlineFlagSourcePath === undefined) {
+          this.hooks = [new SyncMetadataHook(() => config.contextEnricher(this.getSyncContext()))];
+        }
+      } else {
+        this._service = new GRPCService(config, undefined, logger);
+      }
+    } else {
+      this._service = service;
+    }
+  }
+
+  setSyncContext(context: EvaluationContext) {
+    this.syncContext = context;
+  }
+
+  getSyncContext(): EvaluationContext | null {
+    return this.syncContext;
   }
 
   async initialize(): Promise<void> {