posthog-node 5.0.0 → 5.1.1

package/lib/edge/index.mjs

@@ -913,7 +913,7 @@ function setupExpressErrorHandler(_posthog, app) {
   });
 }
 
-var version = "5.0.0";
+var version = "5.1.1";
 
 var PostHogPersistedProperty;
 (function (PostHogPersistedProperty) {
@@ -937,11 +937,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;
@@ -1009,27 +1009,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,
@@ -1092,90 +1092,6 @@ const parsePayload = (response) => {
     }
 };
 
-// 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)) {
@@ -1222,30 +1138,6 @@ function safeSetTimeout(fn, timeout) {
     t?.unref && t?.unref();
     return t;
 }
-// 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 }))));
 }
@@ -1570,13 +1462,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' },
@@ -1589,11 +1477,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;
@@ -1622,15 +1510,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) {
@@ -1680,26 +1568,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
@@ -2303,7 +2191,7 @@ class FeatureFlagsPoller {
     await this.loadFeatureFlags();
     const response = {};
     const payloads = {};
-    let fallbackToDecide = this.featureFlags.length == 0;
+    let fallbackToFlags = this.featureFlags.length == 0;
     await Promise.all(this.featureFlags.map(async flag => {
       try {
         const matchValue = await this.computeFlagLocally(flag, distinctId, groups, personProperties, groupProperties);
@@ -2316,13 +2204,13 @@ class FeatureFlagsPoller {
         if (e instanceof InconclusiveMatchError) ; else if (e instanceof Error) {
           this.onError?.(new Error(`Error computing flag locally: ${flag.key}: ${e}`));
         }
-        fallbackToDecide = true;
+        fallbackToFlags = true;
       }
     }));
     return {
       response,
       payloads,
-      fallbackToDecide
+      fallbackToFlags
     };
   }
   async computeFlagLocally(flag, distinctId, groups = {}, personProperties = {}, groupProperties = {}) {
@@ -3254,7 +3142,24 @@ class PostHogBackendClient extends PostHogCoreStateless {
     return response;
   }
   async getRemoteConfigPayload(flagKey) {
-    return (await this.featureFlagsPoller?._requestRemoteConfigPayload(flagKey))?.json();
+    const response = await this.featureFlagsPoller?._requestRemoteConfigPayload(flagKey);
+    if (!response) {
+      return undefined;
+    }
+    const parsed = await response.json();
+    // The payload from the endpoint is stored as a JSON encoded string. So when we return
+    // it, it's effectively double encoded. As far as we know, we should never get single-encoded
+    // JSON, but we'll be defensive here just in case.
+    if (typeof parsed === 'string') {
+      try {
+        // If the parsed value is a string, try parsing it again to handle double-encoded JSON
+        return JSON.parse(parsed);
+      } catch (e) {
+        // If second parse fails, return the string as is
+        return parsed;
+      }
+    }
+    return parsed;
   }
   async isFeatureEnabled(key, distinctId, options) {
     const feat = await this.getFeatureFlag(key, distinctId, options);
@@ -3287,13 +3192,13 @@ class PostHogBackendClient extends PostHogCoreStateless {
     const localEvaluationResult = await this.featureFlagsPoller?.getAllFlagsAndPayloads(distinctId, groups, personProperties, groupProperties);
     let featureFlags = {};
     let featureFlagPayloads = {};
-    let fallbackToDecide = true;
+    let fallbackToFlags = true;
     if (localEvaluationResult) {
       featureFlags = localEvaluationResult.response;
       featureFlagPayloads = localEvaluationResult.payloads;
-      fallbackToDecide = localEvaluationResult.fallbackToDecide;
+      fallbackToFlags = localEvaluationResult.fallbackToFlags;
     }
-    if (fallbackToDecide && !onlyEvaluateLocally) {
+    if (fallbackToFlags && !onlyEvaluateLocally) {
       const remoteEvaluationResult = await super.getFeatureFlagsAndPayloadsStateless(distinctId, groups, personProperties, groupProperties, disableGeoip);
       featureFlags = {
         ...featureFlags,