posthog-node 4.12.0 → 4.14.0

package/CHANGELOG.md

@@ -1,3 +1,11 @@
+# 4.14.0 - 2025-04-24
+
+1. feat: Add super properties as a concept to the Node SDK
+
+# 4.13.0 - 2025-04-21
+
+1. feat: Add method to wait for local evaluation feature flag definitions to be loaded
+
 # 4.12.0 – 2025-04-17
 
 1. chore: roll out new feature flag evaluation backend to majority of customers

package/lib/index.cjs.js

@@ -22,7 +22,7 @@ function _interopNamespace(e) {
   return Object.freeze(n);
 }
 
-var version = "4.12.0";
+var version = "4.14.0";
 
 var PostHogPersistedProperty;
 (function (PostHogPersistedProperty) {
@@ -327,7 +327,7 @@ function safeSetTimeout(fn, timeout) {
     return t;
 }
 function getFetch() {
-    return typeof fetch !== 'undefined' ? fetch : typeof global.fetch !== 'undefined' ? global.fetch : undefined;
+    return typeof fetch !== 'undefined' ? fetch : typeof globalThis.fetch !== 'undefined' ? globalThis.fetch : undefined;
 }
 // FNV-1a hash function
 // https://en.wikipedia.org/wiki/Fowler%E2%80%93Noll%E2%80%93Vo_hash_function
@@ -1595,6 +1595,30 @@ class PostHogCoreStateless {
         }
         return newSurveys ?? [];
     }
+    get props() {
+        if (!this._props) {
+            this._props = this.getPersistedProperty(PostHogPersistedProperty.Props);
+        }
+        return this._props || {};
+    }
+    set props(val) {
+        this._props = val;
+    }
+    async register(properties) {
+        this.wrap(() => {
+            this.props = {
+                ...this.props,
+                ...properties,
+            };
+            this.setPersistedProperty(PostHogPersistedProperty.Props, this.props);
+        });
+    }
+    async unregister(property) {
+        this.wrap(() => {
+            delete this.props[property];
+            this.setPersistedProperty(PostHogPersistedProperty.Props, this.props);
+        });
+    }
     /***
      *** QUEUEING AND FLUSHING
      ***/
@@ -1988,6 +2012,7 @@ class FeatureFlagsPoller {
     this.fetch = options.fetch || fetch$1;
     this.onError = options.onError;
     this.customHeaders = customHeaders;
+    this.onLoad = options.onLoad;
     void this.loadFeatureFlags();
   }
   debug(enabled = true) {
@@ -2204,6 +2229,13 @@ class FeatureFlagsPoller {
       await this._loadFeatureFlags();
     }
   }
+  /**
+   * Returns true if the feature flags poller has loaded successfully at least once and has more than 0 feature flags.
+   * This is useful to check if local evaluation is ready before calling getFeatureFlag.
+   */
+  isLocalEvaluationReady() {
+    return (this.loadedSuccessfullyOnce ?? false) && (this.featureFlags?.length ?? 0) > 0;
+  }
   /**
    * If a client is misconfigured with an invalid or improper API key, the polling interval is doubled each time
    * until a successful request is made, up to a maximum of 60 seconds.
@@ -2279,6 +2311,7 @@ class FeatureFlagsPoller {
             this.loadedSuccessfullyOnce = true;
             this.shouldBeginExponentialBackoff = false;
             this.backOffCount = 0;
+            this.onLoad?.(this.featureFlags.length);
             break;
           }
         default:
@@ -3069,16 +3102,28 @@ async function propertiesFromUnknownInput(stackParser, input, hint) {
     handled: true,
     type: 'generic'
   };
-  const error = getError(mechanism, input, hint);
-  const exception = await exceptionFromError(stackParser, error);
-  exception.value = exception.value || '';
-  exception.type = exception.type || 'Error';
-  exception.mechanism = mechanism;
+  const errorList = getErrorList(mechanism, input, hint);
+  const exceptionList = await Promise.all(errorList.map(async error => {
+    const exception = await exceptionFromError(stackParser, error);
+    exception.value = exception.value || '';
+    exception.type = exception.type || 'Error';
+    exception.mechanism = mechanism;
+    return exception;
+  }));
   const properties = {
-    $exception_list: [exception]
+    $exception_list: exceptionList
   };
   return properties;
 }
+// Flatten error causes into a list of errors
+// See: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error/cause
+function getErrorList(mechanism, input, hint) {
+  const error = getError(mechanism, input, hint);
+  if (error.cause) {
+    return [error, ...getErrorList(mechanism, error.cause, hint)];
+  }
+  return [error];
+}
 function getError(mechanism, exception, hint) {
   if (isError(exception)) {
     return exception;
@@ -3105,7 +3150,7 @@ function getErrorPropertyFromObject(obj) {
   for (const prop in obj) {
     if (Object.prototype.hasOwnProperty.call(obj, prop)) {
       const value = obj[prop];
-      if (value instanceof Error) {
+      if (isError(value)) {
         return value;
       }
     }
@@ -3532,6 +3577,9 @@ class PostHog extends PostHogCoreStateless {
         onError: err => {
           this._events.emit('error', err);
         },
+        onLoad: count => {
+          this._events.emit('localEvaluationFlagsLoaded', count);
+        },
         customHeaders: this.getCustomHeaders()
       });
     }
@@ -3664,6 +3712,28 @@ class PostHog extends PostHogCoreStateless {
       disableGeoip: data.disableGeoip
     });
   }
+  isLocalEvaluationReady() {
+    return this.featureFlagsPoller?.isLocalEvaluationReady() ?? false;
+  }
+  async waitForLocalEvaluationReady(timeoutMs = THIRTY_SECONDS) {
+    if (this.isLocalEvaluationReady()) {
+      return true;
+    }
+    if (this.featureFlagsPoller === undefined) {
+      return false;
+    }
+    return new Promise(resolve => {
+      const timeout = setTimeout(() => {
+        cleanup();
+        resolve(false);
+      }, timeoutMs);
+      const cleanup = this._events.on('localEvaluationFlagsLoaded', count => {
+        clearTimeout(timeout);
+        cleanup();
+        resolve(count > 0);
+      });
+    });
+  }
   async getFeatureFlag(key, distinctId, options) {
     const {
       groups,
@@ -3841,6 +3911,10 @@ class PostHog extends PostHogCoreStateless {
       disableGeoip
     }, distinctId);
   }
+  /**
+   * Reloads the feature flag definitions from the server for local evaluation.
+   * This is useful to call if you want to ensure that the feature flags are up to date before calling getFeatureFlag.
+   */
   async reloadFeatureFlags() {
     await this.featureFlagsPoller?.loadFeatureFlags(true);
   }