posthog-node 5.4.0 → 5.5.1

package/lib/index.d.ts

@@ -588,10 +588,15 @@ interface IdentifyMessage {
     properties?: Record<string | number, any>;
     disableGeoip?: boolean;
 }
+interface SendFeatureFlagsOptions {
+    onlyEvaluateLocally?: boolean;
+    personProperties?: Record<string, any>;
+    groupProperties?: Record<string, Record<string, any>>;
+}
 interface EventMessage extends IdentifyMessage {
     event: string;
     groups?: Record<string, string | number>;
-    sendFeatureFlags?: boolean;
+    sendFeatureFlags?: boolean | SendFeatureFlagsOptions;
     timestamp?: Date;
     uuid?: string;
 }
@@ -967,4 +972,4 @@ declare class PostHog extends PostHogBackendClient {
     getLibraryId(): string;
 }
 
-export { EventMessage, FeatureFlagCondition, FlagProperty, GroupIdentifyMessage, IPostHog, IdentifyMessage, PostHog, PostHogFeatureFlag, PostHogOptions, PostHogSentryIntegration, PropertyGroup, SentryIntegrationOptions, createEventProcessor, sentryIntegration, setupExpressErrorHandler };
+export { EventMessage, FeatureFlagCondition, FlagProperty, GroupIdentifyMessage, IPostHog, IdentifyMessage, PostHog, PostHogFeatureFlag, PostHogOptions, PostHogSentryIntegration, PropertyGroup, SendFeatureFlagsOptions, SentryIntegrationOptions, createEventProcessor, sentryIntegration, setupExpressErrorHandler };

package/lib/node/index.cjs

@@ -1342,7 +1342,7 @@ function snipLine(line, colno) {
   return newLine;
 }
 
-var version = "5.4.0";
+var version = "5.5.1";
 
 var PostHogPersistedProperty;
 (function (PostHogPersistedProperty) {
@@ -2637,7 +2637,7 @@ class FeatureFlagsPoller {
         }
       } catch (e) {
         if (e instanceof InconclusiveMatchError) {
-          this.onError?.(new Error(`Unable to compute flag locally: ${flag.key} - ${e.message}`));
+          this.logMsgIfDebug(() => console.debug(`InconclusiveMatchError when computing flag locally: ${flag.key}: ${e}`));
         } else if (e instanceof Error) {
           this.onError?.(new Error(`Error computing flag locally: ${flag.key}: ${e}`));
         }
@@ -2734,6 +2734,9 @@ class FeatureFlagsPoller {
         let matches = false;
         if (propertyType === 'cohort') {
           matches = matchCohort(prop, properties, this.cohorts, this.debugMode);
+        } else if (propertyType === 'flag') {
+          this.logMsgIfDebug(() => console.warn(`[FEATURE FLAGS] Flag dependency filters are not supported in local evaluation. ` + `Skipping condition for flag '${flag.key}' with dependency on flag '${prop.key || 'unknown'}'`));
+          continue;
         } else {
           matches = matchProperty(prop, properties, warnFunction);
         }
@@ -3071,6 +3074,11 @@ function matchPropertyGroup(propertyGroup, propertyValues, cohortProperties, deb
         let matches;
         if (prop.type === 'cohort') {
           matches = matchCohort(prop, propertyValues, cohortProperties, debugMode);
+        } else if (prop.type === 'flag') {
+          if (debugMode) {
+            console.warn(`[FEATURE FLAGS] Flag dependency filters are not supported in local evaluation. ` + `Skipping condition with dependency on flag '${prop.key || 'unknown'}'`);
+          }
+          continue;
         } else {
           matches = matchProperty(prop, propertyValues);
         }
@@ -3266,7 +3274,8 @@ class PostHogBackendClient extends PostHogCoreStateless {
     const capturePromise = Promise.resolve().then(async () => {
       if (sendFeatureFlags) {
         // If we are sending feature flags, we evaluate them locally if the user prefers it, otherwise we fall back to remote evaluation
-        return await this.getFeatureFlagsForEvent(distinctId, groups, properties, disableGeoip);
+        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.
@@ -3323,7 +3332,8 @@ class PostHogBackendClient extends PostHogCoreStateless {
     const capturePromise = Promise.resolve().then(async () => {
       if (sendFeatureFlags) {
         // If we are sending feature flags, we evaluate them locally if the user prefers it, otherwise we fall back to remote evaluation
-        return await this.getFeatureFlagsForEvent(distinctId, groups, properties, disableGeoip);
+        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.
@@ -3690,13 +3700,32 @@ class PostHogBackendClient extends PostHogCoreStateless {
       groupProperties
     };
   }
-  async getFeatureFlagsForEvent(distinctId, groups, eventProperties, disableGeoip) {
-    // Extract person and group properties from the event properties
-    const {
-      personProperties: cleanPersonProperties,
-      groupProperties: cleanGroupProperties
-    } = this.extractPropertiesFromEvent(eventProperties, groups);
-    // Prefer local evaluation if available
+  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 || {})) {
@@ -3704,14 +3733,14 @@ class PostHogBackendClient extends PostHogCoreStateless {
       }
       return await this.getAllFlags(distinctId, {
         groups: groupsWithStringValues,
-        personProperties: cleanPersonProperties,
-        groupProperties: cleanGroupProperties,
+        personProperties: finalPersonProperties,
+        groupProperties: finalGroupProperties,
         disableGeoip,
         onlyEvaluateLocally: true
       });
     }
-    // Fall back to remote evaluation if local evaluation is not available/is not being used
-    return (await super.getFeatureFlagsStateless(distinctId, groups, cleanPersonProperties, cleanGroupProperties, disableGeoip)).flags;
+    // 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 = {