posthog-node 3.3.0 → 3.5.0

package/lib/index.d.ts

@@ -108,9 +108,9 @@ declare abstract class PostHogCoreStateless {
     private captureMode;
     private removeDebugCallback?;
     private debugMode;
-    private pendingPromises;
     private disableGeoip;
     private _optoutOverride;
+    private pendingPromises;
     protected _events: SimpleEventEmitter;
     protected _flushTimer?: any;
     protected _retryOptions: RetriableOptions;
@@ -128,6 +128,7 @@ declare abstract class PostHogCoreStateless {
     on(event: string, cb: (...args: any[]) => void): () => void;
     debug(enabled?: boolean): void;
     private buildPayload;
+    protected addPendingPromise(promise: Promise<any>): void;
     /***
      *** TRACKING
      ***/
@@ -377,6 +378,7 @@ declare class PostHog extends PostHogCoreStateless implements PostHogNodeV1 {
     reloadFeatureFlags(): Promise<void>;
     shutdown(): void;
     shutdownAsync(): Promise<void>;
+    private addLocalPersonAndGroupProperties;
 }
 
 /**

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.5.0";
 
 var PostHogPersistedProperty;
 (function (PostHogPersistedProperty) {
@@ -747,8 +747,8 @@ var PostHogCoreStateless = /** @class */ (function () {
     function PostHogCoreStateless(apiKey, options) {
         var _a, _b, _c, _d, _e;
         this.debugMode = false;
-        this.pendingPromises = {};
         this.disableGeoip = true;
+        this.pendingPromises = {};
         // internal
         this._events = new SimpleEventEmitter();
         assert(apiKey, "You must pass your PostHog project's api key.");
@@ -806,6 +806,14 @@ var PostHogCoreStateless = /** @class */ (function () {
             properties: __assign(__assign({}, (payload.properties || {})), this.getCommonEventProperties()),
         };
     };
+    PostHogCoreStateless.prototype.addPendingPromise = function (promise) {
+        var _this = this;
+        var promiseUUID = generateUUID();
+        this.pendingPromises[promiseUUID] = promise;
+        promise.finally(function () {
+            delete _this.pendingPromises[promiseUUID];
+        });
+    };
     /***
      *** TRACKING
      ***/
@@ -856,6 +864,7 @@ var PostHogCoreStateless = /** @class */ (function () {
         if (extraPayload === void 0) { extraPayload = {}; }
         return __awaiter(this, void 0, void 0, function () {
             var url, fetchOptions;
+            var _this = this;
             return __generator(this, function (_a) {
                 url = "".concat(this.host, "/decide/?v=3");
                 fetchOptions = {
@@ -866,7 +875,7 @@ var PostHogCoreStateless = /** @class */ (function () {
                 return [2 /*return*/, this.fetchWithRetry(url, fetchOptions)
                         .then(function (response) { return response.json(); })
                         .catch(function (error) {
-                        console.error('Error fetching feature flags', error);
+                        _this._events.emit('error', error);
                         return undefined;
                     })];
             });
@@ -1053,14 +1062,11 @@ var PostHogCoreStateless = /** @class */ (function () {
             batch: messages,
             sent_at: currentISOTime(),
         };
-        var promiseUUID = generateUUID();
         var done = function (err) {
             if (err) {
                 _this._events.emit('error', err);
             }
             callback === null || callback === void 0 ? void 0 : callback(err, messages);
-            // remove promise from pendingPromises
-            delete _this.pendingPromises[promiseUUID];
             _this._events.emit('flush', messages);
         };
         // Don't set the user agent if we're not on a browser. The latest spec allows
@@ -1086,12 +1092,11 @@ var PostHogCoreStateless = /** @class */ (function () {
                 body: payload,
             };
         var requestPromise = this.fetchWithRetry(url, fetchOptions);
-        this.pendingPromises[promiseUUID] = requestPromise;
-        requestPromise
+        this.addPendingPromise(requestPromise
             .then(function () { return done(); })
             .catch(function (err) {
             done(err);
-        });
+        }));
     };
     PostHogCoreStateless.prototype.fetchWithRetry = function (url, options, retryOptions) {
         var _a;
@@ -1145,7 +1150,7 @@ var PostHogCoreStateless = /** @class */ (function () {
                         clearTimeout(this._flushTimer);
                         _a.label = 1;
                     case 1:
-                        _a.trys.push([1, 4, , 5]);
+                        _a.trys.push([1, 5, , 6]);
                         return [4 /*yield*/, this.flushAsync()];
                     case 2:
                         _a.sent();
@@ -1153,18 +1158,31 @@ var PostHogCoreStateless = /** @class */ (function () {
                                 return x.catch(function () {
                                     // ignore errors as we are shutting down and can't deal with them anyways.
                                 });
-                            }))];
+                            }))
+                            // flush again to make sure we send all events, some of which might've been added
+                            // while we were waiting for the pending promises to resolve
+                            // For example, see sendFeatureFlags in posthog-node/src/posthog-node.ts::capture
+                        ];
                     case 3:
                         _a.sent();
-                        return [3 /*break*/, 5];
+                        // flush again to make sure we send all events, some of which might've been added
+                        // while we were waiting for the pending promises to resolve
+                        // For example, see sendFeatureFlags in posthog-node/src/posthog-node.ts::capture
+                        return [4 /*yield*/, this.flushAsync()];
                     case 4:
+                        // flush again to make sure we send all events, some of which might've been added
+                        // while we were waiting for the pending promises to resolve
+                        // For example, see sendFeatureFlags in posthog-node/src/posthog-node.ts::capture
+                        _a.sent();
+                        return [3 /*break*/, 6];
+                    case 5:
                         e_2 = _a.sent();
                         if (!isPostHogFetchError(e_2)) {
                             throw e_2;
                         }
                         console.error('Error while shutting down PostHog', e_2);
-                        return [3 /*break*/, 5];
-                    case 5: return [2 /*return*/];
+                        return [3 /*break*/, 6];
+                    case 6: return [2 /*return*/];
                 }
             });
         });
@@ -1756,6 +1774,8 @@ function () {
   };
 
   FeatureFlagsPoller.prototype.getFeatureFlag = function (key, distinctId, groups, personProperties, groupProperties) {
+    var _a;
+
     if (groups === void 0) {
       groups = {};
     }
@@ -1769,17 +1789,17 @@ function () {
     }
 
     return __awaiter(this, void 0, void 0, function () {
-      var response, featureFlag, _i, _a, flag;
+      var response, featureFlag, _i, _b, flag;
 
-      return __generator(this, function (_b) {
-        switch (_b.label) {
+      return __generator(this, function (_c) {
+        switch (_c.label) {
           case 0:
             return [4
             /*yield*/
             , this.loadFeatureFlags()];
 
           case 1:
-            _b.sent();
+            _c.sent();
 
             response = undefined;
             featureFlag = undefined;
@@ -1790,8 +1810,8 @@ function () {
               , response];
             }
 
-            for (_i = 0, _a = this.featureFlags; _i < _a.length; _i++) {
-              flag = _a[_i];
+            for (_i = 0, _b = this.featureFlags; _i < _b.length; _i++) {
+              flag = _b[_i];
 
               if (key === flag.key) {
                 featureFlag = flag;
@@ -1812,7 +1832,7 @@ function () {
                     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));
+                  (_a = this.onError) === null || _a === void 0 ? void 0 : _a.call(this, new Error("Error computing flag locally: ".concat(key, ": ").concat(e)));
                 }
               }
             }
@@ -1988,12 +2008,18 @@ function () {
       var groupName = this.groupTypeMapping[String(aggregation_group_type_index)];
 
       if (!groupName) {
-        console.warn("[FEATURE FLAGS] Unknown group type index ".concat(aggregation_group_type_index, " for feature flag ").concat(flag.key));
+        if (this.debugMode) {
+          console.warn("[FEATURE FLAGS] Unknown group type index ".concat(aggregation_group_type_index, " for feature flag ").concat(flag.key));
+        }
+
         throw new InconclusiveMatchError('Flag has unknown group type index');
       }
 
       if (!(groupName in groups)) {
-        console.warn("[FEATURE FLAGS] Can't compute group feature flag: ".concat(flag.key, " without group names passed in"));
+        if (this.debugMode) {
+          console.warn("[FEATURE FLAGS] Can't compute group feature flag: ".concat(flag.key, " without group names passed in"));
+        }
+
         return false;
       }
 
@@ -2170,15 +2196,15 @@ function () {
   };
 
   FeatureFlagsPoller.prototype._loadFeatureFlags = function () {
-    var _a;
+    var _a, _b;
 
     return __awaiter(this, void 0, void 0, function () {
       var res, responseJson, err_1;
 
       var _this = this;
 
-      return __generator(this, function (_b) {
-        switch (_b.label) {
+      return __generator(this, function (_c) {
+        switch (_c.label) {
           case 0:
             if (this.poller) {
               clearTimeout(this.poller);
@@ -2188,17 +2214,17 @@ function () {
             this.poller = setTimeout(function () {
               return _this._loadFeatureFlags();
             }, this.pollingInterval);
-            _b.label = 1;
+            _c.label = 1;
 
           case 1:
-            _b.trys.push([1, 4,, 5]);
+            _c.trys.push([1, 4,, 5]);
 
             return [4
             /*yield*/
             , this._requestFeatureFlagDefinitions()];
 
           case 2:
-            res = _b.sent();
+            res = _c.sent();
 
             if (res && res.status === 401) {
               throw new ClientError("Your personalApiKey is invalid. Are you sure you're not using your Project API key? More information: https://posthog.com/docs/api/overview");
@@ -2217,10 +2243,10 @@ function () {
             , res.json()];
 
           case 3:
-            responseJson = _b.sent();
+            responseJson = _c.sent();
 
             if (!('flags' in responseJson)) {
-              console.error("Invalid response when getting feature flags: ".concat(JSON.stringify(responseJson)));
+              (_a = this.onError) === null || _a === void 0 ? void 0 : _a.call(this, new Error("Invalid response when getting feature flags: ".concat(JSON.stringify(responseJson))));
             }
 
             this.featureFlags = responseJson.flags || [];
@@ -2235,11 +2261,11 @@ function () {
             , 5];
 
           case 4:
-            err_1 = _b.sent(); // if an error that is not an instance of ClientError is thrown
+            err_1 = _c.sent(); // if an error that is not an instance of ClientError is thrown
             // we silently ignore the error when reloading feature flags
 
             if (err_1 instanceof ClientError) {
-              (_a = this.onError) === null || _a === void 0 ? void 0 : _a.call(this, err_1);
+              (_b = this.onError) === null || _b === void 0 ? void 0 : _b.call(this, err_1);
             }
 
             return [3
@@ -2344,12 +2370,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 +2417,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 +2471,7 @@ function matchProperty(property, propertyValues) {
       }
 
     default:
-      console.error("Unknown operator: ".concat(operator));
-      return false;
+      throw new InconclusiveMatchError("Unknown operator: ".concat(operator));
   }
 }
 
@@ -2535,6 +2613,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.
 
@@ -2636,41 +2753,94 @@ function (_super) {
         timestamp: timestamp,
         disableGeoip: disableGeoip
       });
-    };
+    }; // :TRICKY: If we flush, or need to shut down, to not lose events we want this promise to resolve before we flush
 
-    if (sendFeatureFlags) {
-      _super.prototype.getFeatureFlagsStateless.call(this, distinctId, groups, undefined, undefined, disableGeoip).then(function (flags) {
-        var featureVariantProperties = {};
 
-        if (flags) {
-          for (var _i = 0, _a = Object.entries(flags); _i < _a.length; _i++) {
-            var _b = _a[_i],
-                feature = _b[0],
-                variant = _b[1];
+    var capturePromise = Promise.resolve().then(function () {
+      return __awaiter(_this, void 0, void 0, function () {
+        var groupsWithStringValues, _i, _a, _b, key, value;
 
-            if (variant !== false) {
-              featureVariantProperties["$feature/".concat(feature)] = variant;
-            }
+        var _c, _d;
+
+        return __generator(this, function (_e) {
+          switch (_e.label) {
+            case 0:
+              if (!sendFeatureFlags) return [3
+              /*break*/
+              , 2];
+              return [4
+              /*yield*/
+              , _super.prototype.getFeatureFlagsStateless.call(this, distinctId, groups, undefined, undefined, disableGeoip)];
+
+            case 1:
+              // If we are sending feature flags, we need to make sure we have the latest flags
+              return [2
+              /*return*/
+              , _e.sent()];
+
+            case 2:
+              if (!((((_d = (_c = this.featureFlagsPoller) === null || _c === void 0 ? void 0 : _c.featureFlags) === null || _d === void 0 ? void 0 : _d.length) || 0) > 0)) return [3
+              /*break*/
+              , 4];
+              groupsWithStringValues = {};
+
+              for (_i = 0, _a = Object.entries(groups || {}); _i < _a.length; _i++) {
+                _b = _a[_i], key = _b[0], value = _b[1];
+                groupsWithStringValues[key] = String(value);
+              }
+
+              return [4
+              /*yield*/
+              , this.getAllFlags(distinctId, {
+                groups: groupsWithStringValues,
+                disableGeoip: disableGeoip,
+                onlyEvaluateLocally: true
+              })];
+
+            case 3:
+              return [2
+              /*return*/
+              , _e.sent()];
+
+            case 4:
+              return [2
+              /*return*/
+              , {}];
           }
+        });
+      });
+    }).then(function (flags) {
+      // Derive the relevant flag properties to add
+      var additionalProperties = {};
+
+      if (flags) {
+        for (var _i = 0, _a = Object.entries(flags); _i < _a.length; _i++) {
+          var _b = _a[_i],
+              feature = _b[0],
+              variant = _b[1];
+          additionalProperties["$feature/".concat(feature)] = variant;
         }
+      }
 
-        var activeFlags = Object.keys(flags || {}).filter(function (flag) {
-          return (flags === null || flags === void 0 ? void 0 : flags[flag]) !== false;
-        });
+      var activeFlags = Object.keys(flags || {}).filter(function (flag) {
+        return (flags === null || flags === void 0 ? void 0 : flags[flag]) !== false;
+      });
 
-        var flagProperties = __assign({
-          $active_feature_flags: activeFlags || undefined
-        }, featureVariantProperties);
+      if (activeFlags.length > 0) {
+        additionalProperties['$active_feature_flags'] = activeFlags;
+      }
 
-        _capture(__assign(__assign(__assign({}, properties), {
-          $groups: groups
-        }), flagProperties));
-      });
-    } else {
-      _capture(__assign(__assign({}, properties), {
+      return additionalProperties;
+    }).catch(function () {
+      // Something went wrong getting the flag info - we should capture the event anyways
+      return {};
+    }).then(function (additionalProperties) {
+      // No matter what - capture the event
+      _capture(__assign(__assign(__assign({}, additionalProperties), properties), {
         $groups: groups
       }));
-    }
+    });
+    this.addPendingPromise(capturePromise);
   };
 
   PostHog.prototype.identify = function (_a) {
@@ -2697,15 +2867,18 @@ function (_super) {
     var _a;
 
     return __awaiter(this, void 0, void 0, function () {
-      var _b, groups, personProperties, groupProperties, disableGeoip, _c, onlyEvaluateLocally, sendFeatureFlagEvents, response, flagWasLocallyEvaluated, featureFlagReportedKey;
+      var _b, groups, disableGeoip, _c, onlyEvaluateLocally, sendFeatureFlagEvents, personProperties, groupProperties, adjustedProperties, response, flagWasLocallyEvaluated, featureFlagReportedKey;
 
       var _d;
 
       return __generator(this, function (_e) {
         switch (_e.label) {
           case 0:
-            _b = options || {}, groups = _b.groups, personProperties = _b.personProperties, groupProperties = _b.groupProperties, disableGeoip = _b.disableGeoip;
-            _c = options || {}, onlyEvaluateLocally = _c.onlyEvaluateLocally, sendFeatureFlagEvents = _c.sendFeatureFlagEvents; // set defaults
+            _b = options || {}, groups = _b.groups, disableGeoip = _b.disableGeoip;
+            _c = options || {}, onlyEvaluateLocally = _c.onlyEvaluateLocally, sendFeatureFlagEvents = _c.sendFeatureFlagEvents, personProperties = _c.personProperties, groupProperties = _c.groupProperties;
+            adjustedProperties = this.addLocalPersonAndGroupProperties(distinctId, groups, personProperties, groupProperties);
+            personProperties = adjustedProperties.allPersonProperties;
+            groupProperties = adjustedProperties.allGroupProperties; // set defaults
 
             if (onlyEvaluateLocally == undefined) {
               onlyEvaluateLocally = false;
@@ -2772,13 +2945,16 @@ function (_super) {
     var _a;
 
     return __awaiter(this, void 0, void 0, function () {
-      var _b, groups, personProperties, groupProperties, disableGeoip, _c, onlyEvaluateLocally, response, payloadWasLocallyEvaluated;
+      var _b, groups, disableGeoip, _c, onlyEvaluateLocally, personProperties, groupProperties, adjustedProperties, response, payloadWasLocallyEvaluated;
 
       return __generator(this, function (_d) {
         switch (_d.label) {
           case 0:
-            _b = options || {}, groups = _b.groups, personProperties = _b.personProperties, groupProperties = _b.groupProperties, disableGeoip = _b.disableGeoip;
-            _c = options || {}, onlyEvaluateLocally = _c.onlyEvaluateLocally, _c.sendFeatureFlagEvents;
+            _b = options || {}, groups = _b.groups, disableGeoip = _b.disableGeoip;
+            _c = options || {}, onlyEvaluateLocally = _c.onlyEvaluateLocally, _c.sendFeatureFlagEvents, personProperties = _c.personProperties, groupProperties = _c.groupProperties;
+            adjustedProperties = this.addLocalPersonAndGroupProperties(distinctId, groups, personProperties, groupProperties);
+            personProperties = adjustedProperties.allPersonProperties;
+            groupProperties = adjustedProperties.allGroupProperties;
             response = undefined;
             if (!!matchValue) return [3
             /*break*/
@@ -2898,13 +3074,16 @@ function (_super) {
     var _a;
 
     return __awaiter(this, void 0, void 0, function () {
-      var _b, groups, personProperties, groupProperties, disableGeoip, onlyEvaluateLocally, localEvaluationResult, featureFlags, featureFlagPayloads, fallbackToDecide, remoteEvaluationResult;
+      var _b, groups, disableGeoip, _c, onlyEvaluateLocally, personProperties, groupProperties, adjustedProperties, localEvaluationResult, featureFlags, featureFlagPayloads, fallbackToDecide, remoteEvaluationResult;
 
-      return __generator(this, function (_c) {
-        switch (_c.label) {
+      return __generator(this, function (_d) {
+        switch (_d.label) {
           case 0:
-            _b = options || {}, groups = _b.groups, personProperties = _b.personProperties, groupProperties = _b.groupProperties, disableGeoip = _b.disableGeoip;
-            onlyEvaluateLocally = (options || {}).onlyEvaluateLocally; // set defaults
+            _b = options || {}, groups = _b.groups, disableGeoip = _b.disableGeoip;
+            _c = options || {}, onlyEvaluateLocally = _c.onlyEvaluateLocally, personProperties = _c.personProperties, groupProperties = _c.groupProperties;
+            adjustedProperties = this.addLocalPersonAndGroupProperties(distinctId, groups, personProperties, groupProperties);
+            personProperties = adjustedProperties.allPersonProperties;
+            groupProperties = adjustedProperties.allGroupProperties; // set defaults
 
             if (onlyEvaluateLocally == undefined) {
               onlyEvaluateLocally = false;
@@ -2915,7 +3094,7 @@ function (_super) {
             , (_a = this.featureFlagsPoller) === null || _a === void 0 ? void 0 : _a.getAllFlagsAndPayloads(distinctId, groups, personProperties, groupProperties)];
 
           case 1:
-            localEvaluationResult = _c.sent();
+            localEvaluationResult = _d.sent();
             featureFlags = {};
             featureFlagPayloads = {};
             fallbackToDecide = true;
@@ -2934,10 +3113,10 @@ function (_super) {
             , _super.prototype.getFeatureFlagsAndPayloadsStateless.call(this, distinctId, groups, personProperties, groupProperties, disableGeoip)];
 
           case 2:
-            remoteEvaluationResult = _c.sent();
+            remoteEvaluationResult = _d.sent();
             featureFlags = __assign(__assign({}, featureFlags), remoteEvaluationResult.flags || {});
             featureFlagPayloads = __assign(__assign({}, featureFlagPayloads), remoteEvaluationResult.payloads || {});
-            _c.label = 3;
+            _d.label = 3;
 
           case 3:
             return [2
@@ -3002,6 +3181,28 @@ function (_super) {
     });
   };
 
+  PostHog.prototype.addLocalPersonAndGroupProperties = function (distinctId, groups, personProperties, groupProperties) {
+    var allPersonProperties = __assign({
+      $current_distinct_id: distinctId
+    }, personProperties || {});
+
+    var allGroupProperties = {};
+
+    if (groups) {
+      for (var _i = 0, _a = Object.keys(groups); _i < _a.length; _i++) {
+        var groupName = _a[_i];
+        allGroupProperties[groupName] = __assign({
+          $group_key: groups[groupName]
+        }, (groupProperties === null || groupProperties === void 0 ? void 0 : groupProperties[groupName]) || {});
+      }
+    }
+
+    return {
+      allPersonProperties: allPersonProperties,
+      allGroupProperties: allGroupProperties
+    };
+  };
+
   return PostHog;
 }(PostHogCoreStateless);