Move assignment cache to IndexedDB, scoped by clientToken

packages/browser/jest.config.js

@@ -1,6 +1,7 @@
 module.exports = {
   preset: 'ts-jest',
   testEnvironment: 'jsdom',
+  setupFiles: ['<rootDir>/test/setup-indexeddb.ts'],
   setupFilesAfterEnv: ['<rootDir>/src/test-setup.ts'],
   transform: {
     '^.+\\.ts$': [

packages/browser/src/cache/assignment-cache-factory.ts

@@ -1,34 +1,26 @@
 import type { AssignmentCache } from '@datadog/flagging-core'
-import ChromeStorageAssignmentCache from './chrome-storage-assignment-cache'
-import { hasWindowLocalStorage } from './helpers'
+import { hasIndexedDB } from './helpers'
 import HybridAssignmentCache from './hybrid-assignment-cache'
-import { LocalStorageAssignmentCache } from './local-storage-assignment-cache'
+import { IndexedDBAssignmentCache } from './indexeddb-assignment-cache'
 import SimpleAssignmentCache from './simple-assignment-cache'
 
 export function assignmentCacheFactory({
   forceMemoryOnly = false,
-  chromeStorage,
-  storageKeySuffix,
+  clientToken,
 }: {
   forceMemoryOnly?: boolean
-  storageKeySuffix: string
-  chromeStorage?: chrome.storage.StorageArea
+  clientToken: string
 }): AssignmentCache {
   const simpleCache = new SimpleAssignmentCache()
 
   if (forceMemoryOnly) {
     return simpleCache
   }
 
-  if (chromeStorage) {
-    const chromeStorageCache = new ChromeStorageAssignmentCache(chromeStorage)
-    return new HybridAssignmentCache(simpleCache, chromeStorageCache)
-  } else {
-    if (hasWindowLocalStorage()) {
-      const localStorageCache = new LocalStorageAssignmentCache(storageKeySuffix)
-      return new HybridAssignmentCache(simpleCache, localStorageCache)
-    } else {
-      return simpleCache
-    }
+  if (hasIndexedDB()) {
+    const indexedDBCache = new IndexedDBAssignmentCache(clientToken)
+    return new HybridAssignmentCache(simpleCache, indexedDBCache)
   }
+
+  return simpleCache
 }

packages/browser/src/cache/helpers.ts

@@ -1,25 +1,3 @@
-export function hasChromeStorage(): boolean {
-  return typeof chrome !== 'undefined' && !!chrome.storage
-}
-
-export function chromeStorageIfAvailable(): chrome.storage.StorageArea | undefined {
-  return hasChromeStorage() ? chrome.storage.local : undefined
-}
-
-/** Returns whether `window.localStorage` is available */
-export function hasWindowLocalStorage(): boolean {
-  try {
-    return typeof window !== 'undefined' && !!window.localStorage
-  } catch {
-    // Chrome throws an error if local storage is disabled, and you try to access it
-    return false
-  }
-}
-
-export function localStorageIfAvailable(): Storage | undefined {
-  return hasWindowLocalStorage() ? window.localStorage : undefined
-}
-
 /** Returns whether IndexedDB is available */
 export function hasIndexedDB(): boolean {
   try {

packages/browser/src/cache/indexeddb-assignment-cache.ts

@@ -0,0 +1,114 @@
+import {
+  type AssignmentCacheEntry,
+  assignmentCacheKeyToString,
+  assignmentCacheValueToString,
+  buildStorageKeySuffix,
+} from '@datadog/flagging-core'
+
+import type { BulkReadAssignmentCache } from './hybrid-assignment-cache'
+import { openDB, STORE_NAME } from './indexeddb-store'
+
+export class IndexedDBAssignmentCache implements BulkReadAssignmentCache {
+  private readonly storageKey: string
+  private readonly mirror: Map<string, string> = new Map()
+  private persistScheduled = false
+
+  constructor(clientToken: string) {
+    this.storageKey = `assignments-${buildStorageKeySuffix(clientToken)}`
+  }
+
+  /** No-op — IndexedDB entries are loaded lazily via getEntries(). */
+  init(): Promise<void> {
+    return Promise.resolve()
+  }
+
+  /** Fire-and-forget persist to IndexedDB. Never blocks the caller, never throws. */
+  set(entry: AssignmentCacheEntry): void {
+    const key = assignmentCacheKeyToString(entry)
+    const value = assignmentCacheValueToString(entry)
+    this.mirror.set(key, value)
+    this.persist()
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  has(_entry: AssignmentCacheEntry): boolean {
+    throw new Error('This should never be called for IndexedDBAssignmentCache, use getEntries() instead.')
+  }
+
+  /** Read all persisted entries. Returns [] on any error — never throws. */
+  async getEntries(): Promise<[string, string][]> {
+    try {
+      const db = await openDB()
+      try {
+        const entries = await new Promise<[string, string][] | undefined>((resolve, reject) => {
+          const tx = db.transaction(STORE_NAME, 'readonly')
+          const store = tx.objectStore(STORE_NAME)
+          const request = store.get(this.storageKey)
+          request.onsuccess = () => resolve(request.result as [string, string][] | undefined)
+          request.onerror = () => reject(request.error)
+        })
+        if (Array.isArray(entries)) {
+          this.mirror.clear()
+          for (const [k, v] of entries) {
+            this.mirror.set(k, v)
+          }
+          return entries
+        }
+      } finally {
+        db.close()
+      }
+    } catch {
+      // Silently fail — persistence should never break the SDK
+    }
+    return []
+  }
+
+  /** Remove persisted entries. Never throws. */
+  async clear(): Promise<void> {
+    this.mirror.clear()
+    try {
+      const db = await openDB()
+      try {
+        await new Promise<void>((resolve, reject) => {
+          const tx = db.transaction(STORE_NAME, 'readwrite')
+          const store = tx.objectStore(STORE_NAME)
+          store.delete(this.storageKey)
+          tx.oncomplete = () => resolve()
+          tx.onerror = () => reject(tx.error)
+          tx.onabort = () => reject(tx.error)
+        })
+      } finally {
+        db.close()
+      }
+    } catch {
+      // Silently fail
+    }
+  }
+
+  /**
+   * Schedule a fire-and-forget write for the next microtask. Coalesces rapid set() calls
+   * into a single IDB transaction, avoiding O(n^2) write volume and out-of-order races.
+   */
+  private persist(): void {
+    if (this.persistScheduled) {
+      return
+    }
+    this.persistScheduled = true
+    queueMicrotask(() => {
+      this.persistScheduled = false
+      const entries = Array.from(this.mirror.entries())
+      openDB()
+        .then((db) => {
+          const tx = db.transaction(STORE_NAME, 'readwrite')
+          const store = tx.objectStore(STORE_NAME)
+          store.put(entries, this.storageKey)
+          tx.oncomplete = () => db.close()
+          tx.onerror = () => db.close()
+          tx.onabort = () => db.close()
+        })
+        .catch(() => {
+          // Silently fail — persistence should never break the SDK
+        })
+    })
+  }
+}

packages/browser/src/cache/indexeddb-flags-cache.ts

@@ -1,24 +1,7 @@
 import type { FlagsConfiguration } from '@datadog/flagging-core'
 import { buildStorageKeySuffix, getMD5Hash } from '@datadog/flagging-core'
 import type { EvaluationContext } from '@openfeature/web-sdk'
-
-const DB_NAME = 'dd-flagging'
-const DB_VERSION = 1
-const STORE_NAME = 'configurations'
-
-function openDB(): Promise<IDBDatabase> {
-  return new Promise((resolve, reject) => {
-    const request = indexedDB.open(DB_NAME, DB_VERSION)
-    request.onupgradeneeded = () => {
-      const db = request.result
-      if (!db.objectStoreNames.contains(STORE_NAME)) {
-        db.createObjectStore(STORE_NAME)
-      }
-    }
-    request.onsuccess = () => resolve(request.result)
-    request.onerror = () => reject(request.error)
-  })
-}
+import { openDB, STORE_NAME } from './indexeddb-store'
 
 function buildConfigKey(clientToken: string, context: EvaluationContext): string {
   const tokenSuffix = buildStorageKeySuffix(clientToken)

packages/browser/src/cache/indexeddb-store.ts

@@ -0,0 +1,17 @@
+export const DB_NAME = 'dd-flagging'
+export const DB_VERSION = 1
+export const STORE_NAME = 'configurations'
+
+export function openDB(): Promise<IDBDatabase> {
+  return new Promise((resolve, reject) => {
+    const request = indexedDB.open(DB_NAME, DB_VERSION)
+    request.onupgradeneeded = () => {
+      const db = request.result
+      if (!db.objectStoreNames.contains(STORE_NAME)) {
+        db.createObjectStore(STORE_NAME)
+      }
+    }
+    request.onsuccess = () => resolve(request.result)
+    request.onerror = () => reject(request.error)
+  })
+}