posthog-js-lite 4.0.0 → 4.1.0

package/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Next
 
+# 4.1.0 - 2025-06-12
+
+1. chore: use `/flags?v=2&config=true` instead of `/decide?v=4` for the flag evaluation backend
+
 # 4.0.0 - 2025-06-10
 
 ## Removed

package/lib/index.cjs

@@ -2,7 +2,7 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var version = "4.0.0";
+var version = "4.1.0";
 
 var PostHogPersistedProperty;
 (function (PostHogPersistedProperty) {
@@ -26,11 +26,11 @@ var PostHogPersistedProperty;
     PostHogPersistedProperty["InstalledAppBuild"] = "installed_app_build";
     PostHogPersistedProperty["InstalledAppVersion"] = "installed_app_version";
     PostHogPersistedProperty["SessionReplay"] = "session_replay";
-    PostHogPersistedProperty["DecideEndpointWasHit"] = "decide_endpoint_was_hit";
     PostHogPersistedProperty["SurveyLastSeenDate"] = "survey_last_seen_date";
     PostHogPersistedProperty["SurveysSeen"] = "surveys_seen";
     PostHogPersistedProperty["Surveys"] = "surveys";
     PostHogPersistedProperty["RemoteConfig"] = "remote_config";
+    PostHogPersistedProperty["FlagsEndpointWasHit"] = "flags_endpoint_was_hit";
 })(PostHogPersistedProperty || (PostHogPersistedProperty = {}));
 // Any key prefixed with `attr__` can be added
 var Compression;
@@ -98,27 +98,27 @@ var ActionStepStringMatching;
     ActionStepStringMatching["Regex"] = "regex";
 })(ActionStepStringMatching || (ActionStepStringMatching = {}));
 
-const normalizeDecideResponse = (decideResponse) => {
-    if ('flags' in decideResponse) {
-        // Convert v4 format to v3 format
-        const featureFlags = getFlagValuesFromFlags(decideResponse.flags);
-        const featureFlagPayloads = getPayloadsFromFlags(decideResponse.flags);
+const normalizeFlagsResponse = (flagsResponse) => {
+    if ('flags' in flagsResponse) {
+        // Convert v2 format to v1 format
+        const featureFlags = getFlagValuesFromFlags(flagsResponse.flags);
+        const featureFlagPayloads = getPayloadsFromFlags(flagsResponse.flags);
         return {
-            ...decideResponse,
+            ...flagsResponse,
             featureFlags,
             featureFlagPayloads,
         };
     }
     else {
-        // Convert v3 format to v4 format
-        const featureFlags = decideResponse.featureFlags ?? {};
-        const featureFlagPayloads = Object.fromEntries(Object.entries(decideResponse.featureFlagPayloads || {}).map(([k, v]) => [k, parsePayload(v)]));
+        // Convert v1 format to v2 format
+        const featureFlags = flagsResponse.featureFlags ?? {};
+        const featureFlagPayloads = Object.fromEntries(Object.entries(flagsResponse.featureFlagPayloads || {}).map(([k, v]) => [k, parsePayload(v)]));
         const flags = Object.fromEntries(Object.entries(featureFlags).map(([key, value]) => [
             key,
             getFlagDetailFromFlagAndPayload(key, value, featureFlagPayloads[key]),
         ]));
         return {
-            ...decideResponse,
+            ...flagsResponse,
             featureFlags,
             featureFlagPayloads,
             flags,
@@ -190,7 +190,7 @@ const parsePayload = (response) => {
  * @param featureFlagPayloads - The feature flag payloads
  * @returns The normalized flag details
  */
-const createDecideResponseFromFlagsAndPayloads = (featureFlags, featureFlagPayloads) => {
+const createFlagsResponseFromFlagsAndPayloads = (featureFlags, featureFlagPayloads) => {
     // If a feature flag payload key is not in the feature flags, we treat it as true feature flag.
     const allKeys = [...new Set([...Object.keys(featureFlags ?? {}), ...Object.keys(featureFlagPayloads ?? {})])];
     const enabledFlags = allKeys
@@ -200,7 +200,7 @@ const createDecideResponseFromFlagsAndPayloads = (featureFlags, featureFlagPaylo
         featureFlags: enabledFlags,
         featureFlagPayloads: featureFlagPayloads ?? {},
     };
-    return normalizeDecideResponse(flagDetails);
+    return normalizeFlagsResponse(flagDetails);
 };
 const updateFlagValue = (flag, value) => {
     return {
@@ -216,90 +216,6 @@ function getVariantFromValue(value) {
     return typeof value === 'string' ? value : undefined;
 }
 
-// Rollout constants
-const NEW_FLAGS_ROLLOUT_PERCENTAGE = 1;
-// The fnv1a hashes of the tokens that are explicitly excluded from the rollout
-// see https://github.com/PostHog/posthog-js-lite/blob/main/posthog-core/src/utils.ts#L84
-// are hashed API tokens from our top 10 for each category supported by this SDK.
-const NEW_FLAGS_EXCLUDED_HASHES = new Set([
-    // Node
-    '61be3dd8',
-    '96f6df5f',
-    '8cfdba9b',
-    'bf027177',
-    'e59430a8',
-    '7fa5500b',
-    '569798e9',
-    '04809ff7',
-    '0ebc61a5',
-    '32de7f98',
-    '3beeb69a',
-    '12d34ad9',
-    '733853ec',
-    '0645bb64',
-    '5dcbee21',
-    'b1f95fa3',
-    '2189e408',
-    '82b460c2',
-    '3a8cc979',
-    '29ef8843',
-    '2cdbf767',
-    '38084b54',
-    // React Native
-    '50f9f8de',
-    '41d0df91',
-    '5c236689',
-    'c11aedd3',
-    'ada46672',
-    'f4331ee1',
-    '42fed62a',
-    'c957462c',
-    'd62f705a',
-    // Web (lots of teams per org, hence lots of API tokens)
-    'e0162666',
-    '01b3e5cf',
-    '441cef7f',
-    'bb9cafee',
-    '8f348eb0',
-    'b2553f3a',
-    '97469d7d',
-    '39f21a76',
-    '03706dcc',
-    '27d50569',
-    '307584a7',
-    '6433e92e',
-    '150c7fbb',
-    '49f57f22',
-    '3772f65b',
-    '01eb8256',
-    '3c9e9234',
-    'f853c7f7',
-    'c0ac4b67',
-    'cd609d40',
-    '10ca9b1a',
-    '8a87f11b',
-    '8e8e5216',
-    '1f6b63b3',
-    'db7943dd',
-    '79b7164c',
-    '07f78e33',
-    '2d21b6fd',
-    '952db5ee',
-    'a7d3b43f',
-    '1924dd9c',
-    '84e1b8f6',
-    'dff631b6',
-    'c5aa8a79',
-    'fa133a95',
-    '498a4508',
-    '24748755',
-    '98f3d658',
-    '21bbda67',
-    '7dbfed69',
-    'be3ec24c',
-    'fc80b8e2',
-    '75cc0998',
-]);
 const STRING_FORMAT = 'utf8';
 function assert(truthyValue, message) {
     if (!truthyValue || typeof truthyValue !== 'string' || isEmpty(truthyValue)) {
@@ -355,30 +271,6 @@ const isError = (x) => {
 function getFetch() {
     return typeof fetch !== 'undefined' ? fetch : typeof globalThis.fetch !== 'undefined' ? globalThis.fetch : undefined;
 }
-// FNV-1a hash function
-// https://en.wikipedia.org/wiki/Fowler%E2%80%93Noll%E2%80%93Vo_hash_function
-// I know, I know, I'm rolling my own hash function, but I didn't want to take on
-// a crypto dependency and this is just temporary anyway
-function fnv1a(str) {
-    let hash = 0x811c9dc5; // FNV offset basis
-    for (let i = 0; i < str.length; i++) {
-        hash ^= str.charCodeAt(i);
-        hash += (hash << 1) + (hash << 4) + (hash << 7) + (hash << 8) + (hash << 24);
-    }
-    // Convert to hex string, padding to 8 chars
-    return (hash >>> 0).toString(16).padStart(8, '0');
-}
-function isTokenInRollout(token, percentage = 0, excludedHashes) {
-    const tokenHash = fnv1a(token);
-    // Check excluded hashes (we're explicitly including these tokens from the rollout)
-    if (excludedHashes?.has(tokenHash)) {
-        return false;
-    }
-    // Convert hash to int and divide by max value to get number between 0-1
-    const hashInt = parseInt(tokenHash, 16);
-    const hashFloat = hashInt / 0xffffffff;
-    return hashFloat < percentage;
-}
 function allSettled(promises) {
     return Promise.all(promises.map((p) => (p ?? Promise.resolve()).then((value) => ({ status: 'fulfilled', value }), (reason) => ({ status: 'rejected', reason }))));
 }
@@ -1110,13 +1002,9 @@ class PostHogCoreStateless {
     /***
      *** FEATURE FLAGS
      ***/
-    async getDecide(distinctId, groups = {}, personProperties = {}, groupProperties = {}, extraPayload = {}) {
+    async getFlags(distinctId, groups = {}, personProperties = {}, groupProperties = {}, extraPayload = {}) {
         await this._initPromise;
-        // Check if the API token is in the new flags rollout
-        // This is a temporary measure to ensure that we can still use the old flags API
-        // while we migrate to the new flags API
-        const useFlags = isTokenInRollout(this.apiKey, NEW_FLAGS_ROLLOUT_PERCENTAGE, NEW_FLAGS_EXCLUDED_HASHES);
-        const url = useFlags ? `${this.host}/flags/?v=2` : `${this.host}/decide/?v=4`;
+        const url = `${this.host}/flags/?v=2&config=true`;
         const fetchOptions = {
             method: 'POST',
             headers: { ...this.getCustomHeaders(), 'Content-Type': 'application/json' },
@@ -1129,11 +1017,11 @@ class PostHogCoreStateless {
                 ...extraPayload,
             }),
         };
-        this.logMsgIfDebug(() => console.log('PostHog Debug', 'Decide URL', url));
-        // Don't retry /decide API calls
+        this.logMsgIfDebug(() => console.log('PostHog Debug', 'Flags URL', url));
+        // Don't retry /flags API calls
         return this.fetchWithRetry(url, fetchOptions, { retryCount: 0 }, this.featureFlagsRequestTimeoutMs)
             .then((response) => response.json())
-            .then((response) => normalizeDecideResponse(response))
+            .then((response) => normalizeFlagsResponse(response))
             .catch((error) => {
             this._events.emit('error', error);
             return undefined;
@@ -1162,15 +1050,15 @@ class PostHogCoreStateless {
     }
     async getFeatureFlagDetailStateless(key, distinctId, groups = {}, personProperties = {}, groupProperties = {}, disableGeoip) {
         await this._initPromise;
-        const decideResponse = await this.getFeatureFlagDetailsStateless(distinctId, groups, personProperties, groupProperties, disableGeoip, [key]);
-        if (decideResponse === undefined) {
+        const flagsResponse = await this.getFeatureFlagDetailsStateless(distinctId, groups, personProperties, groupProperties, disableGeoip, [key]);
+        if (flagsResponse === undefined) {
             return undefined;
         }
-        const featureFlags = decideResponse.flags;
+        const featureFlags = flagsResponse.flags;
         const flagDetail = featureFlags[key];
         return {
             response: flagDetail,
-            requestId: decideResponse.requestId,
+            requestId: flagsResponse.requestId,
         };
     }
     async getFeatureFlagPayloadStateless(key, distinctId, groups = {}, personProperties = {}, groupProperties = {}, disableGeoip) {
@@ -1220,26 +1108,26 @@ class PostHogCoreStateless {
         if (flagKeysToEvaluate) {
             extraPayload['flag_keys_to_evaluate'] = flagKeysToEvaluate;
         }
-        const decideResponse = await this.getDecide(distinctId, groups, personProperties, groupProperties, extraPayload);
-        if (decideResponse === undefined) {
+        const flagsResponse = await this.getFlags(distinctId, groups, personProperties, groupProperties, extraPayload);
+        if (flagsResponse === undefined) {
             // We probably errored out, so return undefined
             return undefined;
         }
-        // if there's an error on the decideResponse, log a console error, but don't throw an error
-        if (decideResponse.errorsWhileComputingFlags) {
+        // if there's an error on the flagsResponse, log a console error, but don't throw an error
+        if (flagsResponse.errorsWhileComputingFlags) {
             console.error('[FEATURE FLAGS] Error while computing feature flags, some flags may be missing or incorrect. Learn more at https://posthog.com/docs/feature-flags/best-practices');
         }
         // Add check for quota limitation on feature flags
-        if (decideResponse.quotaLimited?.includes(QuotaLimitedFeature.FeatureFlags)) {
+        if (flagsResponse.quotaLimited?.includes(QuotaLimitedFeature.FeatureFlags)) {
             console.warn('[FEATURE FLAGS] Feature flags quota limit exceeded - feature flags unavailable. Learn more about billing limits at https://posthog.com/docs/billing/limits-alerts');
             return {
                 flags: {},
                 featureFlags: {},
                 featureFlagPayloads: {},
-                requestId: decideResponse?.requestId,
+                requestId: flagsResponse?.requestId,
             };
         }
-        return decideResponse;
+        return flagsResponse;
     }
     /***
      *** SURVEYS
@@ -1671,7 +1559,7 @@ class PostHogCore extends PostHogCoreStateless {
         const bootstrapFeatureFlags = bootstrap.featureFlags;
         const bootstrapFeatureFlagPayloads = bootstrap.featureFlagPayloads ?? {};
         if (bootstrapFeatureFlags && Object.keys(bootstrapFeatureFlags).length) {
-            const normalizedBootstrapFeatureFlagDetails = createDecideResponseFromFlagsAndPayloads(bootstrapFeatureFlags, bootstrapFeatureFlagPayloads);
+            const normalizedBootstrapFeatureFlagDetails = createFlagsResponseFromFlagsAndPayloads(bootstrapFeatureFlags, bootstrapFeatureFlagPayloads);
             if (Object.keys(normalizedBootstrapFeatureFlagDetails.flags).length > 0) {
                 this.setBootstrappedFeatureFlagDetails(normalizedBootstrapFeatureFlagDetails);
                 const currentFeatureFlagDetails = this.getKnownFeatureFlagDetails() || { flags: {}, requestId: undefined };
@@ -1813,7 +1701,7 @@ class PostHogCore extends PostHogCoreStateless {
                 ...maybeAdd('$set_once', userPropsOnce),
             });
             if (distinctId !== previousDistinctId) {
-                // We keep the AnonymousId to be used by decide calls and identify to link the previousId
+                // We keep the AnonymousId to be used by flags calls and identify to link the previousId
                 this.setPersistedProperty(PostHogPersistedProperty.AnonymousId, previousDistinctId);
                 this.setPersistedProperty(PostHogPersistedProperty.DistinctId, distinctId);
                 this.reloadFeatureFlags();
@@ -1941,12 +1829,12 @@ class PostHogCore extends PostHogCoreStateless {
     /***
      *** FEATURE FLAGS
      ***/
-    async decideAsync(sendAnonDistinctId = true) {
+    async flagsAsync(sendAnonDistinctId = true) {
         await this._initPromise;
-        if (this._decideResponsePromise) {
-            return this._decideResponsePromise;
+        if (this._flagsResponsePromise) {
+            return this._flagsResponsePromise;
         }
-        return this._decideAsync(sendAnonDistinctId);
+        return this._flagsAsync(sendAnonDistinctId);
     }
     cacheSessionReplay(source, response) {
         const sessionReplay = response?.sessionRecording;
@@ -2017,8 +1905,8 @@ class PostHogCore extends PostHogCoreStateless {
         });
         return this._remoteConfigResponsePromise;
     }
-    async _decideAsync(sendAnonDistinctId = true) {
-        this._decideResponsePromise = this._initPromise
+    async _flagsAsync(sendAnonDistinctId = true) {
+        this._flagsResponsePromise = this._initPromise
             .then(async () => {
             const distinctId = this.getDistinctId();
             const groups = this.props.$groups || {};
@@ -2028,7 +1916,7 @@ class PostHogCore extends PostHogCoreStateless {
             const extraProperties = {
                 $anon_distinct_id: sendAnonDistinctId ? this.getAnonymousId() : undefined,
             };
-            const res = await super.getDecide(distinctId, groups, personProperties, groupProperties, extraProperties);
+            const res = await super.getFlags(distinctId, groups, personProperties, groupProperties, extraProperties);
             // Add check for quota limitation on feature flags
             if (res?.quotaLimited?.includes(QuotaLimitedFeature.FeatureFlags)) {
                 // Unset all feature flags by setting to null
@@ -2052,22 +1940,22 @@ class PostHogCore extends PostHogCoreStateless {
                     };
                 }
                 this.setKnownFeatureFlagDetails(newFeatureFlagDetails);
-                // Mark that we hit the /decide endpoint so we can capture this in the $feature_flag_called event
-                this.setPersistedProperty(PostHogPersistedProperty.DecideEndpointWasHit, true);
-                this.cacheSessionReplay('decide/flags', res);
+                // Mark that we hit the /flags endpoint so we can capture this in the $feature_flag_called event
+                this.setPersistedProperty(PostHogPersistedProperty.FlagsEndpointWasHit, true);
+                this.cacheSessionReplay('flags', res);
             }
             return res;
         })
             .finally(() => {
-            this._decideResponsePromise = undefined;
+            this._flagsResponsePromise = undefined;
         });
-        return this._decideResponsePromise;
+        return this._flagsResponsePromise;
     }
     // We only store the flags and request id in the feature flag details storage key
-    setKnownFeatureFlagDetails(decideResponse) {
+    setKnownFeatureFlagDetails(flagsResponse) {
         this.wrap(() => {
-            this.setPersistedProperty(PostHogPersistedProperty.FeatureFlagDetails, decideResponse);
-            this._events.emit('featureflags', getFlagValuesFromFlags(decideResponse?.flags ?? {}));
+            this.setPersistedProperty(PostHogPersistedProperty.FeatureFlagDetails, flagsResponse);
+            this._events.emit('featureflags', getFlagValuesFromFlags(flagsResponse?.flags ?? {}));
         });
     }
     getKnownFeatureFlagDetails() {
@@ -2079,9 +1967,9 @@ class PostHogCore extends PostHogCoreStateless {
             if (featureFlags === undefined && featureFlagPayloads === undefined) {
                 return undefined;
             }
-            return createDecideResponseFromFlagsAndPayloads(featureFlags ?? {}, featureFlagPayloads ?? {});
+            return createFlagsResponseFromFlagsAndPayloads(featureFlags ?? {}, featureFlagPayloads ?? {});
         }
-        return normalizeDecideResponse(storedDetails);
+        return normalizeFlagsResponse(storedDetails);
     }
     getKnownFeatureFlags() {
         const featureFlagDetails = this.getKnownFeatureFlagDetails();
@@ -2145,8 +2033,8 @@ class PostHogCore extends PostHogCoreStateless {
                 ...maybeAdd('$feature_flag_reason', featureFlag?.reason?.description ?? featureFlag?.reason?.code),
                 ...maybeAdd('$feature_flag_bootstrapped_response', bootstrappedResponse),
                 ...maybeAdd('$feature_flag_bootstrapped_payload', bootstrappedPayload),
-                // If we haven't yet received a response from the /decide endpoint, we must have used the bootstrapped value
-                $used_bootstrap_value: !this.getPersistedProperty(PostHogPersistedProperty.DecideEndpointWasHit),
+                // If we haven't yet received a response from the /flags endpoint, we must have used the bootstrapped value
+                $used_bootstrap_value: !this.getPersistedProperty(PostHogPersistedProperty.FlagsEndpointWasHit),
                 ...maybeAdd('$feature_flag_request_id', details.requestId),
             });
         }
@@ -2195,7 +2083,7 @@ class PostHogCore extends PostHogCoreStateless {
             ...details,
             flags,
         };
-        return normalizeDecideResponse(result);
+        return normalizeFlagsResponse(result);
     }
     getFeatureFlagsAndPayloads() {
         const flags = this.getFeatureFlags();
@@ -2213,14 +2101,14 @@ class PostHogCore extends PostHogCoreStateless {
         return !!response;
     }
     // Used when we want to trigger the reload but we don't care about the result
-    reloadFeatureFlags(cb) {
-        this.decideAsync()
+    reloadFeatureFlags(options) {
+        this.flagsAsync(true)
             .then((res) => {
-            cb?.(undefined, res?.featureFlags);
+            options?.cb?.(undefined, res?.featureFlags);
         })
             .catch((e) => {
-            cb?.(e, undefined);
-            if (!cb) {
+            options?.cb?.(e, undefined);
+            if (!options?.cb) {
                 this.logMsgIfDebug(() => console.log('PostHog Debug', 'Error reloading feature flags', e));
             }
         });
@@ -2228,8 +2116,8 @@ class PostHogCore extends PostHogCoreStateless {
     async reloadRemoteConfigAsync() {
         return await this.remoteConfigAsync();
     }
-    async reloadFeatureFlagsAsync(sendAnonDistinctId = true) {
-        return (await this.decideAsync(sendAnonDistinctId))?.featureFlags;
+    async reloadFeatureFlagsAsync(sendAnonDistinctId) {
+        return (await this.flagsAsync(sendAnonDistinctId ?? true))?.featureFlags;
     }
     onFeatureFlags(cb) {
         return this.on('featureflags', async () => {