posthog-node 3.1.3 → 3.2.0

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/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.0",
   "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

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'

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