Add IndexedDB persistence for browser flag configurations#186
Merged
leoromanovsky merged 9 commits intomainfrom Feb 28, 2026
Merged
Add IndexedDB persistence for browser flag configurations#186leoromanovsky merged 9 commits intomainfrom
leoromanovsky merged 9 commits intomainfrom
Conversation
Store precomputed flag assignments in IndexedDB so the browser SDK can serve cached flags across page loads, surviving short backend outages (e.g., CDN maintenance windows) instead of falling back to programmatic defaults.
There was a problem hiding this comment.
Pull request overview
This PR adds IndexedDB-based persistence for flag configurations in the browser SDK, bringing it to feature parity with the iOS and Android SDKs. When the network is unavailable during initialization, the provider can now fall back to previously cached flags instead of failing, making the SDK more resilient to temporary outages.
Changes:
- Added IndexedDBFlagsCache class to persist and retrieve flag configurations from IndexedDB
- Modified DatadogProvider to load cached flags on initialization and persist successful network fetches
- Added comprehensive test coverage for cache operations and fallback behavior
Reviewed changes
Copilot reviewed 7 out of 8 changed files in this pull request and generated 2 comments.
Show a summary per file
| File | Description |
|---|---|
| packages/browser/src/cache/indexeddb-flags-cache.ts | New cache implementation for storing flag configurations in IndexedDB with graceful error handling |
| packages/browser/src/cache/helpers.ts | Added hasIndexedDB() helper for feature detection with try-catch protection |
| packages/browser/src/openfeature/provider.ts | Integrated cache loading on initialization and persistence after successful fetches, with fallback logic when network fails |
| packages/browser/test/cache/indexeddb-flags-cache.spec.ts | Comprehensive unit tests for cache operations including error scenarios and data validation |
| packages/browser/test/openfeature/provider-persistence.spec.ts | Integration tests verifying persistence behavior, network-first strategy, and graceful degradation |
| packages/browser/package.json | Added fake-indexeddb dev dependency for testing |
| yarn.lock | Added fake-indexeddb package resolution |
| LICENSE-3rdparty.csv | Added fake-indexeddb license attribution |
💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.
Resolve on tx.oncomplete instead of request.onsuccess so that writes are guaranteed to be persisted. A request can succeed but the transaction can still fail (e.g. quota errors), which would silently lose data under the old pattern.
leoromanovsky
commented
Feb 27, 2026
| private flagsConfiguration: FlagsConfiguration = {} | ||
| private configuration?: FlaggingConfiguration | ||
| private exposureCache: AssignmentCache | undefined | ||
| private flagsCache: IndexedDBFlagsCache | undefined |
Collaborator
Author
There was a problem hiding this comment.
I'll probably refactor this into an abstract type
greghuels
reviewed
Feb 27, 2026
greghuels
requested changes
Feb 27, 2026
Collaborator
greghuels
left a comment
greghuels
left a comment
There was a problem hiding this comment.
It's probably worth addressing the comments on how this.flagsConfiguration is set.
…fig guards Prevent cross-user flag leakage on shared computers by validating targetingKey before using cached data, skip cache when caller provides initialFlagsConfiguration, and isolate cache entries per SDK key.
greghuels
approved these changes
Feb 27, 2026
dd-oleksii
reviewed
Feb 27, 2026
…cache, STALE status - Store FlagsConfiguration objects directly in IndexedDB (no JSON stringify/parse — IndexedDB uses the structured clone algorithm). - Key cache entries by clientToken + hashed EvaluationContext, so different contexts don't collide. Removes the targetingKey comparison guard in provider.ts. - Make set() fire-and-forget — cache writes never block initialize or onContextChange, and never put the provider into ERROR state. - Exposure cache init runs concurrently with the network fetch. - Emit ProviderStatus.STALE / ProviderEvents.Stale when serving cached config after a fetch failure (instead of READY).
dd-oleksii
approved these changes
Feb 27, 2026
- Cache read now runs concurrently with the network fetch instead of
blocking it. Cached config is only used as fallback when fetch fails.
- Use full MD5 hash for context key (no truncation) to avoid collisions.
- Sort context keys before hashing so {a:1, b:2} and {b:2, a:1}
produce the same cache key.
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.This suggestion is invalid because no changes were made to the code.Suggestions cannot be applied while the pull request is closed.Suggestions cannot be applied while viewing a subset of changes.Only one suggestion per line can be applied in a batch.Add this suggestion to a batch that can be applied as a single commit.Applying suggestions on deleted lines is not supported.You must change the existing code in this line in order to create a valid suggestion.Outdated suggestions cannot be applied.This suggestion has been applied or marked resolved.Suggestions cannot be applied from pending reviews.Suggestions cannot be applied on multi-line comments.Suggestions cannot be applied while the pull request is queued to merge.Suggestion cannot be applied right now. Please check back later.
Motivation
The browser SDK currently has no disk persistence for flag configurations. If the network is unavailable during a page load (backend outage, flaky connection, CDN maintenance), users get no flags and fall back to programmatic defaults. iOS and Android SDKs both have disk-based caching that makes them resilient to short outages — this brings the browser SDK to parity.
Changes
The provider now stores the full precomputed flag configuration as a JSON blob in IndexedDB after every successful fetch. On the next page load, it reads the cached configuration from IndexedDB before hitting the network. If the network request fails but cached flags exist, the provider goes to READY state using the cached data instead of throwing an error. If IndexedDB is unavailable (private browsing, older browsers), the SDK works exactly as it does today — no behavior change.
Decisions
JSON.stringify/JSON.parseinstead of the wire format — The existingconfigurationToString/configurationFromStringhas a round-trip bug where it nests the response one level deep on deserialization. Direct serialization avoids this.initialize()when the network fails.flagsCacheis undefined and all optional-chain calls are no-ops.Question for reviewers
This is a non-breaking additive feature (no API changes, no behavior change when IndexedDB is unavailable). Should this ship as a patch release or a minor release?