posthog-node 3.3.0 → 3.4.0

package/lib/index.esm.js

@@ -154,7 +154,7 @@ function __spreadArray(to, from, pack) {
     return to.concat(ar || Array.prototype.slice.call(from));
 }
 
-var version = "3.3.0";
+var version = "3.4.0";
 
 var PostHogPersistedProperty;
 (function (PostHogPersistedProperty) {
@@ -2344,12 +2344,36 @@ function matchProperty(property, propertyValues) {
 
   var overrideValue = propertyValues[key];
 
+  function computeExactMatch(value, overrideValue) {
+    if (Array.isArray(value)) {
+      return value.map(function (val) {
+        return String(val).toLowerCase();
+      }).includes(String(overrideValue).toLowerCase());
+    }
+
+    return String(value).toLowerCase() === String(overrideValue).toLowerCase();
+  }
+
+  function compare(lhs, rhs, operator) {
+    if (operator === 'gt') {
+      return lhs > rhs;
+    } else if (operator === 'gte') {
+      return lhs >= rhs;
+    } else if (operator === 'lt') {
+      return lhs < rhs;
+    } else if (operator === 'lte') {
+      return lhs <= rhs;
+    } else {
+      throw new Error("Invalid operator: ".concat(operator));
+    }
+  }
+
   switch (operator) {
     case 'exact':
-      return Array.isArray(value) ? value.indexOf(overrideValue) !== -1 : value === overrideValue;
+      return computeExactMatch(value, overrideValue);
 
     case 'is_not':
-      return Array.isArray(value) ? value.indexOf(overrideValue) === -1 : value !== overrideValue;
+      return !computeExactMatch(value, overrideValue);
 
     case 'is_set':
       return key in propertyValues;
@@ -2367,24 +2391,53 @@ function matchProperty(property, propertyValues) {
       return isValidRegex(String(value)) && String(overrideValue).match(String(value)) === null;
 
     case 'gt':
-      return typeof overrideValue == typeof value && overrideValue > value;
-
     case 'gte':
-      return typeof overrideValue == typeof value && overrideValue >= value;
-
     case 'lt':
-      return typeof overrideValue == typeof value && overrideValue < value;
-
     case 'lte':
-      return typeof overrideValue == typeof value && overrideValue <= value;
+      {
+        // :TRICKY: We adjust comparison based on the override value passed in,
+        // to make sure we handle both numeric and string comparisons appropriately.
+        var parsedValue = typeof value === 'number' ? value : null;
+
+        if (typeof value === 'string') {
+          try {
+            parsedValue = parseFloat(value);
+          } catch (err) {// pass
+          }
+        }
+
+        if (parsedValue != null && overrideValue != null) {
+          // check both null and undefined
+          if (typeof overrideValue === 'string') {
+            return compare(overrideValue, String(value), operator);
+          } else {
+            return compare(overrideValue, parsedValue, operator);
+          }
+        } else {
+          return compare(String(overrideValue), String(value), operator);
+        }
+      }
 
     case 'is_date_after':
     case 'is_date_before':
+    case 'is_relative_date_before':
+    case 'is_relative_date_after':
       {
-        var parsedDate = convertToDateTime(value);
+        var parsedDate = null;
+
+        if (['is_relative_date_before', 'is_relative_date_after'].includes(operator)) {
+          parsedDate = relativeDateParseForFeatureFlagMatching(String(value));
+        } else {
+          parsedDate = convertToDateTime(value);
+        }
+
+        if (parsedDate == null) {
+          throw new InconclusiveMatchError("Invalid date: ".concat(value));
+        }
+
         var overrideDate = convertToDateTime(overrideValue);
 
-        if (operator === 'is_date_before') {
+        if (['is_date_before', 'is_relative_date_before'].includes(operator)) {
           return overrideDate < parsedDate;
         }
 
@@ -2392,8 +2445,7 @@ function matchProperty(property, propertyValues) {
       }
 
     default:
-      console.error("Unknown operator: ".concat(operator));
-      return false;
+      throw new InconclusiveMatchError("Unknown operator: ".concat(operator));
   }
 }
 
@@ -2535,6 +2587,45 @@ function convertToDateTime(value) {
   }
 }
 
+function relativeDateParseForFeatureFlagMatching(value) {
+  var regex = /^(?<number>[0-9]+)(?<interval>[a-z])$/;
+  var match = value.match(regex);
+  var parsedDt = new Date(new Date().toISOString());
+
+  if (match) {
+    if (!match.groups) {
+      return null;
+    }
+
+    var number = parseInt(match.groups['number']);
+
+    if (number >= 10000) {
+      // Guard against overflow, disallow numbers greater than 10_000
+      return null;
+    }
+
+    var interval = match.groups['interval'];
+
+    if (interval == 'h') {
+      parsedDt.setUTCHours(parsedDt.getUTCHours() - number);
+    } else if (interval == 'd') {
+      parsedDt.setUTCDate(parsedDt.getUTCDate() - number);
+    } else if (interval == 'w') {
+      parsedDt.setUTCDate(parsedDt.getUTCDate() - number * 7);
+    } else if (interval == 'm') {
+      parsedDt.setUTCMonth(parsedDt.getUTCMonth() - number);
+    } else if (interval == 'y') {
+      parsedDt.setUTCFullYear(parsedDt.getUTCFullYear() - number);
+    } else {
+      return null;
+    }
+
+    return parsedDt;
+  } else {
+    return null;
+  }
+}
+
 var THIRTY_SECONDS = 30 * 1000;
 var MAX_CACHE_SIZE = 50 * 1000; // The actual exported Nodejs API.