fix: bootstrap flags do not overwrite the current values

posthog-core/src/index.ts

@@ -723,26 +723,65 @@ export abstract class PostHogCore extends PostHogCoreStateless {
     this._sessionExpirationTimeSeconds = options?.sessionExpirationTimeSeconds ?? 1800 // 30 minutes
   }
 
-  protected setupBootstrap(options?: Partial<PostHogCoreOptions>): void {
-    if (options?.bootstrap?.distinctId) {
-      if (options?.bootstrap?.isIdentifiedId) {
-        this.setPersistedProperty(PostHogPersistedProperty.DistinctId, options.bootstrap.distinctId)
+  protected setupBootstrap(options?: Partial<PostHogCoreOptions>, overwriteCurrentValues: boolean = true): void {
+    const bootstrap = options?.bootstrap
+    if (!bootstrap) {
+      return
+    }
+
+    // bootstrap options are only set if no persisted values are found
+    // this is to prevent overwriting existing values
+    if (bootstrap.distinctId) {
+      if (bootstrap.isIdentifiedId) {
+        const distinctId = this.getPersistedProperty(PostHogPersistedProperty.DistinctId)
+
+        if (overwriteCurrentValues || !distinctId) {
+          this.setPersistedProperty(PostHogPersistedProperty.DistinctId, bootstrap.distinctId)
+        }
       } else {
-        this.setPersistedProperty(PostHogPersistedProperty.AnonymousId, options.bootstrap.distinctId)
+        const anonymousId = this.getPersistedProperty(PostHogPersistedProperty.AnonymousId)
+
+        if (overwriteCurrentValues || !anonymousId) {
+          this.setPersistedProperty(PostHogPersistedProperty.AnonymousId, bootstrap.distinctId)
+        }
       }
     }
 
-    if (options?.bootstrap?.featureFlags) {
-      const activeFlags = Object.keys(options.bootstrap?.featureFlags || {})
-        .filter((flag) => !!options.bootstrap?.featureFlags?.[flag])
+    const bootstrapfeatureFlags = bootstrap.featureFlags
+    if (bootstrapfeatureFlags && Object.keys(bootstrapfeatureFlags).length) {
+      const bootstrapFlags = Object.keys(bootstrapfeatureFlags)
+        .filter((flag) => !!bootstrapfeatureFlags[flag])
         .reduce(
-          (res: Record<string, string | boolean>, key) => (
-            (res[key] = options.bootstrap?.featureFlags?.[key] || false), res
-          ),
+          (res: Record<string, string | boolean>, key) => ((res[key] = bootstrapfeatureFlags[key] || false), res),
           {}
         )
-      this.setKnownFeatureFlags(activeFlags)
-      options?.bootstrap.featureFlagPayloads && this.setKnownFeatureFlagPayloads(options?.bootstrap.featureFlagPayloads)
+
+      if (Object.keys(bootstrapFlags).length) {
+        const currentFlags =
+          this.getPersistedProperty<PostHogDecideResponse['featureFlags']>(PostHogPersistedProperty.FeatureFlags) || {}
+
+        if (overwriteCurrentValues) {
+          this.setKnownFeatureFlags(bootstrapFlags)
+        } else {
+          const newFeatureFlags = { ...bootstrapFlags, ...currentFlags }
+          this.setKnownFeatureFlags(newFeatureFlags)
+        }
+      }
+
+      const bootstrapFlagPayloads = bootstrap.featureFlagPayloads
+      if (bootstrapFlagPayloads && Object.keys(bootstrapFlagPayloads).length) {
+        const currentFlagPayloads =
+          this.getPersistedProperty<PostHogDecideResponse['featureFlagPayloads']>(
+            PostHogPersistedProperty.FeatureFlagPayloads
+          ) || {}
+
+        if (overwriteCurrentValues) {
+          this.setKnownFeatureFlagPayloads(bootstrapFlagPayloads)
+        } else {
+          const newFeatureFlagPayloads = { ...bootstrapFlagPayloads, ...currentFlagPayloads }
+          this.setKnownFeatureFlagPayloads(newFeatureFlagPayloads)
+        }
+      }
     }
   }
 

posthog-core/test/posthog.featureflags.spec.ts

@@ -586,4 +586,68 @@ describe('PostHog Core', () => {
       })
     })
   })
+
+  describe('bootstapped do not overwrite values', () => {
+    beforeEach(() => {
+      ;[posthog, mocks] = createTestClient(
+        'TEST_API_KEY',
+        {
+          flushAt: 1,
+          bootstrap: {
+            distinctId: 'tomato',
+            featureFlags: { 'bootstrap-1': 'variant-1', enabled: true, disabled: false },
+            featureFlagPayloads: {
+              'bootstrap-1': {
+                some: 'key',
+              },
+              enabled: 200,
+            },
+          },
+        },
+        (_mocks) => {
+          _mocks.fetch.mockImplementation((url) => {
+            if (url.includes('/decide/')) {
+              return Promise.resolve({
+                status: 200,
+                text: () => Promise.resolve('ok'),
+                json: () =>
+                  Promise.resolve({
+                    featureFlags: createMockFeatureFlags(),
+                    featureFlagPayloads: createMockFeatureFlagPayloads(),
+                  }),
+              })
+            }
+
+            return Promise.resolve({
+              status: 200,
+              text: () => Promise.resolve('ok'),
+              json: () =>
+                Promise.resolve({
+                  status: 'ok',
+                }),
+            })
+          })
+        },
+        {
+          distinct_id: '123',
+          feature_flags: { 'bootstrap-1': 'variant-2' },
+          feature_flag_payloads: { 'bootstrap-1': { some: 'other-key' } },
+        }
+      )
+    })
+
+    it('distinct id should not be overwritten if already there', () => {
+      expect(posthog.getDistinctId()).toEqual('123')
+    })
+
+    it('flags should not be overwritten if already there', () => {
+      expect(posthog.getFeatureFlag('bootstrap-1')).toEqual('variant-2')
+    })
+
+    it('flag payloads should not be overwritten if already there', () => {
+      expect(posthog.getFeatureFlagPayload('bootstrap-1')).toEqual({
+        some: 'other-key',
+      })
+    })
+  })
 })

posthog-core/test/test-utils/PostHogCoreTestClient.ts

@@ -1,4 +1,4 @@
-import { PostHogCore, PostHogCoreOptions, PostHogFetchOptions, PostHogFetchResponse } from '../../src'
+import { JsonType, PostHogCore, PostHogCoreOptions, PostHogFetchOptions, PostHogFetchResponse } from '../../src'
 
 const version = '2.0.0-alpha'
 
@@ -42,9 +42,9 @@ export class PostHogCoreTestClient extends PostHogCore {
 export const createTestClient = (
   apiKey: string,
   options?: PostHogCoreOptions,
-  setupMocks?: (mocks: PostHogCoreTestClientMocks) => void
+  setupMocks?: (mocks: PostHogCoreTestClientMocks) => void,
+  storageCache: { [key: string]: string | JsonType } = {}
 ): [PostHogCoreTestClient, PostHogCoreTestClientMocks] => {
-  const storageCache: { [key: string]: string | undefined } = {}
   const mocks = {
     fetch: jest.fn<Promise<PostHogFetchResponse>, [string, PostHogFetchOptions]>(),
     storage: {

posthog-react-native/CHANGELOG.md

@@ -1,9 +1,12 @@
 # Next
 
+# 3.2.0 - 2024-09-12
+
 ## Changed
 
 1. chore: default `captureMode` changed to `json`.
     1. To keep using the `form` mode, just set the `captureMode` option to `form` when initializing the PostHog client.
+2. fix: fix: bootstrap flags do not overwrite the current values
 
 # 3.1.2 - 2024-08-14
 

posthog-react-native/package.json

@@ -1,6 +1,6 @@
 {
   "name": "posthog-react-native",
-  "version": "3.1.2",
+  "version": "3.2.0",
   "main": "lib/posthog-react-native/index.js",
   "files": [
     "lib/"

posthog-react-native/src/posthog-rn.ts

@@ -82,7 +82,10 @@ export class PostHog extends PostHogCore {
     }
 
     const initAfterStorage = (): void => {
-      this.setupBootstrap(options)
+      // RN should merge the bootstrap options with the existing ones
+      // The existing ones should take precedence since the flags are already loaded
+      // and survive an app reload
+      this.setupBootstrap(options, false)
 
       this._isInitialized = true
       if (options?.preloadFeatureFlags !== false) {