posthog-node 2.3.1 → 2.5.0

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.3.1";
+var version = "2.5.0";
 
 var PostHogPersistedProperty;
 (function (PostHogPersistedProperty) {
@@ -722,11 +722,9 @@ var SimpleEventEmitter = /** @class */ (function () {
     return SimpleEventEmitter;
 }());
 
-var PostHogCore = /** @class */ (function () {
-    function PostHogCore(apiKey, options) {
-        var _this = this;
-        var _a, _b, _c, _d, _e, _f;
-        this.flagCallReported = {};
+var PostHogCoreStateless = /** @class */ (function () {
+    function PostHogCoreStateless(apiKey, options) {
+        var _a, _b, _c, _d;
         // internal
         this._events = new SimpleEventEmitter();
         assert(apiKey, "You must pass your PostHog project's api key.");
@@ -735,33 +733,375 @@ var PostHogCore = /** @class */ (function () {
         this.flushAt = (options === null || options === void 0 ? void 0 : options.flushAt) ? Math.max(options === null || options === void 0 ? void 0 : options.flushAt, 1) : 20;
         this.flushInterval = (_a = options === null || options === void 0 ? void 0 : options.flushInterval) !== null && _a !== void 0 ? _a : 10000;
         this.captureMode = (options === null || options === void 0 ? void 0 : options.captureMode) || 'form';
-        this.sendFeatureFlagEvent = (_b = options === null || options === void 0 ? void 0 : options.sendFeatureFlagEvent) !== null && _b !== void 0 ? _b : true;
         // If enable is explicitly set to false we override the optout
         this._optoutOverride = (options === null || options === void 0 ? void 0 : options.enable) === false;
         this._retryOptions = {
-            retryCount: (_c = options === null || options === void 0 ? void 0 : options.fetchRetryCount) !== null && _c !== void 0 ? _c : 3,
-            retryDelay: (_d = options === null || options === void 0 ? void 0 : options.fetchRetryDelay) !== null && _d !== void 0 ? _d : 3000,
+            retryCount: (_b = options === null || options === void 0 ? void 0 : options.fetchRetryCount) !== null && _b !== void 0 ? _b : 3,
+            retryDelay: (_c = options === null || options === void 0 ? void 0 : options.fetchRetryDelay) !== null && _c !== void 0 ? _c : 3000,
+        };
+        this.requestTimeout = (_d = options === null || options === void 0 ? void 0 : options.requestTimeout) !== null && _d !== void 0 ? _d : 10000; // 10 seconds
+    }
+    PostHogCoreStateless.prototype.getCommonEventProperties = function () {
+        return {
+            $lib: this.getLibraryId(),
+            $lib_version: this.getLibraryVersion(),
+        };
+    };
+    Object.defineProperty(PostHogCoreStateless.prototype, "optedOut", {
+        get: function () {
+            var _a, _b;
+            return (_b = (_a = this.getPersistedProperty(PostHogPersistedProperty.OptedOut)) !== null && _a !== void 0 ? _a : this._optoutOverride) !== null && _b !== void 0 ? _b : false;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    PostHogCoreStateless.prototype.optIn = function () {
+        this.setPersistedProperty(PostHogPersistedProperty.OptedOut, false);
+    };
+    PostHogCoreStateless.prototype.optOut = function () {
+        this.setPersistedProperty(PostHogPersistedProperty.OptedOut, true);
+    };
+    PostHogCoreStateless.prototype.on = function (event, cb) {
+        return this._events.on(event, cb);
+    };
+    PostHogCoreStateless.prototype.debug = function (enabled) {
+        var _a;
+        if (enabled === void 0) { enabled = true; }
+        (_a = this.removeDebugCallback) === null || _a === void 0 ? void 0 : _a.call(this);
+        if (enabled) {
+            this.removeDebugCallback = this.on('*', function (event, payload) { return console.log('PostHog Debug', event, payload); });
+        }
+    };
+    PostHogCoreStateless.prototype.buildPayload = function (payload) {
+        return {
+            distinct_id: payload.distinct_id,
+            event: payload.event,
+            properties: __assign(__assign({}, (payload.properties || {})), this.getCommonEventProperties()),
+        };
+    };
+    /***
+     *** TRACKING
+     ***/
+    PostHogCoreStateless.prototype.identifyStateless = function (distinctId, properties, options) {
+        // The properties passed to identifyStateless are event properties.
+        // To add person properties, pass in all person properties to the `$set` key.
+        var payload = __assign({}, this.buildPayload({
+            distinct_id: distinctId,
+            event: '$identify',
+            properties: properties,
+        }));
+        this.enqueue('identify', payload, options);
+        return this;
+    };
+    PostHogCoreStateless.prototype.captureStateless = function (distinctId, event, properties, options) {
+        var payload = this.buildPayload({ distinct_id: distinctId, event: event, properties: properties });
+        this.enqueue('capture', payload, options);
+        return this;
+    };
+    PostHogCoreStateless.prototype.aliasStateless = function (alias, distinctId, properties) {
+        var payload = this.buildPayload({
+            event: '$create_alias',
+            distinct_id: distinctId,
+            properties: __assign(__assign({}, (properties || {})), { distinct_id: distinctId, alias: alias }),
+        });
+        this.enqueue('alias', payload);
+        return this;
+    };
+    /***
+     *** GROUPS
+     ***/
+    PostHogCoreStateless.prototype.groupIdentifyStateless = function (groupType, groupKey, groupProperties, options, distinctId, eventProperties) {
+        var payload = this.buildPayload({
+            distinct_id: distinctId || "$".concat(groupType, "_").concat(groupKey),
+            event: '$groupidentify',
+            properties: __assign({ $group_type: groupType, $group_key: groupKey, $group_set: groupProperties || {} }, (eventProperties || {})),
+        });
+        this.enqueue('capture', payload, options);
+        return this;
+    };
+    /***
+     *** FEATURE FLAGS
+     ***/
+    PostHogCoreStateless.prototype.getDecide = function (distinctId, groups, personProperties, groupProperties, extraPayload) {
+        if (groups === void 0) { groups = {}; }
+        if (personProperties === void 0) { personProperties = {}; }
+        if (groupProperties === void 0) { groupProperties = {}; }
+        if (extraPayload === void 0) { extraPayload = {}; }
+        return __awaiter(this, void 0, void 0, function () {
+            var url, fetchOptions;
+            return __generator(this, function (_a) {
+                url = "".concat(this.host, "/decide/?v=3");
+                fetchOptions = {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify(__assign({ token: this.apiKey, distinct_id: distinctId, groups: groups, person_properties: personProperties, group_properties: groupProperties }, extraPayload)),
+                };
+                return [2 /*return*/, this.fetchWithRetry(url, fetchOptions)
+                        .then(function (response) { return response.json(); })
+                        .catch(function (error) {
+                        console.error('Error fetching feature flags', error);
+                        return undefined;
+                    })];
+            });
+        });
+    };
+    PostHogCoreStateless.prototype.getFeatureFlagStateless = function (key, distinctId, groups, personProperties, groupProperties) {
+        if (groups === void 0) { groups = {}; }
+        if (personProperties === void 0) { personProperties = {}; }
+        if (groupProperties === void 0) { groupProperties = {}; }
+        return __awaiter(this, void 0, void 0, function () {
+            var featureFlags, response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.getFeatureFlagsStateless(distinctId, groups, personProperties, groupProperties)];
+                    case 1:
+                        featureFlags = _a.sent();
+                        if (!featureFlags) {
+                            // If we haven't loaded flags yet, or errored out, we respond with undefined
+                            return [2 /*return*/, undefined];
+                        }
+                        response = featureFlags[key];
+                        // `/decide` v3 returns all flags
+                        if (response === undefined) {
+                            // For cases where the flag is unknown, return false
+                            response = false;
+                        }
+                        // If we have flags we either return the value (true or string) or false
+                        return [2 /*return*/, response];
+                }
+            });
+        });
+    };
+    PostHogCoreStateless.prototype.getFeatureFlagPayloadStateless = function (key, distinctId, groups, personProperties, groupProperties) {
+        if (groups === void 0) { groups = {}; }
+        if (personProperties === void 0) { personProperties = {}; }
+        if (groupProperties === void 0) { groupProperties = {}; }
+        return __awaiter(this, void 0, void 0, function () {
+            var payloads, response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.getFeatureFlagPayloadsStateless(distinctId, groups, personProperties, groupProperties)];
+                    case 1:
+                        payloads = _a.sent();
+                        if (!payloads) {
+                            return [2 /*return*/, undefined];
+                        }
+                        response = payloads[key];
+                        // Undefined means a loading or missing data issue. Null means evaluation happened and there was no match
+                        if (response === undefined) {
+                            return [2 /*return*/, null];
+                        }
+                        return [2 /*return*/, this._parsePayload(response)];
+                }
+            });
+        });
+    };
+    PostHogCoreStateless.prototype.getFeatureFlagPayloadsStateless = function (distinctId, groups, personProperties, groupProperties) {
+        if (groups === void 0) { groups = {}; }
+        if (personProperties === void 0) { personProperties = {}; }
+        if (groupProperties === void 0) { groupProperties = {}; }
+        return __awaiter(this, void 0, void 0, function () {
+            var payloads;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.getFeatureFlagsAndPayloadsStateless(distinctId, groups, personProperties, groupProperties)];
+                    case 1:
+                        payloads = (_a.sent()).payloads;
+                        if (payloads) {
+                            return [2 /*return*/, Object.fromEntries(Object.entries(payloads).map(function (_a) {
+                                    var k = _a[0], v = _a[1];
+                                    return [k, _this._parsePayload(v)];
+                                }))];
+                        }
+                        return [2 /*return*/, payloads];
+                }
+            });
+        });
+    };
+    PostHogCoreStateless.prototype._parsePayload = function (response) {
+        try {
+            return JSON.parse(response);
+        }
+        catch (_a) {
+            return response;
+        }
+    };
+    PostHogCoreStateless.prototype.getFeatureFlagsStateless = function (distinctId, groups, personProperties, groupProperties) {
+        if (groups === void 0) { groups = {}; }
+        if (personProperties === void 0) { personProperties = {}; }
+        if (groupProperties === void 0) { groupProperties = {}; }
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.getFeatureFlagsAndPayloadsStateless(distinctId, groups, personProperties, groupProperties)];
+                    case 1: return [2 /*return*/, (_a.sent()).flags];
+                }
+            });
+        });
+    };
+    PostHogCoreStateless.prototype.getFeatureFlagsAndPayloadsStateless = function (distinctId, groups, personProperties, groupProperties) {
+        if (groups === void 0) { groups = {}; }
+        if (personProperties === void 0) { personProperties = {}; }
+        if (groupProperties === void 0) { groupProperties = {}; }
+        return __awaiter(this, void 0, void 0, function () {
+            var decideResponse, flags, payloads;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.getDecide(distinctId, groups, personProperties, groupProperties)];
+                    case 1:
+                        decideResponse = _a.sent();
+                        flags = decideResponse === null || decideResponse === void 0 ? void 0 : decideResponse.featureFlags;
+                        payloads = decideResponse === null || decideResponse === void 0 ? void 0 : decideResponse.featureFlagPayloads;
+                        return [2 /*return*/, {
+                                flags: flags,
+                                payloads: payloads,
+                            }];
+                }
+            });
+        });
+    };
+    /***
+     *** QUEUEING AND FLUSHING
+     ***/
+    PostHogCoreStateless.prototype.enqueue = function (type, _message, options) {
+        var _this = this;
+        if (this.optedOut) {
+            this._events.emit(type, "Library is disabled. Not sending event. To re-enable, call posthog.enable()");
+            return;
+        }
+        var message = __assign(__assign({}, _message), { type: type, library: this.getLibraryId(), library_version: this.getLibraryVersion(), timestamp: (options === null || options === void 0 ? void 0 : options.timestamp) ? options === null || options === void 0 ? void 0 : options.timestamp : currentISOTime() });
+        if (message.distinctId) {
+            message.distinct_id = message.distinctId;
+            delete message.distinctId;
+        }
+        var queue = this.getPersistedProperty(PostHogPersistedProperty.Queue) || [];
+        queue.push({ message: message });
+        this.setPersistedProperty(PostHogPersistedProperty.Queue, queue);
+        this._events.emit(type, message);
+        // Flush queued events if we meet the flushAt length
+        if (queue.length >= this.flushAt) {
+            this.flush();
+        }
+        if (this.flushInterval && !this._flushTimer) {
+            this._flushTimer = safeSetTimeout(function () { return _this.flush(); }, this.flushInterval);
+        }
+    };
+    PostHogCoreStateless.prototype.flushAsync = function () {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            _this.flush(function (err, data) {
+                return err ? reject(err) : resolve(data);
+            });
+        });
+    };
+    PostHogCoreStateless.prototype.flush = function (callback) {
+        var _this = this;
+        if (this._flushTimer) {
+            clearTimeout(this._flushTimer);
+            this._flushTimer = null;
+        }
+        var queue = this.getPersistedProperty(PostHogPersistedProperty.Queue) || [];
+        if (!queue.length) {
+            return callback === null || callback === void 0 ? void 0 : callback();
+        }
+        var items = queue.splice(0, this.flushAt);
+        this.setPersistedProperty(PostHogPersistedProperty.Queue, queue);
+        var messages = items.map(function (item) { return item.message; });
+        var data = {
+            api_key: this.apiKey,
+            batch: messages,
+            sent_at: currentISOTime(),
         };
-        this.requestTimeout = (_e = options === null || options === void 0 ? void 0 : options.requestTimeout) !== null && _e !== void 0 ? _e : 10000; // 10 seconds
-        this._sessionExpirationTimeSeconds = (_f = options === null || options === void 0 ? void 0 : options.sessionExpirationTimeSeconds) !== null && _f !== void 0 ? _f : 1800; // 30 minutes
+        var done = function (err) {
+            callback === null || callback === void 0 ? void 0 : callback(err, messages);
+            _this._events.emit('flush', messages);
+        };
+        // Don't set the user agent if we're not on a browser. The latest spec allows
+        // the User-Agent header (see https://fetch.spec.whatwg.org/#terminology-headers
+        // and https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/setRequestHeader),
+        // but browsers such as Chrome and Safari have not caught up.
+        this.getCustomUserAgent();
+        var payload = JSON.stringify(data);
+        var url = this.captureMode === 'form'
+            ? "".concat(this.host, "/e/?ip=1&_=").concat(currentTimestamp(), "&v=").concat(this.getLibraryVersion())
+            : "".concat(this.host, "/batch/");
+        var fetchOptions = this.captureMode === 'form'
+            ? {
+                method: 'POST',
+                mode: 'no-cors',
+                credentials: 'omit',
+                headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+                body: "data=".concat(encodeURIComponent(LZString.compressToBase64(payload)), "&compression=lz64"),
+            }
+            : {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: payload,
+            };
+        this.fetchWithRetry(url, fetchOptions)
+            .then(function () { return done(); })
+            .catch(function (err) {
+            if (err.response) {
+                var error = new Error(err.response.statusText);
+                return done(error);
+            }
+            done(err);
+        });
+    };
+    PostHogCoreStateless.prototype.fetchWithRetry = function (url, options, retryOptions) {
+        var _a;
+        var _b;
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_c) {
+                (_a = (_b = AbortSignal).timeout) !== null && _a !== void 0 ? _a : (_b.timeout = function timeout(ms) {
+                    var ctrl = new AbortController();
+                    setTimeout(function () { return ctrl.abort(); }, ms);
+                    return ctrl.signal;
+                });
+                return [2 /*return*/, retriable(function () {
+                        return _this.fetch(url, __assign({ signal: AbortSignal.timeout(_this.requestTimeout) }, options));
+                    }, retryOptions || this._retryOptions)];
+            });
+        });
+    };
+    PostHogCoreStateless.prototype.shutdownAsync = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        clearTimeout(this._flushTimer);
+                        return [4 /*yield*/, this.flushAsync()];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    PostHogCoreStateless.prototype.shutdown = function () {
+        void this.shutdownAsync();
+    };
+    return PostHogCoreStateless;
+}());
+/** @class */ ((function (_super) {
+    __extends(PostHogCore, _super);
+    function PostHogCore(apiKey, options) {
+        var _this = this;
+        var _a, _b;
+        _this = _super.call(this, apiKey, options) || this;
+        _this.flagCallReported = {};
+        _this.sendFeatureFlagEvent = (_a = options === null || options === void 0 ? void 0 : options.sendFeatureFlagEvent) !== null && _a !== void 0 ? _a : true;
+        _this._sessionExpirationTimeSeconds = (_b = options === null || options === void 0 ? void 0 : options.sessionExpirationTimeSeconds) !== null && _b !== void 0 ? _b : 1800; // 30 minutes
         // NOTE: It is important we don't initiate anything in the constructor as some async IO may still be underway on the parent
         if ((options === null || options === void 0 ? void 0 : options.preloadFeatureFlags) !== false) {
             safeSetTimeout(function () {
-                void _this.reloadFeatureFlagsAsync();
+                _this.reloadFeatureFlags();
             }, 1);
         }
+        return _this;
     }
-    PostHogCore.prototype.getCommonEventProperties = function () {
-        var featureFlags = this.getFeatureFlags();
-        var featureVariantProperties = {};
-        if (featureFlags) {
-            for (var _i = 0, _a = Object.entries(featureFlags); _i < _a.length; _i++) {
-                var _b = _a[_i], feature = _b[0], variant = _b[1];
-                featureVariantProperties["$feature/".concat(feature)] = variant;
-            }
-        }
-        return __assign({ $lib: this.getLibraryId(), $lib_version: this.getLibraryVersion(), $active_feature_flags: featureFlags ? Object.keys(featureFlags) : undefined }, featureVariantProperties);
-    };
     PostHogCore.prototype.setupBootstrap = function (options) {
         var _a, _b, _c, _d;
         if ((_a = options === null || options === void 0 ? void 0 : options.bootstrap) === null || _a === void 0 ? void 0 : _a.distinctId) {
@@ -800,20 +1140,6 @@ var PostHogCore = /** @class */ (function () {
     PostHogCore.prototype.clearProps = function () {
         this.props = undefined;
     };
-    Object.defineProperty(PostHogCore.prototype, "optedOut", {
-        get: function () {
-            var _a, _b;
-            return (_b = (_a = this.getPersistedProperty(PostHogPersistedProperty.OptedOut)) !== null && _a !== void 0 ? _a : this._optoutOverride) !== null && _b !== void 0 ? _b : false;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    PostHogCore.prototype.optIn = function () {
-        this.setPersistedProperty(PostHogPersistedProperty.OptedOut, false);
-    };
-    PostHogCore.prototype.optOut = function () {
-        this.setPersistedProperty(PostHogPersistedProperty.OptedOut, true);
-    };
     PostHogCore.prototype.on = function (event, cb) {
         return this._events.on(event, cb);
     };
@@ -828,20 +1154,19 @@ var PostHogCore = /** @class */ (function () {
             }
         }
     };
-    PostHogCore.prototype.debug = function (enabled) {
-        var _a;
-        if (enabled === void 0) { enabled = true; }
-        (_a = this.removeDebugCallback) === null || _a === void 0 ? void 0 : _a.call(this);
-        if (enabled) {
-            this.removeDebugCallback = this.on('*', function (event, payload) { return console.log('PostHog Debug', event, payload); });
+    PostHogCore.prototype.getCommonEventProperties = function () {
+        var featureFlags = this.getFeatureFlags();
+        var featureVariantProperties = {};
+        if (featureFlags) {
+            for (var _i = 0, _a = Object.entries(featureFlags); _i < _a.length; _i++) {
+                var _b = _a[_i], feature = _b[0], variant = _b[1];
+                featureVariantProperties["$feature/".concat(feature)] = variant;
+            }
         }
+        return __assign(__assign({ $active_feature_flags: featureFlags ? Object.keys(featureFlags) : undefined }, featureVariantProperties), _super.prototype.getCommonEventProperties.call(this));
     };
-    PostHogCore.prototype.buildPayload = function (payload) {
-        return {
-            distinct_id: payload.distinct_id || this.getDistinctId(),
-            event: payload.event,
-            properties: __assign(__assign(__assign(__assign({}, this.props), (payload.properties || {})), this.getCommonEventProperties()), { $session_id: this.getSessionId() }),
-        };
+    PostHogCore.prototype.enrichProperties = function (properties) {
+        return __assign(__assign(__assign(__assign({}, this.props), (properties || {})), this.getCommonEventProperties()), { $session_id: this.getSessionId() });
     };
     PostHogCore.prototype.getSessionId = function () {
         var sessionId = this.getPersistedProperty(PostHogPersistedProperty.SessionId);
@@ -878,61 +1203,48 @@ var PostHogCore = /** @class */ (function () {
     /***
      *** TRACKING
      ***/
-    PostHogCore.prototype.identify = function (distinctId, properties) {
+    PostHogCore.prototype.identify = function (distinctId, properties, options) {
         var previousDistinctId = this.getDistinctId();
         distinctId = distinctId || previousDistinctId;
         if (properties === null || properties === void 0 ? void 0 : properties.$groups) {
             this.groups(properties.$groups);
         }
-        var payload = __assign(__assign({}, this.buildPayload({
-            distinct_id: distinctId,
-            event: '$identify',
-            properties: __assign(__assign({}, (properties || {})), { $anon_distinct_id: this.getAnonymousId() }),
-        })), { $set: properties });
+        var allProperties = this.enrichProperties(__assign(__assign({}, properties), { $anon_distinct_id: this.getAnonymousId(), $set: properties }));
         if (distinctId !== previousDistinctId) {
             // We keep the AnonymousId to be used by decide calls and identify to link the previousId
             this.setPersistedProperty(PostHogPersistedProperty.AnonymousId, previousDistinctId);
             this.setPersistedProperty(PostHogPersistedProperty.DistinctId, distinctId);
             if (this.getFeatureFlags()) {
-                void this.reloadFeatureFlagsAsync();
+                this.reloadFeatureFlags();
             }
         }
-        this.enqueue('identify', payload);
+        _super.prototype.identifyStateless.call(this, distinctId, allProperties, options);
         return this;
     };
-    PostHogCore.prototype.capture = function (event, properties, forceSendFeatureFlags) {
-        if (forceSendFeatureFlags === void 0) { forceSendFeatureFlags = false; }
+    PostHogCore.prototype.capture = function (event, properties, options) {
+        var distinctId = this.getDistinctId();
         if (properties === null || properties === void 0 ? void 0 : properties.$groups) {
             this.groups(properties.$groups);
         }
-        if (forceSendFeatureFlags) {
-            this._sendFeatureFlags(event, properties);
-        }
-        else {
-            var payload = this.buildPayload({ event: event, properties: properties });
-            this.enqueue('capture', payload);
-        }
+        var allProperties = this.enrichProperties(properties);
+        _super.prototype.captureStateless.call(this, distinctId, event, allProperties, options);
         return this;
     };
     PostHogCore.prototype.alias = function (alias) {
         var distinctId = this.getDistinctId();
-        var payload = this.buildPayload({
-            event: '$create_alias',
-            properties: {
-                distinct_id: distinctId,
-                alias: alias,
-            },
-        });
-        this.enqueue('alias', payload);
+        var allProperties = this.enrichProperties({});
+        _super.prototype.aliasStateless.call(this, alias, distinctId, allProperties);
         return this;
     };
-    PostHogCore.prototype.autocapture = function (eventType, elements, properties) {
+    PostHogCore.prototype.autocapture = function (eventType, elements, properties, options) {
         if (properties === void 0) { properties = {}; }
-        var payload = this.buildPayload({
+        var distinctId = this.getDistinctId();
+        var payload = {
+            distinct_id: distinctId,
             event: '$autocapture',
-            properties: __assign(__assign({}, properties), { $event_type: eventType, $elements: elements }),
-        });
-        this.enqueue('autocapture', payload);
+            properties: __assign(__assign({}, this.enrichProperties(properties)), { $event_type: eventType, $elements: elements }),
+        };
+        this.enqueue('autocapture', payload, options);
         return this;
     };
     /***
@@ -945,26 +1257,24 @@ var PostHogCore = /** @class */ (function () {
             $groups: __assign(__assign({}, existingGroups), groups),
         });
         if (Object.keys(groups).find(function (type) { return existingGroups[type] !== groups[type]; }) && this.getFeatureFlags()) {
-            void this.reloadFeatureFlagsAsync();
+            this.reloadFeatureFlags();
         }
         return this;
     };
-    PostHogCore.prototype.group = function (groupType, groupKey, groupProperties) {
+    PostHogCore.prototype.group = function (groupType, groupKey, groupProperties, options) {
         var _a;
         this.groups((_a = {},
             _a[groupType] = groupKey,
             _a));
         if (groupProperties) {
-            this.groupIdentify(groupType, groupKey, groupProperties);
+            this.groupIdentify(groupType, groupKey, groupProperties, options);
         }
         return this;
     };
-    PostHogCore.prototype.groupIdentify = function (groupType, groupKey, groupProperties) {
-        var payload = this.buildPayload({
-            event: '$groupidentify',
-            properties: __assign({ $group_type: groupType, $group_key: groupKey, $group_set: groupProperties || {} }, this.getCommonEventProperties()),
-        });
-        this.enqueue('capture', payload);
+    PostHogCore.prototype.groupIdentify = function (groupType, groupKey, groupProperties, options) {
+        var distinctId = this.getDistinctId();
+        var eventProperties = this.enrichProperties({});
+        _super.prototype.groupIdentifyStateless.call(this, groupType, groupKey, groupProperties, options, distinctId, eventProperties);
         return this;
     };
     /***
@@ -1001,30 +1311,19 @@ var PostHogCore = /** @class */ (function () {
     PostHogCore.prototype._decideAsync = function (sendAnonDistinctId) {
         if (sendAnonDistinctId === void 0) { sendAnonDistinctId = true; }
         return __awaiter(this, void 0, void 0, function () {
-            var url, distinctId, groups, personProperties, groupProperties, fetchOptions;
+            var distinctId, groups, personProperties, groupProperties, extraProperties;
             var _this = this;
             return __generator(this, function (_a) {
-                url = "".concat(this.host, "/decide/?v=3");
                 distinctId = this.getDistinctId();
                 groups = this.props.$groups || {};
                 personProperties = this.getPersistedProperty(PostHogPersistedProperty.PersonProperties) || {};
                 groupProperties = this.getPersistedProperty(PostHogPersistedProperty.GroupProperties) || {};
-                fetchOptions = {
-                    method: 'POST',
-                    headers: { 'Content-Type': 'application/json' },
-                    body: JSON.stringify({
-                        token: this.apiKey,
-                        distinct_id: distinctId,
-                        $anon_distinct_id: sendAnonDistinctId ? this.getAnonymousId() : undefined,
-                        groups: groups,
-                        person_properties: personProperties,
-                        group_properties: groupProperties,
-                    }),
+                extraProperties = {
+                    $anon_distinct_id: sendAnonDistinctId ? this.getAnonymousId() : undefined,
                 };
-                this._decideResponsePromise = this.fetchWithRetry(url, fetchOptions)
-                    .then(function (r) { return r.json(); })
+                this._decideResponsePromise = _super.prototype.getDecide.call(this, distinctId, groups, personProperties, groupProperties, extraProperties)
                     .then(function (res) {
-                    if (res.featureFlags) {
+                    if (res === null || res === void 0 ? void 0 : res.featureFlags) {
                         var newFeatureFlags = res.featureFlags;
                         var newFeatureFlagPayloads = res.featureFlagPayloads;
                         if (res.errorsWhileComputingFlags) {
@@ -1098,14 +1397,6 @@ var PostHogCore = /** @class */ (function () {
         }
         return payloads;
     };
-    PostHogCore.prototype._parsePayload = function (response) {
-        try {
-            return JSON.parse(response);
-        }
-        catch (_a) {
-            return response;
-        }
-    };
     PostHogCore.prototype.getFeatureFlags = function () {
         var flags = this.getPersistedProperty(PostHogPersistedProperty.FeatureFlags);
         var overriddenFlags = this.getPersistedProperty(PostHogPersistedProperty.OverrideFeatureFlags);
@@ -1138,13 +1429,27 @@ var PostHogCore = /** @class */ (function () {
         }
         return !!response;
     };
+    // Used when we want to trigger the reload but we don't care about the result
+    PostHogCore.prototype.reloadFeatureFlags = function (cb) {
+        this.decideAsync()
+            .then(function (res) {
+            cb === null || cb === void 0 ? void 0 : cb(undefined, res === null || res === void 0 ? void 0 : res.featureFlags);
+        })
+            .catch(function (e) {
+            cb === null || cb === void 0 ? void 0 : cb(e, undefined);
+            if (!cb) {
+                console.log('[PostHog] Error reloading feature flags', e);
+            }
+        });
+    };
     PostHogCore.prototype.reloadFeatureFlagsAsync = function (sendAnonDistinctId) {
+        var _a;
         if (sendAnonDistinctId === void 0) { sendAnonDistinctId = true; }
         return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
+            return __generator(this, function (_b) {
+                switch (_b.label) {
                     case 0: return [4 /*yield*/, this.decideAsync(sendAnonDistinctId)];
-                    case 1: return [2 /*return*/, (_a.sent()).featureFlags];
+                    case 1: return [2 /*return*/, (_a = (_b.sent())) === null || _a === void 0 ? void 0 : _a.featureFlags];
                 }
             });
         });
@@ -1181,140 +1486,8 @@ var PostHogCore = /** @class */ (function () {
         }
         return this.setPersistedProperty(PostHogPersistedProperty.OverrideFeatureFlags, flags);
     };
-    PostHogCore.prototype._sendFeatureFlags = function (event, properties) {
-        var _this = this;
-        this.reloadFeatureFlagsAsync(false).finally(function () {
-            // Try to enqueue message irrespective of errors during feature flag fetching
-            var payload = _this.buildPayload({ event: event, properties: properties });
-            _this.enqueue('capture', payload);
-        });
-    };
-    /***
-     *** QUEUEING AND FLUSHING
-     ***/
-    PostHogCore.prototype.enqueue = function (type, _message) {
-        var _this = this;
-        if (this.optedOut) {
-            return;
-        }
-        var message = __assign(__assign({}, _message), { type: type, library: this.getLibraryId(), library_version: this.getLibraryVersion(), timestamp: _message.timestamp ? _message.timestamp : currentISOTime() });
-        if (message.distinctId) {
-            message.distinct_id = message.distinctId;
-            delete message.distinctId;
-        }
-        var queue = this.getPersistedProperty(PostHogPersistedProperty.Queue) || [];
-        queue.push({ message: message });
-        this.setPersistedProperty(PostHogPersistedProperty.Queue, queue);
-        this._events.emit(type, message);
-        // Flush queued events if we meet the flushAt length
-        if (queue.length >= this.flushAt) {
-            this.flush();
-        }
-        if (this.flushInterval && !this._flushTimer) {
-            this._flushTimer = safeSetTimeout(function () { return _this.flush(); }, this.flushInterval);
-        }
-    };
-    PostHogCore.prototype.flushAsync = function () {
-        var _this = this;
-        return new Promise(function (resolve, reject) {
-            _this.flush(function (err, data) {
-                return err ? reject(err) : resolve(data);
-            });
-        });
-    };
-    PostHogCore.prototype.flush = function (callback) {
-        var _this = this;
-        if (this.optedOut) {
-            return callback === null || callback === void 0 ? void 0 : callback();
-        }
-        if (this._flushTimer) {
-            clearTimeout(this._flushTimer);
-            this._flushTimer = null;
-        }
-        var queue = this.getPersistedProperty(PostHogPersistedProperty.Queue) || [];
-        if (!queue.length) {
-            return callback === null || callback === void 0 ? void 0 : callback();
-        }
-        var items = queue.splice(0, this.flushAt);
-        this.setPersistedProperty(PostHogPersistedProperty.Queue, queue);
-        var messages = items.map(function (item) { return item.message; });
-        var data = {
-            api_key: this.apiKey,
-            batch: messages,
-            sent_at: currentISOTime(),
-        };
-        var done = function (err) {
-            callback === null || callback === void 0 ? void 0 : callback(err, messages);
-            _this._events.emit('flush', messages);
-        };
-        // Don't set the user agent if we're not on a browser. The latest spec allows
-        // the User-Agent header (see https://fetch.spec.whatwg.org/#terminology-headers
-        // and https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/setRequestHeader),
-        // but browsers such as Chrome and Safari have not caught up.
-        this.getCustomUserAgent();
-        var payload = JSON.stringify(data);
-        var url = this.captureMode === 'form'
-            ? "".concat(this.host, "/e/?ip=1&_=").concat(currentTimestamp(), "&v=").concat(this.getLibraryVersion())
-            : "".concat(this.host, "/batch/");
-        var fetchOptions = this.captureMode === 'form'
-            ? {
-                method: 'POST',
-                mode: 'no-cors',
-                credentials: 'omit',
-                headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
-                body: "data=".concat(encodeURIComponent(LZString.compressToBase64(payload)), "&compression=lz64"),
-            }
-            : {
-                method: 'POST',
-                headers: { 'Content-Type': 'application/json' },
-                body: payload,
-            };
-        this.fetchWithRetry(url, fetchOptions)
-            .then(function () { return done(); })
-            .catch(function (err) {
-            if (err.response) {
-                var error = new Error(err.response.statusText);
-                return done(error);
-            }
-            done(err);
-        });
-    };
-    PostHogCore.prototype.fetchWithRetry = function (url, options, retryOptions) {
-        var _a;
-        var _b;
-        return __awaiter(this, void 0, void 0, function () {
-            var _this = this;
-            return __generator(this, function (_c) {
-                (_a = (_b = AbortSignal).timeout) !== null && _a !== void 0 ? _a : (_b.timeout = function timeout(ms) {
-                    var ctrl = new AbortController();
-                    setTimeout(function () { return ctrl.abort(); }, ms);
-                    return ctrl.signal;
-                });
-                return [2 /*return*/, retriable(function () {
-                        return _this.fetch(url, __assign({ signal: AbortSignal.timeout(_this.requestTimeout) }, options));
-                    }, retryOptions || this._retryOptions)];
-            });
-        });
-    };
-    PostHogCore.prototype.shutdownAsync = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        clearTimeout(this._flushTimer);
-                        return [4 /*yield*/, this.flushAsync()];
-                    case 1:
-                        _a.sent();
-                        return [2 /*return*/];
-                }
-            });
-        });
-    };
-    PostHogCore.prototype.shutdown = function () {
-        void this.shutdownAsync();
-    };
     return PostHogCore;
-}());
+})(PostHogCoreStateless));
 
 var PostHogMemoryStorage = /** @class */ (function () {
     function PostHogMemoryStorage() {
@@ -2079,133 +2252,128 @@ function convertToDateTime(value) {
 }
 
 var THIRTY_SECONDS = 30 * 1000;
-var MAX_CACHE_SIZE = 50 * 1000;
+var MAX_CACHE_SIZE = 50 * 1000; // The actual exported Nodejs API.
 
-var PostHogClient =
+var PostHog =
 /** @class */
 function (_super) {
-  __extends(PostHogClient, _super);
+  __extends(PostHog, _super);
 
-  function PostHogClient(apiKey, options) {
+  function PostHog(apiKey, options) {
     if (options === void 0) {
       options = {};
     }
 
     var _this = this;
 
-    options.captureMode = (options === null || options === void 0 ? void 0 : options.captureMode) || 'json';
-    options.preloadFeatureFlags = false; // Don't preload as this makes no sense without a distinctId
-
-    options.sendFeatureFlagEvent = false; // Let `posthog-node` handle this on its own, since we're dealing with multiple distinctIDs
+    var _a;
 
+    options.captureMode = (options === null || options === void 0 ? void 0 : options.captureMode) || 'json';
     _this = _super.call(this, apiKey, options) || this;
-    _this.options = options;
     _this._memoryStorage = new PostHogMemoryStorage();
+    _this.options = options;
+
+    if (options.personalApiKey) {
+      _this.featureFlagsPoller = new FeatureFlagsPoller({
+        pollingInterval: typeof options.featureFlagsPollingInterval === 'number' ? options.featureFlagsPollingInterval : THIRTY_SECONDS,
+        personalApiKey: options.personalApiKey,
+        projectApiKey: apiKey,
+        timeout: (_a = options.requestTimeout) !== null && _a !== void 0 ? _a : 10000,
+        host: _this.host,
+        fetch: options.fetch
+      });
+    }
+
+    _this.distinctIdHasSentFlagCalls = {};
+    _this.maxCacheSize = options.maxCacheSize || MAX_CACHE_SIZE;
     return _this;
   }
 
-  PostHogClient.prototype.getPersistedProperty = function (key) {
+  PostHog.prototype.getPersistedProperty = function (key) {
     return this._memoryStorage.getProperty(key);
   };
 
-  PostHogClient.prototype.setPersistedProperty = function (key, value) {
+  PostHog.prototype.setPersistedProperty = function (key, value) {
     return this._memoryStorage.setProperty(key, value);
   };
 
-  PostHogClient.prototype.getSessionId = function () {
-    // Sessions don't make sense for Node
-    return undefined;
-  };
-
-  PostHogClient.prototype.fetch = function (url, options) {
+  PostHog.prototype.fetch = function (url, options) {
     return this.options.fetch ? this.options.fetch(url, options) : fetch(url, options);
   };
 
-  PostHogClient.prototype.getLibraryId = function () {
+  PostHog.prototype.getLibraryId = function () {
     return 'posthog-node';
   };
 
-  PostHogClient.prototype.getLibraryVersion = function () {
+  PostHog.prototype.getLibraryVersion = function () {
     return version;
   };
 
-  PostHogClient.prototype.getCustomUserAgent = function () {
+  PostHog.prototype.getCustomUserAgent = function () {
     return "posthog-node/".concat(version);
   };
 
-  return PostHogClient;
-}(PostHogCore); // The actual exported Nodejs API.
-
-
-var PostHog =
-/** @class */
-function () {
-  function PostHog(apiKey, options) {
-    if (options === void 0) {
-      options = {};
-    }
-
-    var _a;
-
-    this._sharedClient = new PostHogClient(apiKey, options);
-
-    if (options.personalApiKey) {
-      this.featureFlagsPoller = new FeatureFlagsPoller({
-        pollingInterval: typeof options.featureFlagsPollingInterval === 'number' ? options.featureFlagsPollingInterval : THIRTY_SECONDS,
-        personalApiKey: options.personalApiKey,
-        projectApiKey: apiKey,
-        timeout: (_a = options.requestTimeout) !== null && _a !== void 0 ? _a : 10000,
-        host: this._sharedClient.host,
-        fetch: options.fetch
-      });
-    }
-
-    this.distinctIdHasSentFlagCalls = {};
-    this.maxCacheSize = options.maxCacheSize || MAX_CACHE_SIZE;
-  }
-
-  PostHog.prototype.reInit = function (distinctId) {
-    // Certain properties we want to persist. Queue is persisted always by default.
-    this._sharedClient.reset([PostHogPersistedProperty.OptedOut]);
-
-    this._sharedClient.setPersistedProperty(PostHogPersistedProperty.DistinctId, distinctId);
-  };
-
   PostHog.prototype.enable = function () {
-    return this._sharedClient.optIn();
+    return _super.prototype.optIn.call(this);
   };
 
   PostHog.prototype.disable = function () {
-    return this._sharedClient.optOut();
+    return _super.prototype.optOut.call(this);
   };
 
   PostHog.prototype.capture = function (_a) {
+    var _this = this;
+
     var distinctId = _a.distinctId,
         event = _a.event,
         properties = _a.properties,
         groups = _a.groups,
-        sendFeatureFlags = _a.sendFeatureFlags;
-    this.reInit(distinctId);
+        sendFeatureFlags = _a.sendFeatureFlags,
+        timestamp = _a.timestamp;
 
-    if (groups) {
-      this._sharedClient.groups(groups);
-    }
+    var _capture = function (props) {
+      _super.prototype.captureStateless.call(_this, distinctId, event, props, {
+        timestamp: timestamp
+      });
+    };
+
+    if (sendFeatureFlags) {
+      _super.prototype.getFeatureFlagsStateless.call(this, distinctId, groups).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];
+            featureVariantProperties["$feature/".concat(feature)] = variant;
+          }
+        }
+
+        var flagProperties = __assign({
+          $active_feature_flags: flags ? Object.keys(flags) : undefined
+        }, featureVariantProperties);
 
-    this._sharedClient.capture(event, properties, sendFeatureFlags || false);
+        _capture(__assign(__assign(__assign({}, properties), {
+          $groups: groups
+        }), flagProperties));
+      });
+    } else {
+      _capture(__assign(__assign({}, properties), {
+        $groups: groups
+      }));
+    }
   };
 
   PostHog.prototype.identify = function (_a) {
     var distinctId = _a.distinctId,
         properties = _a.properties;
-    this.reInit(distinctId);
 
-    this._sharedClient.identify(distinctId, properties);
+    _super.prototype.identifyStateless.call(this, distinctId, properties);
   };
 
   PostHog.prototype.alias = function (data) {
-    this.reInit(data.distinctId);
-
-    this._sharedClient.alias(data.alias);
+    _super.prototype.aliasStateless.call(this, data.alias, data.distinctId);
   };
 
   PostHog.prototype.getFeatureFlag = function (key, distinctId, options) {
@@ -2238,28 +2406,12 @@ function () {
             if (!(!flagWasLocallyEvaluated && !onlyEvaluateLocally)) return [3
             /*break*/
             , 3];
-            this.reInit(distinctId);
-
-            if (groups != undefined) {
-              this._sharedClient.groups(groups);
-            }
-
-            if (personProperties) {
-              this._sharedClient.personProperties(personProperties);
-            }
-
-            if (groupProperties) {
-              this._sharedClient.groupProperties(groupProperties);
-            }
-
             return [4
             /*yield*/
-            , this._sharedClient.reloadFeatureFlagsAsync(false)];
+            , _super.prototype.getFeatureFlagStateless.call(this, key, distinctId, groups, personProperties, groupProperties)];
 
           case 2:
-            _d.sent();
-
-            response = this._sharedClient.getFeatureFlag(key);
+            response = _d.sent();
             _d.label = 3;
 
           case 3:
@@ -2348,28 +2500,12 @@ function () {
             if (!(!payloadWasLocallyEvaluated && !onlyEvaluateLocally)) return [3
             /*break*/
             , 6];
-            this.reInit(distinctId);
-
-            if (groups != undefined) {
-              this._sharedClient.groups(groups);
-            }
-
-            if (personProperties) {
-              this._sharedClient.personProperties(personProperties);
-            }
-
-            if (groupProperties) {
-              this._sharedClient.groupProperties(groupProperties);
-            }
-
             return [4
             /*yield*/
-            , this._sharedClient.reloadFeatureFlagsAsync(false)];
+            , _super.prototype.getFeatureFlagPayloadStateless.call(this, key, distinctId, groups, personProperties, groupProperties)];
 
           case 5:
-            _d.sent();
-
-            response = this._sharedClient.getFeatureFlagPayload(key);
+            response = _d.sent();
             _d.label = 6;
 
           case 6:
@@ -2473,28 +2609,12 @@ function () {
             if (!(fallbackToDecide && !onlyEvaluateLocally)) return [3
             /*break*/
             , 3];
-            this.reInit(distinctId);
-
-            if (groups) {
-              this._sharedClient.groups(groups);
-            }
-
-            if (personProperties) {
-              this._sharedClient.personProperties(personProperties);
-            }
-
-            if (groupProperties) {
-              this._sharedClient.groupProperties(groupProperties);
-            }
-
             return [4
             /*yield*/
-            , this._sharedClient.reloadFeatureFlagsAsync(false)];
+            , _super.prototype.getFeatureFlagsAndPayloadsStateless.call(this, distinctId, groups, personProperties, groupProperties)];
 
           case 2:
-            _c.sent();
-
-            remoteEvaluationResult = this._sharedClient.getFeatureFlagsAndPayloads();
+            remoteEvaluationResult = _c.sent();
             featureFlags = __assign(__assign({}, featureFlags), remoteEvaluationResult.flags || {});
             featureFlagPayloads = __assign(__assign({}, featureFlagPayloads), remoteEvaluationResult.payloads || {});
             _c.label = 3;
@@ -2515,9 +2635,8 @@ function () {
     var groupType = _a.groupType,
         groupKey = _a.groupKey,
         properties = _a.properties;
-    this.reInit("$".concat(groupType, "_").concat(groupKey));
 
-    this._sharedClient.groupIdentify(groupType, groupKey, properties);
+    _super.prototype.groupIdentifyStateless.call(this, groupType, groupKey, properties);
   };
 
   PostHog.prototype.reloadFeatureFlags = function () {
@@ -2542,10 +2661,6 @@ function () {
     });
   };
 
-  PostHog.prototype.flush = function () {
-    this._sharedClient.flush();
-  };
-
   PostHog.prototype.shutdown = function () {
     void this.shutdownAsync();
   };
@@ -2558,17 +2673,13 @@ function () {
         (_a = this.featureFlagsPoller) === null || _a === void 0 ? void 0 : _a.stopPoller();
         return [2
         /*return*/
-        , this._sharedClient.shutdownAsync()];
+        , _super.prototype.shutdownAsync.call(this)];
       });
     });
   };
 
-  PostHog.prototype.debug = function (enabled) {
-    return this._sharedClient.debug(enabled);
-  };
-
   return PostHog;
-}();
+}(PostHogCoreStateless);
 
 exports.PostHog = PostHog;
 //# sourceMappingURL=index.cjs.js.map