posthog-node 4.15.0 → 4.17.0

package/src/extensions/express.ts

@@ -1,7 +1,7 @@
 import type * as http from 'node:http'
 import { uuidv7 } from 'posthog-core/src/vendor/uuidv7'
-import ErrorTracking from '../error-tracking'
-import { PostHog } from '../posthog-node'
+import ErrorTracking from './error-tracking'
+import { PostHogBackendClient } from '../client'
 
 type ExpressMiddleware = (req: http.IncomingMessage, res: http.ServerResponse, next: () => void) => void
 
@@ -22,7 +22,7 @@ interface MiddlewareError extends Error {
 }
 
 export function setupExpressErrorHandler(
-  _posthog: PostHog,
+  _posthog: PostHogBackendClient,
   app: {
     use: (middleware: ExpressMiddleware | ExpressErrorMiddleware) => unknown
   }

package/src/{crypto-helpers.ts → extensions/feature-flags/crypto-helpers.ts}

@@ -1,5 +1,5 @@
 /// <reference lib="dom" />
-import { Lazy } from 'posthog-node/src/lazy'
+import { Lazy } from './lazy'
 
 const nodeCrypto = new Lazy(async () => {
   try {

package/src/{feature-flags.ts → extensions/feature-flags/feature-flags.ts}

@@ -1,9 +1,10 @@
-import { FeatureFlagCondition, FlagProperty, PostHogFeatureFlag, PropertyGroup } from './types'
-import { FeatureFlagValue, JsonType, PostHogFetchOptions, PostHogFetchResponse } from 'posthog-core/src'
-import { safeSetTimeout } from 'posthog-core/src/utils'
-import fetch from './fetch'
-import { SIXTY_SECONDS } from './posthog-node'
-import { hashSHA1 } from 'posthog-node/src/crypto'
+import { FeatureFlagCondition, FlagProperty, PostHogFeatureFlag, PropertyGroup } from '../../types'
+import type { FeatureFlagValue, JsonType, PostHogFetchOptions, PostHogFetchResponse } from 'posthog-core'
+import { safeSetTimeout } from 'posthog-core'
+import fetch from '../../fetch'
+import { hashSHA1 } from './crypto'
+
+const SIXTY_SECONDS = 60 * 1000
 
 // eslint-disable-next-line
 const LONG_SCALE = 0xfffffffffffffff

package/src/extensions/sentry-integration.ts

@@ -22,8 +22,8 @@
  * @param {SeverityLevel[] | '*'} [severityAllowList] Optional: send events matching the provided levels. Use '*' to send all events (default: ['error'])
  */
 
-import { SeverityLevel } from 'posthog-node/src/extensions/error-tracking/types'
-import { type PostHog } from '../posthog-node'
+import { SeverityLevel } from './error-tracking/types'
+import { type PostHogBackendClient } from '../client'
 
 // NOTE - we can't import from @sentry/types because it changes frequently and causes clashes
 // We only use a small subset of the types, so we can just define the integration overall and use any for the rest
@@ -75,7 +75,7 @@ export type SentryIntegrationOptions = {
 const NAME = 'posthog-node'
 
 export function createEventProcessor(
-  _posthog: PostHog,
+  _posthog: PostHogBackendClient,
   { organization, projectId, prefix, severityAllowList = ['error'] }: SentryIntegrationOptions = {}
 ): (event: _SentryEvent) => _SentryEvent {
   return (event) => {
@@ -154,7 +154,10 @@ export function createEventProcessor(
 }
 
 // V8 integration - function based
-export function sentryIntegration(_posthog: PostHog, options?: SentryIntegrationOptions): _SentryIntegration {
+export function sentryIntegration(
+  _posthog: PostHogBackendClient,
+  options?: SentryIntegrationOptions
+): _SentryIntegration {
   const processor = createEventProcessor(_posthog, options)
   return {
     name: NAME,
@@ -175,7 +178,12 @@ export class PostHogSentryIntegration implements _SentryIntegrationClass {
     getCurrentHub: () => _SentryHub
   ) => void
 
-  constructor(_posthog: PostHog, organization?: string, prefix?: string, severityAllowList?: SeverityLevel[] | '*') {
+  constructor(
+    _posthog: PostHogBackendClient,
+    organization?: string,
+    prefix?: string,
+    severityAllowList?: SeverityLevel[] | '*'
+  ) {
     // setupOnce gets called by Sentry when it intializes the plugin
     this.name = NAME
     this.setupOnce = function (

package/src/fetch.ts

@@ -7,8 +7,8 @@
  * See https://github.com/PostHog/posthog-js-lite/issues/127 for more info
  */
 
-import { FetchLike, PostHogFetchOptions, PostHogFetchResponse } from 'posthog-core/src'
-import { getFetch } from 'posthog-core/src/utils'
+import { FetchLike, PostHogFetchOptions, PostHogFetchResponse } from 'posthog-core'
+import { getFetch } from 'posthog-core'
 
 let _fetch: FetchLike | undefined = getFetch()
 

package/src/storage-memory.ts

@@ -0,0 +1,13 @@
+import { PostHogPersistedProperty } from 'posthog-core'
+
+export class PostHogMemoryStorage {
+  private _memoryStorage: { [key: string]: any | undefined } = {}
+
+  getProperty(key: PostHogPersistedProperty): any | undefined {
+    return this._memoryStorage[key]
+  }
+
+  setProperty(key: PostHogPersistedProperty, value: any | null): void {
+    this._memoryStorage[key] = value !== null ? value : undefined
+  }
+}

package/src/types.ts

@@ -1,4 +1,10 @@
-import { FeatureFlagValue, JsonType } from '../../posthog-core/src'
+import type {
+  PostHogCoreOptions,
+  FeatureFlagValue,
+  JsonType,
+  PostHogFetchOptions,
+  PostHogFetchResponse,
+} from 'posthog-core'
 
 export interface IdentifyMessage {
   distinctId: string
@@ -41,6 +47,18 @@ export type FeatureFlagCondition = {
   variant?: string
 }
 
+export type PostHogOptions = PostHogCoreOptions & {
+  persistence?: 'memory'
+  personalApiKey?: string
+  privacyMode?: boolean
+  enableExceptionAutocapture?: boolean
+  // The interval in milliseconds between polls for refreshing feature flag definitions. Defaults to 30 seconds.
+  featureFlagsPollingInterval?: number
+  // Maximum size of cache that deduplicates $feature_flag_called calls per user.
+  maxCacheSize?: number
+  fetch?: (url: string, options: PostHogFetchOptions) => Promise<PostHogFetchResponse>
+}
+
 export type PostHogFeatureFlag = {
   id: number
   name: string

package/test/crypto.spec.ts

@@ -1,5 +1,5 @@
-import * as crypto from '../src/crypto'
-import * as cryptoHelpers from '../src/crypto-helpers'
+import * as crypto from '../src/extensions/feature-flags/crypto'
+import * as cryptoHelpers from '../src/extensions/feature-flags/crypto-helpers'
 
 describe('crypto', () => {
   describe('hashSHA1', () => {

package/test/extensions/error-conversion.spec.ts

@@ -1,11 +1,11 @@
 import { propertiesFromUnknownInput } from '../../src/extensions/error-tracking/error-conversion'
-import { defaultStackParser } from '../../src/extensions/error-tracking/stack-trace'
 import { ErrorProperties } from '../../src/extensions/error-tracking/types'
+import { createStackParser } from '../../src/extensions/error-tracking/stack-parser'
 
 describe('error conversion', () => {
   async function getExceptionList(error: unknown): Promise<ErrorProperties['$exception_list']> {
     const syntheticException = new Error('PostHog syntheticException')
-    const exceptionProperties = await propertiesFromUnknownInput(defaultStackParser, error, {
+    const exceptionProperties = await propertiesFromUnknownInput(createStackParser(), [], error, {
       syntheticException,
     })
     return exceptionProperties.$exception_list

package/test/extensions/sentry-integration.spec.ts

@@ -1,5 +1,4 @@
-// import { PostHog } from '../'
-import { PostHog as PostHog } from '../../src/posthog-node'
+import { PostHog } from '../../src/entrypoints/index.node'
 import { PostHogSentryIntegration } from '../../src/extensions/sentry-integration'
 jest.mock('../../src/fetch')
 import fetch from '../../src/fetch'

package/test/feature-flags.decide.spec.ts

@@ -1,4 +1,5 @@
-import { PostHog as PostHog, PostHogOptions } from '../src/posthog-node'
+import { PostHog } from '../src/entrypoints/index.node'
+import { PostHogOptions } from '../src/types'
 import fetch from '../src/fetch'
 import { apiImplementation, apiImplementationV4 } from './test-utils'
 import { waitForPromises } from 'posthog-core/test/test-utils/test-utils'

package/test/feature-flags.spec.ts

@@ -1,7 +1,10 @@
-// import { PostHog, PostHogOptions } from '../'
-// Uncomment below line while developing to not compile code everytime
-import { PostHog as PostHog, PostHogOptions } from '../src/posthog-node'
-import { matchProperty, InconclusiveMatchError, relativeDateParseForFeatureFlagMatching } from '../src/feature-flags'
+import { PostHogOptions } from '../src/types'
+import { PostHog } from '../src/entrypoints/index.node'
+import {
+  matchProperty,
+  InconclusiveMatchError,
+  relativeDateParseForFeatureFlagMatching,
+} from '../src/extensions/feature-flags/feature-flags'
 import fetch from '../src/fetch'
 import { anyDecideCall, anyLocalEvalCall, apiImplementation } from './test-utils'
 import { waitForPromises } from 'posthog-core/test/test-utils/test-utils'

package/test/lazy.spec.ts

@@ -1,4 +1,4 @@
-import { Lazy } from '../src/lazy'
+import { Lazy } from '../src/extensions/feature-flags/lazy'
 
 describe('Lazy', () => {
   it('should only call the factory once', async (): Promise<void> => {

package/test/posthog-node.spec.ts

@@ -1,6 +1,6 @@
-import { MINIMUM_POLLING_INTERVAL, PostHog as PostHog, THIRTY_SECONDS } from '../src/posthog-node'
 import fetch from '../src/fetch'
-import { anyDecideCall, anyLocalEvalCall, apiImplementation } from './test-utils'
+import { PostHog } from '../src/entrypoints/index.node'
+import { anyDecideCall, anyLocalEvalCall, apiImplementation, isPending } from './test-utils'
 import { waitForPromises, wait } from '../../posthog-core/test/test-utils/test-utils'
 import { randomUUID } from 'crypto'
 jest.mock('../src/fetch')
@@ -381,33 +381,31 @@ describe('PostHog Node.js', () => {
       })
       ph.debug(true)
 
-      // using debug mode to check console.log output
-      // which tells us when the flush is complete
+      ph.capture({ event: 'test-event-1', distinctId: '123' })
 
-      ph.capture({ event: 'test-event', distinctId: '123' })
-      await wait(100)
-      expect(logSpy).toHaveBeenCalledTimes(1)
+      // start flushing, but don't wait for promise to resolve before resuming events
+      const flushPromise = ph.flush()
+      expect(isPending(flushPromise)).toEqual(true)
 
-      ph.capture({ event: 'test-event', distinctId: '123' })
-      ph.capture({ event: 'test-event', distinctId: '123' })
-      await wait(100)
-      expect(logSpy).toHaveBeenCalledTimes(3)
-      await wait(400) // The flush will resolve in this time
-      ph.capture({ event: 'test-event', distinctId: '123' })
-      ph.capture({ event: 'test-event', distinctId: '123' })
-      await wait(100)
-      expect(logSpy).toHaveBeenCalledTimes(6) // 5 captures and 1 flush
-      expect(5).toEqual(logSpy.mock.calls.filter((call) => call[1].includes('capture')).length)
-      expect(1).toEqual(logSpy.mock.calls.filter((call) => call[1].includes('flush')).length)
+      ph.capture({ event: 'test-event-2', distinctId: '123' })
 
-      logSpy.mockClear()
-      expect(logSpy).toHaveBeenCalledTimes(0)
+      // start shutdown, but don't wait for promise to resolve before resuming events
+      const shutdownPromise = ph.shutdown()
 
-      console.warn('YOO!!')
+      ph.capture({ event: 'test-event-3', distinctId: '123' })
+
+      // wait for shutdown to finish
+      await shutdownPromise
+      expect(isPending(flushPromise)).toEqual(false)
+
+      expect(3).toEqual(logSpy.mock.calls.filter((call) => call[1].includes('capture')).length)
+      const flushedEvents = logSpy.mock.calls.filter((call) => call[1].includes('flush')).flatMap((flush) => flush[2])
+      expect(flushedEvents).toMatchObject([
+        { event: 'test-event-1' },
+        { event: 'test-event-2' },
+        { event: 'test-event-3' },
+      ])
 
-      await ph.shutdown()
-      // 1 final flush for the events that were queued during shutdown
-      expect(1).toEqual(logSpy.mock.calls.filter((call) => call[1].includes('flush')).length)
       logSpy.mockRestore()
       warnSpy.mockRestore()
     })
@@ -685,7 +683,7 @@ describe('PostHog Node.js', () => {
         featureFlagsPollingInterval: 98,
       })
 
-      expect(posthog.options.featureFlagsPollingInterval).toEqual(MINIMUM_POLLING_INTERVAL)
+      expect(posthog.options.featureFlagsPollingInterval).toEqual(100)
     })
 
     it('should use default featureFlagsPollingInterval of 30000ms if none provided', async () => {
@@ -695,7 +693,7 @@ describe('PostHog Node.js', () => {
         personalApiKey: 'TEST_PERSONAL_API_KEY',
       })
 
-      expect(posthog.options.featureFlagsPollingInterval).toEqual(THIRTY_SECONDS)
+      expect(posthog.options.featureFlagsPollingInterval).toEqual(30000)
     })
 
     it('should throw an error when creating SDK if a project key is passed in as personalApiKey', async () => {

package/test/test-utils.ts

@@ -1,4 +1,5 @@
 import { PostHogV4DecideResponse } from 'posthog-core/src/types'
+import util from 'util'
 
 type ErrorResponse = {
   status: number
@@ -104,3 +105,7 @@ export const anyLocalEvalCall = [
   expect.any(Object),
 ]
 export const anyDecideCall = ['http://example.com/flags/?v=2', expect.any(Object)]
+
+export const isPending = (promise: Promise<any>): boolean => {
+  return util.inspect(promise).includes('pending')
+}

package/tsconfig.json

@@ -1,6 +1,7 @@
 {
   "extends": "../tsconfig.json",
   "compilerOptions": {
+    "incremental": false,
     "types": ["node"],
     "typeRoots": ["./node_modules/@types", "../node_modules/@types"]
   }

package/index.ts

@@ -1,3 +0,0 @@
-export * from './src/posthog-node'
-export * from './src/extensions/sentry-integration'
-export * from './src/extensions/express'