[FFL-2871] treat empty contexts literally

Author: sameerank

packages/browser/README.md

@@ -135,17 +135,26 @@ import { configurationFromString, DatadogProvider } from '@datadog/openfeature-b
 
 `DatadogOfflineProvider` is an opt-in evaluation-only provider for applications that supply their own flags configuration, such as an SSR bootstrap or offline init payload. It does not fetch or poll configuration.
 
-For static offline initialization, a precomputed-only configuration adopts its embedded context when the OpenFeature context is empty. You do not need to call `OpenFeature.setContext()`. An explicit non-empty context must match the embedded context.
+For static offline initialization, a context-specific precomputed configuration must use the OpenFeature context for which it was computed. Use `getPrecomputedContext()` to access a detached copy through the supported API. An empty context (`{}`) is treated literally and does not select the embedded context.
 
 ```javascript
-import { configurationFromString, DatadogOfflineProvider } from '@datadog/openfeature-browser/precomputed'
+import {
+  configurationFromString,
+  getPrecomputedContext,
+  DatadogOfflineProvider,
+} from '@datadog/openfeature-browser/precomputed'
 import { OpenFeature } from '@openfeature/web-sdk'
 
 const configuration = configurationFromString('...flags configuration string...')
 const provider = new DatadogOfflineProvider()
 provider.setConfiguration(configuration)
+const context = getPrecomputedContext(configuration)
 
-await OpenFeature.setProviderAndWait(provider)
+if (context === undefined) {
+  await OpenFeature.setProviderAndWait(provider)
+} else {
+  await OpenFeature.setProviderAndWait(provider, context)
+}
 
 const client = OpenFeature.getClient()
 const enabled = client.getBooleanValue('new-checkout', false)

packages/browser/src/openfeature/offline-provider.ts

@@ -31,9 +31,7 @@ export class DatadogOfflineProvider extends DatadogCoreProvider {
     const hadEvaluatableConfiguration = this.canEvaluateCurrentContext()
     this.flagsConfiguration = configuration
 
-    const error = toOpenFeatureError(
-      getFlagsConfigurationError(configuration, getEffectiveContext(configuration, this.context))
-    )
+    const error = toOpenFeatureError(getFlagsConfigurationError(configuration, this.context))
     if (error) {
       this.events.emit(ProviderEvents.Error, toProviderErrorEvent(error))
       return
@@ -47,25 +45,15 @@ export class DatadogOfflineProvider extends DatadogCoreProvider {
 
   async initialize(context: EvaluationContext = {}): Promise<void> {
     this.context = context
-    const error = toOpenFeatureError(
-      getFlagsConfigurationError(
-        this.flagsConfiguration,
-        getEffectiveContext(this.flagsConfiguration, this.context)
-      )
-    )
+    const error = toOpenFeatureError(getFlagsConfigurationError(this.flagsConfiguration, this.context))
     if (error) {
       throw error
     }
   }
 
   onContextChange(_oldContext: EvaluationContext, newContext: EvaluationContext): void {
     this.context = newContext
-    const error = toOpenFeatureError(
-      getFlagsConfigurationError(
-        this.flagsConfiguration,
-        getEffectiveContext(this.flagsConfiguration, this.context)
-      )
-    )
+    const error = toOpenFeatureError(getFlagsConfigurationError(this.flagsConfiguration, this.context))
     if (error) {
       throw error
     }
@@ -78,21 +66,11 @@ export class DatadogOfflineProvider extends DatadogCoreProvider {
     context: EvaluationContext,
     logger: Logger
   ): ResolutionDetails<FlagTypeToValue<T>> {
-    return evaluate(
-      this.flagsConfiguration,
-      type,
-      flagKey,
-      defaultValue,
-      getEffectiveContext(this.flagsConfiguration, context),
-      logger
-    )
+    return evaluate(this.flagsConfiguration, type, flagKey, defaultValue, context, logger)
   }
 
   private canEvaluateCurrentContext(): boolean {
-    return !getFlagsConfigurationError(
-      this.flagsConfiguration,
-      getEffectiveContext(this.flagsConfiguration, this.context)
-    )
+    return !getFlagsConfigurationError(this.flagsConfiguration, this.context)
   }
 }
 
@@ -102,19 +80,3 @@ function toOpenFeatureError(error: FlagsConfigurationError | undefined): Error |
   if (error.errorCode === 'INVALID_CONTEXT') return new InvalidContextError(error.errorMessage)
   return new ProviderNotReadyError(error.errorMessage)
 }
-
-function getEffectiveContext(
-  configuration: FlagsConfiguration | undefined,
-  context: EvaluationContext
-): EvaluationContext {
-  // An empty OpenFeature context means there is no external override for an offline precomputed configuration.
-  if (isEmptyContext(context) && configuration.precomputed?.context) {
-    return configuration.precomputed.context
-  }
-
-  return context
-}
-
-function isEmptyContext(context: EvaluationContext): boolean {
-  return Object.values(context).every((value) => value === undefined)
-}

packages/browser/test/openfeature/offline-provider.spec.ts

@@ -144,28 +144,30 @@ describe('DatadogOfflineProvider', () => {
     })
   })
 
-  it('adopts the context embedded in decoded precomputed configuration when initialized without a context', async () => {
-    const provider = new DatadogOfflineProvider({ configuration: decodedPrecomputedConfiguration })
+  it('treats an empty initialization context literally', async () => {
+    const provider = providerWithConfiguration(decodedPrecomputedConfiguration)
 
-    await expect(provider.initialize({})).resolves.toBeUndefined()
+    await expect(provider.initialize({})).rejects.toBeInstanceOf(InvalidContextError)
 
-    expect(provider.resolveStringEvaluation('string-flag', 'default', {}, logger)).toMatchObject({
-      value: 'red',
-      variant: 'variation-123',
-      reason: 'TARGETING_MATCH',
+    expect(provider.resolveStringEvaluation('string-flag', 'default', {}, logger)).toEqual({
+      value: 'default',
+      reason: 'ERROR',
+      errorCode: 'INVALID_CONTEXT',
+      errorMessage: 'Precomputed flags configuration does not match the current context',
     })
   })
 
-  it('treats a context containing only undefined values as empty', async () => {
-    const provider = new DatadogOfflineProvider({ configuration: precomputedConfiguration })
+  it('does not replace a context containing only undefined values with the embedded context', async () => {
+    const provider = providerWithConfiguration(precomputedConfiguration)
     const emptyContext = { targetingKey: undefined } as unknown as EvaluationContext
 
-    await expect(provider.initialize(emptyContext)).resolves.toBeUndefined()
+    await expect(provider.initialize(emptyContext)).rejects.toBeInstanceOf(InvalidContextError)
 
-    expect(provider.resolveStringEvaluation('static-flag', 'default', emptyContext, logger)).toMatchObject({
-      value: 'static-value',
-      variant: 'static-variation',
-      reason: 'TARGETING_MATCH',
+    expect(provider.resolveStringEvaluation('static-flag', 'default', emptyContext, logger)).toEqual({
+      value: 'default',
+      reason: 'ERROR',
+      errorCode: 'INVALID_CONTEXT',
+      errorMessage: 'Precomputed flags configuration does not match the current context',
     })
   })
 
@@ -284,7 +286,7 @@ describe('DatadogOfflineProvider', () => {
   })
 
   it('throws ProviderNotReadyError when initialized without evaluatable configuration', async () => {
-    const provider = new DatadogOfflineProvider({ configuration: {} })
+    const provider = new DatadogOfflineProvider()
 
     await expect(provider.initialize({})).rejects.toBeInstanceOf(ProviderNotReadyError)
   })
@@ -303,14 +305,15 @@ describe('DatadogOfflineProvider precomputed lifecycle', () => {
     OpenFeature.clearHandlers()
   })
 
-  it('recovers the embedded context after the OpenFeature context is cleared', async () => {
-    const provider = new DatadogOfflineProvider({ configuration: precomputedConfiguration })
-    await OpenFeature.setProviderAndWait(provider)
+  it('treats a cleared OpenFeature context as an empty context', async () => {
+    const provider = providerWithConfiguration(precomputedConfiguration)
+    const matchingContext = { targetingKey: 'static-user', plan: 'free' }
+    await OpenFeature.setProviderAndWait(provider, matchingContext)
     const client = OpenFeature.getClient()
 
     expect(client.getStringValue('static-flag', 'default')).toBe('static-value')
 
-    await OpenFeature.setContext({ targetingKey: 'other-user', plan: 'free' })
+    await OpenFeature.clearContext()
 
     const errorHandler = jest.fn()
     OpenFeature.addHandler(ProviderEvents.Error, errorHandler)
@@ -321,7 +324,7 @@ describe('DatadogOfflineProvider precomputed lifecycle', () => {
       errorCode: 'INVALID_CONTEXT',
     })
 
-    await OpenFeature.clearContext()
+    await OpenFeature.setContext(matchingContext)
 
     const readyHandler = jest.fn()
     OpenFeature.addHandler(ProviderEvents.Ready, readyHandler)