posthog-node 2.5.4 → 2.6.0

package/CHANGELOG.md

@@ -1,3 +1,7 @@
+# 2.6.0 - 2023-03-14
+
+1. Add support for all cohorts local evaluation in feature flags.
+
 # 2.5.4 - 2023-02-27
 
 1. Fix error log for local evaluation of feature flags (InconclusiveMatchError(s)) to only show during debug mode.

package/lib/index.cjs.js

@@ -163,7 +163,7 @@ function __spreadArray(to, from, pack) {
     return to.concat(ar || Array.prototype.slice.call(from));
 }
 
-var version = "2.5.4";
+var version = "2.6.0";
 
 var PostHogPersistedProperty;
 (function (PostHogPersistedProperty) {
@@ -1606,6 +1606,7 @@ function () {
     this.featureFlags = [];
     this.featureFlagsByKey = {};
     this.groupTypeMapping = {};
+    this.cohorts = {};
     this.loadedSuccessfullyOnce = false;
     this.timeout = timeout;
     this.projectApiKey = projectApiKey;
@@ -1943,14 +1944,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;
       }
     }
@@ -2083,6 +2093,7 @@ function () {
               return acc[curr.key] = curr, acc;
             }, {});
             this.groupTypeMapping = responseJson.group_type_mapping || {};
+            this.cohorts = responseJson.cohorts || [];
             this.loadedSuccessfullyOnce = true;
             return [3
             /*break*/
@@ -2115,7 +2126,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: {
@@ -2252,6 +2263,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);