posthog-node 2.0.2 → 2.2.0

package/lib/index.d.ts

@@ -1,3 +1,4 @@
+/// <reference types="node" />
 declare type PosthogCoreOptions = {
     host?: string;
     flushAt?: number;
@@ -5,10 +6,30 @@ declare type PosthogCoreOptions = {
     enable?: boolean;
     sendFeatureFlagEvent?: boolean;
     preloadFeatureFlags?: boolean;
+    bootstrap?: {
+        distinctId?: string;
+        isIdentifiedId?: boolean;
+        featureFlags?: Record<string, boolean | string>;
+    };
     fetchRetryCount?: number;
     fetchRetryDelay?: number;
     sessionExpirationTimeSeconds?: number;
     captureMode?: 'json' | 'form';
+};
+declare type PostHogFetchOptions = {
+    method: 'GET' | 'POST' | 'PUT' | 'PATCH';
+    mode?: 'no-cors';
+    credentials?: 'omit';
+    headers: {
+        [key: string]: string;
+    };
+    body?: string;
+    signal?: AbortSignal;
+};
+declare type PostHogFetchResponse = {
+    status: number;
+    text: () => Promise<string>;
+    json: () => Promise<any>;
 };
 
 interface IdentifyMessageV1 {
@@ -134,6 +155,7 @@ declare type PostHogOptions = PosthogCoreOptions & {
     featureFlagsPollingInterval?: number;
     requestTimeout?: number;
     maxCacheSize?: number;
+    fetch?: (url: string, options: PostHogFetchOptions) => Promise<PostHogFetchResponse>;
 };
 declare class PostHog implements PostHogNodeV1 {
     private _sharedClient;

package/lib/index.esm.js

@@ -1,5 +1,5 @@
-import undici, { request } from 'undici';
 import { createHash } from 'crypto';
+import axios from 'axios';
 
 /******************************************************************************
 Copyright (c) Microsoft Corporation.
@@ -43,6 +43,18 @@ var __assign = function () {
     };
     return __assign.apply(this, arguments);
 };
+function __rest(s, e) {
+    var t = {};
+    for (var p in s)
+        if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+            t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+}
 function __awaiter(thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -143,7 +155,7 @@ function __spreadArray(to, from, pack) {
     return to.concat(ar || Array.prototype.slice.call(from));
 }
 
-var version = "2.0.2";
+var version = "2.2.0";
 
 var PostHogPersistedProperty;
 (function (PostHogPersistedProperty) {
@@ -740,6 +752,26 @@ var PostHogCore = /** @class */ (function () {
         }
         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) {
+            if ((_b = options === null || options === void 0 ? void 0 : options.bootstrap) === null || _b === void 0 ? void 0 : _b.isIdentifiedId) {
+                this.setPersistedProperty(PostHogPersistedProperty.DistinctId, options.bootstrap.distinctId);
+            }
+            else {
+                this.setPersistedProperty(PostHogPersistedProperty.AnonymousId, options.bootstrap.distinctId);
+            }
+        }
+        if ((_c = options === null || options === void 0 ? void 0 : options.bootstrap) === null || _c === void 0 ? void 0 : _c.featureFlags) {
+            var activeFlags = Object.keys(((_d = options.bootstrap) === null || _d === void 0 ? void 0 : _d.featureFlags) || {})
+                .filter(function (flag) { var _a, _b; return !!((_b = (_a = options.bootstrap) === null || _a === void 0 ? void 0 : _a.featureFlags) === null || _b === void 0 ? void 0 : _b[flag]); })
+                .reduce(function (res, key) {
+                var _a, _b;
+                return ((res[key] = ((_b = (_a = options.bootstrap) === null || _a === void 0 ? void 0 : _a.featureFlags) === null || _b === void 0 ? void 0 : _b[key]) || false), res);
+            }, {});
+            this.setKnownFeatureFlags(activeFlags);
+        }
+    };
     Object.defineProperty(PostHogCore.prototype, "props", {
         // NOTE: Props are lazy loaded from localstorage hence the complex getter setter logic
         get: function () {
@@ -983,8 +1015,7 @@ var PostHogCore = /** @class */ (function () {
                     .then(function (r) { return r.json(); })
                     .then(function (res) {
                     if (res.featureFlags) {
-                        _this.setPersistedProperty(PostHogPersistedProperty.FeatureFlags, res.featureFlags);
-                        _this._events.emit('featureflags', res.featureFlags);
+                        _this.setKnownFeatureFlags(res.featureFlags);
                     }
                     return res;
                 })
@@ -995,6 +1026,10 @@ var PostHogCore = /** @class */ (function () {
             });
         });
     };
+    PostHogCore.prototype.setKnownFeatureFlags = function (featureFlags) {
+        this.setPersistedProperty(PostHogPersistedProperty.FeatureFlags, featureFlags);
+        this._events.emit('featureflags', featureFlags);
+    };
     PostHogCore.prototype.getFeatureFlag = function (key) {
         var featureFlags = this.getFeatureFlags();
         if (!featureFlags) {
@@ -1222,6 +1257,42 @@ var PostHogMemoryStorage = /** @class */ (function () {
     return PostHogMemoryStorage;
 }());
 
+// So that alternative implementations can be used if desired
+
+var fetch = function (url, options) {
+  return __awaiter(void 0, void 0, void 0, function () {
+    var res;
+    return __generator(this, function (_a) {
+      switch (_a.label) {
+        case 0:
+          return [4
+          /*yield*/
+          , axios.request({
+            url: url,
+            headers: options.headers,
+            method: options.method.toLowerCase(),
+            data: options.body,
+            signal: options.signal
+          })];
+
+        case 1:
+          res = _a.sent();
+          return [2
+          /*return*/
+          , {
+            status: res.status,
+            text: function () {
+              return res.data;
+            },
+            json: function () {
+              return res.data;
+            }
+          }];
+      }
+    });
+  });
+};
+
 var LONG_SCALE = 0xfffffffffffffff;
 
 var ClientError =
@@ -1270,7 +1341,9 @@ function () {
         personalApiKey = _a.personalApiKey,
         projectApiKey = _a.projectApiKey,
         timeout = _a.timeout,
-        host = _a.host;
+        host = _a.host,
+        options = __rest(_a, ["pollingInterval", "personalApiKey", "projectApiKey", "timeout", "host"]);
+
     this.pollingInterval = pollingInterval;
     this.personalApiKey = personalApiKey;
     this.featureFlags = [];
@@ -1279,7 +1352,9 @@ function () {
     this.timeout = timeout;
     this.projectApiKey = projectApiKey;
     this.host = host;
-    this.poller = undefined;
+    this.poller = undefined; // NOTE: as any is required here as the AbortSignal typing is slightly misaligned but works just fine
+
+    this.fetch = options.fetch || fetch;
     void this.loadFeatureFlags();
   }
 
@@ -1445,16 +1520,44 @@ function () {
   };
 
   FeatureFlagsPoller.prototype.matchFeatureFlagProperties = function (flag, distinctId, properties) {
-    var _this = this;
+    var _a;
 
     var flagFilters = flag.filters || {};
     var flagConditions = flagFilters.groups || [];
     var isInconclusive = false;
-    var result = undefined;
-    flagConditions.forEach(function (condition) {
+    var result = undefined; // # Stable sort conditions with variant overrides to the top. This ensures that if overrides are present, they are
+    // # evaluated first, and the variant override is applied to the first matching condition.
+
+    var sortedFlagConditions = __spreadArray([], flagConditions, true).sort(function (conditionA, conditionB) {
+      var AHasVariantOverride = !!conditionA.variant;
+      var BHasVariantOverride = !!conditionB.variant;
+
+      if (AHasVariantOverride && BHasVariantOverride) {
+        return 0;
+      } else if (AHasVariantOverride) {
+        return -1;
+      } else if (BHasVariantOverride) {
+        return 1;
+      } else {
+        return 0;
+      }
+    });
+
+    var _loop_1 = function (condition) {
       try {
-        if (_this.isConditionMatch(flag, distinctId, condition, properties)) {
-          result = _this.getMatchingVariant(flag, distinctId) || true;
+        if (this_1.isConditionMatch(flag, distinctId, condition, properties)) {
+          var variantOverride_1 = condition.variant;
+          var flagVariants = ((_a = flagFilters.multivariate) === null || _a === void 0 ? void 0 : _a.variants) || [];
+
+          if (variantOverride_1 && flagVariants.some(function (variant) {
+            return variant.key === variantOverride_1;
+          })) {
+            result = variantOverride_1;
+          } else {
+            result = this_1.getMatchingVariant(flag, distinctId) || true;
+          }
+
+          return "break";
         }
       } catch (e) {
         if (e instanceof InconclusiveMatchError) {
@@ -1463,7 +1566,17 @@ function () {
           throw e;
         }
       }
-    });
+    };
+
+    var this_1 = this;
+
+    for (var _i = 0, sortedFlagConditions_1 = sortedFlagConditions; _i < sortedFlagConditions_1.length; _i++) {
+      var condition = sortedFlagConditions_1[_i];
+
+      var state_1 = _loop_1(condition);
+
+      if (state_1 === "break") break;
+    }
 
     if (result !== undefined) {
       return result;
@@ -1591,13 +1704,13 @@ function () {
           case 2:
             res = _a.sent();
 
-            if (res && res.statusCode === 401) {
+            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");
             }
 
             return [4
             /*yield*/
-            , res.body.json()];
+            , res.json()];
 
           case 3:
             responseJson = _a.sent();
@@ -1636,48 +1749,57 @@ function () {
 
   FeatureFlagsPoller.prototype._requestFeatureFlagDefinitions = function () {
     return __awaiter(this, void 0, void 0, function () {
-      var url, headers, options, res, err_2;
+      var url, options, abortTimeout, controller_1, err_2;
       return __generator(this, function (_a) {
         switch (_a.label) {
           case 0:
             url = "".concat(this.host, "/api/feature_flag/local_evaluation?token=").concat(this.projectApiKey);
-            headers = {
-              'Content-Type': 'application/json',
-              Authorization: "Bearer ".concat(this.personalApiKey),
-              'user-agent': "posthog-node/".concat(version)
-            };
             options = {
               method: 'GET',
-              headers: headers
+              headers: {
+                'Content-Type': 'application/json',
+                Authorization: "Bearer ".concat(this.personalApiKey),
+                'user-agent': "posthog-node/".concat(version)
+              }
             };
+            abortTimeout = null;
 
             if (this.timeout && typeof this.timeout === 'number') {
-              options.bodyTimeout = this.timeout;
+              controller_1 = new AbortController();
+              abortTimeout = safeSetTimeout(function () {
+                controller_1.abort();
+              }, this.timeout);
+              options.signal = controller_1.signal;
             }
 
             _a.label = 1;
 
           case 1:
-            _a.trys.push([1, 3,, 4]);
+            _a.trys.push([1, 3, 4, 5]);
 
             return [4
             /*yield*/
-            , request(url, options)];
+            , this.fetch(url, options)];
 
           case 2:
-            res = _a.sent();
-            return [3
-            /*break*/
-            , 4];
+            return [2
+            /*return*/
+            , _a.sent()];
 
           case 3:
             err_2 = _a.sent();
             throw new Error("Request failed with error: ".concat(err_2));
 
           case 4:
+            clearTimeout(abortTimeout);
+            return [7
+            /*endfinally*/
+            ];
+
+          case 5:
             return [2
             /*return*/
-            , res];
+            ];
         }
       });
     });
@@ -1751,6 +1873,17 @@ function matchProperty(property, propertyValues) {
     case 'lte':
       return typeof overrideValue == typeof value && overrideValue <= value;
 
+    case 'is_date_after':
+    case 'is_date_before':
+      var parsedDate = convertToDateTime(value);
+      var overrideDate = convertToDateTime(overrideValue);
+
+      if (operator === 'is_date_before') {
+        return overrideDate < parsedDate;
+      }
+
+      return overrideDate > parsedDate;
+
     default:
       console.error("Unknown operator: ".concat(operator));
       return false;
@@ -1766,6 +1899,22 @@ function isValidRegex(regex) {
   }
 }
 
+function convertToDateTime(value) {
+  if (value instanceof Date) {
+    return value;
+  } else if (typeof value === 'string' || typeof value === 'number') {
+    var date = new Date(value);
+
+    if (!isNaN(date.valueOf())) {
+      return date;
+    }
+
+    throw new InconclusiveMatchError("".concat(value, " is in an invalid date format"));
+  } else {
+    throw new InconclusiveMatchError("The date provided ".concat(value, " must be a string, number, or date object"));
+  }
+}
+
 var THIRTY_SECONDS = 30 * 1000;
 var MAX_CACHE_SIZE = 50 * 1000;
 
@@ -1787,6 +1936,7 @@ function (_super) {
     options.sendFeatureFlagEvent = false; // Let `posthog-node` handle this on its own, since we're dealing with multiple distinctIDs
 
     _this = _super.call(this, apiKey, options) || this;
+    _this.options = options;
     _this._memoryStorage = new PostHogMemoryStorage();
     return _this;
   }
@@ -1805,7 +1955,7 @@ function (_super) {
   };
 
   PostHogClient.prototype.fetch = function (url, options) {
-    return undici.fetch(url, options);
+    return this.options.fetch ? this.options.fetch(url, options) : fetch(url, options);
   };
 
   PostHogClient.prototype.getLibraryId = function () {
@@ -1840,7 +1990,8 @@ function () {
         personalApiKey: options.personalApiKey,
         projectApiKey: apiKey,
         timeout: options.requestTimeout,
-        host: this._sharedClient.host
+        host: this._sharedClient.host,
+        fetch: options.fetch
       });
     }