posthog-node 5.3.1 → 5.5.0

package/lib/node/index.mjs

@@ -1320,7 +1320,7 @@ function snipLine(line, colno) {
   return newLine;
 }
 
-var version = "5.3.1";
+var version = "5.5.0";
 
 var PostHogPersistedProperty;
 (function (PostHogPersistedProperty) {
@@ -2614,7 +2614,9 @@ class FeatureFlagsPoller {
           payloads[flag.key] = matchPayload;
         }
       } catch (e) {
-        if (e instanceof InconclusiveMatchError) ; else if (e instanceof Error) {
+        if (e instanceof InconclusiveMatchError) {
+          this.onError?.(new Error(`Unable to compute flag locally: ${flag.key} - ${e.message}`));
+        } else if (e instanceof Error) {
           this.onError?.(new Error(`Error computing flag locally: ${flag.key}: ${e}`));
         }
         fallbackToFlags = true;
@@ -3238,32 +3240,17 @@ class PostHogBackendClient extends PostHogCoreStateless {
         uuid
       });
     };
-    const _getFlags = async (distinctId, groups, disableGeoip) => {
-      return (await super.getFeatureFlagsStateless(distinctId, groups, undefined, undefined, disableGeoip)).flags;
-    };
     // :TRICKY: If we flush, or need to shut down, to not lose events we want this promise to resolve before we flush
     const capturePromise = Promise.resolve().then(async () => {
       if (sendFeatureFlags) {
-        // If we are sending feature flags, we need to make sure we have the latest flags
-        // return await super.getFeatureFlagsStateless(distinctId, groups, undefined, undefined, disableGeoip)
-        return await _getFlags(distinctId, groups, disableGeoip);
+        // If we are sending feature flags, we evaluate them locally if the user prefers it, otherwise we fall back to remote evaluation
+        const sendFeatureFlagsOptions = typeof sendFeatureFlags === 'object' ? sendFeatureFlags : undefined;
+        return await this.getFeatureFlagsForEvent(distinctId, groups, disableGeoip, sendFeatureFlagsOptions);
       }
       if (event === '$feature_flag_called') {
         // If we're capturing a $feature_flag_called event, we don't want to enrich the event with cached flags that may be out of date.
         return {};
       }
-      if ((this.featureFlagsPoller?.featureFlags?.length || 0) > 0) {
-        // Otherwise we may as well check for the flags locally and include them if they are already loaded
-        const groupsWithStringValues = {};
-        for (const [key, value] of Object.entries(groups || {})) {
-          groupsWithStringValues[key] = String(value);
-        }
-        return await this.getAllFlags(distinctId, {
-          groups: groupsWithStringValues,
-          disableGeoip,
-          onlyEvaluateLocally: true
-        });
-      }
       return {};
     }).then(flags => {
       // Derive the relevant flag properties to add
@@ -3312,31 +3299,16 @@ class PostHogBackendClient extends PostHogCoreStateless {
         uuid
       });
     };
-    const _getFlags = async (distinctId, groups, disableGeoip) => {
-      return (await super.getFeatureFlagsStateless(distinctId, groups, undefined, undefined, disableGeoip)).flags;
-    };
     const capturePromise = Promise.resolve().then(async () => {
       if (sendFeatureFlags) {
-        // If we are sending feature flags, we need to make sure we have the latest flags
-        // return await super.getFeatureFlagsStateless(distinctId, groups, undefined, undefined, disableGeoip)
-        return await _getFlags(distinctId, groups, disableGeoip);
+        // If we are sending feature flags, we evaluate them locally if the user prefers it, otherwise we fall back to remote evaluation
+        const sendFeatureFlagsOptions = typeof sendFeatureFlags === 'object' ? sendFeatureFlags : undefined;
+        return await this.getFeatureFlagsForEvent(distinctId, groups, disableGeoip, sendFeatureFlagsOptions);
       }
       if (event === '$feature_flag_called') {
         // If we're capturing a $feature_flag_called event, we don't want to enrich the event with cached flags that may be out of date.
         return {};
       }
-      if ((this.featureFlagsPoller?.featureFlags?.length || 0) > 0) {
-        // Otherwise we may as well check for the flags locally and include them if they are already loaded
-        const groupsWithStringValues = {};
-        for (const [key, value] of Object.entries(groups || {})) {
-          groupsWithStringValues[key] = String(value);
-        }
-        return await this.getAllFlags(distinctId, {
-          groups: groupsWithStringValues,
-          disableGeoip,
-          onlyEvaluateLocally: true
-        });
-      }
       return {};
     }).then(flags => {
       // Derive the relevant flag properties to add
@@ -3671,6 +3643,75 @@ class PostHogBackendClient extends PostHogCoreStateless {
       }
     }
   }
+  extractPropertiesFromEvent(eventProperties, groups) {
+    if (!eventProperties) {
+      return {
+        personProperties: {},
+        groupProperties: {}
+      };
+    }
+    const personProperties = {};
+    const groupProperties = {};
+    for (const [key, value] of Object.entries(eventProperties)) {
+      // If the value is a plain object and the key exists in groups, treat it as group properties
+      if (isPlainObject(value) && groups && key in groups) {
+        const groupProps = {};
+        for (const [groupKey, groupValue] of Object.entries(value)) {
+          groupProps[String(groupKey)] = String(groupValue);
+        }
+        groupProperties[String(key)] = groupProps;
+      } else {
+        // Otherwise treat as person property
+        personProperties[String(key)] = String(value);
+      }
+    }
+    return {
+      personProperties,
+      groupProperties
+    };
+  }
+  async getFeatureFlagsForEvent(distinctId, groups, disableGeoip, sendFeatureFlagsOptions) {
+    // Use properties directly from options if they exist
+    const finalPersonProperties = sendFeatureFlagsOptions?.personProperties || {};
+    const finalGroupProperties = sendFeatureFlagsOptions?.groupProperties || {};
+    // Check if we should only evaluate locally
+    const onlyEvaluateLocally = sendFeatureFlagsOptions?.onlyEvaluateLocally ?? false;
+    // If onlyEvaluateLocally is true, only use local evaluation
+    if (onlyEvaluateLocally) {
+      if ((this.featureFlagsPoller?.featureFlags?.length || 0) > 0) {
+        const groupsWithStringValues = {};
+        for (const [key, value] of Object.entries(groups || {})) {
+          groupsWithStringValues[key] = String(value);
+        }
+        return await this.getAllFlags(distinctId, {
+          groups: groupsWithStringValues,
+          personProperties: finalPersonProperties,
+          groupProperties: finalGroupProperties,
+          disableGeoip,
+          onlyEvaluateLocally: true
+        });
+      } else {
+        // If onlyEvaluateLocally is true but we don't have local flags, return empty
+        return {};
+      }
+    }
+    // Prefer local evaluation if available (default behavior; I'd rather not penalize users who haven't updated to the new API but still want to use local evaluation)
+    if ((this.featureFlagsPoller?.featureFlags?.length || 0) > 0) {
+      const groupsWithStringValues = {};
+      for (const [key, value] of Object.entries(groups || {})) {
+        groupsWithStringValues[key] = String(value);
+      }
+      return await this.getAllFlags(distinctId, {
+        groups: groupsWithStringValues,
+        personProperties: finalPersonProperties,
+        groupProperties: finalGroupProperties,
+        disableGeoip,
+        onlyEvaluateLocally: true
+      });
+    }
+    // Fall back to remote evaluation if local evaluation is not available
+    return (await super.getFeatureFlagsStateless(distinctId, groups, finalPersonProperties, finalGroupProperties, disableGeoip)).flags;
+  }
   addLocalPersonAndGroupProperties(distinctId, groups, personProperties, groupProperties) {
     const allPersonProperties = {
       distinct_id: distinctId,