posthog-node 2.5.3 → 2.6.0

package/lib/index.d.ts

@@ -103,6 +103,7 @@ declare abstract class PostHogCoreStateless {
     private requestTimeout;
     private captureMode;
     private removeDebugCallback?;
+    private debugMode;
     private pendingPromises;
     private _optoutOverride;
     protected _events: SimpleEventEmitter;
@@ -319,6 +320,7 @@ declare class PostHog extends PostHogCoreStateless implements PostHogNodeV1 {
     getCustomUserAgent(): string;
     enable(): void;
     disable(): void;
+    debug(enabled?: boolean): void;
     capture({ distinctId, event, properties, groups, sendFeatureFlags, timestamp }: EventMessageV1): void;
     identify({ distinctId, properties }: IdentifyMessageV1): void;
     alias(data: {

package/lib/index.esm.js

@@ -155,7 +155,7 @@ function __spreadArray(to, from, pack) {
     return to.concat(ar || Array.prototype.slice.call(from));
 }
 
-var version = "2.5.3";
+var version = "2.6.0";
 
 var PostHogPersistedProperty;
 (function (PostHogPersistedProperty) {
@@ -717,6 +717,7 @@ var SimpleEventEmitter = /** @class */ (function () {
 var PostHogCoreStateless = /** @class */ (function () {
     function PostHogCoreStateless(apiKey, options) {
         var _a, _b, _c, _d;
+        this.debugMode = false;
         this.pendingPromises = {};
         // internal
         this._events = new SimpleEventEmitter();
@@ -761,6 +762,7 @@ var PostHogCoreStateless = /** @class */ (function () {
         var _a;
         if (enabled === void 0) { enabled = true; }
         (_a = this.removeDebugCallback) === null || _a === void 0 ? void 0 : _a.call(this);
+        this.debugMode = enabled;
         if (enabled) {
             this.removeDebugCallback = this.on('*', function (event, payload) { return console.log('PostHog Debug', event, payload); });
         }
@@ -1590,11 +1592,13 @@ function () {
         host = _a.host,
         options = __rest(_a, ["pollingInterval", "personalApiKey", "projectApiKey", "timeout", "host"]);
 
+    this.debugMode = false;
     this.pollingInterval = pollingInterval;
     this.personalApiKey = personalApiKey;
     this.featureFlags = [];
     this.featureFlagsByKey = {};
     this.groupTypeMapping = {};
+    this.cohorts = {};
     this.loadedSuccessfullyOnce = false;
     this.timeout = timeout;
     this.projectApiKey = projectApiKey;
@@ -1605,6 +1609,14 @@ function () {
     void this.loadFeatureFlags();
   }
 
+  FeatureFlagsPoller.prototype.debug = function (enabled) {
+    if (enabled === void 0) {
+      enabled = true;
+    }
+
+    this.debugMode = enabled;
+  };
+
   FeatureFlagsPoller.prototype.getFeatureFlag = function (key, distinctId, groups, personProperties, groupProperties) {
     if (groups === void 0) {
       groups = {};
@@ -1652,9 +1664,15 @@ function () {
             if (featureFlag !== undefined) {
               try {
                 response = this.computeFlagLocally(featureFlag, distinctId, groups, personProperties, groupProperties);
+
+                if (this.debugMode) {
+                  console.debug("Successfully computed flag locally: ".concat(key, " -> ").concat(response));
+                }
               } catch (e) {
                 if (e instanceof InconclusiveMatchError) {
-                  console.error("InconclusiveMatchError when computing flag locally: ".concat(key, ": ").concat(e));
+                  if (this.debugMode) {
+                    console.debug("InconclusiveMatchError when computing flag locally: ".concat(key, ": ").concat(e));
+                  }
                 } else if (e instanceof Error) {
                   console.error("Error computing flag locally: ".concat(key, ": ").concat(e));
                 }
@@ -1918,14 +1936,23 @@ function () {
     var rolloutPercentage = condition.rollout_percentage;
 
     if ((condition.properties || []).length > 0) {
-      var matchAll = condition.properties.every(function (property) {
-        return matchProperty(property, properties);
-      });
+      for (var _i = 0, _a = condition.properties; _i < _a.length; _i++) {
+        var prop = _a[_i];
+        var propertyType = prop.type;
+        var matches = false;
 
-      if (!matchAll) {
-        return false;
-      } else if (rolloutPercentage == undefined) {
-        // == to include `null` as a match, not just `undefined`
+        if (propertyType === 'cohort') {
+          matches = matchCohort(prop, properties, this.cohorts);
+        } else {
+          matches = matchProperty(prop, properties);
+        }
+
+        if (!matches) {
+          return false;
+        }
+      }
+
+      if (rolloutPercentage == undefined) {
         return true;
       }
     }
@@ -2058,6 +2085,7 @@ function () {
               return acc[curr.key] = curr, acc;
             }, {});
             this.groupTypeMapping = responseJson.group_type_mapping || {};
+            this.cohorts = responseJson.cohorts || [];
             this.loadedSuccessfullyOnce = true;
             return [3
             /*break*/
@@ -2090,7 +2118,7 @@ function () {
       return __generator(this, function (_a) {
         switch (_a.label) {
           case 0:
-            url = "".concat(this.host, "/api/feature_flag/local_evaluation?token=").concat(this.projectApiKey);
+            url = "".concat(this.host, "/api/feature_flag/local_evaluation?token=").concat(this.projectApiKey, "&send_cohorts");
             options = {
               method: 'GET',
               headers: {
@@ -2227,6 +2255,119 @@ function matchProperty(property, propertyValues) {
   }
 }
 
+function matchCohort(property, propertyValues, cohortProperties) {
+  var cohortId = String(property.value);
+
+  if (!(cohortId in cohortProperties)) {
+    throw new InconclusiveMatchError("can't match cohort without a given cohort property value");
+  }
+
+  var propertyGroup = cohortProperties[cohortId];
+  return matchPropertyGroup(propertyGroup, propertyValues, cohortProperties);
+}
+
+function matchPropertyGroup(propertyGroup, propertyValues, cohortProperties) {
+  if (!propertyGroup) {
+    return true;
+  }
+
+  var propertyGroupType = propertyGroup.type;
+  var properties = propertyGroup.values;
+
+  if (!properties || properties.length === 0) {
+    // empty groups are no-ops, always match
+    return true;
+  }
+
+  var errorMatchingLocally = false;
+
+  if ('values' in properties[0]) {
+    // a nested property group
+    for (var _i = 0, _a = properties; _i < _a.length; _i++) {
+      var prop = _a[_i];
+
+      try {
+        var matches = matchPropertyGroup(prop, propertyValues, cohortProperties);
+
+        if (propertyGroupType === 'AND') {
+          if (!matches) {
+            return false;
+          }
+        } else {
+          // OR group
+          if (matches) {
+            return true;
+          }
+        }
+      } catch (err) {
+        if (err instanceof InconclusiveMatchError) {
+          console.debug("Failed to compute property ".concat(prop, " locally: ").concat(err));
+          errorMatchingLocally = true;
+        } else {
+          throw err;
+        }
+      }
+    }
+
+    if (errorMatchingLocally) {
+      throw new InconclusiveMatchError("Can't match cohort without a given cohort property value");
+    } // if we get here, all matched in AND case, or none matched in OR case
+
+
+    return propertyGroupType === 'AND';
+  } else {
+    for (var _b = 0, _c = properties; _b < _c.length; _b++) {
+      var prop = _c[_b];
+
+      try {
+        var matches = void 0;
+
+        if (prop.type === 'cohort') {
+          matches = matchCohort(prop, propertyValues, cohortProperties);
+        } else {
+          matches = matchProperty(prop, propertyValues);
+        }
+
+        var negation = prop.negation || false;
+
+        if (propertyGroupType === 'AND') {
+          // if negated property, do the inverse
+          if (!matches && !negation) {
+            return false;
+          }
+
+          if (matches && negation) {
+            return false;
+          }
+        } else {
+          // OR group
+          if (matches && !negation) {
+            return true;
+          }
+
+          if (!matches && negation) {
+            return true;
+          }
+        }
+      } catch (err) {
+        if (err instanceof InconclusiveMatchError) {
+          console.debug("Failed to compute property ".concat(prop, " locally: ").concat(err));
+          errorMatchingLocally = true;
+        } else {
+          throw err;
+        }
+      }
+    }
+
+    if (errorMatchingLocally) {
+      throw new InconclusiveMatchError("can't match cohort without a given cohort property value");
+    } // if we get here, all matched in AND case, or none matched in OR case
+
+
+    return propertyGroupType === 'AND';
+  }
+}
+
 function isValidRegex(regex) {
   try {
     new RegExp(regex);
@@ -2322,6 +2463,18 @@ function (_super) {
     return _super.prototype.optOut.call(this);
   };
 
+  PostHog.prototype.debug = function (enabled) {
+    var _a;
+
+    if (enabled === void 0) {
+      enabled = true;
+    }
+
+    _super.prototype.debug.call(this, enabled);
+
+    (_a = this.featureFlagsPoller) === null || _a === void 0 ? void 0 : _a.debug(enabled);
+  };
+
   PostHog.prototype.capture = function (_a) {
     var _this = this;