posthog-node 3.1.3 → 3.2.1

package/lib/posthog-core/src/index.d.ts

@@ -117,9 +117,19 @@ export declare abstract class PostHogCore extends PostHogCoreStateless {
     /***
      * PROPERTIES
      ***/
+    setPersonPropertiesForFlags(properties: {
+        [type: string]: string;
+    }): this;
+    resetPersonPropertiesForFlags(): void;
+    /** @deprecated - Renamed to setPersonPropertiesForFlags */
     personProperties(properties: {
         [type: string]: string;
     }): this;
+    setGroupPropertiesForFlags(properties: {
+        [type: string]: Record<string, string>;
+    }): this;
+    resetGroupPropertiesForFlags(): void;
+    /** @deprecated - Renamed to setGroupPropertiesForFlags */
     groupProperties(properties: {
         [type: string]: Record<string, string>;
     }): this;

package/lib/posthog-node/src/feature-flags.d.ts

@@ -14,6 +14,7 @@ declare type FeatureFlagsPollerOptions = {
     pollingInterval: number;
     timeout?: number;
     fetch?: (url: string, options: PostHogFetchOptions) => Promise<PostHogFetchResponse>;
+    onError?: (error: Error) => void;
 };
 declare class FeatureFlagsPoller {
     pollingInterval: number;
@@ -29,6 +30,7 @@ declare class FeatureFlagsPoller {
     poller?: NodeJS.Timeout;
     fetch: (url: string, options: PostHogFetchOptions) => Promise<PostHogFetchResponse>;
     debugMode: boolean;
+    onError?: (error: Error) => void;
     constructor({ pollingInterval, personalApiKey, projectApiKey, timeout, host, ...options }: FeatureFlagsPollerOptions);
     debug(enabled?: boolean): void;
     getFeatureFlag(key: string, distinctId: string, groups?: Record<string, string>, personProperties?: Record<string, string>, groupProperties?: Record<string, Record<string, string>>): Promise<string | boolean | undefined>;

package/lib/posthog-node/src/fetch.d.ts

@@ -1,2 +1,12 @@
+/**
+ * Fetch wrapper
+ *
+ * We want to polyfill fetch when not available with axios but use it when it is.
+ * NOTE: The current version of Axios has an issue when in non-node environments like Clouflare Workers.
+ * This is currently solved by using the global fetch if available instead.
+ * See https://github.com/PostHog/posthog-js-lite/issues/127 for more info
+ */
 import { PostHogFetchOptions, PostHogFetchResponse } from 'posthog-core/src';
-export declare const fetch: (url: string, options: PostHogFetchOptions) => Promise<PostHogFetchResponse>;
+declare type FetchLike = (url: string, options: PostHogFetchOptions) => Promise<PostHogFetchResponse>;
+declare const _default: FetchLike;
+export default _default;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "posthog-node",
-  "version": "3.1.3",
+  "version": "3.2.1",
   "description": "PostHog Node.js integration",
   "repository": "PostHog/posthog-node",
   "scripts": {
@@ -19,7 +19,7 @@
   "module": "lib/index.esm.js",
   "types": "lib/index.d.ts",
   "dependencies": {
-    "axios": "^1.6.0",
+    "axios": "^1.6.2",
     "rusha": "^0.8.14"
   },
   "devDependencies": {

package/src/feature-flags.ts

@@ -3,7 +3,7 @@ import { FeatureFlagCondition, FlagProperty, PostHogFeatureFlag, PropertyGroup }
 import { version } from '../package.json'
 import { JsonType, PostHogFetchOptions, PostHogFetchResponse } from 'posthog-core/src'
 import { safeSetTimeout } from 'posthog-core/src/utils'
-import { fetch } from './fetch'
+import fetch from './fetch'
 
 // eslint-disable-next-line
 const LONG_SCALE = 0xfffffffffffffff
@@ -37,6 +37,7 @@ type FeatureFlagsPollerOptions = {
   pollingInterval: number
   timeout?: number
   fetch?: (url: string, options: PostHogFetchOptions) => Promise<PostHogFetchResponse>
+  onError?: (error: Error) => void
 }
 
 class FeatureFlagsPoller {
@@ -53,6 +54,7 @@ class FeatureFlagsPoller {
   poller?: NodeJS.Timeout
   fetch: (url: string, options: PostHogFetchOptions) => Promise<PostHogFetchResponse>
   debugMode: boolean = false
+  onError?: (error: Error) => void
 
   constructor({
     pollingInterval,
@@ -75,6 +77,7 @@ class FeatureFlagsPoller {
     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
+    this.onError = options.onError
 
     void this.loadFeatureFlags()
   }
@@ -177,7 +180,7 @@ class FeatureFlagsPoller {
         if (e instanceof InconclusiveMatchError) {
           // do nothing
         } else if (e instanceof Error) {
-          console.error(`Error computing flag locally: ${flag.key}: ${e}`)
+          this.onError?.(new Error(`Error computing flag locally: ${flag.key}: ${e}`))
         }
         fallbackToDecide = true
       }
@@ -395,7 +398,7 @@ class FeatureFlagsPoller {
       // if an error that is not an instance of ClientError is thrown
       // we silently ignore the error when reloading feature flags
       if (err instanceof ClientError) {
-        throw err
+        this.onError?.(err)
       }
     }
   }

package/src/fetch.ts

@@ -1,22 +1,43 @@
-import axios from 'axios'
+/**
+ * Fetch wrapper
+ *
+ * We want to polyfill fetch when not available with axios but use it when it is.
+ * NOTE: The current version of Axios has an issue when in non-node environments like Clouflare Workers.
+ * This is currently solved by using the global fetch if available instead.
+ * See https://github.com/PostHog/posthog-js-lite/issues/127 for more info
+ */
+
 import { PostHogFetchOptions, PostHogFetchResponse } from 'posthog-core/src'
 
-// NOTE: We use axios as a reliable, well supported request library but follow the Fetch API (roughly)
-// So that alternative implementations can be used if desired
-export const fetch = async (url: string, options: PostHogFetchOptions): Promise<PostHogFetchResponse> => {
-  const res = await axios.request({
-    url,
-    headers: options.headers,
-    method: options.method.toLowerCase(),
-    data: options.body,
-    signal: options.signal,
-    // fetch only throws on network errors, not on HTTP errors
-    validateStatus: () => true,
-  })
+type FetchLike = (url: string, options: PostHogFetchOptions) => Promise<PostHogFetchResponse>
+
+let _fetch: FetchLike | undefined =
+  // eslint-disable-next-line @typescript-eslint/prefer-ts-expect-error
+  // @ts-ignore
+  typeof fetch !== 'undefined' ? fetch : typeof global.fetch !== 'undefined' ? global.fetch : undefined
+
+if (!_fetch) {
+  // eslint-disable-next-line @typescript-eslint/no-var-requires
+  const axios = require('axios')
 
-  return {
-    status: res.status,
-    text: async () => res.data,
-    json: async () => res.data,
+  _fetch = async (url: string, options: PostHogFetchOptions): Promise<PostHogFetchResponse> => {
+    const res = await axios.request({
+      url,
+      headers: options.headers,
+      method: options.method.toLowerCase(),
+      data: options.body,
+      signal: options.signal,
+      // fetch only throws on network errors, not on HTTP errors
+      validateStatus: () => true,
+    })
+
+    return {
+      status: res.status,
+      text: async () => res.data,
+      json: async () => res.data,
+    }
   }
 }
+
+// NOTE: We have to export this as default, even though we prefer named exports as we are relying on detecting "fetch" in the global scope
+export default _fetch as FetchLike

package/src/posthog-node.ts

@@ -12,7 +12,7 @@ import {
 import { PostHogMemoryStorage } from '../../posthog-core/src/storage-memory'
 import { EventMessageV1, GroupIdentifyMessage, IdentifyMessageV1, PostHogNodeV1 } from './types'
 import { FeatureFlagsPoller } from './feature-flags'
-import { fetch } from './fetch'
+import fetch from './fetch'
 
 export type PostHogOptions = PosthogCoreOptions & {
   persistence?: 'memory'
@@ -56,6 +56,9 @@ export class PostHog extends PostHogCoreStateless implements PostHogNodeV1 {
         timeout: options.requestTimeout ?? 10000, // 10 seconds
         host: this.host,
         fetch: options.fetch,
+        onError: (err: Error) => {
+          this._events.emit('error', err)
+        },
       })
     }
     this.distinctIdHasSentFlagCalls = {}

package/test/feature-flags.spec.ts

@@ -3,9 +3,9 @@
 import { PostHog as PostHog, PostHogOptions } from '../src/posthog-node'
 import { matchProperty, InconclusiveMatchError } from '../src/feature-flags'
 jest.mock('../src/fetch')
-import { fetch } from '../src/fetch'
+import fetch from '../src/fetch'
 
-jest.spyOn(global.console, 'debug').mockImplementation()
+jest.spyOn(console, 'debug').mockImplementation()
 
 const mockedFetch = jest.mocked(fetch, true)
 

package/test/posthog-node.spec.ts

@@ -1,7 +1,7 @@
 // import { PostHog } from '../'
 import { PostHog as PostHog } from '../src/posthog-node'
 jest.mock('../src/fetch')
-import { fetch } from '../src/fetch'
+import fetch from '../src/fetch'
 import { anyDecideCall, anyLocalEvalCall, apiImplementation } from './feature-flags.spec'
 import { waitForPromises, wait } from '../../posthog-core/test/test-utils/test-utils'
 
@@ -295,7 +295,7 @@ describe('PostHog Node.js', () => {
         flushAt: 1,
       })
 
-      const logSpy = jest.spyOn(global.console, 'log').mockImplementation(() => {})
+      const logSpy = jest.spyOn(console, 'log').mockImplementation(() => {})
       jest.useRealTimers()
       // using debug mode to check console.log output
       // which tells us when the flush is complete