posthog-node 4.3.0 → 4.3.1

package/lib/index.esm.js

@@ -1,6 +1,6 @@
 import { createHash } from 'rusha';
 
-var version = "4.3.0";
+var version = "4.3.1";
 
 var PostHogPersistedProperty;
 (function (PostHogPersistedProperty) {
@@ -2230,44 +2230,70 @@ class PostHog extends PostHogCoreStateless {
   async getFeatureFlagPayload(key, distinctId, matchValue, options) {
     const {
       groups,
-      disableGeoip
-    } = options || {};
-    let {
-      onlyEvaluateLocally,
-      sendFeatureFlagEvents,
+      disableGeoip,
+      onlyEvaluateLocally = false,
       personProperties,
       groupProperties
     } = options || {};
-    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) {
+    const {
+      allPersonProperties,
+      allGroupProperties
+    } = this.addLocalPersonAndGroupProperties(distinctId, groups, personProperties, groupProperties);
+    if (matchValue === undefined) {
       matchValue = await this.getFeatureFlag(key, distinctId, {
         ...options,
-        onlyEvaluateLocally: true
+        onlyEvaluateLocally: true,
+        sendFeatureFlagEvents: false
       });
     }
+    let response;
+    let payload;
     if (matchValue) {
-      response = await this.featureFlagsPoller?.computeFeatureFlagPayloadLocally(key, matchValue);
-    }
-    // set defaults
-    if (onlyEvaluateLocally == undefined) {
-      onlyEvaluateLocally = false;
-    }
-    if (sendFeatureFlagEvents == undefined) {
-      sendFeatureFlagEvents = true;
-    }
-    // set defaults
-    if (onlyEvaluateLocally == undefined) {
-      onlyEvaluateLocally = false;
+      response = matchValue;
+      payload = await this.featureFlagsPoller?.computeFeatureFlagPayloadLocally(key, matchValue);
+    } else {
+      response = undefined;
+      payload = undefined;
     }
-    const payloadWasLocallyEvaluated = response !== undefined;
-    if (!payloadWasLocallyEvaluated && !onlyEvaluateLocally) {
-      response = await super.getFeatureFlagPayloadStateless(key, distinctId, groups, personProperties, groupProperties, disableGeoip);
+    // 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 || {};
     }
-    return response;
+    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;
   }
   async isFeatureEnabled(key, distinctId, options) {
     const feat = await this.getFeatureFlag(key, distinctId, options);