posthog-node 4.3.1 → 4.4.0

package/lib/index.d.ts

@@ -49,6 +49,8 @@ declare enum PostHogPersistedProperty {
     Props = "props",
     FeatureFlags = "feature_flags",
     FeatureFlagPayloads = "feature_flag_payloads",
+    BootstrapFeatureFlags = "bootstrap_feature_flags",
+    BootstrapFeatureFlagPayloads = "bootstrap_feature_flag_payloads",
     OverrideFeatureFlags = "override_feature_flags",
     Queue = "queue",
     OptedOut = "opted_out",
@@ -58,7 +60,8 @@ declare enum PostHogPersistedProperty {
     GroupProperties = "group_properties",
     InstalledAppBuild = "installed_app_build",
     InstalledAppVersion = "installed_app_version",
-    SessionReplay = "session_replay"
+    SessionReplay = "session_replay",
+    DecideEndpointWasHit = "decide_endpoint_was_hit"
 }
 type PostHogFetchOptions = {
     method: 'GET' | 'POST' | 'PUT' | 'PATCH';
@@ -319,13 +322,25 @@ type PostHogNodeV1 = {
     }): Promise<string | boolean | undefined>;
     /**
      * @description Retrieves payload associated with the specified flag and matched value that is passed in.
-     * (Expected to be used in conjuction with getFeatureFlag but allows for manual lookup).
-     * If matchValue isn't passed, getFeatureFlag is called implicitly.
-     * Will try to evaluate for payload locally first otherwise default to network call if allowed
+     *
+     * IMPORTANT: The `matchValue` parameter should be the value you previously obtained from `getFeatureFlag()`.
+     * If matchValue isn't passed (or is undefined), this method will automatically call `getFeatureFlag()`
+     * internally to fetch the flag value, which could result in a network call to the PostHog server if this flag can
+     * not be evaluated locally. This means that omitting `matchValue` will potentially:
+     * - Bypass local evaluation
+     * - Count as an additional flag evaluation against your quota
+     * - Impact performance due to the extra network request
+     *
+     * Example usage:
+     * ```js
+     * const flagValue = await client.getFeatureFlag('my-flag', distinctId);
+     * const payload = await client.getFeatureFlagPayload('my-flag', distinctId, flagValue);
+     * ```
      *
      * @param key the unique key of your feature flag
      * @param distinctId the current unique id
-     * @param matchValue optional- the matched flag string or boolean
+     * @param matchValue The flag value previously obtained from calling `getFeatureFlag()`. Can be a string or boolean.
+     *                   To avoid extra network calls, pass this parameter when you can.
      * @param options: dict with optional parameters below
      * @param onlyEvaluateLocally optional - whether to only evaluate the flag locally. Defaults to false.
      *

package/lib/index.esm.js

@@ -1,6 +1,6 @@
-import { createHash } from 'rusha';
+import { createHash } from 'node:crypto';
 
-var version = "4.3.1";
+var version = "4.4.0";
 
 var PostHogPersistedProperty;
 (function (PostHogPersistedProperty) {
@@ -9,6 +9,8 @@ var PostHogPersistedProperty;
     PostHogPersistedProperty["Props"] = "props";
     PostHogPersistedProperty["FeatureFlags"] = "feature_flags";
     PostHogPersistedProperty["FeatureFlagPayloads"] = "feature_flag_payloads";
+    PostHogPersistedProperty["BootstrapFeatureFlags"] = "bootstrap_feature_flags";
+    PostHogPersistedProperty["BootstrapFeatureFlagPayloads"] = "bootstrap_feature_flag_payloads";
     PostHogPersistedProperty["OverrideFeatureFlags"] = "override_feature_flags";
     PostHogPersistedProperty["Queue"] = "queue";
     PostHogPersistedProperty["OptedOut"] = "opted_out";
@@ -19,6 +21,7 @@ var PostHogPersistedProperty;
     PostHogPersistedProperty["InstalledAppBuild"] = "installed_app_build";
     PostHogPersistedProperty["InstalledAppVersion"] = "installed_app_version";
     PostHogPersistedProperty["SessionReplay"] = "session_replay";
+    PostHogPersistedProperty["DecideEndpointWasHit"] = "decide_endpoint_was_hit";
 })(PostHogPersistedProperty || (PostHogPersistedProperty = {}));
 
 function assert(truthyValue, message) {
@@ -1782,8 +1785,7 @@ class FeatureFlagsPoller {
 // # uniformly distributed between 0 and 1, so if we want to show this feature to 20% of traffic
 // # we can do _hash(key, distinct_id) < 0.2
 function _hash(key, distinctId, salt = '') {
-  // rusha is a fast sha1 implementation in pure javascript
-  const sha1Hash = createHash();
+  const sha1Hash = createHash('sha1');
   sha1Hash.update(`${key}.${distinctId}${salt}`);
   return parseInt(sha1Hash.digest('hex').slice(0, 15), 16) / LONG_SCALE;
 }
@@ -2230,70 +2232,44 @@ class PostHog extends PostHogCoreStateless {
   async getFeatureFlagPayload(key, distinctId, matchValue, options) {
     const {
       groups,
-      disableGeoip,
-      onlyEvaluateLocally = false,
+      disableGeoip
+    } = options || {};
+    let {
+      onlyEvaluateLocally,
+      sendFeatureFlagEvents,
       personProperties,
       groupProperties
     } = options || {};
-    const {
-      allPersonProperties,
-      allGroupProperties
-    } = this.addLocalPersonAndGroupProperties(distinctId, groups, personProperties, groupProperties);
-    if (matchValue === undefined) {
+    const adjustedProperties = this.addLocalPersonAndGroupProperties(distinctId, groups, personProperties, groupProperties);
+    personProperties = adjustedProperties.allPersonProperties;
+    groupProperties = adjustedProperties.allGroupProperties;
+    let response = undefined;
+    // Try to get match value locally if not provided
+    if (!matchValue) {
       matchValue = await this.getFeatureFlag(key, distinctId, {
         ...options,
-        onlyEvaluateLocally: true,
-        sendFeatureFlagEvents: false
+        onlyEvaluateLocally: true
       });
     }
-    let response;
-    let payload;
     if (matchValue) {
-      response = matchValue;
-      payload = await this.featureFlagsPoller?.computeFeatureFlagPayloadLocally(key, matchValue);
-    } else {
-      response = undefined;
-      payload = undefined;
+      response = await this.featureFlagsPoller?.computeFeatureFlagPayloadLocally(key, matchValue);
     }
-    // Determine if the payload was evaluated locally
-    const payloadWasLocallyEvaluated = payload !== undefined;
-    // Fetch final flags and payloads either locally or from the remote server
-    let fetchedOrLocalFlags;
-    let fetchedOrLocalPayloads;
-    if (payloadWasLocallyEvaluated || onlyEvaluateLocally) {
-      if (response !== undefined) {
-        fetchedOrLocalFlags = {
-          [key]: response
-        };
-        fetchedOrLocalPayloads = {
-          [key]: payload
-        };
-      } else {
-        fetchedOrLocalFlags = {};
-        fetchedOrLocalPayloads = {};
-      }
-    } else {
-      const fetchedData = await super.getFeatureFlagsAndPayloadsStateless(distinctId, groups, allPersonProperties, allGroupProperties, disableGeoip);
-      fetchedOrLocalFlags = fetchedData.flags || {};
-      fetchedOrLocalPayloads = fetchedData.payloads || {};
+    // set defaults
+    if (onlyEvaluateLocally == undefined) {
+      onlyEvaluateLocally = false;
     }
-    const finalResponse = fetchedOrLocalFlags[key];
-    const finalPayload = fetchedOrLocalPayloads[key];
-    const finalLocallyEvaluated = payloadWasLocallyEvaluated;
-    this.capture({
-      distinctId,
-      event: '$feature_flag_called',
-      properties: {
-        $feature_flag: key,
-        $feature_flag_response: finalResponse,
-        $feature_flag_payload: finalPayload,
-        locally_evaluated: finalLocallyEvaluated,
-        [`$feature/${key}`]: finalResponse
-      },
-      groups,
-      disableGeoip
-    });
-    return finalPayload;
+    if (sendFeatureFlagEvents == undefined) {
+      sendFeatureFlagEvents = true;
+    }
+    // set defaults
+    if (onlyEvaluateLocally == undefined) {
+      onlyEvaluateLocally = false;
+    }
+    const payloadWasLocallyEvaluated = response !== undefined;
+    if (!payloadWasLocallyEvaluated && !onlyEvaluateLocally) {
+      response = await super.getFeatureFlagPayloadStateless(key, distinctId, groups, personProperties, groupProperties, disableGeoip);
+    }
+    return response;
   }
   async isFeatureEnabled(key, distinctId, options) {
     const feat = await this.getFeatureFlag(key, distinctId, options);