posthog-node 3.6.2 → 4.0.0-beta.1

package/test/feature-flags.spec.ts

@@ -4,6 +4,7 @@ import { PostHog as PostHog, PostHogOptions } from '../src/posthog-node'
 import { matchProperty, InconclusiveMatchError, relativeDateParseForFeatureFlagMatching } from '../src/feature-flags'
 jest.mock('../src/fetch')
 import fetch from '../src/fetch'
+import { anyDecideCall, anyLocalEvalCall, apiImplementation } from './test-utils'
 
 jest.spyOn(console, 'debug').mockImplementation()
 
@@ -13,71 +14,6 @@ const posthogImmediateResolveOptions: PostHogOptions = {
   fetchRetryCount: 0,
 }
 
-export const apiImplementation = ({
-  localFlags,
-  decideFlags,
-  decideFlagPayloads,
-  decideStatus = 200,
-}: {
-  localFlags?: any
-  decideFlags?: any
-  decideFlagPayloads?: any
-  decideStatus?: number
-}) => {
-  return (url: any): Promise<any> => {
-    if ((url as any).includes('/decide/')) {
-      return Promise.resolve({
-        status: decideStatus,
-        text: () => Promise.resolve('ok'),
-        json: () => {
-          if (decideStatus !== 200) {
-            return Promise.resolve(decideFlags)
-          } else {
-            return Promise.resolve({
-              featureFlags: decideFlags,
-              featureFlagPayloads: decideFlagPayloads,
-            })
-          }
-        },
-      }) as any
-    }
-
-    if ((url as any).includes('api/feature_flag/local_evaluation?token=TEST_API_KEY&send_cohorts')) {
-      return Promise.resolve({
-        status: 200,
-        text: () => Promise.resolve('ok'),
-        json: () => Promise.resolve(localFlags),
-      }) as any
-    }
-
-    if ((url as any).includes('batch/')) {
-      return Promise.resolve({
-        status: 200,
-        text: () => Promise.resolve('ok'),
-        json: () =>
-          Promise.resolve({
-            status: 'ok',
-          }),
-      }) as any
-    }
-
-    return Promise.resolve({
-      status: 400,
-      text: () => Promise.resolve('ok'),
-      json: () =>
-        Promise.resolve({
-          status: 'ok',
-        }),
-    }) as any
-  }
-}
-
-export const anyLocalEvalCall = [
-  'http://example.com/api/feature_flag/local_evaluation?token=TEST_API_KEY&send_cohorts',
-  expect.any(Object),
-]
-export const anyDecideCall = ['http://example.com/decide/?v=3', expect.any(Object)]
-
 describe('local evaluation', () => {
   let posthog: PostHog
 
@@ -2051,80 +1987,74 @@ describe('match properties', () => {
     expect(matchProperty(property_d, { key: '2022-04-05 11:34:13 +00:00' })).toBe(false)
   })
 
-  it('with relative date operators', () => {
+  it.each([
+    ['is_date_before', '-6h', '2022-03-01', true],
+    ['is_date_before', '-6h', '2022-04-30', true],
+    // :TRICKY: MonthIndex is 0 indexed, so 3 is actually the 4th month, April.
+    ['is_date_before', '-6h', new Date(Date.UTC(2022, 3, 30, 1, 2, 3)), true],
+    // false because date comparison, instead of datetime, so reduces to same date
+    ['is_date_before', '-6h', new Date('2022-04-30T01:02:03+02:00'), true], // europe/madrid
+    ['is_date_before', '-6h', new Date('2022-04-30T20:02:03+02:00'), false], // europe/madrid
+    ['is_date_before', '-6h', new Date('2022-04-30T19:59:03+02:00'), true], // europe/madrid
+    ['is_date_before', '-6h', new Date('2022-04-30'), true],
+    ['is_date_before', '-6h', '2022-05-30', false],
+    // is date after
+    ['is_date_after', '1h', '2022-05-02', true],
+    ['is_date_after', '1h', '2022-05-30', true],
+    ['is_date_after', '1h', new Date(2022, 4, 30), true],
+    ['is_date_after', '1h', new Date('2022-05-30'), true],
+    ['is_date_after', '1h', '2022-04-30', false],
+    // # Try all possible relative dates
+    ['is_date_before', '1h', '2022-05-01 00:00:00', false],
+    ['is_date_before', '1h', '2022-04-30 22:00:00', true],
+    ['is_date_before', '-1d', '2022-04-29 23:59:00 GMT', true],
+    ['is_date_before', '-1d', '2022-04-30 00:00:01 GMT', false],
+    ['is_date_before', '1w', '2022-04-23 00:00:00 GMT', true],
+    ['is_date_before', '1w', '2022-04-24 00:00:00 GMT', false],
+    ['is_date_before', '1w', '2022-04-24 00:00:01 GMT', false],
+    ['is_date_before', '1m', '2022-03-01 00:00:00 GMT', true],
+    ['is_date_before', '1m', '2022-04-01 00:00:00 GMT', false],
+    ['is_date_before', '1m', '2022-04-05 00:00:01 GMT', false],
+
+    ['is_date_before', '-1y', '2021-04-28 00:00:00 GMT', true],
+    ['is_date_before', '-1y', '2021-05-01 00:00:01 GMT', false],
+
+    ['is_date_after', '122h', '2022-05-01 00:00:00 GMT', true],
+    ['is_date_after', '122h', '2022-04-23 01:00:00 GMT', false],
+
+    ['is_date_after', '2d', '2022-05-01 00:00:00 GMT', true],
+    ['is_date_after', '2d', '2022-04-29 00:00:01 GMT', true],
+    ['is_date_after', '2d', '2022-04-29 00:00:00 GMT', false],
+
+    ['is_date_after', '02w', '2022-05-01 00:00:00 GMT', true],
+    ['is_date_after', '02w', '2022-04-16 00:00:00 GMT', false],
+
+    ['is_date_after', '-1m', '2022-04-01 00:00:01 GMT', true],
+    ['is_date_after', '-1m', '2022-04-01 00:00:00 GMT', false],
+
+    ['is_date_after', '1y', '2022-05-01 00:00:00 GMT', true],
+    ['is_date_after', '1y', '2021-05-01 00:00:01 GMT', true],
+    ['is_date_after', '1y', '2021-05-01 00:00:00 GMT', false],
+    ['is_date_after', '1y', '2021-04-30 00:00:00 GMT', false],
+    ['is_date_after', '1y', '2021-03-01 12:13:00 GMT', false],
+  ])('with relative date operators: %s, %s, %s', (operator, value, date, expectation) => {
     jest.setSystemTime(new Date('2022-05-01'))
+    expect(matchProperty({ key: 'key', value, operator }, { key: date })).toBe(expectation)
 
-    const property_a = { key: 'key', value: '-6h', operator: 'is_date_before' }
-    expect(matchProperty(property_a, { key: '2022-03-01' })).toBe(true)
-    expect(matchProperty(property_a, { key: '2022-04-30' })).toBe(true)
+    return
+  })
 
-    // :TRICKY: MonthIndex is 0 indexed, so 3 is actually the 4th month, April.
-    expect(matchProperty(property_a, { key: new Date(Date.UTC(2022, 3, 30, 1, 2, 3)) })).toBe(true)
-    // false because date comparison, instead of datetime, so reduces to same date
-    expect(matchProperty(property_a, { key: new Date(2022, 3, 30, 19, 2, 3) })).toBe(false)
-    expect(matchProperty(property_a, { key: new Date('2022-04-30T01:02:03+02:00') })).toBe(true) // europe/madrid
-    expect(matchProperty(property_a, { key: new Date('2022-04-30T20:02:03+02:00') })).toBe(false) // europe/madrid
-    expect(matchProperty(property_a, { key: new Date('2022-04-30T19:59:03+02:00') })).toBe(true) // europe/madrid
-    expect(matchProperty(property_a, { key: new Date('2022-04-30') })).toBe(true)
-    expect(matchProperty(property_a, { key: '2022-05-30' })).toBe(false)
+  it('with relative date operators handles invalid keys', () => {
+    jest.setSystemTime(new Date('2022-05-01'))
 
     // # can't be an invalid string
-    expect(() => matchProperty(property_a, { key: 'abcdef' })).toThrow(InconclusiveMatchError)
+    expect(() => matchProperty({ key: 'key', value: '1d', operator: 'is_date_before' }, { key: 'abcdef' })).toThrow(
+      InconclusiveMatchError
+    )
     // however js understands numbers as date offsets from utc epoch
-    expect(() => matchProperty(property_a, { key: 1 })).not.toThrow(InconclusiveMatchError)
-
-    const property_b = { key: 'key', value: '1h', operator: 'is_date_after' }
-    expect(matchProperty(property_b, { key: '2022-05-02' })).toBe(true)
-    expect(matchProperty(property_b, { key: '2022-05-30' })).toBe(true)
-    expect(matchProperty(property_b, { key: new Date(2022, 4, 30) })).toBe(true)
-    expect(matchProperty(property_b, { key: new Date('2022-05-30') })).toBe(true)
-    expect(matchProperty(property_b, { key: '2022-04-30' })).toBe(false)
-
-    // # Try all possible relative dates
-    const property_e = { key: 'key', value: '1h', operator: 'is_date_before' }
-    expect(matchProperty(property_e, { key: '2022-05-01 00:00:00' })).toBe(false)
-    expect(matchProperty(property_e, { key: '2022-04-30 22:00:00' })).toBe(true)
-
-    const property_f = { key: 'key', value: '-1d', operator: 'is_date_before' }
-    expect(matchProperty(property_f, { key: '2022-04-29 23:59:00 GMT' })).toBe(true)
-    expect(matchProperty(property_f, { key: '2022-04-30 00:00:01 GMT' })).toBe(false)
-
-    const property_g = { key: 'key', value: '1w', operator: 'is_date_before' }
-    expect(matchProperty(property_g, { key: '2022-04-23 00:00:00 GMT' })).toBe(true)
-    expect(matchProperty(property_g, { key: '2022-04-24 00:00:00 GMT' })).toBe(false)
-    expect(matchProperty(property_g, { key: '2022-04-24 00:00:01 GMT' })).toBe(false)
-
-    const property_h = { key: 'key', value: '1m', operator: 'is_date_before' }
-    expect(matchProperty(property_h, { key: '2022-03-01 00:00:00 GMT' })).toBe(true)
-    expect(matchProperty(property_h, { key: '2022-04-05 00:00:00 GMT' })).toBe(false)
-
-    const property_i = { key: 'key', value: '-1y', operator: 'is_date_before' }
-    expect(matchProperty(property_i, { key: '2021-04-28 00:00:00 GMT' })).toBe(true)
-    expect(matchProperty(property_i, { key: '2021-05-01 00:00:01 GMT' })).toBe(false)
-
-    const property_j = { key: 'key', value: '122h', operator: 'is_date_after' }
-    expect(matchProperty(property_j, { key: '2022-05-01 00:00:00 GMT' })).toBe(true)
-    expect(matchProperty(property_j, { key: '2022-04-23 01:00:00 GMT' })).toBe(false)
-
-    const property_k = { key: 'key', value: '2d', operator: 'is_date_after' }
-    expect(matchProperty(property_k, { key: '2022-05-01 00:00:00 GMT' })).toBe(true)
-    expect(matchProperty(property_k, { key: '2022-04-29 00:00:01 GMT' })).toBe(true)
-    expect(matchProperty(property_k, { key: '2022-04-29 00:00:00 GMT' })).toBe(false)
-
-    const property_l = { key: 'key', value: '02w', operator: 'is_date_after' }
-    expect(matchProperty(property_l, { key: '2022-05-01 00:00:00 GMT' })).toBe(true)
-    expect(matchProperty(property_l, { key: '2022-04-16 00:00:00 GMT' })).toBe(false)
-
-    const property_m = { key: 'key', value: '-1m', operator: 'is_date_after' }
-    expect(matchProperty(property_m, { key: '2022-04-01 00:00:01 GMT' })).toBe(true)
-    expect(matchProperty(property_m, { key: '2022-04-01 00:00:00 GMT' })).toBe(false)
-
-    const property_n = { key: 'key', value: '1y', operator: 'is_date_after' }
-    expect(matchProperty(property_n, { key: '2022-05-01 00:00:00 GMT' })).toBe(true)
-    expect(matchProperty(property_n, { key: '2021-05-01 00:00:01 GMT' })).toBe(true)
-    expect(matchProperty(property_n, { key: '2021-05-01 00:00:00 GMT' })).toBe(false)
-    expect(matchProperty(property_n, { key: '2021-04-30 00:00:00 GMT' })).toBe(false)
-    expect(matchProperty(property_n, { key: '2021-03-01 12:13:00 GMT' })).toBe(false)
+    expect(() => matchProperty({ key: 'key', value: '1d', operator: 'is_date_before' }, { key: 1 })).not.toThrow(
+      InconclusiveMatchError
+    )
   })
 
   it('null or undefined property value', () => {

package/test/posthog-node.spec.ts

@@ -2,7 +2,7 @@
 import { PostHog as PostHog } from '../src/posthog-node'
 jest.mock('../src/fetch')
 import fetch from '../src/fetch'
-import { anyDecideCall, anyLocalEvalCall, apiImplementation } from './feature-flags.spec'
+import { anyDecideCall, anyLocalEvalCall, apiImplementation } from './test-utils'
 import { waitForPromises, wait } from '../../posthog-core/test/test-utils/test-utils'
 import { randomUUID } from 'crypto'
 
@@ -260,7 +260,6 @@ describe('PostHog Node.js', () => {
       await waitForPromises()
       jest.runOnlyPendingTimers()
       batchEvents = getLastBatchEvents()
-      console.warn(batchEvents)
       expect(batchEvents?.[0].properties).toEqual({
         $groups: { org: 123 },
         foo: 'bar',

package/test/test-utils.ts

@@ -0,0 +1,64 @@
+export const apiImplementation = ({
+  localFlags,
+  decideFlags,
+  decideFlagPayloads,
+  decideStatus = 200,
+}: {
+  localFlags?: any
+  decideFlags?: any
+  decideFlagPayloads?: any
+  decideStatus?: number
+}) => {
+  return (url: any): Promise<any> => {
+    if ((url as any).includes('/decide/')) {
+      return Promise.resolve({
+        status: decideStatus,
+        text: () => Promise.resolve('ok'),
+        json: () => {
+          if (decideStatus !== 200) {
+            return Promise.resolve(decideFlags)
+          } else {
+            return Promise.resolve({
+              featureFlags: decideFlags,
+              featureFlagPayloads: decideFlagPayloads,
+            })
+          }
+        },
+      }) as any
+    }
+
+    if ((url as any).includes('api/feature_flag/local_evaluation?token=TEST_API_KEY&send_cohorts')) {
+      return Promise.resolve({
+        status: 200,
+        text: () => Promise.resolve('ok'),
+        json: () => Promise.resolve(localFlags),
+      }) as any
+    }
+
+    if ((url as any).includes('batch/')) {
+      return Promise.resolve({
+        status: 200,
+        text: () => Promise.resolve('ok'),
+        json: () =>
+          Promise.resolve({
+            status: 'ok',
+          }),
+      }) as any
+    }
+
+    return Promise.resolve({
+      status: 400,
+      text: () => Promise.resolve('ok'),
+      json: () =>
+        Promise.resolve({
+          status: 'ok',
+        }),
+    }) as any
+  }
+}
+
+export const anyLocalEvalCall = [
+  'http://example.com/api/feature_flag/local_evaluation?token=TEST_API_KEY&send_cohorts',
+  expect.any(Object),
+]
+export const anyDecideCall = ['http://example.com/decide/?v=3', expect.any(Object)]