posthog-node 5.0.0 → 5.1.0

package/lib/index.d.ts

@@ -79,11 +79,11 @@ declare enum PostHogPersistedProperty {
     InstalledAppBuild = "installed_app_build",
     InstalledAppVersion = "installed_app_version",
     SessionReplay = "session_replay",
-    DecideEndpointWasHit = "decide_endpoint_was_hit",
     SurveyLastSeenDate = "survey_last_seen_date",
     SurveysSeen = "surveys_seen",
     Surveys = "surveys",
-    RemoteConfig = "remote_config"
+    RemoteConfig = "remote_config",
+    FlagsEndpointWasHit = "flags_endpoint_was_hit"
 }
 type PostHogFetchOptions = {
     method: 'GET' | 'POST' | 'PUT' | 'PATCH';
@@ -132,7 +132,7 @@ type PostHogRemoteConfig = {
     hasFeatureFlags?: boolean;
 };
 type FeatureFlagValue = string | boolean;
-type PostHogDecideResponse = Omit<PostHogRemoteConfig, 'surveys' | 'hasFeatureFlags'> & {
+type PostHogFlagsResponse = Omit<PostHogRemoteConfig, 'surveys' | 'hasFeatureFlags'> & {
     featureFlags: {
         [key: string]: FeatureFlagValue;
     };
@@ -178,13 +178,13 @@ type PartialWithRequired<T, K extends keyof T> = {
     [P in Exclude<keyof T, K>]?: T[P];
 };
 /**
- * These are the fields we care about from PostHogDecideResponse for feature flags.
+ * These are the fields we care about from PostHogFlagsResponse for feature flags.
  */
-type PostHogFeatureFlagDetails = PartialWithRequired<PostHogDecideResponse, 'flags' | 'featureFlags' | 'featureFlagPayloads' | 'requestId'>;
+type PostHogFeatureFlagDetails = PartialWithRequired<PostHogFlagsResponse, 'flags' | 'featureFlags' | 'featureFlagPayloads' | 'requestId'>;
 /**
  * Models legacy flags and payloads return type for many public methods.
  */
-type PostHogFlagsAndPayloadsResponse = Partial<Pick<PostHogDecideResponse, 'featureFlags' | 'featureFlagPayloads'>>;
+type PostHogFlagsAndPayloadsResponse = Partial<Pick<PostHogFlagsResponse, 'featureFlags' | 'featureFlagPayloads'>>;
 type JsonType = string | number | boolean | null | {
     [key: string]: JsonType;
 } | Array<JsonType> | JsonType[];
@@ -494,7 +494,7 @@ declare abstract class PostHogCoreStateless {
     /***
      *** FEATURE FLAGS
      ***/
-    protected getDecide(distinctId: string, groups?: Record<string, string | number>, personProperties?: Record<string, string>, groupProperties?: Record<string, Record<string, string>>, extraPayload?: Record<string, any>): Promise<PostHogDecideResponse | undefined>;
+    protected getFlags(distinctId: string, groups?: Record<string, string | number>, personProperties?: Record<string, string>, groupProperties?: Record<string, Record<string, string>>, extraPayload?: Record<string, any>): Promise<PostHogFlagsResponse | undefined>;
     protected getFeatureFlagStateless(key: string, distinctId: string, groups?: Record<string, string>, personProperties?: Record<string, string>, groupProperties?: Record<string, Record<string, string>>, disableGeoip?: boolean): Promise<{
         response: FeatureFlagValue | undefined;
         requestId: string | undefined;
@@ -504,16 +504,16 @@ declare abstract class PostHogCoreStateless {
         requestId: string | undefined;
     } | undefined>;
     protected getFeatureFlagPayloadStateless(key: string, distinctId: string, groups?: Record<string, string>, personProperties?: Record<string, string>, groupProperties?: Record<string, Record<string, string>>, disableGeoip?: boolean): Promise<JsonType | undefined>;
-    protected getFeatureFlagPayloadsStateless(distinctId: string, groups?: Record<string, string>, personProperties?: Record<string, string>, groupProperties?: Record<string, Record<string, string>>, disableGeoip?: boolean, flagKeysToEvaluate?: string[]): Promise<PostHogDecideResponse['featureFlagPayloads'] | undefined>;
+    protected getFeatureFlagPayloadsStateless(distinctId: string, groups?: Record<string, string>, personProperties?: Record<string, string>, groupProperties?: Record<string, Record<string, string>>, disableGeoip?: boolean, flagKeysToEvaluate?: string[]): Promise<PostHogFlagsResponse['featureFlagPayloads'] | undefined>;
     protected getFeatureFlagsStateless(distinctId: string, groups?: Record<string, string | number>, personProperties?: Record<string, string>, groupProperties?: Record<string, Record<string, string>>, disableGeoip?: boolean, flagKeysToEvaluate?: string[]): Promise<{
-        flags: PostHogDecideResponse['featureFlags'] | undefined;
-        payloads: PostHogDecideResponse['featureFlagPayloads'] | undefined;
-        requestId: PostHogDecideResponse['requestId'] | undefined;
+        flags: PostHogFlagsResponse['featureFlags'] | undefined;
+        payloads: PostHogFlagsResponse['featureFlagPayloads'] | undefined;
+        requestId: PostHogFlagsResponse['requestId'] | undefined;
     }>;
     protected getFeatureFlagsAndPayloadsStateless(distinctId: string, groups?: Record<string, string | number>, personProperties?: Record<string, string>, groupProperties?: Record<string, Record<string, string>>, disableGeoip?: boolean, flagKeysToEvaluate?: string[]): Promise<{
-        flags: PostHogDecideResponse['featureFlags'] | undefined;
-        payloads: PostHogDecideResponse['featureFlagPayloads'] | undefined;
-        requestId: PostHogDecideResponse['requestId'] | undefined;
+        flags: PostHogFlagsResponse['featureFlags'] | undefined;
+        payloads: PostHogFlagsResponse['featureFlagPayloads'] | undefined;
+        requestId: PostHogFlagsResponse['requestId'] | undefined;
     }>;
     protected getFeatureFlagDetailsStateless(distinctId: string, groups?: Record<string, string | number>, personProperties?: Record<string, string>, groupProperties?: Record<string, Record<string, string>>, disableGeoip?: boolean, flagKeysToEvaluate?: string[]): Promise<PostHogFeatureFlagDetails | undefined>;
     /***

package/lib/node/index.cjs

@@ -1340,7 +1340,7 @@ function snipLine(line, colno) {
   return newLine;
 }
 
-var version = "5.0.0";
+var version = "5.1.0";
 
 var PostHogPersistedProperty;
 (function (PostHogPersistedProperty) {
@@ -1364,11 +1364,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;
@@ -1436,27 +1436,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,
@@ -1519,90 +1519,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)) {
@@ -1649,30 +1565,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 }))));
 }
@@ -1997,13 +1889,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' },
@@ -2016,11 +1904,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;
@@ -2049,15 +1937,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) {
@@ -2107,26 +1995,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
@@ -2730,7 +2618,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);
@@ -2743,13 +2631,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 = {}) {
@@ -3714,13 +3602,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,