@posthog/core 1.2.1 → 1.2.2

package/src/__tests__/gzip.spec.ts

@@ -1,69 +0,0 @@
-import { isGzipSupported, gzipCompress } from '@/gzip'
-import { gzip } from 'node:zlib'
-import { randomBytes, randomUUID } from 'node:crypto'
-import { promisify } from 'node:util'
-
-const RANDOM_TEST_INPUT = JSON.stringify({
-  abc: randomBytes(16),
-  def: randomBytes(64),
-})
-const API_TEST_INPUT = JSON.stringify({
-  api_key: 'TEST_API_KEY',
-  batch: [
-    {
-      event: 'custom-event',
-      distinct_id: 'user-distinct-id',
-      library: 'posthog-core-tests',
-      library_version: '2.0.0-alpha',
-      properties: {
-        $lib: 'posthog-core-tests',
-        $lib_version: '2.0.0-alpha',
-        $session_id: 'session.id',
-      },
-      timestamp: new Date().toISOString(),
-      uuid: randomUUID(),
-      type: 'capture',
-    },
-  ],
-  sent_at: new Date().toISOString(),
-})
-
-describe('gzip', () => {
-  describe('isGzipSupported', () => {
-    it('should return true if CompressStream exists', () => {
-      expect(globalThis.CompressionStream).toBeDefined()
-      expect(isGzipSupported()).toBe(true)
-    })
-    it('should return false if CompressStream not available', () => {
-      const CompressionStream = globalThis.CompressionStream
-      delete (globalThis as any).CompressionStream
-      expect(isGzipSupported()).toBe(false)
-      ;(globalThis as any).CompressionStream = CompressionStream
-    })
-  })
-  describe('gzipCompress', () => {
-    it('compressed random data should match node', async () => {
-      const compressed = await gzipCompress(RANDOM_TEST_INPUT)
-      expect(compressed).not.toBe(null)
-      if (!compressed) {
-        return
-      }
-      const webCompress = Buffer.from(await compressed.arrayBuffer())
-      const nodeCompress = await promisify(gzip)(RANDOM_TEST_INPUT)
-      expect(webCompress).not.toBeFalsy()
-      expect(webCompress).toEqual(nodeCompress)
-    })
-
-    it('compressed mock request should match node', async () => {
-      const compressed = await gzipCompress(API_TEST_INPUT)
-      expect(compressed).not.toBe(null)
-      if (!compressed) {
-        return
-      }
-      const webCompress = Buffer.from(await compressed.arrayBuffer())
-      const nodeCompress = await promisify(gzip)(API_TEST_INPUT)
-      expect(webCompress).not.toBeFalsy()
-      expect(webCompress).toEqual(nodeCompress)
-    })
-  })
-})

package/src/__tests__/posthog.ai.spec.ts

@@ -1,110 +0,0 @@
-import {
-  parseBody,
-  waitForPromises,
-  createTestClient,
-  PostHogCoreTestClient,
-  PostHogCoreTestClientMocks,
-} from '@/testing'
-
-describe('PostHog Core', () => {
-  let posthog: PostHogCoreTestClient
-  let mocks: PostHogCoreTestClientMocks
-
-  jest.useFakeTimers()
-
-  beforeEach(() => {
-    ;[posthog, mocks] = createTestClient('TEST_API_KEY', { flushAt: 1 })
-  })
-
-  describe('ai', () => {
-    it('should capture feedback', async () => {
-      jest.setSystemTime(new Date('2022-01-01'))
-
-      posthog.captureTraceFeedback('trace-id', 'feedback')
-
-      await waitForPromises()
-      expect(mocks.fetch).toHaveBeenCalledTimes(1)
-      const body = parseBody(mocks.fetch.mock.calls[0])
-
-      expect(body).toMatchObject({
-        batch: [
-          {
-            event: '$ai_feedback',
-            properties: {
-              $ai_feedback_text: 'feedback',
-              $ai_trace_id: 'trace-id',
-            },
-          },
-        ],
-      })
-    })
-
-    it('should convert numeric traceId in captureTraceFeedback', async () => {
-      jest.setSystemTime(new Date('2022-01-01'))
-
-      posthog.captureTraceFeedback(10, 'feedback')
-
-      await waitForPromises()
-      expect(mocks.fetch).toHaveBeenCalledTimes(1)
-      const body = parseBody(mocks.fetch.mock.calls[0])
-
-      expect(body).toMatchObject({
-        batch: [
-          {
-            event: '$ai_feedback',
-            properties: {
-              $ai_feedback_text: 'feedback',
-              $ai_trace_id: '10',
-            },
-          },
-        ],
-      })
-    })
-
-    it('should capture a metric', async () => {
-      jest.setSystemTime(new Date('2022-01-01'))
-
-      posthog.captureTraceMetric('trace-id', 'metric-name', 'good')
-
-      await waitForPromises()
-      expect(mocks.fetch).toHaveBeenCalledTimes(1)
-      const body = parseBody(mocks.fetch.mock.calls[0])
-
-      expect(body).toMatchObject({
-        batch: [
-          {
-            event: '$ai_metric',
-            properties: {
-              $ai_metric_name: 'metric-name',
-              $ai_metric_value: 'good',
-              $ai_trace_id: 'trace-id',
-            },
-          },
-        ],
-      })
-    })
-
-    it('should convert numeric arguments in captureTraceMetric', async () => {
-      jest.setSystemTime(new Date('2022-01-01'))
-
-      posthog.captureTraceMetric(10, 'metric-name', 1)
-
-      await waitForPromises()
-      expect(mocks.fetch).toHaveBeenCalledTimes(1)
-      const body = parseBody(mocks.fetch.mock.calls[0])
-
-      expect(body).toMatchObject({
-        batch: [
-          {
-            event: '$ai_metric',
-            properties: {
-              $ai_metric_name: 'metric-name',
-              $ai_metric_value: '1',
-              $ai_trace_id: '10',
-            },
-          },
-        ],
-      })
-    })
-  })
-})

package/src/__tests__/posthog.capture.spec.ts

@@ -1,91 +0,0 @@
-import {
-  parseBody,
-  waitForPromises,
-  createTestClient,
-  PostHogCoreTestClient,
-  PostHogCoreTestClientMocks,
-} from '@/testing'
-import { uuidv7 } from '@/vendor/uuidv7'
-
-describe('PostHog Core', () => {
-  let posthog: PostHogCoreTestClient
-  let mocks: PostHogCoreTestClientMocks
-
-  jest.useFakeTimers()
-
-  beforeEach(() => {
-    ;[posthog, mocks] = createTestClient('TEST_API_KEY', { flushAt: 1 })
-  })
-
-  describe('capture', () => {
-    it('should capture an event', async () => {
-      jest.setSystemTime(new Date('2022-01-01'))
-
-      posthog.capture('custom-event')
-
-      await waitForPromises()
-      expect(mocks.fetch).toHaveBeenCalledTimes(1)
-      const [url, options] = mocks.fetch.mock.calls[0]
-      expect(url).toMatch(/^https:\/\/us\.i\.posthog\.com\/batch\//)
-      expect(options.method).toBe('POST')
-      const body = parseBody(mocks.fetch.mock.calls[0])
-
-      expect(body).toEqual({
-        api_key: 'TEST_API_KEY',
-        batch: [
-          {
-            event: 'custom-event',
-            distinct_id: posthog.getDistinctId(),
-            library: 'posthog-core-tests',
-            library_version: '2.0.0-alpha',
-            properties: {
-              $lib: 'posthog-core-tests',
-              $lib_version: '2.0.0-alpha',
-              $session_id: expect.any(String),
-            },
-            timestamp: '2022-01-01T00:00:00.000Z',
-            uuid: expect.any(String),
-            type: 'capture',
-          },
-        ],
-        sent_at: expect.any(String),
-      })
-    })
-
-    it('should allow overriding the timestamp', async () => {
-      jest.setSystemTime(new Date('2022-01-01'))
-
-      posthog.capture('custom-event', { foo: 'bar' }, { timestamp: new Date('2021-01-02') })
-      await waitForPromises()
-      const body = parseBody(mocks.fetch.mock.calls[0])
-      expect(body).toMatchObject({
-        api_key: 'TEST_API_KEY',
-        batch: [
-          {
-            event: 'custom-event',
-            timestamp: '2021-01-02T00:00:00.000Z',
-          },
-        ],
-      })
-    })
-
-    it('should allow overriding the uuid', async () => {
-      jest.setSystemTime(new Date('2022-01-01'))
-
-      const id = uuidv7()
-
-      posthog.capture('custom-event', { foo: 'bar' }, { uuid: id })
-      await waitForPromises()
-      const body = parseBody(mocks.fetch.mock.calls[0])
-
-      expect(body).toMatchObject({
-        batch: [
-          {
-            event: 'custom-event',
-            uuid: expect.any(String),
-          },
-        ],
-      })
-    })
-  })
-})

package/src/__tests__/posthog.core.spec.ts

@@ -1,135 +0,0 @@
-import { createTestClient, PostHogCoreTestClient, PostHogCoreTestClientMocks } from '@/testing'
-
-describe('PostHog Core', () => {
-  let posthog: PostHogCoreTestClient
-  let mocks: PostHogCoreTestClientMocks
-
-  jest.useFakeTimers()
-  jest.setSystemTime(new Date('2022-01-01'))
-
-  const errorAPIResponse = Promise.resolve({
-    status: 400,
-    text: () => Promise.resolve('error'),
-    json: () =>
-      Promise.resolve({
-        status: 'error',
-      }),
-  })
-
-  describe('getFlags', () => {
-    beforeEach(() => {
-      ;[posthog, mocks] = createTestClient('TEST_API_KEY', { flushAt: 1 })
-    })
-
-    it('should handle successful v1 response and return normalized response', async () => {
-      const mockV1Response = {
-        featureFlags: { 'test-flag': true },
-        featureFlagPayloads: { 'test-flag': { a: 'payload' } },
-      }
-
-      const expectedResponse = {
-        ...mockV1Response,
-        flags: {
-          'test-flag': {
-            key: 'test-flag',
-            enabled: true,
-            variant: undefined,
-            reason: undefined,
-            metadata: {
-              id: undefined,
-              version: undefined,
-              description: undefined,
-              payload: '{"a":"payload"}',
-            },
-          },
-        },
-      }
-
-      mocks.fetch.mockImplementation((url) => {
-        if (url.includes('/flags/?v=2&config=true')) {
-          return Promise.resolve({
-            status: 200,
-            text: () => Promise.resolve('ok'),
-            json: () => Promise.resolve(mockV1Response),
-          })
-        }
-        return errorAPIResponse
-      })
-
-      const response = await posthog.getFlags('test-distinct-id')
-      expect(response).toEqual(expectedResponse)
-    })
-
-    it('should handle successful v4 response and return normalized response', async () => {
-      const mockV4Response = {
-        flags: {
-          'test-flag': {
-            key: 'test-flag',
-            enabled: true,
-            variant: 'test-payload',
-            reason: {
-              code: 'matched_condition',
-              description: 'matched condition set 1',
-              condition_index: 0,
-            },
-            metadata: {
-              id: 1,
-              version: 1,
-              description: 'test-flag',
-              payload: '{"a":"payload"}',
-            },
-          },
-        },
-      }
-
-      const expectedResponse = {
-        ...mockV4Response,
-        featureFlags: { 'test-flag': 'test-payload' },
-        featureFlagPayloads: { 'test-flag': { a: 'payload' } },
-      }
-      mocks.fetch.mockImplementation((url) => {
-        if (url.includes('/flags/?v=2&config=true')) {
-          return Promise.resolve({
-            status: 200,
-            text: () => Promise.resolve('ok'),
-            json: () => Promise.resolve(mockV4Response),
-          })
-        }
-        return errorAPIResponse
-      })
-
-      const response = await posthog.getFlags('test-distinct-id')
-      expect(response).toEqual(expectedResponse)
-    })
-
-    it('should handle error response', async () => {
-      mocks.fetch.mockImplementation((url) => {
-        if (url.includes('/flags/?v=2&config=true')) {
-          return Promise.resolve({
-            status: 400,
-            text: () => Promise.resolve('error'),
-            json: () => Promise.resolve({ error: 'went wrong' }),
-          })
-        }
-        return errorAPIResponse
-      })
-
-      const response = await posthog.getFlags('test-distinct-id')
-      expect(response).toBeUndefined()
-    })
-
-    it('should handle network errors', async () => {
-      const emitSpy = jest.spyOn(posthog['_events'], 'emit')
-      mocks.fetch.mockImplementation((url) => {
-        if (url.includes('/flags/?v=2&config=true')) {
-          return Promise.reject(new Error('Network error'))
-        }
-        return errorAPIResponse
-      })
-
-      const response = await posthog.getFlags('test-distinct-id')
-      expect(response).toBeUndefined()
-      expect(emitSpy).toHaveBeenCalledWith('error', expect.any(Error))
-    })
-  })
-})

package/src/__tests__/posthog.debug.spec.ts

@@ -1,36 +0,0 @@
-import { createTestClient, PostHogCoreTestClient, PostHogCoreTestClientMocks } from '@/testing'
-
-describe('PostHog Core', () => {
-  let posthog: PostHogCoreTestClient
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  let mocks: PostHogCoreTestClientMocks
-
-  beforeEach(() => {
-    ;[posthog, mocks] = createTestClient('TEST_API_KEY', {})
-  })
-
-  describe('debug', () => {
-    it('should log emitted events when enabled', () => {
-      const spy = jest.spyOn(console, 'log')
-
-      posthog.capture('test-event1')
-      expect(spy).toHaveBeenCalledTimes(0)
-
-      posthog.debug()
-      posthog.capture('test-event1')
-      expect(spy).toHaveBeenCalledTimes(1)
-      expect(spy).toHaveBeenCalledWith(
-        'PostHog Debug',
-        'capture',
-        expect.objectContaining({
-          event: 'test-event1',
-        })
-      )
-
-      spy.mockReset()
-      posthog.debug(false)
-      posthog.capture('test-event1')
-      expect(spy).toHaveBeenCalledTimes(0)
-    })
-  })
-})

package/src/__tests__/posthog.enqueue.spec.ts

@@ -1,93 +0,0 @@
-import { PostHogPersistedProperty } from '@/types'
-import { createTestClient, PostHogCoreTestClient, PostHogCoreTestClientMocks } from '@/testing'
-
-describe('PostHog Core', () => {
-  let posthog: PostHogCoreTestClient
-  let mocks: PostHogCoreTestClientMocks
-
-  beforeEach(() => {
-    jest.setSystemTime(new Date('2022-01-01'))
-  })
-
-  function createSut(maxQueueSize: number = 1000, flushAt: number = 20): void {
-    ;[posthog, mocks] = createTestClient('TEST_API_KEY', {
-      maxQueueSize: maxQueueSize,
-      flushAt: flushAt,
-    })
-  }
-
-  describe('enqueue', () => {
-    it('should add a message to the queue', () => {
-      createSut()
-
-      posthog.capture('type', {
-        foo: 'bar',
-      })
-
-      expect(posthog.getPersistedProperty(PostHogPersistedProperty.Queue)).toHaveLength(1)
-
-      const item = posthog.getPersistedProperty<any[]>(PostHogPersistedProperty.Queue)?.pop()
-
-      expect(item).toMatchObject({
-        message: {
-          library: 'posthog-core-tests',
-          library_version: '2.0.0-alpha',
-          type: 'capture',
-          properties: {
-            foo: 'bar',
-          },
-        },
-      })
-
-      expect(mocks.fetch).not.toHaveBeenCalled()
-    })
-
-    it('should delete oldest message if queue is full', () => {
-      createSut(2, 2)
-
-      posthog.capture('type1', {
-        foo: 'bar',
-      })
-
-      posthog.capture('type2', {
-        foo: 'bar',
-      })
-
-      posthog.capture('type3', {
-        foo: 'bar',
-      })
-
-      expect(posthog.getPersistedProperty(PostHogPersistedProperty.Queue)).toHaveLength(2)
-
-      let item = posthog.getPersistedProperty<any[]>(PostHogPersistedProperty.Queue)?.pop()
-
-      expect(item).toMatchObject({
-        message: {
-          library: 'posthog-core-tests',
-          library_version: '2.0.0-alpha',
-          type: 'capture',
-          properties: {
-            foo: 'bar',
-          },
-          event: 'type3',
-        },
-      })
-
-      item = posthog.getPersistedProperty<any[]>(PostHogPersistedProperty.Queue)?.pop()
-
-      expect(item).toMatchObject({
-        message: {
-          library: 'posthog-core-tests',
-          library_version: '2.0.0-alpha',
-          type: 'capture',
-          properties: {
-            foo: 'bar',
-          },
-          event: 'type2',
-        },
-      })
-
-      expect(mocks.fetch).not.toHaveBeenCalled()
-    })
-  })
-})