feat(multi-provider): Add Track Method Support to Multi-Provider (#1323)

Signed-off-by: Jonathan Norris <jonathan@taplytics.com>

.eslintrc.json

@@ -7,6 +7,14 @@
     {
       "files": ["*.ts", "*.tsx", "*.js", "*.jsx"],
       "rules": {
+        "@typescript-eslint/consistent-type-imports": [
+          "error",
+          {
+            "disallowTypeAnnotations": true,
+            "fixStyle": "separate-type-imports",
+            "prefer": "type-imports"
+          }
+        ],
         "@nx/enforce-module-boundaries": [
           "error",
           {
@@ -56,7 +64,7 @@
             "checkObsoleteDependencies": true,
             "checkVersionMismatches": true,
             "ignoredDependencies": ["jest-cucumber", "jest"],
-            "ignoredFiles": ["**/test/**", "**/spec/**", "**/*.spec.ts", "**/*.spec.js", "**/*.test.ts", "**/*.test.js"]
+            "ignoredFiles": ["**/test/**", "**/tests/*", "**/spec/**", "**/*.spec.ts", "**/*.spec.js", "**/*.test.ts", "**/*.test.js", "**/jest.*"]
           }
         ]
       }

.github/workflows/ci.yml

@@ -14,14 +14,14 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        node-version: [18.x, 20.x, 22.x]
+        node-version: [20.x, 22.x, 24.x]
     steps:
       - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
         with:
           fetch-depth: 0
           submodules: recursive
       - name: Use Node.js ${{ matrix.node-version }}
-        uses: actions/setup-node@cdca7365b2dadb8aad0a33bc7601856ffabcc48e # v4
+        uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4
         with:
           node-version: ${{ matrix.node-version }}
 
@@ -43,10 +43,9 @@ jobs:
           with:
             fetch-depth: 0
             submodules: recursive
-        - uses: actions/setup-node@cdca7365b2dadb8aad0a33bc7601856ffabcc48e # v4
+        - uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4
           with:
-            # we need 'fetch' for this test, which is only in 18+
-            node-version: 18
+            node-version: 20
             cache: 'npm'
 
         - name: Install

.github/workflows/release-please.yml

@@ -5,6 +5,7 @@ on:
 name: Run Release Please
 jobs:
   release-please:
+    environment: publish
     runs-on: ubuntu-latest
 
     # Release-please creates a PR that tracks all changes
@@ -28,10 +29,10 @@ jobs:
         with:
           github_token: ${{ github.token }}
       - name: Setup Node
-        uses: actions/setup-node@cdca7365b2dadb8aad0a33bc7601856ffabcc48e # v4
+        uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4
         if: ${{ steps.release.outputs.releases_created }}
         with:
-          node-version: 18
+          node-version: 20
           registry-url: "https://registry.npmjs.org"
       - name: Build Packages
         if: ${{ steps.release.outputs.releases_created }}

.gitmodules

@@ -13,7 +13,7 @@
 [submodule "libs/shared/flagd-core/test-harness"]
 	path = libs/shared/flagd-core/test-harness
 	url = https://github.com/open-feature/flagd-testbed
-	branch = v0.5.21
+	branch = v2.8.0
 [submodule "libs/shared/flagd-core/spec"]
 	path = libs/shared/flagd-core/spec
 	url = https://github.com/open-feature/spec

.release-please-manifest.json

@@ -1,19 +1,19 @@
 {
   "libs/hooks/open-telemetry": "0.4.0",
-  "libs/providers/go-feature-flag": "0.7.7",
+  "libs/providers/go-feature-flag": "0.7.8",
   "libs/providers/flagd": "0.13.3",
   "libs/providers/flagd-web": "0.7.3",
   "libs/providers/env-var": "0.3.1",
-  "libs/providers/config-cat": "0.7.5",
+  "libs/providers/config-cat": "0.7.6",
   "libs/providers/launchdarkly-client": "0.3.2",
-  "libs/providers/go-feature-flag-web": "0.2.5",
-  "libs/shared/flagd-core": "1.0.0",
+  "libs/providers/go-feature-flag-web": "0.2.6",
+  "libs/shared/flagd-core": "1.1.0",
   "libs/shared/ofrep-core": "1.0.1",
   "libs/providers/ofrep": "0.2.1",
-  "libs/providers/ofrep-web": "0.3.2",
+  "libs/providers/ofrep-web": "0.3.3",
   "libs/providers/flipt": "0.1.3",
   "libs/providers/flagsmith-client": "0.1.3",
-  "libs/providers/flipt-web": "0.1.3",
+  "libs/providers/flipt-web": "0.1.5",
   "libs/providers/multi-provider": "0.1.2",
   "libs/providers/multi-provider-web": "0.0.3",
   "libs/providers/growthbook-client": "0.1.2",
@@ -21,5 +21,5 @@
   "libs/shared/config-cat-core": "0.1.1",
   "libs/providers/unleash-web": "0.1.1",
   "libs/providers/growthbook": "0.1.2",
-  "libs/providers/aws-ssm": "0.1.2"
+  "libs/providers/aws-ssm": "0.1.3"
 }

libs/hooks/open-telemetry/src/lib/metrics/metrics-hook.spec.ts

@@ -1,6 +1,8 @@
-import { BeforeHookContext, EvaluationDetails, HookContext, StandardResolutionReasons } from '@openfeature/server-sdk';
+import type { BeforeHookContext, EvaluationDetails, HookContext } from '@openfeature/server-sdk';
+import { StandardResolutionReasons } from '@openfeature/server-sdk';
 import opentelemetry from '@opentelemetry/api';
-import { DataPoint, MeterProvider, MetricReader, ScopeMetrics } from '@opentelemetry/sdk-metrics';
+import type { DataPoint, ScopeMetrics } from '@opentelemetry/sdk-metrics';
+import { MeterProvider, MetricReader } from '@opentelemetry/sdk-metrics';
 import {
   ACTIVE_COUNT_NAME,
   ERROR_TOTAL_NAME,
@@ -12,7 +14,7 @@ import {
   VARIANT_ATTR,
 } from '../conventions';
 import { MetricsHook } from './metrics-hook';
-import { AttributeMapper } from '../otel-hook';
+import type { AttributeMapper } from '../otel-hook';
 
 // no-op "in-memory" reader
 class InMemoryMetricReader extends MetricReader {

libs/hooks/open-telemetry/src/lib/metrics/metrics-hook.ts

@@ -1,19 +1,18 @@
+import type { BeforeHookContext, Logger } from '@openfeature/server-sdk';
 import {
-  BeforeHookContext,
-  Logger,
   StandardResolutionReasons,
   type EvaluationDetails,
   type FlagValue,
   type Hook,
   type HookContext,
 } from '@openfeature/server-sdk';
-import { Attributes, Counter, UpDownCounter, ValueType, metrics } from '@opentelemetry/api';
+import type { Attributes, Counter, UpDownCounter } from '@opentelemetry/api';
+import { ValueType, metrics } from '@opentelemetry/api';
+import type { EvaluationAttributes, ExceptionAttributes } from '../conventions';
 import {
   ACTIVE_COUNT_NAME,
   ERROR_TOTAL_NAME,
   EXCEPTION_ATTR,
-  EvaluationAttributes,
-  ExceptionAttributes,
   KEY_ATTR,
   PROVIDER_NAME_ATTR,
   REASON_ATTR,
@@ -21,7 +20,8 @@ import {
   SUCCESS_TOTAL_NAME,
   VARIANT_ATTR,
 } from '../conventions';
-import { OpenTelemetryHook, OpenTelemetryHookOptions } from '../otel-hook';
+import type { OpenTelemetryHookOptions } from '../otel-hook';
+import { OpenTelemetryHook } from '../otel-hook';
 
 type ErrorEvaluationAttributes = EvaluationAttributes & ExceptionAttributes;
 

libs/hooks/open-telemetry/src/lib/otel-hook.ts

@@ -1,5 +1,5 @@
-import { FlagMetadata, Logger } from '@openfeature/server-sdk';
-import { Attributes } from '@opentelemetry/api';
+import type { FlagMetadata, Logger } from '@openfeature/server-sdk';
+import type { Attributes } from '@opentelemetry/api';
 
 export type AttributeMapper = (flagMetadata: FlagMetadata) => Attributes;
 

libs/hooks/open-telemetry/src/lib/traces/tracing-hook.spec.ts

@@ -1,4 +1,4 @@
-import { EvaluationDetails, HookContext } from '@openfeature/server-sdk';
+import type { EvaluationDetails, HookContext } from '@openfeature/server-sdk';
 
 const addEvent = jest.fn();
 const recordException = jest.fn();

libs/hooks/open-telemetry/src/lib/traces/tracing-hook.ts

@@ -1,7 +1,8 @@
-import { Hook, HookContext, EvaluationDetails, FlagValue, Logger } from '@openfeature/server-sdk';
+import type { Hook, HookContext, EvaluationDetails, FlagValue, Logger } from '@openfeature/server-sdk';
 import { trace } from '@opentelemetry/api';
 import { FEATURE_FLAG, KEY_ATTR, PROVIDER_NAME_ATTR, VARIANT_ATTR } from '../conventions';
-import { OpenTelemetryHook, OpenTelemetryHookOptions } from '../otel-hook';
+import type { OpenTelemetryHookOptions } from '../otel-hook';
+import { OpenTelemetryHook } from '../otel-hook';
 
 export type TracingHookOptions = OpenTelemetryHookOptions;
 

libs/providers/aws-ssm/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## [0.1.3](https://github.com/open-feature/js-sdk-contrib/compare/aws-ssm-provider-v0.1.2...aws-ssm-provider-v0.1.3) (2025-06-04)
+
+
+### 🐛 Bug Fixes
+
+* **deps:** update dependency @aws-sdk/client-ssm to v3.787.0 ([#1278](https://github.com/open-feature/js-sdk-contrib/issues/1278)) ([afae82c](https://github.com/open-feature/js-sdk-contrib/commit/afae82c1a1472d33b884105edaac2976c19e7423))
+* **deps:** update dependency lru-cache to v11.1.0 ([#1279](https://github.com/open-feature/js-sdk-contrib/issues/1279)) ([a80f5ce](https://github.com/open-feature/js-sdk-contrib/commit/a80f5ce3d7a6e74e762a75ba8fa9f5b70ca2a179))
+
 ## [0.1.2](https://github.com/open-feature/js-sdk-contrib/compare/aws-ssm-provider-v0.1.1...aws-ssm-provider-v0.1.2) (2025-03-27)
 
 

libs/providers/aws-ssm/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openfeature/aws-ssm-provider",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "dependencies": {
     "@aws-sdk/client-ssm": "^3.759.0",
     "lru-cache": "^11.0.2",

libs/providers/aws-ssm/src/integration/integration.spec.ts

@@ -1,6 +1,7 @@
 import { OpenFeature } from '@openfeature/server-sdk';
 import { AwsSsmProvider } from '../lib/aws-ssm-provider';
-import { GetParameterCommand, GetParameterCommandOutput, SSMClient } from '@aws-sdk/client-ssm';
+import type { GetParameterCommandOutput } from '@aws-sdk/client-ssm';
+import { GetParameterCommand, SSMClient } from '@aws-sdk/client-ssm';
 import { mockClient } from 'aws-sdk-client-mock';
 
 const ssmMock = mockClient(SSMClient);

libs/providers/aws-ssm/src/lib/aws-ssm-provider.spec.ts

@@ -1,4 +1,4 @@
-import { SSMClientConfig } from '@aws-sdk/client-ssm';
+import type { SSMClientConfig } from '@aws-sdk/client-ssm';
 import { AwsSsmProvider } from './aws-ssm-provider';
 import { ErrorCode, StandardResolutionReasons } from '@openfeature/core';
 

libs/providers/aws-ssm/src/lib/aws-ssm-provider.ts

@@ -1,13 +1,7 @@
-import {
-  EvaluationContext,
-  Provider,
-  JsonValue,
-  ResolutionDetails,
-  StandardResolutionReasons,
-  ErrorCode,
-} from '@openfeature/server-sdk';
+import type { EvaluationContext, Provider, JsonValue, ResolutionDetails } from '@openfeature/server-sdk';
+import { StandardResolutionReasons, ErrorCode } from '@openfeature/server-sdk';
 import { InternalServerError } from '@aws-sdk/client-ssm';
-import { AwsSsmProviderConfig } from './types';
+import type { AwsSsmProviderConfig } from './types';
 import { SSMService } from './ssm-service';
 import { Cache } from './cache';
 

libs/providers/aws-ssm/src/lib/cache.ts

@@ -1,5 +1,5 @@
-import { ResolutionDetails } from '@openfeature/core';
-import { LRUCacheConfig } from './types';
+import type { ResolutionDetails } from '@openfeature/core';
+import type { LRUCacheConfig } from './types';
 import { LRUCache } from 'lru-cache';
 
 export class Cache {

libs/providers/aws-ssm/src/lib/ssm-service.ts

@@ -1,19 +1,8 @@
-import {
-  GetParameterCommand,
-  SSMClient,
-  SSMClientConfig,
-  GetParameterCommandInput,
-  DescribeParametersCommand,
-} from '@aws-sdk/client-ssm';
-import { ResponseMetadata } from '@smithy/types';
-import {
-  FlagNotFoundError,
-  TypeMismatchError,
-  JsonValue,
-  ParseError,
-  ResolutionDetails,
-  StandardResolutionReasons,
-} from '@openfeature/core';
+import type { SSMClientConfig, GetParameterCommandInput } from '@aws-sdk/client-ssm';
+import { GetParameterCommand, SSMClient, DescribeParametersCommand } from '@aws-sdk/client-ssm';
+import type { ResponseMetadata } from '@smithy/types';
+import type { JsonValue, ResolutionDetails } from '@openfeature/core';
+import { FlagNotFoundError, TypeMismatchError, ParseError, StandardResolutionReasons } from '@openfeature/core';
 
 export class SSMService {
   client: SSMClient;

libs/providers/aws-ssm/src/lib/types.ts

@@ -1,4 +1,4 @@
-import { SSMClientConfig } from '@aws-sdk/client-ssm';
+import type { SSMClientConfig } from '@aws-sdk/client-ssm';
 
 export type AwsSsmProviderConfig = {
   ssmClientConfig: SSMClientConfig;

libs/providers/config-cat-web/src/lib/config-cat-web-provider.spec.ts

@@ -1,14 +1,7 @@
 import { ConfigCatWebProvider } from './config-cat-web-provider';
-import {
-  createConsoleLogger,
-  createFlagOverridesFromMap,
-  HookEvents,
-  IConfigCatCache,
-  ISettingUnion,
-  LogLevel,
-  OverrideBehaviour,
-} from 'configcat-js-ssr';
-import { EventEmitter } from 'events';
+import type { HookEvents, IConfigCatCache, ISettingUnion } from 'configcat-js-ssr';
+import { createConsoleLogger, createFlagOverridesFromMap, LogLevel, OverrideBehaviour } from 'configcat-js-ssr';
+import type { EventEmitter } from 'events';
 import { ProviderEvents, ParseError, FlagNotFoundError, TypeMismatchError } from '@openfeature/web-sdk';
 
 describe('ConfigCatWebProvider', () => {

libs/providers/config-cat-web/src/lib/config-cat-web-provider.ts

@@ -1,32 +1,15 @@
+import type { EvaluationContext, JsonValue, Paradigm, Provider, ResolutionDetails } from '@openfeature/web-sdk';
 import {
-  EvaluationContext,
-  JsonValue,
   OpenFeatureEventEmitter,
-  Paradigm,
   ParseError,
-  Provider,
   ProviderEvents,
   ProviderNotReadyError,
-  ResolutionDetails,
   TypeMismatchError,
 } from '@openfeature/web-sdk';
-import {
-  isType,
-  parseError,
-  PrimitiveType,
-  PrimitiveTypeName,
-  toResolutionDetails,
-  transformContext,
-} from '@openfeature/config-cat-core';
-import {
-  ClientCacheState,
-  getClient,
-  IConfig,
-  IConfigCatClient,
-  OptionsForPollingMode,
-  PollingMode,
-  SettingValue,
-} from 'configcat-js-ssr';
+import type { PrimitiveType, PrimitiveTypeName } from '@openfeature/config-cat-core';
+import { isType, parseError, toResolutionDetails, transformContext } from '@openfeature/config-cat-core';
+import type { IConfig, IConfigCatClient, OptionsForPollingMode, SettingValue } from 'configcat-js-ssr';
+import { ClientCacheState, getClient, PollingMode } from 'configcat-js-ssr';
 
 export class ConfigCatWebProvider implements Provider {
   public readonly events = new OpenFeatureEventEmitter();

libs/providers/config-cat/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## [0.7.6](https://github.com/open-feature/js-sdk-contrib/compare/config-cat-provider-v0.7.5...config-cat-provider-v0.7.6) (2025-07-04)
+
+
+### 🐛 Bug Fixes
+
+* **security:** update dependency configcat-common to v9.4.0 ([#1348](https://github.com/open-feature/js-sdk-contrib/issues/1348)) ([601e7de](https://github.com/open-feature/js-sdk-contrib/commit/601e7de19948bc826778a076f27b46a8cb1fabca))
+
 ## [0.7.5](https://github.com/open-feature/js-sdk-contrib/compare/config-cat-provider-v0.7.4...config-cat-provider-v0.7.5) (2025-04-09)
 
 

libs/providers/config-cat/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "@openfeature/config-cat-provider",
-  "version": "0.7.5",
+  "version": "0.7.6",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@openfeature/config-cat-provider",
-      "version": "0.7.5",
+      "version": "0.7.6",
       "peerDependencies": {
         "@openfeature/server-sdk": "^1.13.5",
         "configcat-node": "^11.3.1"

libs/providers/config-cat/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openfeature/config-cat-provider",
-  "version": "0.7.5",
+  "version": "0.7.6",
   "license": "Apache-2.0",
   "scripts": {
     "publish-if-not-exists": "cp $NPM_CONFIG_USERCONFIG .npmrc && if [ \"$(npm show $npm_package_name@$npm_package_version version)\" = \"$(npm run current-version -s)\" ]; then echo 'already published, skipping'; else npm publish --access public; fi",
@@ -10,6 +10,6 @@
     "@openfeature/server-sdk": "^1.13.5",
     "configcat-node": "^11.3.1",
     "@openfeature/config-cat-core": "0.1.1",
-    "configcat-common": "9.3.1"
+    "configcat-common": "9.4.0"
   }
 }

libs/providers/config-cat/src/lib/config-cat-provider.spec.ts

@@ -1,16 +1,14 @@
 import { ConfigCatProvider } from './config-cat-provider';
 import { ProviderEvents, ParseError, FlagNotFoundError, TypeMismatchError } from '@openfeature/web-sdk';
+import type { HookEvents, IConfigCatCache, ISettingUnion } from 'configcat-js-ssr';
 import {
   createConsoleLogger,
   createFlagOverridesFromMap,
-  HookEvents,
-  IConfigCatCache,
-  ISettingUnion,
   LogLevel,
   OverrideBehaviour,
   PollingMode,
 } from 'configcat-js-ssr';
-import { EventEmitter } from 'events';
+import type { EventEmitter } from 'events';
 
 describe('ConfigCatProvider', () => {
   const targetingKey = 'abc';

libs/providers/config-cat/src/lib/config-cat-provider.ts

@@ -1,25 +1,17 @@
+import type { EvaluationContext, JsonValue, Provider, ResolutionDetails, Paradigm } from '@openfeature/server-sdk';
 import {
-  EvaluationContext,
-  JsonValue,
   OpenFeatureEventEmitter,
-  Provider,
   ProviderEvents,
-  ResolutionDetails,
-  Paradigm,
   ProviderNotReadyError,
   TypeMismatchError,
   ParseError,
 } from '@openfeature/server-sdk';
-import {
-  isType,
-  parseError,
-  PrimitiveType,
-  PrimitiveTypeName,
-  toResolutionDetails,
-  transformContext,
-} from '@openfeature/config-cat-core';
-import { ClientCacheState, PollingMode, SettingValue } from 'configcat-common';
-import { IConfigCatClient, getClient, IConfig, OptionsForPollingMode } from 'configcat-node';
+import type { PrimitiveType, PrimitiveTypeName } from '@openfeature/config-cat-core';
+import { isType, parseError, toResolutionDetails, transformContext } from '@openfeature/config-cat-core';
+import type { SettingValue } from 'configcat-common';
+import { ClientCacheState, PollingMode } from 'configcat-common';
+import type { IConfigCatClient, IConfig, OptionsForPollingMode } from 'configcat-node';
+import { getClient } from 'configcat-node';
 
 export class ConfigCatProvider implements Provider {
   public readonly events = new OpenFeatureEventEmitter();

libs/providers/env-var/src/lib/env-var-provider.ts

@@ -1,11 +1,5 @@
-import {
-  FlagNotFoundError,
-  JsonValue,
-  ParseError,
-  Provider,
-  ResolutionDetails,
-  StandardResolutionReasons,
-} from '@openfeature/server-sdk';
+import type { JsonValue, Provider, ResolutionDetails } from '@openfeature/server-sdk';
+import { FlagNotFoundError, ParseError, StandardResolutionReasons } from '@openfeature/server-sdk';
 import { constantCase } from './constant-case';
 
 export type Config = {

libs/providers/flagd-web/package.json

@@ -10,7 +10,7 @@
     "@openfeature/web-sdk": "^1.0.0"
   },
   "dependencies": {
-    "@openfeature/flagd-core": "1.0.0",
+    "@openfeature/flagd-core": "1.1.0",
     "@connectrpc/connect": "^1.4.0",
     "@connectrpc/connect-web": "^1.4.0",
     "@bufbuild/protobuf": "^1.2.0"

libs/providers/flagd-web/schemas

@@ -1 +1 @@
-Subproject commit c707f563d0a1b35ebea802568c6d3151633bde31
+Subproject commit 2852d7772e6b8674681a6ee6b88db10dbe3f6899

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

@@ -2,4 +2,7 @@ import { getGherkinTestPath } from '@openfeature/flagd-core';
 
 export const FLAGD_NAME = 'flagd';
 
-export const GHERKIN_EVALUATION_FEATURE = getGherkinTestPath('flagd.feature');
+export const GHERKIN_EVALUATION_FEATURE = getGherkinTestPath(
+  'evaluation.feature',
+  'spec/specification/assets/gherkin/',
+);

libs/providers/flagd-web/src/e2e/step-definitions/flag.ts

@@ -1,12 +1,6 @@
-import { StepDefinitions } from 'jest-cucumber';
-import {
-  EvaluationDetails,
-  FlagValue,
-  JsonObject,
-  OpenFeature,
-  ProviderEvents,
-  StandardResolutionReasons,
-} from '@openfeature/web-sdk';
+import type { StepDefinitions } from 'jest-cucumber';
+import type { EvaluationContext, EvaluationDetails, FlagValue, JsonObject } from '@openfeature/web-sdk';
+import { OpenFeature, ProviderEvents, StandardResolutionReasons } from '@openfeature/web-sdk';
 import { E2E_CLIENT_NAME } from '@openfeature/flagd-core';
 
 export const flagStepDefinitions: StepDefinitions = ({ given, and, when, then }) => {
@@ -14,6 +8,7 @@ export const flagStepDefinitions: StepDefinitions = ({ given, and, when, then })
   let value: FlagValue;
   let details: EvaluationDetails<FlagValue>;
   let fallback: FlagValue;
+  let context: EvaluationContext;
 
   const client = OpenFeature.getClient(E2E_CLIENT_NAME);
 
@@ -23,7 +18,7 @@ export const flagStepDefinitions: StepDefinitions = ({ given, and, when, then })
     });
   });
 
-  given('a provider is registered', () => undefined);
+  given('a stable provider', () => undefined);
   given('a flagd provider is set', () => undefined);
 
   when(
@@ -85,6 +80,32 @@ export const flagStepDefinitions: StepDefinitions = ({ given, and, when, then })
     value = client.getObjectValue(key, defaultValue);
   });
 
+  and(/^a flag with key "(.*)" is evaluated with default value "(.*)"$/, async (key, defaultValue) => {
+    await OpenFeature.setContext(context);
+    flagKey = key;
+    fallback = defaultValue;
+    value = client.getStringValue(flagKey, fallback as string);
+  });
+
+  when(
+    /^context contains keys "(.*)", "(.*)", "(.*)", "(.*)" with values "(.*)", "(.*)", (\d+), "(.*)"$/,
+    (key0, key1, key2, key3, stringVal1, stringVal2, intVal, boolVal) => {
+      context = {
+        [key0]: stringVal1,
+        [key1]: stringVal2,
+        [key2]: Number.parseInt(intVal),
+        [key3]: boolVal === true,
+      };
+    },
+  );
+
+  and(/^the resolved flag value is "(.*)" when the context is empty$/, async (expectedValue) => {
+    context = {};
+    await OpenFeature.setContext(context);
+    value = client.getStringValue(flagKey, fallback as string);
+    expect(value).toEqual(expectedValue);
+  });
+
   then(
     /^the resolved object value should be contain fields "(.*)", "(.*)", and "(.*)", with values "(.*)", "(.*)" and (\d+), respectively$/,
     (field1: string, field2: string, field3: string, boolValue: string, stringValue: string, intValue: string) => {

libs/providers/flagd-web/src/e2e/tests/provider.spec.ts

@@ -1,6 +1,7 @@
 import assert from 'assert';
 import { OpenFeature } from '@openfeature/web-sdk';
-import { GenericContainer, StartedTestContainer } from 'testcontainers';
+import type { StartedTestContainer } from 'testcontainers';
+import { GenericContainer } from 'testcontainers';
 import { FlagdWebProvider } from '../../lib/flagd-web-provider';
 import { autoBindSteps, loadFeature } from 'jest-cucumber';
 import { FLAGD_NAME, GHERKIN_EVALUATION_FEATURE } from '../constants';

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

@@ -1,16 +1,11 @@
-import { CallbackClient, Code, ConnectError, PromiseClient } from '@connectrpc/connect';
+import type { CallbackClient, ConnectError, PromiseClient } from '@connectrpc/connect';
+import { Code } from '@connectrpc/connect';
 import { Struct } from '@bufbuild/protobuf';
-import {
-  Client,
-  ErrorCode,
-  JsonValue,
-  OpenFeature,
-  ProviderEvents,
-  StandardResolutionReasons,
-} from '@openfeature/web-sdk';
+import type { Client, JsonValue } from '@openfeature/web-sdk';
+import { ErrorCode, OpenFeature, ProviderEvents, StandardResolutionReasons } from '@openfeature/web-sdk';
 import fetchMock from 'jest-fetch-mock';
-import { Service } from '../proto/ts/flagd/evaluation/v1/evaluation_connect';
-import { AnyFlag, EventStreamResponse, ResolveAllResponse } from '../proto/ts/flagd/evaluation/v1/evaluation_pb';
+import type { Service } from '../proto/ts/flagd/evaluation/v1/evaluation_connect';
+import type { AnyFlag, EventStreamResponse, ResolveAllResponse } from '../proto/ts/flagd/evaluation/v1/evaluation_pb';
 import { FlagdWebProvider } from './flagd-web-provider';
 
 const EVENT_CONFIGURATION_CHANGE = 'configuration_change';

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

@@ -1,23 +1,27 @@
-import { CallbackClient, createCallbackClient, createPromiseClient, PromiseClient } from '@connectrpc/connect';
+import type { CallbackClient, PromiseClient } from '@connectrpc/connect';
+import { createCallbackClient, createPromiseClient } from '@connectrpc/connect';
 import { createConnectTransport } from '@connectrpc/connect-web';
 import { Struct } from '@bufbuild/protobuf';
-import {
+import type {
   EvaluationContext,
-  FlagNotFoundError,
   FlagValue,
   JsonValue,
   Logger,
+  Provider,
+  ResolutionDetails,
+} from '@openfeature/web-sdk';
+import {
+  FlagNotFoundError,
   OpenFeature,
   OpenFeatureEventEmitter,
-  Provider,
   ProviderEvents,
-  ResolutionDetails,
   StandardResolutionReasons,
   TypeMismatchError,
 } from '@openfeature/web-sdk';
 import { Service } from '../proto/ts/flagd/evaluation/v1/evaluation_connect';
-import { AnyFlag } from '../proto/ts/flagd/evaluation/v1/evaluation_pb';
-import { FlagdProviderOptions, getOptions } from './options';
+import type { AnyFlag } from '../proto/ts/flagd/evaluation/v1/evaluation_pb';
+import type { FlagdProviderOptions } from './options';
+import { getOptions } from './options';
 
 export const ERROR_DISABLED = 'DISABLED';
 

libs/providers/flagd/schemas

@@ -1 +1 @@
-Subproject commit c707f563d0a1b35ebea802568c6d3151633bde31
+Subproject commit 2852d7772e6b8674681a6ee6b88db10dbe3f6899

libs/providers/flagd/spec

@@ -1 +1 @@
-Subproject commit 27e4461b452429ec64bcb89af0301f7664cb702a
+Subproject commit a3678719bf9f62880375ba835ebe1bb7a77de409

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

@@ -4,9 +4,15 @@ export const FLAGD_NAME = 'flagd';
 export const UNSTABLE_CLIENT_NAME = 'unstable';
 export const UNAVAILABLE_CLIENT_NAME = 'unavailable';
 
-export const GHERKIN_FLAGD_FEATURE = getGherkinTestPath('flagd.feature');
-export const GHERKIN_FLAGD_JSON_EVALUATOR_FEATURE = getGherkinTestPath('flagd-json-evaluator.feature');
-export const GHERKIN_FLAGD_RECONNECT_FEATURE = getGherkinTestPath('flagd-reconnect.feature');
+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/index.ts

@@ -1,2 +1 @@
 export * from './constants';
-export * from './step-definitions';

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

@@ -0,0 +1,47 @@
+import type { StepsDefinitionCallbackOptions } from 'jest-cucumber/dist/src/feature-definition-creation';
+import type { State, Steps } from './state';
+import { CacheOption, getConfig, ResolverType } from '../../lib/configuration';
+import { mapValueToType } from './utils';
+
+export const configSteps: Steps = (state: State) => {
+  function mapName(name: string): string {
+    switch (name) {
+      case 'resolver':
+        return 'resolverType';
+      default:
+        return name;
+    }
+  }
+
+  return ({ given, when, then }: StepsDefinitionCallbackOptions) => {
+    beforeEach(() => {
+      state.options = {};
+    });
+    given(/^an option "(.*)" of type "(.*)" with value "(.*)"$/, (name: string, type: string, value: string) => {
+      state.options[mapName(name)] = mapValueToType(value, type);
+    });
+    given(/^an environment variable "(.*)" with value "(.*)"$/, (name, value) => {
+      process.env[name] = value;
+    });
+    when('a config was initialized', () => {
+      state.config = getConfig(state.options);
+    });
+
+    then(
+      /^the option "(.*)" of type "(.*)" should have the value "(.*)"$/,
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      (_name: string, _type: string, _value: string) => {
+        // TODO: implement with configuration unification, see: https://github.com/open-feature/js-sdk-contrib/issues/1096
+        // const expected = mapValueToType(value, type);
+        // const propertyName = mapName(name);
+        // // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // // @ts-ignore
+        // const configElement = state.config[propertyName];
+        // expect(configElement).toBe(expected);
+      },
+    );
+
+    // eslint-disable-next-line @typescript-eslint/no-empty-function
+    then('we should have an error', () => {});
+  };
+};

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

@@ -0,0 +1,33 @@
+import type { JsonObject } from '@openfeature/server-sdk';
+import type { State, Steps } from './state';
+import { mapValueToType } from './utils';
+
+export const contextSteps: Steps =
+  (state: State) =>
+  ({ given, when, then }) => {
+    beforeEach(() => (state.context = undefined));
+    given(
+      /^a context containing a key "(.*)", with type "(.*)" and with value "(.*)"$/,
+      (key: string, type: string, value: string) => {
+        if (state.context == undefined) {
+          state.context = {};
+        }
+        state.context[key] = mapValueToType(value, type);
+      },
+    );
+    given(
+      /^a context containing a nested property with outer key "(.*)" and inner key "(.*)", with value "(.*)"$/,
+      (outer: string, inner: string, value) => {
+        if (state.context == undefined) {
+          state.context = {};
+        }
+        state.context[outer] = { ...(state.context[outer] as JsonObject), [inner]: value };
+      },
+    );
+    given(/^a context containing a targeting key with value "(.*)"$/, (key) => {
+      if (state.context == undefined) {
+        state.context = {};
+      }
+      state.context.targetingKey = key;
+    });
+  };

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

@@ -0,0 +1,49 @@
+import { ServerProviderEvents } from '@openfeature/server-sdk';
+import type { State, Steps } from './state';
+import { waitFor } from './utils';
+
+export const eventSteps: Steps =
+  (state: State) =>
+  ({ given, when, then }) => {
+    function map(eventType: string): ServerProviderEvents {
+      switch (eventType) {
+        case 'error':
+          return ServerProviderEvents.Error;
+        case 'ready':
+          return ServerProviderEvents.Ready;
+        case 'stale':
+          return ServerProviderEvents.Stale;
+        case 'change':
+          return ServerProviderEvents.ConfigurationChanged;
+
+        default:
+          throw new Error('unknown eventtype');
+      }
+    }
+
+    given(/a (.*) event handler/, async (type: string) => {
+      state.client?.addHandler(map(type), (details) => {
+        state.events.push({ type, details });
+      });
+    });
+
+    then(/^the (.*) event handler should have been executed$/, async (type: string) => {
+      await waitFor(() => expect(state.events.find((value) => value.type == type)).toBeDefined(), { timeout: 20000 });
+      expect(state.events.find((value) => value.type == type)).toBeDefined();
+    });
+
+    then(/^the (.*) event handler should have been executed within (\d+)ms$/, async (type: string, ms: number) => {
+      await waitFor(() => expect(state.events.find((value) => value.type == type)).toBeDefined(), { timeout: ms });
+      const actual = state.events.find((value) => value.type == type);
+      expect(actual).toBeDefined();
+    });
+
+    when(/^a (.*) event was fired$/, async (type: string) => {
+      await waitFor(() => expect(state.events.find((value) => value.type == type)), { timeout: 2000 });
+      expect(state.events.find((value) => value.type == type)).toBeDefined();
+    });
+
+    then('the flag should be part of the event payload', async () => {
+      await waitFor(() => expect(state.events.find((value) => value.type == 'change')), { timeout: 2000 });
+    });
+  };

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

@@ -1,13 +1,6 @@
-import { StepDefinitions } from 'jest-cucumber';
-import {
-  EvaluationContext,
-  EvaluationDetails,
-  FlagValue,
-  JsonObject,
-  OpenFeature,
-  ProviderEvents,
-  StandardResolutionReasons,
-} from '@openfeature/server-sdk';
+import type { StepDefinitions } from 'jest-cucumber';
+import type { EvaluationContext, EvaluationDetails, FlagValue, JsonObject } from '@openfeature/server-sdk';
+import { OpenFeature, ProviderEvents, StandardResolutionReasons } from '@openfeature/server-sdk';
 import { E2E_CLIENT_NAME } from '@openfeature/flagd-core';
 
 export const flagStepDefinitions: StepDefinitions = ({ given, and, when, then }) => {

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

@@ -0,0 +1,77 @@
+import type { State, Steps } from './state';
+import { mapValueToType } from './utils';
+
+export const flagSteps: Steps =
+  (state: State) =>
+  ({ given, when, then }) => {
+    beforeEach(() => {
+      state.flag = undefined;
+    });
+
+    given(
+      /^a (.*)-flag with key "(.*)" and a default value "(.*)"$/,
+      (type: string, name: string, defaultValue: string) => {
+        state.flag = {
+          name,
+          type,
+          defaultValue: mapValueToType(defaultValue, type),
+        };
+      },
+    );
+
+    when('the flag was evaluated with details', async () => {
+      switch (state.flag?.type) {
+        case 'Boolean':
+          state.details = await state.client?.getBooleanDetails(
+            state.flag?.name,
+            <boolean>state.flag?.defaultValue,
+            state.context,
+          );
+          break;
+        case 'String':
+          state.details = await state.client?.getStringDetails(
+            state.flag?.name,
+            <string>state.flag?.defaultValue,
+            state.context,
+          );
+          break;
+        case 'Integer':
+        case 'Float':
+          state.details = await state.client?.getNumberDetails(
+            state.flag?.name,
+            <number>state.flag?.defaultValue,
+            state.context,
+          );
+          break;
+        case 'Object':
+          state.details = await state.client?.getObjectDetails(
+            state.flag?.name,
+            <boolean>state.flag?.defaultValue,
+            state.context,
+          );
+          break;
+        default:
+          throw new Error('unknown type');
+      }
+    });
+
+    then(/^the resolved details value should be "(.*)"$/, (arg0) => {
+      expect(state.details?.value).toEqual(mapValueToType(arg0, state.flag!.type));
+    });
+
+    then(/^the reason should be "(.*)"$/, (expectedReason) => {
+      expect(state.details?.reason).toBe(expectedReason);
+    });
+
+    then(/^the variant should be "(.*)"$/, (expectedVariant) => {
+      expect(state.details?.variant).toBe(expectedVariant);
+    });
+
+    then('the resolved metadata should contain', (table) => {
+      // TODO: implement metadata tests, https://github.com/open-feature/js-sdk-contrib/issues/1290
+    });
+
+    then('the resolved metadata is empty', () => {
+      // TODO: implement metadata tests, https://github.com/open-feature/js-sdk-contrib/issues/1290
+    });
+  };

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

@@ -1,2 +0,0 @@
-export * from './flag';
-export * from './reconnect';

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

@@ -0,0 +1,78 @@
+import { OpenFeature } from '@openfeature/server-sdk';
+import { FlagdContainer } from '../tests/flagdContainer';
+import type { State, Steps } from './state';
+import { FlagdProvider } from '../../lib/flagd-provider';
+import type { FlagdProviderOptions } from '../../lib/configuration';
+
+export const providerSteps: Steps =
+  (state: State) =>
+  ({ given, when, then }) => {
+    const container: FlagdContainer = FlagdContainer.build();
+    beforeAll(async () => {
+      console.log('Setting flagd provider...');
+
+      return await container.start();
+    }, 50000);
+
+    afterAll(async () => {
+      await OpenFeature.close();
+      await container.stop();
+    });
+
+    afterEach(async () => {
+      // everything breaks without this
+      await OpenFeature.close();
+      if (state.client) {
+        await fetch('http://' + container.getLaunchpadUrl() + '/stop');
+        await new Promise((r) => setTimeout(r, 100));
+      }
+      return Promise.resolve();
+    }, 50000);
+
+    given(/a (.*) flagd provider/, async (providerType: string) => {
+      const flagdOptions: FlagdProviderOptions = {
+        resolverType: state.resolverType,
+        deadlineMs: 2000,
+      };
+      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;
+      }
+
+      await fetch('http://' + container.getLaunchpadUrl() + '/start?config=' + type);
+      await new Promise((r) => setTimeout(r, 50));
+      if (providerType == 'unavailable') {
+        OpenFeature.setProvider(providerType, new FlagdProvider(flagdOptions));
+      } else {
+        await OpenFeature.setProviderAndWait(providerType, new FlagdProvider(flagdOptions));
+      }
+
+      state.client = OpenFeature.getClient(providerType);
+      state.providerType = providerType;
+    });
+
+    when(/^the connection is lost for (\d+)s$/, async (time) => {
+      console.log('stopping flagd');
+      await fetch('http://' + container.getLaunchpadUrl() + '/restart?seconds=' + time);
+    });
+
+    when('the flag was modified', async () => {
+      await fetch('http://' + container.getLaunchpadUrl() + '/change');
+    });
+  };

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

@@ -1,4 +1,4 @@
-import { StepDefinitions } from 'jest-cucumber';
+import type { StepDefinitions } from 'jest-cucumber';
 import { OpenFeature, ProviderEvents } from '@openfeature/server-sdk';
 import { UNAVAILABLE_CLIENT_NAME, UNSTABLE_CLIENT_NAME } from '../constants';
 

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

@@ -0,0 +1,39 @@
+import type { StepDefinitions } from 'jest-cucumber';
+import type { CacheOption, ResolverType } from '../../lib/configuration';
+import type { Client, EvaluationContext, EvaluationDetails, EventDetails, FlagValue } from '@openfeature/server-sdk';
+
+interface Flag {
+  name: string;
+  type: string;
+  defaultValue: unknown;
+}
+
+interface Event {
+  type: string;
+  details?: EventDetails;
+}
+
+export interface State {
+  flagsChanged?: string[];
+  providerType?: string;
+  details?: EvaluationDetails<FlagValue>;
+  client?: Client;
+  resolverType: ResolverType;
+  context?: EvaluationContext;
+  config?: {
+    cache?: CacheOption;
+    socketPath?: string;
+    port: number;
+    maxCacheSize?: number;
+    resolverType?: ResolverType;
+    host: string;
+    offlineFlagSourcePath?: string;
+    tls: boolean;
+    selector?: string;
+  };
+  options: Record<string, unknown>;
+  events: Event[];
+  flag?: Flag;
+}
+
+export type Steps = (state: State) => StepDefinitions;

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

@@ -0,0 +1,53 @@
+import type { CacheOption, ResolverType } from '../../lib/configuration';
+
+export function mapValueToType(value: string, type: string): any {
+  switch (type) {
+    case 'String':
+      if (value == 'null') {
+        return undefined;
+      }
+      return value;
+    case 'Integer':
+      return Number.parseInt(value);
+    case 'Float':
+      return Number.parseFloat(value);
+    case 'Long':
+      return Number.parseFloat(value);
+    case 'Boolean':
+      return value.toLowerCase() === 'true';
+    case 'ResolverType':
+      return value.toLowerCase() as ResolverType;
+    case 'CacheType':
+      return value as CacheOption;
+    case 'Object':
+      if (value == 'null') {
+        return undefined;
+      }
+      return JSON.parse(value);
+    default:
+      throw new Error('type not supported');
+  }
+}
+
+export function waitFor<T>(check: () => T, options: { timeout?: number; interval?: number } = {}): Promise<T> {
+  const { timeout = 5000, interval = 50 } = options; // Default 5s timeout, 50ms polling interval
+
+  return new Promise((resolve, reject) => {
+    const startTime = Date.now();
+
+    const checkCondition = () => {
+      try {
+        const result = check();
+        resolve(result); // If condition passes, resolve the promise
+      } catch (error) {
+        if (Date.now() - startTime > timeout) {
+          reject(new Error('Timeout while waiting for condition'));
+        } else {
+          setTimeout(checkCondition, interval); // Retry after interval
+        }
+      }
+    };
+
+    checkCondition();
+  });
+}

libs/providers/flagd/src/e2e/tests/flagdContainer.ts

@@ -0,0 +1,66 @@
+import type { StartedTestContainer, StoppedTestContainer } from 'testcontainers';
+import { GenericContainer } from 'testcontainers';
+import fs from 'fs';
+import * as path from 'node:path';
+import type { ResolverType } from '../../lib/configuration';
+
+export class FlagdContainer extends GenericContainer {
+  private static imageBase = 'ghcr.io/open-feature/flagd-testbed';
+  private started: StartedTestContainer | undefined;
+  private stopped: StoppedTestContainer | undefined;
+
+  public static build() {
+    return new FlagdContainer(this.generateImageName());
+  }
+
+  private constructor(image: string) {
+    super(image);
+    this.withExposedPorts(8080, 8013, 8014, 8015, 8016);
+  }
+
+  isStarted(): boolean {
+    return this.started !== undefined;
+  }
+
+  async start(): Promise<StartedTestContainer> {
+    if (this.isStarted()) {
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore
+      return Promise.resolve(this.started);
+    }
+    const containerPromise = super.start();
+    this.started = await containerPromise;
+    this.stopped = undefined;
+    return containerPromise;
+  }
+
+  async stop(): Promise<StoppedTestContainer> {
+    if (!this.started) {
+      throw new Error('container not started');
+    }
+    const containerPromise = this.started.stop();
+    this.stopped = await containerPromise;
+    this.started = undefined;
+    return containerPromise;
+  }
+
+  getLaunchpadUrl() {
+    return this.started?.getHost() + ':' + this.started?.getMappedPort(8080);
+  }
+
+  private static generateImageName(): string {
+    const image = this.imageBase;
+    const file = path.join(__dirname, './../../../../../shared/flagd-core/test-harness/', 'version.txt');
+    const version = fs.readFileSync(file, 'utf8').trim();
+    return `${image}:v${version}`;
+  }
+
+  getPort(resolverType: ResolverType) {
+    switch (resolverType) {
+      default:
+        return this.started?.getMappedPort(8013);
+      case 'in-process':
+        return this.started?.getMappedPort(8015);
+    }
+  }
+}

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

@@ -1,69 +0,0 @@
-import assert from 'assert';
-import { OpenFeature } from '@openfeature/server-sdk';
-import { FlagdProvider } from '../../lib/flagd-provider';
-import { GenericContainer, StartedTestContainer } from 'testcontainers';
-import { autoBindSteps, loadFeature } from 'jest-cucumber';
-import {
-  FLAGD_NAME,
-  GHERKIN_FLAGD_RECONNECT_FEATURE,
-  UNAVAILABLE_CLIENT_NAME,
-  UNSTABLE_CLIENT_NAME,
-} from '../constants';
-import { IMAGE_VERSION } from '@openfeature/flagd-core';
-import { reconnectStepDefinitions } from '../step-definitions';
-
-// register the flagd provider before the tests.
-async function setup() {
-  const containers: StartedTestContainer[] = [];
-
-  console.log('Setting flagd provider...');
-  const unstable = await new GenericContainer(`ghcr.io/open-feature/flagd-testbed-unstable:${IMAGE_VERSION}`)
-    .withExposedPorts(8015)
-    .start();
-  containers.push(unstable);
-  await OpenFeature.setProviderAndWait(
-    UNSTABLE_CLIENT_NAME,
-    new FlagdProvider({ resolverType: 'in-process', host: 'localhost', port: unstable.getFirstMappedPort() }),
-  );
-
-  OpenFeature.setProvider(
-    UNAVAILABLE_CLIENT_NAME,
-    new FlagdProvider({ resolverType: 'in-process', host: 'localhost', port: 9092 }),
-  );
-  assert(
-    OpenFeature.getProviderMetadata(UNSTABLE_CLIENT_NAME).name === FLAGD_NAME,
-    new Error(
-      `Expected ${FLAGD_NAME} provider to be configured, instead got: ${
-        OpenFeature.getProviderMetadata(UNSTABLE_CLIENT_NAME).name
-      }`,
-    ),
-  );
-  assert(
-    OpenFeature.getProviderMetadata(UNAVAILABLE_CLIENT_NAME).name === FLAGD_NAME,
-    new Error(
-      `Expected ${FLAGD_NAME} provider to be configured, instead got: ${
-        OpenFeature.getProviderMetadata(UNAVAILABLE_CLIENT_NAME).name
-      }`,
-    ),
-  );
-
-  console.log('flagd provider configured!');
-  return containers;
-}
-
-jest.setTimeout(30000);
-
-describe('in process', () => {
-  let containers: StartedTestContainer[] = [];
-  beforeAll(async () => {
-    containers = await setup();
-  }, 60000);
-  afterAll(async () => {
-    await OpenFeature.close();
-    for (const container of containers) {
-      await container.stop();
-    }
-  });
-  const features = [loadFeature(GHERKIN_FLAGD_RECONNECT_FEATURE)];
-  autoBindSteps(features, [reconnectStepDefinitions]);
-});

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

@@ -1,60 +1,32 @@
-import assert from 'assert';
-import { OpenFeature } from '@openfeature/server-sdk';
-import { FlagdProvider } from '../../lib/flagd-provider';
-import { GenericContainer, StartedTestContainer } from 'testcontainers';
-import { autoBindSteps, loadFeature } from 'jest-cucumber';
-import {
-  FLAGD_NAME,
-  GHERKIN_EVALUATION_FEATURE,
-  GHERKIN_FLAGD_FEATURE,
-  GHERKIN_FLAGD_JSON_EVALUATOR_FEATURE,
-} from '../constants';
-import { flagStepDefinitions } from '../step-definitions';
-import { E2E_CLIENT_NAME, IMAGE_VERSION } from '@openfeature/flagd-core';
+import { autoBindSteps, loadFeatures } from 'jest-cucumber';
+import { GHERKIN_FLAGD } from '../constants';
+import { providerSteps } from '../step-definitions/providerSteps';
+import { configSteps } from '../step-definitions/configSteps';
+import type { State } from '../step-definitions/state';
+import { eventSteps } from '../step-definitions/eventSteps';
+import { flagSteps } from '../step-definitions/flagSteps';
+import { contextSteps } from '../step-definitions/contextSteps';
 
-// register the flagd provider before the tests.
-async function setup() {
-  const containers: StartedTestContainer[] = [];
+const steps = [providerSteps, configSteps, eventSteps, flagSteps, contextSteps];
 
-  console.log('Setting flagd provider...');
-
-  const stable = await new GenericContainer(`ghcr.io/open-feature/flagd-testbed:${IMAGE_VERSION}`)
-    .withExposedPorts(8015)
-    .start();
-  containers.push(stable);
-  OpenFeature.setProvider(
-    E2E_CLIENT_NAME,
-    new FlagdProvider({ resolverType: 'in-process', host: 'localhost', port: stable.getFirstMappedPort() }),
+jest.setTimeout(50000);
+describe('in-process', () => {
+  const state: State = {
+    resolverType: 'in-process',
+    options: {},
+    config: undefined,
+    events: [],
+  };
+  autoBindSteps(
+    loadFeatures(GHERKIN_FLAGD, {
+      // 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',
+      scenarioNameTemplate: (vars) => {
+        return `${vars.scenarioTitle} (${vars.scenarioTags.join(',')} ${vars.featureTags.join(',')})`;
+      },
+    }),
+    steps.map((step) => step(state)),
   );
-
-  assert(
-    OpenFeature.getProviderMetadata(E2E_CLIENT_NAME).name === FLAGD_NAME,
-    new Error(
-      `Expected ${FLAGD_NAME} provider to be configured, instead got: ${
-        OpenFeature.getProviderMetadata(E2E_CLIENT_NAME).name
-      }`,
-    ),
-  );
-
-  console.log('flagd provider configured!');
-  return containers;
-}
-
-describe('in process', () => {
-  let containers: StartedTestContainer[] = [];
-  beforeAll(async () => {
-    containers = await setup();
-  }, 60000);
-  afterAll(async () => {
-    await OpenFeature.close();
-    for (const container of containers) {
-      await container.stop();
-    }
-  });
-  const features = [
-    loadFeature(GHERKIN_FLAGD_FEATURE),
-    loadFeature(GHERKIN_EVALUATION_FEATURE),
-    loadFeature(GHERKIN_FLAGD_JSON_EVALUATOR_FEATURE),
-  ];
-  autoBindSteps(features, [flagStepDefinitions]);
 });

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

@@ -1,69 +0,0 @@
-import assert from 'assert';
-import { OpenFeature } from '@openfeature/server-sdk';
-import { FlagdProvider } from '../../lib/flagd-provider';
-import { GenericContainer, StartedTestContainer } from 'testcontainers';
-import { autoBindSteps, loadFeature } from 'jest-cucumber';
-import {
-  FLAGD_NAME,
-  GHERKIN_FLAGD_RECONNECT_FEATURE,
-  UNAVAILABLE_CLIENT_NAME,
-  UNSTABLE_CLIENT_NAME,
-} from '../constants';
-import { reconnectStepDefinitions } from '../step-definitions';
-import { IMAGE_VERSION } from '@openfeature/flagd-core';
-
-// register the flagd provider before the tests.
-async function setup() {
-  const containers: StartedTestContainer[] = [];
-
-  console.log('Setting flagd provider...');
-  const unstable = await new GenericContainer(`ghcr.io/open-feature/flagd-testbed-unstable:${IMAGE_VERSION}`)
-    .withExposedPorts(8013)
-    .start();
-  containers.push(unstable);
-  OpenFeature.setProvider(
-    UNSTABLE_CLIENT_NAME,
-    new FlagdProvider({ cache: 'disabled', port: unstable.getFirstMappedPort() }),
-  );
-  OpenFeature.setProvider(UNAVAILABLE_CLIENT_NAME, new FlagdProvider({ cache: 'disabled', port: 8015 }));
-  assert(
-    OpenFeature.getProviderMetadata(UNSTABLE_CLIENT_NAME).name === FLAGD_NAME,
-    new Error(
-      `Expected ${FLAGD_NAME} provider to be configured, instead got: ${
-        OpenFeature.getProviderMetadata(UNSTABLE_CLIENT_NAME).name
-      }`,
-    ),
-  );
-  assert(
-    OpenFeature.getProviderMetadata(UNAVAILABLE_CLIENT_NAME).name === FLAGD_NAME,
-    new Error(
-      `Expected ${FLAGD_NAME} provider to be configured, instead got: ${
-        OpenFeature.getProviderMetadata(UNAVAILABLE_CLIENT_NAME).name
-      }`,
-    ),
-  );
-
-  console.log('flagd provider configured!');
-  return containers;
-}
-
-jest.setTimeout(30000);
-describe('rpc', () => {
-  let containers: StartedTestContainer[] = [];
-  beforeAll(async () => {
-    containers = await setup();
-  }, 60000);
-  afterAll(async () => {
-    await OpenFeature.close();
-    for (const container of containers) {
-      try {
-        await container.stop();
-      } catch {
-        console.warn(`Failed to stop container ${container.getName()}`);
-      }
-    }
-  });
-
-  const features = [loadFeature(GHERKIN_FLAGD_RECONNECT_FEATURE)];
-  autoBindSteps(features, [reconnectStepDefinitions]);
-});

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

@@ -1,56 +1,33 @@
-import assert from 'assert';
-import { OpenFeature } from '@openfeature/server-sdk';
-import { FlagdProvider } from '../../lib/flagd-provider';
-import { GenericContainer, StartedTestContainer } from 'testcontainers';
-import { autoBindSteps, loadFeature } from 'jest-cucumber';
-import {
-  FLAGD_NAME,
-  GHERKIN_EVALUATION_FEATURE,
-  GHERKIN_FLAGD_FEATURE,
-  GHERKIN_FLAGD_JSON_EVALUATOR_FEATURE,
-} from '../constants';
-import { E2E_CLIENT_NAME, IMAGE_VERSION } from '@openfeature/flagd-core';
-import { flagStepDefinitions } from '../step-definitions';
+import { autoBindSteps, loadFeatures } from 'jest-cucumber';
+import { providerSteps } from '../step-definitions/providerSteps';
+import { configSteps } from '../step-definitions/configSteps';
+import type { State } from '../step-definitions/state';
+import { eventSteps } from '../step-definitions/eventSteps';
+import { flagSteps } from '../step-definitions/flagSteps';
+import { contextSteps } from '../step-definitions/contextSteps';
+import { GHERKIN_FLAGD } from '../constants';
 
-// register the flagd provider before the tests.
-async function setup() {
-  const containers: StartedTestContainer[] = [];
+const steps = [providerSteps, configSteps, eventSteps, flagSteps, contextSteps];
 
-  console.log('Setting flagd provider...');
-  const stable = await new GenericContainer(`ghcr.io/open-feature/flagd-testbed:${IMAGE_VERSION}`)
-    .withExposedPorts(8013)
-    .start();
-  containers.push(stable);
-  OpenFeature.setProvider(E2E_CLIENT_NAME, new FlagdProvider({ cache: 'disabled', port: stable.getFirstMappedPort() }));
-
-  assert(
-    OpenFeature.getProviderMetadata(E2E_CLIENT_NAME).name === FLAGD_NAME,
-    new Error(
-      `Expected ${FLAGD_NAME} provider to be configured, instead got: ${
-        OpenFeature.getProviderMetadata(E2E_CLIENT_NAME).name
-      }`,
-    ),
-  );
-
-  console.log('flagd provider configured!');
-  return containers;
-}
+jest.setTimeout(50000);
 
 describe('rpc', () => {
-  let containers: StartedTestContainer[] = [];
-  beforeAll(async () => {
-    containers = await setup();
-  }, 60000);
-  afterAll(async () => {
-    await OpenFeature.close();
-    for (const container of containers) {
-      await container.stop();
-    }
-  });
-  const features = [
-    loadFeature(GHERKIN_FLAGD_FEATURE),
-    loadFeature(GHERKIN_EVALUATION_FEATURE),
-    loadFeature(GHERKIN_FLAGD_JSON_EVALUATOR_FEATURE),
-  ];
-  autoBindSteps(features, [flagStepDefinitions]);
+  const state: State = {
+    resolverType: 'rpc',
+    options: {},
+    config: undefined,
+    events: [],
+  };
+  autoBindSteps(
+    loadFeatures(GHERKIN_FLAGD, {
+      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',
+      scenarioNameTemplate: (vars) => {
+        return `${vars.scenarioTitle} (${vars.scenarioTags.join(',')} ${vars.featureTags.join(',')})`;
+      },
+    }),
+    steps.map((step) => step(state)),
+  );
 });

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

@@ -1,4 +1,5 @@
-import { Config, FlagdProviderOptions, getConfig } from './configuration';
+import type { Config, FlagdProviderOptions } from './configuration';
+import { getConfig } from './configuration';
 import { DEFAULT_MAX_CACHE_SIZE } from './constants';
 
 describe('Configuration', () => {
@@ -18,6 +19,7 @@ describe('Configuration', () => {
       cache: 'lru',
       resolverType: 'rpc',
       selector: '',
+      deadlineMs: 500,
     });
   });
 
@@ -55,6 +57,7 @@ describe('Configuration', () => {
       selector,
       offlineFlagSourcePath,
       defaultAuthority,
+      deadlineMs: 500,
     });
   });
 
@@ -68,6 +71,7 @@ describe('Configuration', () => {
       resolverType: 'rpc',
       selector: '',
       defaultAuthority: '',
+      deadlineMs: 500,
     };
 
     process.env['FLAGD_HOST'] = 'override';

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

@@ -18,6 +18,13 @@ export interface Config {
    */
   port: number;
 
+  /**
+   * The deadline for connections.
+   *
+   * @default 500
+   */
+  deadlineMs: number;
+
   /**
    * Determines if TLS should be used.
    *
@@ -79,6 +86,7 @@ export interface Config {
 export type FlagdProviderOptions = Partial<Config>;
 
 const DEFAULT_CONFIG: Omit<Config, 'port' | 'resolverType'> = {
+  deadlineMs: 500,
   host: 'localhost',
   tls: false,
   selector: '',
@@ -93,6 +101,7 @@ const DEFAULT_IN_PROCESS_CONFIG: Config = { ...DEFAULT_CONFIG, resolverType: 'in
 enum ENV_VAR {
   FLAGD_HOST = 'FLAGD_HOST',
   FLAGD_PORT = 'FLAGD_PORT',
+  FLAGD_DEADLINE_MS = 'FLAGD_DEADLINE_MS',
   FLAGD_TLS = 'FLAGD_TLS',
   FLAGD_SOCKET_PATH = 'FLAGD_SOCKET_PATH',
   FLAGD_CACHE = 'FLAGD_CACHE',
@@ -103,38 +112,60 @@ enum ENV_VAR {
   FLAGD_DEFAULT_AUTHORITY = 'FLAGD_DEFAULT_AUTHORITY',
 }
 
-const getEnvVarConfig = (): Partial<Config> => ({
-  ...(process.env[ENV_VAR.FLAGD_HOST] && {
-    host: process.env[ENV_VAR.FLAGD_HOST],
-  }),
-  ...(Number(process.env[ENV_VAR.FLAGD_PORT]) && {
-    port: Number(process.env[ENV_VAR.FLAGD_PORT]),
-  }),
-  ...(process.env[ENV_VAR.FLAGD_TLS] && {
-    tls: process.env[ENV_VAR.FLAGD_TLS]?.toLowerCase() === 'true',
-  }),
-  ...(process.env[ENV_VAR.FLAGD_SOCKET_PATH] && {
-    socketPath: process.env[ENV_VAR.FLAGD_SOCKET_PATH],
-  }),
-  ...((process.env[ENV_VAR.FLAGD_CACHE] === 'lru' || process.env[ENV_VAR.FLAGD_CACHE] === 'disabled') && {
-    cache: process.env[ENV_VAR.FLAGD_CACHE],
-  }),
-  ...(process.env[ENV_VAR.FLAGD_MAX_CACHE_SIZE] && {
-    maxCacheSize: Number(process.env[ENV_VAR.FLAGD_MAX_CACHE_SIZE]),
-  }),
-  ...(process.env[ENV_VAR.FLAGD_SOURCE_SELECTOR] && {
-    selector: process.env[ENV_VAR.FLAGD_SOURCE_SELECTOR],
-  }),
-  ...((process.env[ENV_VAR.FLAGD_RESOLVER] === 'rpc' || process.env[ENV_VAR.FLAGD_RESOLVER] === 'in-process') && {
-    resolverType: process.env[ENV_VAR.FLAGD_RESOLVER],
-  }),
-  ...(process.env[ENV_VAR.FLAGD_OFFLINE_FLAG_SOURCE_PATH] && {
-    offlineFlagSourcePath: process.env[ENV_VAR.FLAGD_OFFLINE_FLAG_SOURCE_PATH],
-  }),
-  ...(process.env[ENV_VAR.FLAGD_DEFAULT_AUTHORITY] && {
-    defaultAuthority: process.env[ENV_VAR.FLAGD_DEFAULT_AUTHORITY],
-  }),
-});
+function checkEnvVarResolverType() {
+  return (
+    process.env[ENV_VAR.FLAGD_RESOLVER] &&
+    (process.env[ENV_VAR.FLAGD_RESOLVER].toLowerCase() === 'rpc' ||
+      process.env[ENV_VAR.FLAGD_RESOLVER].toLowerCase() === 'in-process')
+  );
+}
+
+const getEnvVarConfig = (): Partial<Config> => {
+  let provider = undefined;
+  if (
+    process.env[ENV_VAR.FLAGD_RESOLVER] &&
+    (process.env[ENV_VAR.FLAGD_RESOLVER].toLowerCase() === 'rpc' ||
+      process.env[ENV_VAR.FLAGD_RESOLVER].toLowerCase() === 'in-process')
+  ) {
+    provider = process.env[ENV_VAR.FLAGD_RESOLVER].toLowerCase();
+  }
+
+  return {
+    ...(process.env[ENV_VAR.FLAGD_HOST] && {
+      host: process.env[ENV_VAR.FLAGD_HOST],
+    }),
+    ...(Number(process.env[ENV_VAR.FLAGD_PORT]) && {
+      port: Number(process.env[ENV_VAR.FLAGD_PORT]),
+    }),
+    ...(Number(process.env[ENV_VAR.FLAGD_DEADLINE_MS]) && {
+      deadlineMs: Number(process.env[ENV_VAR.FLAGD_DEADLINE_MS]),
+    }),
+    ...(process.env[ENV_VAR.FLAGD_TLS] && {
+      tls: process.env[ENV_VAR.FLAGD_TLS]?.toLowerCase() === 'true',
+    }),
+    ...(process.env[ENV_VAR.FLAGD_SOCKET_PATH] && {
+      socketPath: process.env[ENV_VAR.FLAGD_SOCKET_PATH],
+    }),
+    ...((process.env[ENV_VAR.FLAGD_CACHE] === 'lru' || process.env[ENV_VAR.FLAGD_CACHE] === 'disabled') && {
+      cache: process.env[ENV_VAR.FLAGD_CACHE],
+    }),
+    ...(process.env[ENV_VAR.FLAGD_MAX_CACHE_SIZE] && {
+      maxCacheSize: Number(process.env[ENV_VAR.FLAGD_MAX_CACHE_SIZE]),
+    }),
+    ...(process.env[ENV_VAR.FLAGD_SOURCE_SELECTOR] && {
+      selector: process.env[ENV_VAR.FLAGD_SOURCE_SELECTOR],
+    }),
+    ...(provider && {
+      resolverType: provider as ResolverType,
+    }),
+    ...(process.env[ENV_VAR.FLAGD_OFFLINE_FLAG_SOURCE_PATH] && {
+      offlineFlagSourcePath: process.env[ENV_VAR.FLAGD_OFFLINE_FLAG_SOURCE_PATH],
+    }),
+    ...(process.env[ENV_VAR.FLAGD_DEFAULT_AUTHORITY] && {
+      defaultAuthority: process.env[ENV_VAR.FLAGD_DEFAULT_AUTHORITY],
+    }),
+  };
+};
 
 export function getConfig(options: FlagdProviderOptions = {}) {
   const envVarConfig = getEnvVarConfig();

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

@@ -1,16 +1,10 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { ServiceError, status } from '@grpc/grpc-js';
-import {
-  Client,
-  ErrorCode,
-  EvaluationContext,
-  FlagMetadata,
-  OpenFeature,
-  ProviderEvents,
-  StandardResolutionReasons,
-} from '@openfeature/server-sdk';
+import type { ServiceError } from '@grpc/grpc-js';
+import { status } from '@grpc/grpc-js';
+import type { Client, EvaluationContext, FlagMetadata } from '@openfeature/server-sdk';
+import { ErrorCode, OpenFeature, ProviderEvents, StandardResolutionReasons } from '@openfeature/server-sdk';
 import type { UnaryCall } from '@protobuf-ts/runtime-rpc';
-import {
+import type {
   EventStreamResponse,
   ResolveBooleanRequest,
   ResolveBooleanResponse,
@@ -22,10 +16,11 @@ import {
   ResolveObjectResponse,
   ResolveStringRequest,
   ResolveStringResponse,
-  ServiceClient,
 } from '../proto/ts/flagd/evaluation/v1/evaluation';
+import { ServiceClient } from '../proto/ts/flagd/evaluation/v1/evaluation';
 import { FlagdProvider } from './flagd-provider';
-import { FlagChangeMessage, GRPCService } from './service/grpc/grpc-service';
+import type { FlagChangeMessage } from './service/grpc/grpc-service';
+import { GRPCService } from './service/grpc/grpc-service';
 import { ConnectivityState } from '@grpc/grpc-js/build/src/connectivity-state';
 import { EVENT_CONFIGURATION_CHANGE, EVENT_PROVIDER_READY } from './constants';
 
@@ -149,7 +144,7 @@ describe(FlagdProvider.name, () => {
         new FlagdProvider(
           undefined,
           undefined,
-          new GRPCService({ host: '', port: 123, tls: false }, basicServiceClientMock),
+          new GRPCService({ deadlineMs: 100, host: '', port: 123, tls: false }, basicServiceClientMock),
         ),
       );
       client = OpenFeature.getClient('basic test');
@@ -306,7 +301,10 @@ describe(FlagdProvider.name, () => {
         new FlagdProvider(
           undefined,
           undefined,
-          new GRPCService({ host: '', port: 123, tls: false, cache: 'lru' }, streamingServiceClientMock),
+          new GRPCService(
+            { deadlineMs: 100, host: '', port: 123, tls: false, cache: 'lru' },
+            streamingServiceClientMock,
+          ),
         )
           .initialize()
           .then(() => {
@@ -331,7 +329,10 @@ describe(FlagdProvider.name, () => {
           new FlagdProvider(
             undefined,
             undefined,
-            new GRPCService({ host: '', port: 123, tls: false, cache: 'lru' }, streamingServiceClientMock),
+            new GRPCService(
+              { deadlineMs: 100, host: '', port: 123, tls: false, cache: 'lru' },
+              streamingServiceClientMock,
+            ),
           ),
         );
         // fire message saying provider is ready
@@ -380,7 +381,10 @@ describe(FlagdProvider.name, () => {
           new FlagdProvider(
             undefined,
             undefined,
-            new GRPCService({ host: '', port: 123, tls: false, cache: 'lru' }, streamingServiceClientMock),
+            new GRPCService(
+              { deadlineMs: 100, host: '', port: 123, tls: false, cache: 'lru' },
+              streamingServiceClientMock,
+            ),
           ),
         );
         // fire message saying provider is ready
@@ -412,7 +416,10 @@ describe(FlagdProvider.name, () => {
           new FlagdProvider(
             undefined,
             undefined,
-            new GRPCService({ host: '', port: 123, tls: false, cache: 'lru' }, streamingServiceClientMock),
+            new GRPCService(
+              { deadlineMs: 100, host: '', port: 123, tls: false, cache: 'lru' },
+              streamingServiceClientMock,
+            ),
           ),
         );
         // fire message saying provider is ready
@@ -501,7 +508,10 @@ describe(FlagdProvider.name, () => {
         const provider = new FlagdProvider(
           undefined,
           undefined,
-          new GRPCService({ host: '', port: 123, tls: false, cache: 'lru' }, streamingServiceClientMock),
+          new GRPCService(
+            { deadlineMs: 100, host: '', port: 123, tls: false, cache: 'lru' },
+            streamingServiceClientMock,
+          ),
         );
         provider.initialize().catch(() => {
           // ignore
@@ -579,7 +589,7 @@ describe(FlagdProvider.name, () => {
         new FlagdProvider(
           undefined,
           undefined,
-          new GRPCService({ host: '', port: 123, tls: false }, errServiceClientMock),
+          new GRPCService({ deadlineMs: 100, host: '', port: 123, tls: false }, errServiceClientMock),
         ),
       );
       client = OpenFeature.getClient('errors test');
@@ -666,7 +676,7 @@ describe(FlagdProvider.name, () => {
         new FlagdProvider(
           undefined,
           undefined,
-          new GRPCService({ host: '', port: 123, tls: false }, errServiceClientMock),
+          new GRPCService({ deadlineMs: 100, host: '', port: 123, tls: false }, errServiceClientMock),
         ),
       );
     });

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

@@ -1,15 +1,9 @@
-import {
-  EvaluationContext,
-  JsonValue,
-  Logger,
-  OpenFeatureEventEmitter,
-  Provider,
-  ProviderEvents,
-  ResolutionDetails,
-} from '@openfeature/server-sdk';
-import { FlagdProviderOptions, getConfig } from './configuration';
+import type { EvaluationContext, JsonValue, Logger, Provider, ResolutionDetails } from '@openfeature/server-sdk';
+import { OpenFeatureEventEmitter, ProviderEvents } from '@openfeature/server-sdk';
+import type { FlagdProviderOptions } from './configuration';
+import { getConfig } from './configuration';
 import { GRPCService } from './service/grpc/grpc-service';
-import { Service } from './service/service';
+import type { Service } from './service/service';
 import { InProcessService } from './service/in-process/in-process-service';
 
 export class FlagdProvider implements Provider {

libs/providers/flagd/src/lib/service/common/grpc-util.ts

@@ -1,4 +1,4 @@
-import { ClientReadableStream } from '@grpc/grpc-js';
+import type { ClientReadableStream } from '@grpc/grpc-js';
 
 export const closeStreamIfDefined = (stream: ClientReadableStream<unknown> | undefined) => {
   /**

libs/providers/flagd/src/lib/service/grpc/grpc-service.ts

@@ -1,20 +1,17 @@
-import { ClientReadableStream, ClientUnaryCall, ServiceError, credentials, status, ClientOptions } from '@grpc/grpc-js';
+import type { ClientOptions, ClientReadableStream, ClientUnaryCall, ServiceError } from '@grpc/grpc-js';
+import { credentials, status } from '@grpc/grpc-js';
 import { ConnectivityState } from '@grpc/grpc-js/build/src/connectivity-state';
+import type { EvaluationContext, FlagValue, JsonValue, Logger, ResolutionDetails } from '@openfeature/server-sdk';
 import {
-  EvaluationContext,
   FlagNotFoundError,
-  FlagValue,
   GeneralError,
-  JsonValue,
-  Logger,
   ParseError,
-  ResolutionDetails,
   StandardResolutionReasons,
   TypeMismatchError,
 } from '@openfeature/server-sdk';
 import { LRUCache } from 'lru-cache';
 import { promisify } from 'node:util';
-import {
+import type {
   EventStreamResponse,
   ResolveBooleanRequest,
   ResolveBooleanResponse,
@@ -26,12 +23,12 @@ import {
   ResolveObjectResponse,
   ResolveStringRequest,
   ResolveStringResponse,
-  ServiceClient,
 } from '../../../proto/ts/flagd/evaluation/v1/evaluation';
-import { Config } from '../../configuration';
+import { ServiceClient } from '../../../proto/ts/flagd/evaluation/v1/evaluation';
+import type { Config } from '../../configuration';
 import { DEFAULT_MAX_CACHE_SIZE, EVENT_CONFIGURATION_CHANGE, EVENT_PROVIDER_READY } from '../../constants';
 import { FlagdProvider } from '../../flagd-provider';
-import { Service } from '../service';
+import type { Service } from '../service';
 import { closeStreamIfDefined } from '../common';
 
 type AnyResponse =
@@ -70,6 +67,8 @@ export class GRPCService implements Service {
   private _cache: LRUCache<string, ResolutionDetails<FlagValue>> | undefined;
   private _cacheEnabled = false;
   private _eventStream: ClientReadableStream<EventStreamResponse> | undefined = undefined;
+  private _deadline: number;
+
   private get _cacheActive() {
     // the cache is "active" (able to be used) if the config enabled it, AND the gRPC stream is live
     return this._cacheEnabled && this._client.getChannel().getConnectivityState(false) === ConnectivityState.READY;
@@ -95,6 +94,7 @@ export class GRPCService implements Service {
           tls ? credentials.createSsl() : credentials.createInsecure(),
           clientOptions,
         );
+    this._deadline = config.deadlineMs;
 
     if (config.cache === 'lru') {
       this._cacheEnabled = true;
@@ -165,7 +165,7 @@ export class GRPCService implements Service {
     // close the previous stream if we're reconnecting
     closeStreamIfDefined(this._eventStream);
 
-    const stream = this._client.eventStream({}, {});
+    const stream = this._client.eventStream({ waitForReady: true }, {});
     stream.on('error', (err: Error) => {
       rejectConnect?.(err);
       this.handleError(reconnectCallback, changedCallback, disconnectCallback);

libs/providers/flagd/src/lib/service/in-process/file/file-fetch.spec.ts

@@ -1,7 +1,7 @@
 import fs from 'fs';
 import { FileFetch } from './file-fetch';
 import { FlagdCore } from '@openfeature/flagd-core';
-import { Logger } from '@openfeature/server-sdk';
+import type { Logger } from '@openfeature/server-sdk';
 
 jest.mock('fs', () => ({
   ...jest.requireActual('fs'),

libs/providers/flagd/src/lib/service/in-process/file/file-fetch.ts

@@ -1,5 +1,6 @@
-import { Logger, OpenFeatureError, GeneralError } from '@openfeature/server-sdk';
-import { DataFetch } from '../data-fetch';
+import type { Logger } from '@openfeature/server-sdk';
+import { OpenFeatureError, GeneralError } from '@openfeature/server-sdk';
+import type { DataFetch } from '../data-fetch';
 import { promises as fsPromises, watchFile, unwatchFile } from 'fs';
 
 const encoding = 'utf8';

libs/providers/flagd/src/lib/service/in-process/grpc/grpc-fetch.spec.ts

@@ -1,6 +1,6 @@
 import { GrpcFetch } from './grpc-fetch';
-import { Config } from '../../../configuration';
-import { FlagSyncServiceClient, SyncFlagsResponse } from '../../../../proto/ts/flagd/sync/v1/sync';
+import type { Config } from '../../../configuration';
+import type { FlagSyncServiceClient, SyncFlagsResponse } from '../../../../proto/ts/flagd/sync/v1/sync';
 import { ConnectivityState } from '@grpc/grpc-js/build/src/connectivity-state';
 
 let watchStateCallback: () => void = () => ({});
@@ -44,7 +44,14 @@ const serviceMock: FlagSyncServiceClient = {
 } as unknown as FlagSyncServiceClient;
 
 describe('grpc fetch', () => {
-  const cfg: Config = { host: 'localhost', port: 8000, tls: false, socketPath: '', defaultAuthority: 'test-authority' };
+  const cfg: Config = {
+    deadlineMs: 500,
+    host: 'localhost',
+    port: 8000,
+    tls: false,
+    socketPath: '',
+    defaultAuthority: 'test-authority',
+  };
 
   afterEach(() => {
     jest.clearAllMocks();

libs/providers/flagd/src/lib/service/in-process/grpc/grpc-fetch.ts

@@ -1,9 +1,12 @@
-import { ClientReadableStream, ServiceError, credentials, ClientOptions } from '@grpc/grpc-js';
-import { GeneralError, Logger } from '@openfeature/server-sdk';
-import { FlagSyncServiceClient, SyncFlagsRequest, SyncFlagsResponse } from '../../../../proto/ts/flagd/sync/v1/sync';
-import { Config } from '../../../configuration';
+import type { ClientReadableStream, ServiceError, ClientOptions } from '@grpc/grpc-js';
+import { credentials } from '@grpc/grpc-js';
+import type { Logger } from '@openfeature/server-sdk';
+import { GeneralError } from '@openfeature/server-sdk';
+import type { SyncFlagsRequest, SyncFlagsResponse } from '../../../../proto/ts/flagd/sync/v1/sync';
+import { FlagSyncServiceClient } from '../../../../proto/ts/flagd/sync/v1/sync';
+import type { Config } from '../../../configuration';
 import { closeStreamIfDefined } from '../../common';
-import { DataFetch } from '../data-fetch';
+import type { DataFetch } from '../data-fetch';
 
 /**
  * Implements the gRPC sync contract to fetch flag data.

libs/providers/flagd/src/lib/service/in-process/in-process-service.spec.ts

@@ -1,4 +1,4 @@
-import { DataFetch } from './data-fetch';
+import type { DataFetch } from './data-fetch';
 import { InProcessService } from './in-process-service';
 
 describe('In-process-service', () => {
@@ -13,7 +13,7 @@ describe('In-process-service', () => {
 
   it('should sync and allow to resolve flags', async () => {
     // given
-    const service = new InProcessService({ host: '', port: 0, tls: false }, dataFetcher);
+    const service = new InProcessService({ deadlineMs: 500, host: '', port: 0, tls: false }, dataFetcher);
 
     // when
     await service.connect(jest.fn, jest.fn, jest.fn);
@@ -31,7 +31,7 @@ describe('In-process-service', () => {
     it('should include scope as flag metadata', async () => {
       // given
       const selector = 'devFlags';
-      const service = new InProcessService({ host: '', port: 0, tls: false, selector }, dataFetcher);
+      const service = new InProcessService({ deadlineMs: 500, host: '', port: 0, tls: false, selector }, dataFetcher);
 
       // when
       await service.connect(jest.fn, jest.fn, jest.fn);
@@ -44,7 +44,7 @@ describe('In-process-service', () => {
     it('should not override existing scope in flag metadata', async () => {
       // given
       const selector = 'devFlags';
-      const service = new InProcessService({ host: '', port: 0, tls: false, selector }, dataFetcher);
+      const service = new InProcessService({ deadlineMs: 500, host: '', port: 0, tls: false, selector }, dataFetcher);
 
       // when
       await service.connect(jest.fn, jest.fn, jest.fn);

libs/providers/flagd/src/lib/service/in-process/in-process-service.ts

@@ -7,9 +7,9 @@ import type {
   Logger,
   ResolutionDetails,
 } from '@openfeature/server-sdk';
-import { Config } from '../../configuration';
-import { Service } from '../service';
-import { DataFetch } from './data-fetch';
+import type { Config } from '../../configuration';
+import type { Service } from '../service';
+import type { DataFetch } from './data-fetch';
 import { FileFetch } from './file/file-fetch';
 import { GrpcFetch } from './grpc/grpc-fetch';
 

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

@@ -1,4 +1,4 @@
-import { EvaluationContext, JsonValue, Logger, ResolutionDetails } from '@openfeature/server-sdk';
+import type { EvaluationContext, JsonValue, Logger, ResolutionDetails } from '@openfeature/server-sdk';
 
 export interface Service {
   connect(

libs/providers/flagsmith-client/src/lib/flagsmith-client-provider.ts

@@ -1,19 +1,18 @@
-import {
+import type {
   EvaluationContext,
   FlagValue,
   JsonValue,
   Logger,
-  OpenFeatureEventEmitter,
   Provider,
-  ProviderEvents,
   ProviderMetadata,
   ResolutionDetails,
   ResolutionReason,
-  TypeMismatchError,
 } from '@openfeature/web-sdk';
+import { OpenFeatureEventEmitter, ProviderEvents, TypeMismatchError } from '@openfeature/web-sdk';
 import { createFlagsmithInstance } from 'flagsmith';
-import { IFlagsmith, IInitConfig, IState } from 'flagsmith/types';
-import { FlagType, typeFactory } from './type-factory';
+import type { IFlagsmith, IInitConfig, IState } from 'flagsmith/types';
+import type { FlagType } from './type-factory';
+import { typeFactory } from './type-factory';
 
 export class FlagsmithClientProvider implements Provider {
   readonly metadata: ProviderMetadata = {

libs/providers/flagsmith-client/src/lib/flagsmith.mocks.ts

@@ -1,4 +1,4 @@
-import { IFlagsmithResponse, IInitConfig } from 'flagsmith/types';
+import type { IFlagsmithResponse, IInitConfig } from 'flagsmith/types';
 type Flatten<T> = T extends unknown[] ? T[number] : T;
 type FeatureResponse = Flatten<IFlagsmithResponse['flags']>;
 type Callback = (err: Error | null, val: string | null) => void;

libs/providers/flagsmith-client/src/lib/type-factory.ts

@@ -1,4 +1,4 @@
-import { FlagValue } from '@openfeature/web-sdk';
+import type { FlagValue } from '@openfeature/web-sdk';
 
 export type FlagType = 'string' | 'number' | 'object' | 'boolean';
 

libs/providers/flipt-web/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## [0.1.5](https://github.com/open-feature/js-sdk-contrib/compare/flipt-web-provider-v0.1.4...flipt-web-provider-v0.1.5) (2025-06-06)
+
+
+### ✨ New Features
+
+* **flipt-web:** update types to match flipt-client-js ([#1303](https://github.com/open-feature/js-sdk-contrib/issues/1303)) ([9e8496a](https://github.com/open-feature/js-sdk-contrib/commit/9e8496a384e65bee8d6cb096bdfaa909e2bfa311))
+
+## [0.1.4](https://github.com/open-feature/js-sdk-contrib/compare/flipt-web-provider-v0.1.3...flipt-web-provider-v0.1.4) (2025-06-04)
+
+
+### 🐛 Bug Fixes
+
+* **deps:** update dependency @flipt-io/flipt-client-js to v0.0.2 ([#1272](https://github.com/open-feature/js-sdk-contrib/issues/1272)) ([d7f8746](https://github.com/open-feature/js-sdk-contrib/commit/d7f8746434f58333a2458418c35749c125932369))
+
 ## [0.1.3](https://github.com/open-feature/js-sdk-contrib/compare/flipt-web-provider-v0.1.2...flipt-web-provider-v0.1.3) (2025-04-10)
 
 

libs/providers/flipt-web/package-lock.json

@@ -1,32 +1,22 @@
 {
   "name": "@openfeature/flipt-web-provider",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@openfeature/flipt-web-provider",
-      "version": "0.1.3",
+      "version": "0.1.5",
       "license": "Apache-2.0",
       "peerDependencies": {
-        "@flipt-io/flipt-client-js": "^0.0.1 || ^0.0.2",
-        "@openfeature/web-sdk": "^1.0.0",
-        "undici": "^5.0.0"
-      }
-    },
-    "node_modules/@fastify/busboy": {
-      "version": "2.1.1",
-      "resolved": "https://registry.npmjs.org/@fastify/busboy/-/busboy-2.1.1.tgz",
-      "integrity": "sha512-vBZP4NlzfOlerQTnba4aqZoMhE/a9HY7HRqoOPaETQcSQuWEIyZMHGfVu6w9wGtGK5fED5qRs2DteVCjOH60sA==",
-      "peer": true,
-      "engines": {
-        "node": ">=14"
+        "@flipt-io/flipt-client-js": "^0.0.1 || ^0.0.2 || ^0.0.6 || ^0.2.0",
+        "@openfeature/web-sdk": "^1.0.0"
       }
     },
     "node_modules/@flipt-io/flipt-client-js": {
-      "version": "0.0.2",
-      "resolved": "https://registry.npmjs.org/@flipt-io/flipt-client-js/-/flipt-client-js-0.0.2.tgz",
-      "integrity": "sha512-aYxsXq95ZAard6OoTjzX2Y0WGsW1fCOXyKhmpCnm9qOFC02tcSCsaILzK1Qy8UFMoPTO0ZItP6T/xHBvMYLXUA==",
+      "version": "0.2.0",
+      "resolved": "https://registry.npmjs.org/@flipt-io/flipt-client-js/-/flipt-client-js-0.2.0.tgz",
+      "integrity": "sha512-3VIU2pDUyHafp3ahgxHOde81fKP+5hvSm9Q+8hqt9+D7MCIWNvHTLqFo5hc87WSgq3TlR8ILRWfFC18BE1AmeQ==",
       "license": "MIT",
       "peer": true,
       "dependencies": {
@@ -132,18 +122,6 @@
         "url": "https://opencollective.com/node-fetch"
       }
     },
-    "node_modules/undici": {
-      "version": "5.29.0",
-      "resolved": "https://registry.npmjs.org/undici/-/undici-5.29.0.tgz",
-      "integrity": "sha512-raqeBD6NQK4SkWhQzeYKd1KmIG6dllBOTt55Rmkt4HtI9mwdWtJljnrXjAFUBLTSN67HWrOIZ3EPF4kjUw80Bg==",
-      "peer": true,
-      "dependencies": {
-        "@fastify/busboy": "^2.0.0"
-      },
-      "engines": {
-        "node": ">=14.0"
-      }
-    },
     "node_modules/web-streams-polyfill": {
       "version": "3.3.3",
       "resolved": "https://registry.npmjs.org/web-streams-polyfill/-/web-streams-polyfill-3.3.3.tgz",

libs/providers/flipt-web/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openfeature/flipt-web-provider",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "license": "Apache-2.0",
   "main": "./src/index.js",
   "typings": "./src/index.d.ts",
@@ -10,7 +10,6 @@
   },
   "peerDependencies": {
     "@openfeature/web-sdk": "^1.0.0",
-    "@flipt-io/flipt-client-js": "^0.0.1 || ^0.0.2",
-    "undici": "^5.0.0"
+    "@flipt-io/flipt-client-js": "^0.0.1 || ^0.0.2 || ^0.0.6 || ^0.2.0"
   }
 }

libs/providers/flipt-web/src/index.ts

@@ -1 +1,2 @@
 export * from './lib/flipt-web-provider';
+export * from './lib/models';

libs/providers/flipt-web/src/lib/context-transformer.spec.ts

@@ -1,4 +1,4 @@
-import { EvaluationContext } from '@openfeature/server-sdk';
+import type { EvaluationContext } from '@openfeature/server-sdk';
 import { transformContext } from './context-transformer';
 
 describe('context-transformer', () => {

libs/providers/flipt-web/src/lib/context-transformer.ts

@@ -1,4 +1,4 @@
-import { EvaluationContext } from '@openfeature/web-sdk';
+import type { EvaluationContext } from '@openfeature/web-sdk';
 
 export function transformContext(context: EvaluationContext): Record<string, string> {
   const evalContext: Record<string, string> = {};

libs/providers/flipt-web/src/lib/flipt-web-provider.ts

@@ -1,16 +1,8 @@
-import {
-  EvaluationContext,
-  Provider,
-  JsonValue,
-  ResolutionDetails,
-  Logger,
-  StandardResolutionReasons,
-  TypeMismatchError,
-  GeneralError,
-  ProviderFatalError,
-} from '@openfeature/web-sdk';
+import type { EvaluationContext, Provider, JsonValue, ResolutionDetails, Logger } from '@openfeature/web-sdk';
+import { StandardResolutionReasons, TypeMismatchError, GeneralError, ProviderFatalError } from '@openfeature/web-sdk';
 import { FliptClient } from '@flipt-io/flipt-client-js/browser';
-import { EvaluationReason, FliptWebProviderOptions } from './models';
+import type { FliptWebProviderOptions } from './models';
+import { EvaluationReason } from './models';
 import { transformContext } from './context-transformer';
 
 export class FliptWebProvider implements Provider {

libs/providers/flipt-web/src/lib/models.ts

@@ -1,7 +1,13 @@
 export interface FliptWebProviderOptions {
   url?: string;
   authentication?: FliptWebProviderAuthentication;
-  fetcher?: () => Promise<Response>;
+  fetcher?: FliptFetcher;
+}
+
+export type FliptFetcher = (args?: FliptFetcherOptions) => Promise<Response>;
+
+export interface FliptFetcherOptions {
+  etag?: string;
 }
 
 export interface FliptClientTokenAuthentication {

libs/providers/flipt/src/lib/context-transformer.spec.ts

@@ -1,4 +1,4 @@
-import { EvaluationContext } from '@openfeature/server-sdk';
+import type { EvaluationContext } from '@openfeature/server-sdk';
 import { transformContext } from './context-transformer';
 
 describe('context-transformer', () => {

libs/providers/flipt/src/lib/context-transformer.ts

@@ -1,4 +1,4 @@
-import { EvaluationContext } from '@openfeature/server-sdk';
+import type { EvaluationContext } from '@openfeature/server-sdk';
 
 export function transformContext(context: EvaluationContext): Record<string, string> {
   const evalContext: Record<string, string> = {};

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

@@ -1,11 +1,14 @@
-import { AuthenticationStrategy, FliptClient } from '@flipt-io/flipt';
-import {
+import type { AuthenticationStrategy } from '@flipt-io/flipt';
+import { FliptClient } from '@flipt-io/flipt';
+import type {
   EvaluationContext,
   Provider,
   JsonValue,
   ResolutionDetails,
-  ProviderStatus,
   ProviderMetadata,
+} from '@openfeature/server-sdk';
+import {
+  ProviderStatus,
   TypeMismatchError,
   ProviderNotReadyError,
   StandardResolutionReasons,

libs/providers/go-feature-flag-web/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## [0.2.6](https://github.com/open-feature/js-sdk-contrib/compare/go-feature-flag-web-provider-v0.2.5...go-feature-flag-web-provider-v0.2.6) (2025-05-26)
+
+
+### ✨ New Features
+
+* **goff web:** Support tracking events ([#1268](https://github.com/open-feature/js-sdk-contrib/issues/1268)) ([d9ffcec](https://github.com/open-feature/js-sdk-contrib/commit/d9ffcec1652aa96eefccc45dfe079ca126d55142))
+
+
+### 🧹 Chore
+
+* **main:** release flipt-web-provider 0.1.3 ([#1253](https://github.com/open-feature/js-sdk-contrib/issues/1253)) ([7be62ae](https://github.com/open-feature/js-sdk-contrib/commit/7be62ae45f4dfbaefecc6205a28060698fdd884d))
+
 ## [0.2.5](https://github.com/open-feature/js-sdk-contrib/compare/go-feature-flag-web-provider-v0.2.4...go-feature-flag-web-provider-v0.2.5) (2025-01-23)
 
 

libs/providers/go-feature-flag-web/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "@openfeature/go-feature-flag-web-provider",
-  "version": "0.2.5",
+  "version": "0.2.6",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@openfeature/go-feature-flag-web-provider",
-      "version": "0.2.5",
+      "version": "0.2.6",
       "peerDependencies": {
         "@openfeature/web-sdk": "*"
       }

libs/providers/go-feature-flag-web/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openfeature/go-feature-flag-web-provider",
-  "version": "0.2.5",
+  "version": "0.2.6",
   "license": "Apache-2.0",
   "scripts": {
     "publish-if-not-exists": "cp $NPM_CONFIG_USERCONFIG .npmrc && if [ \"$(npm show $npm_package_name@$npm_package_version version)\" = \"$(npm run current-version -s)\" ]; then echo 'already published, skipping'; else npm publish --access public; fi",

libs/providers/go-feature-flag-web/src/lib/collector-manager.ts

@@ -0,0 +1,71 @@
+import type { Logger } from '@openfeature/web-sdk';
+import type { ExporterMetadataValue, FeatureEvent, GoFeatureFlagWebProviderOptions, TrackingEvent } from './model';
+import { GoffApiController } from './controller/goff-api';
+import { CollectorError } from './errors/collector-error';
+import { copy } from 'copy-anything';
+
+type Timer = ReturnType<typeof setInterval>;
+
+export class CollectorManager {
+  // bgSchedulerId contains the id of the setInterval that is running.
+  private bgScheduler?: Timer;
+  // dataCollectorBuffer contains all the FeatureEvents that we need to send to the relay-proxy for data collection.
+  private dataCollectorBuffer?: Array<FeatureEvent<any> | TrackingEvent>;
+  // dataFlushInterval interval time (in millisecond) we use to call the relay proxy to collect data.
+  private readonly dataFlushInterval: number;
+  // logger is the Open Feature logger to use
+  private logger?: Logger;
+  // dataCollectorMetadata are the metadata used when calling the data collector endpoint
+  private readonly dataCollectorMetadata: Record<string, ExporterMetadataValue>;
+
+  private readonly goffApiController: GoffApiController;
+
+  constructor(options: GoFeatureFlagWebProviderOptions, logger?: Logger) {
+    this.dataFlushInterval = options.dataFlushInterval || 1000 * 60;
+    this.logger = logger;
+    this.goffApiController = new GoffApiController(options);
+
+    this.dataCollectorMetadata = {
+      provider: 'web',
+      openfeature: true,
+      ...options.exporterMetadata,
+    };
+  }
+
+  init() {
+    this.bgScheduler = setInterval(async () => await this.callGoffDataCollection(), this.dataFlushInterval);
+    this.dataCollectorBuffer = [];
+  }
+
+  async close() {
+    clearInterval(this.bgScheduler);
+    // We call the data collector with what is still in the buffer.
+    await this.callGoffDataCollection();
+  }
+
+  add(event: FeatureEvent<any> | TrackingEvent) {
+    if (this.dataCollectorBuffer) {
+      this.dataCollectorBuffer.push(event);
+    }
+  }
+
+  /**
+   * callGoffDataCollection is a function called periodically to send the usage of the flag to the
+   * central service in charge of collecting the data.
+   */
+  async callGoffDataCollection() {
+    const dataToSend = copy(this.dataCollectorBuffer) || [];
+    this.dataCollectorBuffer = [];
+    try {
+      await this.goffApiController.collectData(dataToSend, this.dataCollectorMetadata);
+    } catch (e) {
+      if (!(e instanceof CollectorError)) {
+        throw e;
+      }
+      this.logger?.error(e);
+      // if we have an issue calling the collector, we put the data back in the buffer
+      this.dataCollectorBuffer = [...this.dataCollectorBuffer, ...dataToSend];
+      return;
+    }
+  }
+}

libs/providers/go-feature-flag-web/src/lib/context-transfomer.spec.ts

@@ -1,6 +1,7 @@
-import { GoFeatureFlagEvaluationContext } from './model';
+import type { GoFeatureFlagEvaluationContext } from './model';
 import { transformContext } from './context-transformer';
-import { TargetingKeyMissingError, EvaluationContext } from '@openfeature/web-sdk';
+import type { EvaluationContext } from '@openfeature/web-sdk';
+import { TargetingKeyMissingError } from '@openfeature/web-sdk';
 
 describe('contextTransformer', () => {
   it('should use the targetingKey as user key', () => {

libs/providers/go-feature-flag-web/src/lib/context-transformer.ts

@@ -1,5 +1,6 @@
-import { GoFeatureFlagEvaluationContext } from './model';
-import { TargetingKeyMissingError, EvaluationContext } from '@openfeature/web-sdk';
+import type { GoFeatureFlagEvaluationContext } from './model';
+import type { EvaluationContext } from '@openfeature/web-sdk';
+import { TargetingKeyMissingError } from '@openfeature/web-sdk';
 
 /**
  * transformContext takes the raw OpenFeature context returns a GoFeatureFlagEvaluationContext.

libs/providers/go-feature-flag-web/src/lib/controller/goff-api.spec.ts

@@ -1,6 +1,6 @@
 import fetchMock from 'fetch-mock-jest';
 import { GoffApiController } from './goff-api';
-import { GoFeatureFlagWebProviderOptions } from '../model';
+import type { GoFeatureFlagWebProviderOptions } from '../model';
 
 describe('Collect Data API', () => {
   beforeEach(() => {

libs/providers/go-feature-flag-web/src/lib/controller/goff-api.ts

@@ -1,4 +1,10 @@
-import { DataCollectorRequest, ExporterMetadataValue, FeatureEvent, GoFeatureFlagWebProviderOptions } from '../model';
+import type {
+  DataCollectorRequest,
+  ExporterMetadataValue,
+  FeatureEvent,
+  GoFeatureFlagWebProviderOptions,
+  TrackingEvent,
+} from '../model';
 import { CollectorError } from '../errors/collector-error';
 
 export class GoffApiController {
@@ -15,7 +21,10 @@ export class GoffApiController {
     this.options = options;
   }
 
-  async collectData(events: FeatureEvent<any>[], dataCollectorMetadata: Record<string, ExporterMetadataValue>) {
+  async collectData(
+    events: Array<FeatureEvent<any> | TrackingEvent>,
+    dataCollectorMetadata: Record<string, ExporterMetadataValue>,
+  ) {
     if (events?.length === 0) {
       return;
     }

libs/providers/go-feature-flag-web/src/lib/data-collector-hook.ts

@@ -1,65 +1,14 @@
-import { EvaluationDetails, FlagValue, Hook, HookContext, Logger } from '@openfeature/web-sdk';
-import { ExporterMetadataValue, FeatureEvent, GoFeatureFlagWebProviderOptions } from './model';
-import { copy } from 'copy-anything';
-import { CollectorError } from './errors/collector-error';
-import { GoffApiController } from './controller/goff-api';
+import type { EvaluationDetails, FlagValue, Hook, HookContext } from '@openfeature/web-sdk';
+import type { CollectorManager } from './collector-manager';
 
 const defaultTargetingKey = 'undefined-targetingKey';
 type Timer = ReturnType<typeof setInterval>;
 
 export class GoFeatureFlagDataCollectorHook implements Hook {
-  // bgSchedulerId contains the id of the setInterval that is running.
-  private bgScheduler?: Timer;
-  // dataCollectorBuffer contains all the FeatureEvents that we need to send to the relay-proxy for data collection.
-  private dataCollectorBuffer?: FeatureEvent<any>[];
-  // dataFlushInterval interval time (in millisecond) we use to call the relay proxy to collect data.
-  private readonly dataFlushInterval: number;
-  // dataCollectorMetadata are the metadata used when calling the data collector endpoint
-  private readonly dataCollectorMetadata: Record<string, ExporterMetadataValue>;
-  private readonly goffApiController: GoffApiController;
-  // logger is the Open Feature logger to use
-  private logger?: Logger;
+  private collectorManagger?: CollectorManager;
 
-  constructor(options: GoFeatureFlagWebProviderOptions, logger?: Logger) {
-    this.dataFlushInterval = options.dataFlushInterval || 1000 * 60;
-    this.logger = logger;
-    this.goffApiController = new GoffApiController(options);
-    this.dataCollectorMetadata = {
-      provider: 'web',
-      openfeature: true,
-      ...options.exporterMetadata,
-    };
-  }
-
-  init() {
-    this.bgScheduler = setInterval(async () => await this.callGoffDataCollection(), this.dataFlushInterval);
-    this.dataCollectorBuffer = [];
-  }
-
-  async close() {
-    clearInterval(this.bgScheduler);
-    // We call the data collector with what is still in the buffer.
-    await this.callGoffDataCollection();
-  }
-
-  /**
-   * callGoffDataCollection is a function called periodically to send the usage of the flag to the
-   * central service in charge of collecting the data.
-   */
-  async callGoffDataCollection() {
-    const dataToSend = copy(this.dataCollectorBuffer) || [];
-    this.dataCollectorBuffer = [];
-    try {
-      await this.goffApiController.collectData(dataToSend, this.dataCollectorMetadata);
-    } catch (e) {
-      if (!(e instanceof CollectorError)) {
-        throw e;
-      }
-      this.logger?.error(e);
-      // if we have an issue calling the collector, we put the data back in the buffer
-      this.dataCollectorBuffer = [...this.dataCollectorBuffer, ...dataToSend];
-      return;
-    }
+  constructor(collectorManager: CollectorManager) {
+    this.collectorManagger = collectorManager;
   }
 
   after(hookContext: HookContext, evaluationDetails: EvaluationDetails<FlagValue>) {
@@ -74,7 +23,7 @@ export class GoFeatureFlagDataCollectorHook implements Hook {
       userKey: hookContext.context.targetingKey || defaultTargetingKey,
       source: 'PROVIDER_CACHE',
     };
-    this.dataCollectorBuffer?.push(event);
+    this.collectorManagger?.add(event);
   }
 
   error(hookContext: HookContext) {
@@ -89,6 +38,6 @@ export class GoFeatureFlagDataCollectorHook implements Hook {
       userKey: hookContext.context.targetingKey || defaultTargetingKey,
       source: 'PROVIDER_CACHE',
     };
-    this.dataCollectorBuffer?.push(event);
+    this.collectorManagger?.add(event);
   }
 }

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

@@ -1,16 +1,9 @@
 import { GoFeatureFlagWebProvider } from './go-feature-flag-web-provider';
-import {
-  ErrorCode,
-  EvaluationContext,
-  EvaluationDetails,
-  JsonValue,
-  OpenFeature,
-  ProviderEvents,
-  StandardResolutionReasons,
-} from '@openfeature/web-sdk';
+import type { EvaluationContext, EvaluationDetails, JsonValue } from '@openfeature/web-sdk';
+import { ErrorCode, OpenFeature, ProviderEvents, StandardResolutionReasons } from '@openfeature/web-sdk';
 import WS from 'jest-websocket-mock';
 import TestLogger from './test-logger';
-import { DataCollectorRequest, GOFeatureFlagWebsocketResponse } from './model';
+import type { DataCollectorRequest, GOFeatureFlagWebsocketResponse, TrackingEvent } from './model';
 import fetchMock from 'fetch-mock-jest';
 
 describe('GoFeatureFlagWebProvider', () => {
@@ -456,156 +449,204 @@ describe('GoFeatureFlagWebProvider', () => {
   });
 
   describe('data collector testing', () => {
-    it('should call the data collector when closing Open Feature', async () => {
-      const clientName = expect.getState().currentTestName ?? 'test-provider';
-      await OpenFeature.setContext(defaultContext);
-      const p = new GoFeatureFlagWebProvider(
-        {
-          endpoint: endpoint,
-          apiTimeout: 1000,
-          maxRetries: 1,
-          dataFlushInterval: 10000,
-          apiKey: 'toto',
-        },
-        logger,
-      );
+    describe('tracking event', () => {
+      it('should send tracking event to the data collector', async () => {
+        const clientName = expect.getState().currentTestName ?? 'test-provider';
+        await OpenFeature.setContext(defaultContext);
+        const p = new GoFeatureFlagWebProvider(
+          {
+            endpoint: endpoint,
+            apiTimeout: 1000,
+            maxRetries: 1,
+            dataFlushInterval: 10000,
+          },
+          logger,
+        );
 
-      await OpenFeature.setProviderAndWait(clientName, p);
-      const client = OpenFeature.getClient(clientName);
-      await websocketMockServer.connected;
-      await new Promise((resolve) => setTimeout(resolve, 5));
+        await OpenFeature.setProviderAndWait(clientName, p);
+        const client = OpenFeature.getClient(clientName);
+        await websocketMockServer.connected;
+        await new Promise((resolve) => setTimeout(resolve, 5));
 
-      client.getBooleanDetails('bool_flag', false);
-      client.getBooleanDetails('bool_flag', false);
+        client.getBooleanDetails('bool_flag', false);
+        client.getBooleanDetails('bool_flag', false);
+        client.track('event-key-123abc', { value: 99.77, currency: 'USD' });
 
-      await OpenFeature.close();
+        await OpenFeature.close();
 
-      expect(fetchMock.calls(dataCollectorEndpoint).length).toBe(1);
-      expect(fetchMock.lastOptions(dataCollectorEndpoint)?.headers).toEqual({
-        'Content-Type': 'application/json',
-        Accept: 'application/json',
-        Authorization: 'Bearer toto',
+        expect(fetchMock.calls(dataCollectorEndpoint).length).toBe(1);
+        const reqBody = fetchMock.lastOptions(dataCollectorEndpoint)?.body;
+        const parsedBody = JSON.parse(reqBody as never) as DataCollectorRequest<never>;
+        expect(parsedBody.events.length).toBe(3);
+        expect(parsedBody.events.filter((event) => event.kind === 'tracking').length).toBe(1);
+        expect(parsedBody.events.filter((event) => event.kind === 'feature').length).toBe(2);
+
+        const trackingEvent = parsedBody.events.find((event) => event.kind === 'tracking');
+        expect(trackingEvent).not.toBeUndefined();
+        const c = trackingEvent as TrackingEvent;
+        expect(c.key).toEqual('event-key-123abc');
+        expect(c.kind).toEqual('tracking');
+        expect(c.contextKind).toEqual('user');
+        expect(c.userKey).toEqual(defaultContext.targetingKey);
+        expect(c.creationDate).toBeGreaterThan(0);
+        expect(c.evaluationContext).toEqual(defaultContext);
+        expect(c.trackingEventDetails).toEqual({ value: 99.77, currency: 'USD' });
       });
     });
 
-    it('should call the data collector when waiting more than the dataFlushInterval', async () => {
-      const clientName = expect.getState().currentTestName ?? 'test-provider';
-      await OpenFeature.setContext(defaultContext);
-      const p = new GoFeatureFlagWebProvider(
-        {
-          endpoint: endpoint,
-          apiTimeout: 1000,
-          maxRetries: 1,
-          dataFlushInterval: 200,
-        },
-        logger,
-      );
+    describe('feature event', () => {
+      it('should call the data collector when closing Open Feature', async () => {
+        const clientName = expect.getState().currentTestName ?? 'test-provider';
+        await OpenFeature.setContext(defaultContext);
+        const p = new GoFeatureFlagWebProvider(
+          {
+            endpoint: endpoint,
+            apiTimeout: 1000,
+            maxRetries: 1,
+            dataFlushInterval: 10000,
+            apiKey: 'toto',
+          },
+          logger,
+        );
 
-      await OpenFeature.setProviderAndWait(clientName, p);
-      const client = OpenFeature.getClient(clientName);
-      await websocketMockServer.connected;
-      await new Promise((resolve) => setTimeout(resolve, 5));
+        await OpenFeature.setProviderAndWait(clientName, p);
+        const client = OpenFeature.getClient(clientName);
+        await websocketMockServer.connected;
+        await new Promise((resolve) => setTimeout(resolve, 5));
 
-      client.getBooleanDetails('bool_flag', false);
-      client.getBooleanDetails('bool_flag', false);
+        client.getBooleanDetails('bool_flag', false);
+        client.getBooleanDetails('bool_flag', false);
 
-      await new Promise((resolve) => setTimeout(resolve, 300));
+        await OpenFeature.close();
 
-      expect(fetchMock.calls(dataCollectorEndpoint).length).toBe(1);
-      expect(fetchMock.lastOptions(dataCollectorEndpoint)?.headers).toEqual({
-        'Content-Type': 'application/json',
-        Accept: 'application/json',
+        expect(fetchMock.calls(dataCollectorEndpoint).length).toBe(1);
+        expect(fetchMock.lastOptions(dataCollectorEndpoint)?.headers).toEqual({
+          'Content-Type': 'application/json',
+          Accept: 'application/json',
+          Authorization: 'Bearer toto',
+        });
       });
-      await OpenFeature.close();
-    });
-    it('should call the data collector multiple time while waiting dataFlushInterval time', async () => {
-      const clientName = expect.getState().currentTestName ?? 'test-provider';
-      await OpenFeature.setContext(defaultContext);
-      const p = new GoFeatureFlagWebProvider(
-        {
-          endpoint: endpoint,
-          apiTimeout: 1000,
-          maxRetries: 1,
-          dataFlushInterval: 200,
-        },
-        logger,
-      );
 
-      await OpenFeature.setProviderAndWait(clientName, p);
-      const client = OpenFeature.getClient(clientName);
-      await websocketMockServer.connected;
-      await new Promise((resolve) => setTimeout(resolve, 5));
-      client.getBooleanDetails('bool_flag', false);
-      client.getBooleanDetails('bool_flag', false);
-      await new Promise((resolve) => setTimeout(resolve, 250));
-      client.getBooleanDetails('bool_flag', false);
-      client.getBooleanDetails('bool_flag', false);
-      await new Promise((resolve) => setTimeout(resolve, 300));
+      it('should call the data collector when waiting more than the dataFlushInterval', async () => {
+        const clientName = expect.getState().currentTestName ?? 'test-provider';
+        await OpenFeature.setContext(defaultContext);
+        const p = new GoFeatureFlagWebProvider(
+          {
+            endpoint: endpoint,
+            apiTimeout: 1000,
+            maxRetries: 1,
+            dataFlushInterval: 200,
+          },
+          logger,
+        );
 
-      expect(fetchMock.calls(dataCollectorEndpoint).length).toBe(2);
-      await OpenFeature.close();
-    });
+        await OpenFeature.setProviderAndWait(clientName, p);
+        const client = OpenFeature.getClient(clientName);
+        await websocketMockServer.connected;
+        await new Promise((resolve) => setTimeout(resolve, 5));
 
-    it('should not call the data collector before the dataFlushInterval', async () => {
-      const clientName = expect.getState().currentTestName ?? 'test-provider';
-      await OpenFeature.setContext(defaultContext);
-      const p = new GoFeatureFlagWebProvider(
-        {
-          endpoint: endpoint,
-          apiTimeout: 1000,
-          maxRetries: 1,
-          dataFlushInterval: 200,
-        },
-        logger,
-      );
+        client.getBooleanDetails('bool_flag', false);
+        client.getBooleanDetails('bool_flag', false);
 
-      await OpenFeature.setProviderAndWait(clientName, p);
-      const client = OpenFeature.getClient(clientName);
-      await websocketMockServer.connected;
-      await new Promise((resolve) => setTimeout(resolve, 5));
-      client.getBooleanDetails('bool_flag', false);
-      client.getBooleanDetails('bool_flag', false);
-      await new Promise((resolve) => setTimeout(resolve, 100));
+        await new Promise((resolve) => setTimeout(resolve, 300));
 
-      expect(fetchMock.calls(dataCollectorEndpoint).length).toBe(0);
-      await OpenFeature.close();
-    });
+        expect(fetchMock.calls(dataCollectorEndpoint).length).toBe(1);
+        expect(fetchMock.lastOptions(dataCollectorEndpoint)?.headers).toEqual({
+          'Content-Type': 'application/json',
+          Accept: 'application/json',
+        });
+        await OpenFeature.close();
+      });
+      it('should call the data collector multiple time while waiting dataFlushInterval time', async () => {
+        const clientName = expect.getState().currentTestName ?? 'test-provider';
+        await OpenFeature.setContext(defaultContext);
+        const p = new GoFeatureFlagWebProvider(
+          {
+            endpoint: endpoint,
+            apiTimeout: 1000,
+            maxRetries: 1,
+            dataFlushInterval: 200,
+          },
+          logger,
+        );
 
-    it('should have a log when data collector is not available', async () => {
-      const clientName = expect.getState().currentTestName ?? 'test-provider';
-      fetchMock.post(dataCollectorEndpoint, 500, { overwriteRoutes: true });
-      await OpenFeature.setContext(defaultContext);
-      const p = new GoFeatureFlagWebProvider(
-        {
-          endpoint: endpoint,
-          apiTimeout: 1000,
-          maxRetries: 1,
-          dataFlushInterval: 200,
-        },
-        logger,
-      );
+        await OpenFeature.setProviderAndWait(clientName, p);
+        const client = OpenFeature.getClient(clientName);
+        await websocketMockServer.connected;
+        await new Promise((resolve) => setTimeout(resolve, 5));
+        client.getBooleanDetails('bool_flag', false);
+        client.getBooleanDetails('bool_flag', false);
+        await new Promise((resolve) => setTimeout(resolve, 250));
+        client.getBooleanDetails('bool_flag', false);
+        client.getBooleanDetails('bool_flag', false);
+        await new Promise((resolve) => setTimeout(resolve, 300));
 
-      await OpenFeature.setProviderAndWait(clientName, p);
-      const client = OpenFeature.getClient(clientName);
-      await websocketMockServer.connected;
-      await new Promise((resolve) => setTimeout(resolve, 5));
-      client.getBooleanDetails('bool_flag', false);
-      client.getBooleanDetails('bool_flag', false);
-      await new Promise((resolve) => setTimeout(resolve, 250));
+        expect(fetchMock.calls(dataCollectorEndpoint).length).toBe(2);
+        await OpenFeature.close();
+      });
 
-      fetchMock.post(dataCollectorEndpoint, 500, { overwriteRoutes: true });
+      it('should not call the data collector before the dataFlushInterval', async () => {
+        const clientName = expect.getState().currentTestName ?? 'test-provider';
+        await OpenFeature.setContext(defaultContext);
+        const p = new GoFeatureFlagWebProvider(
+          {
+            endpoint: endpoint,
+            apiTimeout: 1000,
+            maxRetries: 1,
+            dataFlushInterval: 200,
+          },
+          logger,
+        );
 
-      client.getBooleanDetails('bool_flag', false);
-      client.getBooleanDetails('bool_flag', false);
-      fetchMock.post(dataCollectorEndpoint, 200, { overwriteRoutes: true });
-      await new Promise((resolve) => setTimeout(resolve, 250));
+        await OpenFeature.setProviderAndWait(clientName, p);
+        const client = OpenFeature.getClient(clientName);
+        await websocketMockServer.connected;
+        await new Promise((resolve) => setTimeout(resolve, 5));
+        client.getBooleanDetails('bool_flag', false);
+        client.getBooleanDetails('bool_flag', false);
+        await new Promise((resolve) => setTimeout(resolve, 100));
 
-      const lastBody = fetchMock.lastOptions(dataCollectorEndpoint)?.body;
-      const parsedBody = JSON.parse(lastBody as never);
-      expect(parsedBody['events'].length).toBe(4);
-      await OpenFeature.close();
+        expect(fetchMock.calls(dataCollectorEndpoint).length).toBe(0);
+        await OpenFeature.close();
+      });
+
+      it('should have a log when data collector is not available', async () => {
+        const clientName = expect.getState().currentTestName ?? 'test-provider';
+        fetchMock.post(dataCollectorEndpoint, 500, { overwriteRoutes: true });
+        await OpenFeature.setContext(defaultContext);
+        const p = new GoFeatureFlagWebProvider(
+          {
+            endpoint: endpoint,
+            apiTimeout: 1000,
+            maxRetries: 1,
+            dataFlushInterval: 200,
+          },
+          logger,
+        );
+
+        await OpenFeature.setProviderAndWait(clientName, p);
+        const client = OpenFeature.getClient(clientName);
+        await websocketMockServer.connected;
+        await new Promise((resolve) => setTimeout(resolve, 5));
+        client.getBooleanDetails('bool_flag', false);
+        client.getBooleanDetails('bool_flag', false);
+        await new Promise((resolve) => setTimeout(resolve, 250));
+
+        fetchMock.post(dataCollectorEndpoint, 500, { overwriteRoutes: true });
+
+        client.getBooleanDetails('bool_flag', false);
+        client.getBooleanDetails('bool_flag', false);
+        fetchMock.post(dataCollectorEndpoint, 200, { overwriteRoutes: true });
+        await new Promise((resolve) => setTimeout(resolve, 250));
+
+        const lastBody = fetchMock.lastOptions(dataCollectorEndpoint)?.body;
+        const parsedBody = JSON.parse(lastBody as never);
+        expect(parsedBody['events'].length).toBe(4);
+        await OpenFeature.close();
+      });
     });
   });
+
   it('should resolve when WebSocket is open', async () => {
     const provider = new GoFeatureFlagWebProvider({ endpoint: 'http://localhost:1031', apiTimeout: 1000 });
     await provider.initialize({ targetingKey: 'user-key' });
@@ -658,7 +699,13 @@ describe('GoFeatureFlagWebProvider', () => {
     expect(fetchMock.calls(dataCollectorEndpoint).length).toBe(1);
     const jsonBody = fetchMock.lastOptions(dataCollectorEndpoint)?.body;
     const body = JSON.parse(jsonBody as never) as DataCollectorRequest<never>;
-    expect(body.meta).toEqual({ browser: 'chrome', version: '1.0.0', score: 123, openfeature: true, provider: 'web' });
+    expect(body.meta).toEqual({
+      browser: 'chrome',
+      version: '1.0.0',
+      score: 123,
+      openfeature: true,
+      provider: 'web',
+    });
   });
 });
 

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

@@ -1,27 +1,32 @@
-import {
+import type {
   EvaluationContext,
-  FlagNotFoundError,
   FlagValue,
   Hook,
   Logger,
+  Provider,
+  ResolutionDetails,
+  TrackingEventDetails,
+} from '@openfeature/web-sdk';
+import {
+  FlagNotFoundError,
   OpenFeature,
   OpenFeatureEventEmitter,
-  Provider,
   ProviderEvents,
-  ResolutionDetails,
   StandardResolutionReasons,
   TypeMismatchError,
 } from '@openfeature/web-sdk';
-import {
+import type {
   FlagState,
   GoFeatureFlagAllFlagRequest,
   GOFeatureFlagAllFlagsResponse,
   GoFeatureFlagWebProviderOptions,
   GOFeatureFlagWebsocketResponse,
+  TrackingEvent,
 } from './model';
 import { transformContext } from './context-transformer';
 import { FetchError } from './errors/fetch-error';
 import { GoFeatureFlagDataCollectorHook } from './data-collector-hook';
+import { CollectorManager } from './collector-manager';
 
 export class GoFeatureFlagWebProvider implements Provider {
   metadata = {
@@ -49,6 +54,8 @@ export class GoFeatureFlagWebProvider implements Provider {
   private _websocket?: WebSocket;
   // _flags is the in memory representation of all the flags.
   private _flags: { [key: string]: ResolutionDetails<FlagValue> } = {};
+
+  private readonly _collectorManager: CollectorManager;
   private readonly _dataCollectorHook: GoFeatureFlagDataCollectorHook;
   // disableDataCollection set to true if you don't want to collect the usage of flags retrieved in the cache.
   private readonly _disableDataCollection: boolean;
@@ -62,13 +69,15 @@ export class GoFeatureFlagWebProvider implements Provider {
     this._maxRetries = options.maxRetries || 10;
     this._apiKey = options.apiKey;
     this._disableDataCollection = options.disableDataCollection || false;
-    this._dataCollectorHook = new GoFeatureFlagDataCollectorHook(options, logger);
+
+    this._collectorManager = new CollectorManager(options, logger);
+    this._dataCollectorHook = new GoFeatureFlagDataCollectorHook(this._collectorManager);
   }
 
   async initialize(context: EvaluationContext): Promise<void> {
     if (!this._disableDataCollection && this._dataCollectorHook) {
       this.hooks = [this._dataCollectorHook];
-      this._dataCollectorHook.init();
+      this._collectorManager.init();
     }
     return Promise.all([this.fetchAll(context), this.connectWebsocket()])
       .then(() => {
@@ -157,8 +166,8 @@ export class GoFeatureFlagWebProvider implements Provider {
   }
 
   async onClose(): Promise<void> {
-    if (!this._disableDataCollection && this._dataCollectorHook) {
-      await this._dataCollectorHook?.close();
+    if (!this._disableDataCollection && this._collectorManager) {
+      await this._collectorManager?.close();
     }
     this._websocket?.close(1000, 'Closing GO Feature Flag provider');
     return Promise.resolve();
@@ -187,6 +196,29 @@ export class GoFeatureFlagWebProvider implements Provider {
     return this.evaluate(flagKey, 'boolean');
   }
 
+  /**
+   * Track allows to send tracking events to a tracking exporter.
+   *
+   * Warning: Note that you need to have a relay proxy with version 1.45.0 or upper to use this feature.
+   * If you are using a version lower than 1.45.0, the events may look weird in your exporter.
+   *
+   * @param trackingEventName
+   * @param context
+   * @param trackingEventDetails
+   */
+  track(trackingEventName: string, context: EvaluationContext, trackingEventDetails: TrackingEventDetails): void {
+    const trackingEvent: TrackingEvent = {
+      kind: 'tracking',
+      contextKind: context['anonymous'] ? 'anonymousUser' : 'user',
+      creationDate: Math.round(Date.now() / 1000),
+      key: trackingEventName,
+      evaluationContext: context,
+      trackingEventDetails: trackingEventDetails,
+      userKey: context.targetingKey || 'undefined-targetingKey',
+    };
+    this._collectorManager?.add(trackingEvent);
+  }
+
   /**
    * extract flag names from the websocket answer
    */

libs/providers/go-feature-flag-web/src/lib/model.ts

@@ -1,5 +1,11 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { ErrorCode, EvaluationContextValue, FlagValue } from '@openfeature/web-sdk';
+import type {
+  ErrorCode,
+  EvaluationContext,
+  EvaluationContextValue,
+  FlagValue,
+  TrackingEventDetails,
+} from '@openfeature/web-sdk';
 
 /**
  * GoFeatureFlagEvaluationContext is the representation of a user for GO Feature Flag
@@ -106,7 +112,7 @@ export interface GOFeatureFlagWebsocketResponse {
 }
 
 export interface DataCollectorRequest<T> {
-  events: FeatureEvent<T>[];
+  events: Array<FeatureEvent<T> | TrackingEvent>;
   meta: Record<string, ExporterMetadataValue>;
 }
 
@@ -122,3 +128,13 @@ export interface FeatureEvent<T> {
   version?: string;
   source?: string;
 }
+
+export interface TrackingEvent {
+  kind: string;
+  contextKind: string;
+  userKey: string;
+  creationDate: number;
+  key: string;
+  evaluationContext: EvaluationContext;
+  trackingEventDetails: TrackingEventDetails;
+}

libs/providers/go-feature-flag/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## [0.7.8](https://github.com/open-feature/js-sdk-contrib/compare/go-feature-flag-provider-v0.7.7...go-feature-flag-provider-v0.7.8) (2025-05-26)
+
+
+### ✨ New Features
+
+* **gofeatureflag:** added cache option ([#1284](https://github.com/open-feature/js-sdk-contrib/issues/1284)) ([7083655](https://github.com/open-feature/js-sdk-contrib/commit/7083655c78eed957502f46dc202522a604024886))
+
 ## [0.7.7](https://github.com/open-feature/js-sdk-contrib/compare/go-feature-flag-provider-v0.7.6...go-feature-flag-provider-v0.7.7) (2025-04-11)
 
 

libs/providers/go-feature-flag/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openfeature/go-feature-flag-provider",
-  "version": "0.7.7",
+  "version": "0.7.8",
   "license": "Apache-2.0",
   "scripts": {
     "publish-if-not-exists": "cp $NPM_CONFIG_USERCONFIG .npmrc && if [ \"$(npm show $npm_package_name@$npm_package_version version)\" = \"$(npm run current-version -s)\" ]; then echo 'already published, skipping'; else npm publish --access public; fi",
@@ -12,7 +12,7 @@
   "dependencies": {
     "object-hash": "^3.0.0",
     "lru-cache": "^11.0.0",
-    "axios": "1.8.4",
+    "axios": "1.10.0",
     "copy-anything": "^3.0.5"
   }
 }

libs/providers/go-feature-flag/src/lib/context-transfomer.spec.ts

@@ -1,5 +1,5 @@
-import { EvaluationContext } from '@openfeature/server-sdk';
-import { GOFFEvaluationContext } from './model';
+import type { EvaluationContext } from '@openfeature/server-sdk';
+import type { GOFFEvaluationContext } from './model';
 import { transformContext } from './context-transformer';
 
 describe('contextTransformer', () => {

libs/providers/go-feature-flag/src/lib/context-transformer.ts

@@ -1,6 +1,6 @@
-import { EvaluationContext } from '@openfeature/server-sdk';
+import type { EvaluationContext } from '@openfeature/server-sdk';
 import { sha1 } from 'object-hash';
-import { GOFFEvaluationContext } from './model';
+import type { GOFFEvaluationContext } from './model';
 
 /**
  * transformContext takes the raw OpenFeature context returns a GoFeatureFlagUser.

libs/providers/go-feature-flag/src/lib/controller/cache.ts

@@ -1,5 +1,5 @@
-import { GoFeatureFlagProviderOptions } from '../model';
-import { EvaluationContext, Logger, ResolutionDetails } from '@openfeature/server-sdk';
+import type { GoFeatureFlagProviderOptions, Cache } from '../model';
+import type { EvaluationContext, Logger, ResolutionDetails } from '@openfeature/server-sdk';
 import { LRUCache } from 'lru-cache';
 import hash from 'object-hash';
 
@@ -10,7 +10,7 @@ export class CacheController {
   // logger is the Open Feature logger to use
   private logger?: Logger;
   // cache contains the local cache used in the provider to avoid calling the relay-proxy for every evaluation
-  private readonly cache?: LRUCache<string, ResolutionDetails<any>>;
+  private readonly cache?: Cache;
   // options for this provider
   private readonly options: GoFeatureFlagProviderOptions;
 
@@ -20,7 +20,7 @@ export class CacheController {
     this.logger = logger;
     const cacheSize =
       options.flagCacheSize !== undefined && options.flagCacheSize !== 0 ? options.flagCacheSize : 10000;
-    this.cache = new LRUCache({ maxSize: cacheSize, sizeCalculation: () => 1 });
+    this.cache = options.cache || new LRUCache({ maxSize: cacheSize, sizeCalculation: () => 1 });
   }
 
   get(flagKey: string, evaluationContext: EvaluationContext): ResolutionDetails<any> | undefined {

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

@@ -1,5 +1,4 @@
-import {
-  ConfigurationChange,
+import type {
   DataCollectorRequest,
   DataCollectorResponse,
   ExporterMetadataValue,
@@ -8,15 +7,9 @@ import {
   GoFeatureFlagProxyRequest,
   GoFeatureFlagProxyResponse,
 } from '../model';
-import {
-  ErrorCode,
-  EvaluationContext,
-  FlagNotFoundError,
-  Logger,
-  ResolutionDetails,
-  StandardResolutionReasons,
-  TypeMismatchError,
-} from '@openfeature/server-sdk';
+import { ConfigurationChange } from '../model';
+import type { EvaluationContext, Logger, ResolutionDetails } from '@openfeature/server-sdk';
+import { ErrorCode, FlagNotFoundError, StandardResolutionReasons, TypeMismatchError } from '@openfeature/server-sdk';
 import { transformContext } from '../context-transformer';
 import axios, { isAxiosError } from 'axios';
 import { Unauthorized } from '../errors/unauthorized';

libs/providers/go-feature-flag/src/lib/data-collector-hook.ts

@@ -1,15 +1,9 @@
-import {
-  EvaluationDetails,
-  FlagValue,
-  Hook,
-  HookContext,
-  Logger,
-  StandardResolutionReasons,
-} from '@openfeature/server-sdk';
-import { DataCollectorHookOptions, ExporterMetadataValue, FeatureEvent } from './model';
+import type { EvaluationDetails, FlagValue, Hook, HookContext, Logger } from '@openfeature/server-sdk';
+import { StandardResolutionReasons } from '@openfeature/server-sdk';
+import type { DataCollectorHookOptions, ExporterMetadataValue, FeatureEvent } from './model';
 import { copy } from 'copy-anything';
 import { CollectorError } from './errors/collector-error';
-import { GoffApiController } from './controller/goff-api';
+import type { GoffApiController } from './controller/goff-api';
 
 const defaultTargetingKey = 'undefined-targetingKey';
 type Timer = ReturnType<typeof setInterval>;

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

@@ -1,17 +1,12 @@
 /**
  * @jest-environment node
  */
-import {
-  Client,
-  ErrorCode,
-  OpenFeature,
-  ServerProviderStatus,
-  StandardResolutionReasons,
-} from '@openfeature/server-sdk';
+import type { Client } from '@openfeature/server-sdk';
+import { ErrorCode, OpenFeature, ServerProviderStatus, StandardResolutionReasons } from '@openfeature/server-sdk';
 import axios from 'axios';
 import MockAdapter from 'axios-mock-adapter';
 import { GoFeatureFlagProvider } from './go-feature-flag-provider';
-import { GoFeatureFlagProxyResponse } from './model';
+import type { GoFeatureFlagProxyResponse } from './model';
 import TestLogger from './test-logger';
 
 describe('GoFeatureFlagProvider', () => {