✨ [FFL-24] add openfeature dependency and datadog provider

Author: leoromanovsky

LICENSE-3rdparty.csv

@@ -6,12 +6,16 @@ file,tracekit,MIT,Copyright 2013 Onur Can Cakmak and all TraceKit contributors
 file,web-vitals,Apache-2.0,Copyright 2020 Google LLC
 prod,@mantine/core,MIT,Copyright (c) 2021 Vitaly Rtishchev
 prod,@mantine/hooks,MIT,Copyright (c) 2021 Vitaly Rtishchev
+prod,@openfeature/core,Apache-2.0,Copyright Linux Foundation
+prod,@openfeature/web-sdk,Apache-2.0,Copyright Linux Foundation
 prod,@tabler/icons-react,MIT,Copyright (c) 2020-2023 Paweł Kuna
 prod,clsx,MIT,Copyright (c) Luke Edwards <[email protected]> (lukeed.com)
 prod,react,MIT,Copyright (c) Facebook, Inc. and its affiliates.
 prod,react-dom,MIT,Copyright (c) Facebook, Inc. and its affiliates.
 dev,@eslint/js,MIT,Copyright OpenJS Foundation and other contributors, <www.openjsf.org>
 dev,@jsdevtools/coverage-istanbul-loader,MIT,Copyright (c) 2015 James Messinger
+dev,@openfeature/core,Apache-2.0,Copyright Linux Foundation
+dev,@openfeature/web-sdk,Apache-2.0,Copyright Linux Foundation
 dev,@playwright/test,Apache-2.0,Copyright Microsoft Corporation
 dev,@types/chrome,MIT,Copyright Microsoft Corporation
 dev,@types/connect-busboy,MIT,Copyright Microsoft Corporation
@@ -72,4 +76,4 @@ dev,webpack,MIT,Copyright JS Foundation and other contributors
 dev,webpack-cli,MIT,Copyright JS Foundation and other contributors
 dev,webpack-dev-middleware,MIT,Copyright JS Foundation and other contributors
 dev,@swc/core,Apache-2.0,Copyright (c) SWC Contributors
-dev,swc-loader,MIT,Copyright (c) SWC Contributors
+dev,swc-loader,MIT,Copyright (c) SWC Contributors

packages/flagging/README.md

@@ -1,3 +1,29 @@
 # Flagging SDK (Prerelease)
 
 This package supports flagging and experimentation by performing evaluation in the browser.
+
+## Initialize
+
+```typescript
+import { DatadogProvider } from '@datadog/browser-flagging'
+
+const datadogFlaggingProvider = new DatadogProvider()
+
+// provide the subject
+const subject = {
+  key: 'subject-key-1',
+}
+await OpenFeature.setContext(subject)
+
+// initialize
+await OpenFeature.setProviderAndWait(datadogFlaggingProvider)
+```
+
+## Evaluation
+
+```typescript
+const client = OpenFeature.getClient()
+
+// provide the flag key and a default value which is returned for exceptional conditions.
+const flagEval = client.getBooleanValue('<FLAG_KEY>', false)
+```

packages/flagging/package.json

@@ -15,10 +15,14 @@
     "replace-build-env": "node ../../scripts/build/replace-build-env.js"
   },
   "dependencies": {
-    "@datadog/browser-core": "6.8.0"
+    "@datadog/browser-core": "6.8.0",
+    "@openfeature/core": "1.8.0",
+    "@openfeature/web-sdk": "1.5.0"
   },
   "peerDependencies": {
-    "@datadog/browser-rum": "6.8.0"
+    "@datadog/browser-rum": "6.8.0",
+    "@openfeature/core": "1.8.0",
+    "@openfeature/web-sdk": "1.5.0"
   },
   "peerDependenciesMeta": {
     "@datadog/browser-rum": {

packages/flagging/src/configuration-store/configurationStore.ts

@@ -0,0 +1,7 @@
+export interface ISyncStore<T> {
+  get(key: string): T | null
+  entries(): Record<string, T>
+  getKeys(): string[]
+  isInitialized(): boolean
+  setEntries(entries: Record<string, T>): void
+}

packages/flagging/src/configuration-store/memoryStore.spec.ts

@@ -0,0 +1,52 @@
+import { createMemoryStore } from './memoryStore'
+
+describe('MemoryOnlyConfigurationStore', () => {
+  let memoryStore: ReturnType<typeof createMemoryStore<string>>
+
+  beforeEach(() => {
+    memoryStore = createMemoryStore()
+  })
+
+  it('should initialize without any entries', () => {
+    expect(memoryStore.isInitialized()).toBe(false)
+    expect(memoryStore.getKeys()).toEqual([])
+  })
+
+  it('should return null for non-existent keys', () => {
+    expect(memoryStore.get('nonexistent')).toBeNull()
+  })
+
+  it('should allow setting and retrieving entries', () => {
+    memoryStore.setEntries({ key1: 'value1', key2: 'value2' })
+    expect(memoryStore.get('key1')).toBe('value1')
+    expect(memoryStore.get('key2')).toBe('value2')
+  })
+
+  it('should report initialized after setting entries', () => {
+    memoryStore.setEntries({ key1: 'value1' })
+    expect(memoryStore.isInitialized()).toBe(true)
+  })
+
+  it('should return all keys', () => {
+    memoryStore.setEntries({ key1: 'value1', key2: 'value2', key3: 'value3' })
+    expect(memoryStore.getKeys()).toEqual(['key1', 'key2', 'key3'])
+  })
+
+  it('should return all entries', () => {
+    const entries = { key1: 'value1', key2: 'value2', key3: 'value3' }
+    memoryStore.setEntries(entries)
+    expect(memoryStore.entries()).toEqual(entries)
+  })
+
+  it('should overwrite existing entries', () => {
+    memoryStore.setEntries({ toBeReplaced: 'old value', toBeRemoved: 'delete me' })
+    expect(memoryStore.get('toBeReplaced')).toBe('old value')
+    expect(memoryStore.get('toBeRemoved')).toBe('delete me')
+    expect(memoryStore.get('toBeAdded')).toBeNull()
+
+    memoryStore.setEntries({ toBeReplaced: 'new value', toBeAdded: 'add me' })
+    expect(memoryStore.get('toBeReplaced')).toBe('new value')
+    expect(memoryStore.get('toBeRemoved')).toBeNull()
+    expect(memoryStore.get('toBeAdded')).toBe('add me')
+  })
+})

packages/flagging/src/configuration-store/memoryStore.ts

@@ -0,0 +1,29 @@
+import type { ISyncStore } from './configurationStore'
+
+export function createMemoryStore<T>(): ISyncStore<T> {
+  let store: Record<string, T> = {}
+  let initialized = false
+
+  return {
+    get(key: string): T | null {
+      return store[key] ?? null
+    },
+
+    entries(): Record<string, T> {
+      return store
+    },
+
+    getKeys(): string[] {
+      return Object.keys(store)
+    },
+
+    isInitialized(): boolean {
+      return initialized
+    },
+
+    setEntries(entries: Record<string, T>): void {
+      store = { ...entries }
+      initialized = true
+    },
+  }
+}

packages/flagging/src/configuration-wire/configurationWireTypes.spec.ts

@@ -0,0 +1,24 @@
+import { MOCK_DEOBFUSCATED_PRECOMPUTED_RESPONSE_FILE, readMockConfigurationWireResponse } from '../../test/helpers'
+import { configurationWireV1 } from './configurationWireTypes'
+
+describe('Response String Type Safety', () => {
+  const mockFlagConfig = readMockConfigurationWireResponse(MOCK_DEOBFUSCATED_PRECOMPUTED_RESPONSE_FILE)
+
+  describe('ConfigurationWireV1', () => {
+    it('should create empty configuration', () => {
+      const config = configurationWireV1.empty()
+
+      expect(config.version).toBe(1)
+      expect(config.precomputed).toBeUndefined()
+    })
+
+    it('should include fetchedAt timestamps', () => {
+      const wirePacket = configurationWireV1.fromString(mockFlagConfig)
+
+      expect(wirePacket.precomputed).toBeDefined()
+      expect(wirePacket.precomputed?.response).toBeDefined()
+      expect(wirePacket.precomputed?.subjectKey).toBeDefined()
+      expect(wirePacket.precomputed?.subjectAttributes).toBeDefined()
+    })
+  })
+})

packages/flagging/src/configuration-wire/configurationWireTypes.ts

@@ -0,0 +1,99 @@
+import type { ContextAttributes, Environment, FlagKey, PrecomputedFlag } from '../interfaces'
+import { FormatEnum } from '../interfaces'
+
+// Base interface for all configuration responses
+interface IBasePrecomputedConfigurationResponse {
+  readonly format: FormatEnum.PRECOMPUTED
+  readonly obfuscated: boolean
+  readonly createdAt: string
+  readonly environment?: Environment
+  readonly subjectKey: string
+  readonly subjectAttributes?: ContextAttributes
+}
+
+export interface IPrecomputedConfigurationResponse extends IBasePrecomputedConfigurationResponse {
+  readonly obfuscated: false // Always false
+  readonly flags: Record<FlagKey, PrecomputedFlag>
+}
+
+export interface IPrecomputedConfiguration {
+  // JSON encoded configuration response (obfuscated or unobfuscated)
+  readonly response: string
+  readonly subjectKey: string
+  readonly subjectAttributes?: ContextAttributes
+}
+
+export function createPrecomputedConfiguration(
+  response: string,
+  subjectKey: string,
+  subjectAttributes?: ContextAttributes
+): IPrecomputedConfiguration {
+  return {
+    response,
+    subjectKey,
+    subjectAttributes,
+  }
+}
+
+export function createUnobfuscatedPrecomputedConfiguration(
+  subjectKey: string,
+  flags: Record<FlagKey, PrecomputedFlag>,
+  subjectAttributes?: ContextAttributes,
+  environment?: Environment
+): IPrecomputedConfiguration {
+  const response = createPrecomputedConfigurationResponse(subjectKey, flags, subjectAttributes, environment)
+  return createPrecomputedConfiguration(JSON.stringify(response), subjectKey, subjectAttributes)
+}
+
+export function createPrecomputedConfigurationResponse(
+  subjectKey: string,
+  flags: Record<FlagKey, PrecomputedFlag>,
+  subjectAttributes?: ContextAttributes,
+  environment?: Environment
+): IPrecomputedConfigurationResponse {
+  return {
+    format: FormatEnum.PRECOMPUTED,
+    obfuscated: false,
+    createdAt: new Date().toISOString(),
+    subjectKey,
+    subjectAttributes,
+    environment,
+    flags,
+  }
+}
+
+// "Wire" in the name means "in-transit"/"file" format.
+// In-memory representation may differ significantly and is up to SDKs.
+export interface IConfigurationWire {
+  /**
+   * Version field should be incremented for breaking format changes.
+   * For example, removing required fields or changing field type/meaning.
+   */
+  readonly version: number
+  readonly precomputed?: IPrecomputedConfiguration
+}
+
+export function createConfigurationWireV1(precomputed?: IPrecomputedConfiguration): IConfigurationWire {
+  return {
+    version: 1,
+    precomputed,
+  }
+}
+
+export const configurationWireV1 = {
+  fromString(str: string): IConfigurationWire {
+    return JSON.parse(str) as IConfigurationWire
+  },
+
+  precomputed(precomputedConfig: IPrecomputedConfiguration): IConfigurationWire {
+    return createConfigurationWireV1(precomputedConfig)
+  },
+
+  empty(): IConfigurationWire {
+    return createConfigurationWireV1()
+  },
+
+  toString(config: IConfigurationWire): string {
+    return JSON.stringify(config)
+  },
+}

packages/flagging/src/configurationFactory.ts

@@ -0,0 +1,7 @@
+import { ISyncStore } from './configuration-store/configurationStore'
+import { createMemoryStore } from './configuration-store/memoryStore'
+import type { PrecomputedFlag } from './interfaces'
+
+export function precomputedFlagsStorageFactory(): ISyncStore<PrecomputedFlag> {
+  return createMemoryStore()
+}

packages/flagging/src/entries/main.ts

@@ -1,9 +1,15 @@
 import { defineGlobal, getGlobalObject } from '@datadog/browser-core'
-import { flagging as importedFlagging } from '../hello'
+import { DatadogProvider } from '../openfeature/provider'
+import { offlinePrecomputedInit as offlineClientInit } from '../precomputeClient'
 
-export const datadogFlagging = importedFlagging
+export { DatadogProvider, offlineClientInit }
 
 interface BrowserWindow extends Window {
-  DD_FLAGGING?: typeof datadogFlagging
+  DD_FLAGGING?: DatadogProvider
 }
-defineGlobal(getGlobalObject<BrowserWindow>(), 'DD_FLAGGING', datadogFlagging)
+
+defineGlobal(
+  getGlobalObject<BrowserWindow>(),
+  'DD_FLAGGING',
+  new DatadogProvider(offlineClientInit({ precomputedConfiguration: '' }) ?? undefined)
+)