posthog-node 2.5.4 → 3.0.0

package/test/feature-flags.spec.ts

@@ -38,7 +38,7 @@ export const apiImplementation = ({
       }) as any
     }
 
-    if ((url as any).includes('api/feature_flag/local_evaluation?token=TEST_API_KEY')) {
+    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'),
@@ -58,7 +58,7 @@ export const apiImplementation = ({
 }
 
 export const anyLocalEvalCall = [
-  'http://example.com/api/feature_flag/local_evaluation?token=TEST_API_KEY',
+  '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)]
@@ -336,6 +336,7 @@ describe('local evaluation', () => {
           groups: {},
           person_properties: { region: 'USA', email: 'a@b.com' },
           group_properties: {},
+          geoip_disable: true,
         }),
       })
     )
@@ -354,6 +355,7 @@ describe('local evaluation', () => {
           groups: {},
           person_properties: { doesnt_matter: '1' },
           group_properties: {},
+          geoip_disable: true,
         }),
       })
     )
@@ -1179,6 +1181,177 @@ describe('local evaluation', () => {
     expect(mockedFetch).not.toHaveBeenCalledWith(...anyDecideCall)
   })
 
+  it('computes complex cohorts locally', async () => {
+    const flags = {
+      flags: [
+        {
+          id: 1,
+          name: 'Beta Feature',
+          key: 'beta-feature',
+          is_simple_flag: false,
+          active: true,
+          rollout_percentage: 100,
+          filters: {
+            groups: [
+              {
+                properties: [
+                  {
+                    key: 'region',
+                    operator: 'exact',
+                    value: ['USA'],
+                    type: 'person',
+                  },
+                  { key: 'id', value: 98, type: 'cohort' },
+                ],
+                rollout_percentage: 100,
+              },
+            ],
+          },
+        },
+      ],
+      cohorts: {
+        '98': {
+          type: 'OR',
+          values: [
+            { key: 'id', value: 1, type: 'cohort' },
+            {
+              key: 'nation',
+              operator: 'exact',
+              value: ['UK'],
+              type: 'person',
+            },
+          ],
+        },
+        '1': {
+          type: 'AND',
+          values: [{ key: 'other', operator: 'exact', value: ['thing'], type: 'person' }],
+        },
+      },
+    }
+    mockedFetch.mockImplementation(
+      apiImplementation({
+        localFlags: flags,
+        decideFlags: {},
+      })
+    )
+
+    posthog = new PostHog('TEST_API_KEY', {
+      host: 'http://example.com',
+      personalApiKey: 'TEST_PERSONAL_API_KEY',
+    })
+
+    expect(
+      await posthog.getFeatureFlag('beta-feature', 'some-distinct-id', { personProperties: { region: 'UK' } })
+    ).toEqual(false)
+    expect(mockedFetch).not.toHaveBeenCalledWith(...anyDecideCall)
+
+    // # even though 'other' property is not present, the cohort should still match since it's an OR condition
+    expect(
+      await posthog.getFeatureFlag('beta-feature', 'some-distinct-id', {
+        personProperties: { region: 'USA', nation: 'UK' },
+      })
+    ).toEqual(true)
+    expect(mockedFetch).not.toHaveBeenCalledWith(...anyDecideCall)
+
+    // # even though 'other' property is not present, the cohort should still match since it's an OR condition
+    expect(
+      await posthog.getFeatureFlag('beta-feature', 'some-distinct-id', {
+        personProperties: { region: 'USA', other: 'thing' },
+      })
+    ).toEqual(true)
+    expect(mockedFetch).not.toHaveBeenCalledWith(...anyDecideCall)
+  })
+
+  it('computes complex cohorts with negation locally', async () => {
+    const flags = {
+      flags: [
+        {
+          id: 1,
+          name: 'Beta Feature',
+          key: 'beta-feature',
+          is_simple_flag: false,
+          active: true,
+          rollout_percentage: 100,
+          filters: {
+            groups: [
+              {
+                properties: [
+                  {
+                    key: 'region',
+                    operator: 'exact',
+                    value: ['USA'],
+                    type: 'person',
+                  },
+                  { key: 'id', value: 98, type: 'cohort' },
+                ],
+                rollout_percentage: 100,
+              },
+            ],
+          },
+        },
+      ],
+      cohorts: {
+        '98': {
+          type: 'OR',
+          values: [
+            { key: 'id', value: 1, type: 'cohort' },
+            {
+              key: 'nation',
+              operator: 'exact',
+              value: ['UK'],
+              type: 'person',
+            },
+          ],
+        },
+        '1': {
+          type: 'AND',
+          values: [{ key: 'other', operator: 'exact', value: ['thing'], type: 'person', negation: true }],
+        },
+      },
+    }
+    mockedFetch.mockImplementation(
+      apiImplementation({
+        localFlags: flags,
+        decideFlags: {},
+      })
+    )
+
+    posthog = new PostHog('TEST_API_KEY', {
+      host: 'http://example.com',
+      personalApiKey: 'TEST_PERSONAL_API_KEY',
+    })
+
+    expect(
+      await posthog.getFeatureFlag('beta-feature', 'some-distinct-id', { personProperties: { region: 'UK' } })
+    ).toEqual(false)
+    expect(mockedFetch).not.toHaveBeenCalledWith(...anyDecideCall)
+
+    // # even though 'other' property is not present, the cohort should still match since it's an OR condition
+    expect(
+      await posthog.getFeatureFlag('beta-feature', 'some-distinct-id', {
+        personProperties: { region: 'USA', nation: 'UK' },
+      })
+    ).toEqual(true)
+    expect(mockedFetch).not.toHaveBeenCalledWith(...anyDecideCall)
+
+    // # since 'other' is negated, we return False. Since 'nation' is not present, we can't tell whether the flag should be true or false, so go to decide
+    expect(
+      await posthog.getFeatureFlag('beta-feature', 'some-distinct-id', {
+        personProperties: { region: 'USA', other: 'thing' },
+      })
+    ).toEqual(false)
+    expect(mockedFetch).toHaveBeenCalledWith(...anyDecideCall)
+
+    mockedFetch.mockClear()
+
+    expect(
+      await posthog.getFeatureFlag('beta-feature', 'some-distinct-id', {
+        personProperties: { region: 'USA', other: 'thing2' },
+      })
+    ).toEqual(true)
+    expect(mockedFetch).not.toHaveBeenCalledWith(...anyDecideCall)
+  })
+
   it('gets feature flag with variant overrides', async () => {
     const flags = {
       flags: [

package/test/posthog-node.spec.ts

@@ -12,7 +12,8 @@ const mockedFetch = jest.mocked(fetch, true)
 const getLastBatchEvents = (): any[] | undefined => {
   expect(mockedFetch).toHaveBeenCalledWith('http://example.com/batch/', expect.objectContaining({ method: 'POST' }))
 
-  const call = mockedFetch.mock.calls.find((x) => (x[0] as string).includes('/batch/'))
+  // reverse mock calls array to get the last call
+  const call = mockedFetch.mock.calls.reverse().find((x) => (x[0] as string).includes('/batch/'))
   if (!call) {
     return undefined
   }
@@ -51,14 +52,21 @@ describe('PostHog Node.js', () => {
 
       jest.runOnlyPendingTimers()
       const batchEvents = getLastBatchEvents()
-      expect(batchEvents).toMatchObject([
+      expect(batchEvents).toEqual([
         {
           distinct_id: '123',
           event: 'test-event',
           properties: {
             $groups: { org: 123 },
             foo: 'bar',
+            $geoip_disable: true,
+            $lib: 'posthog-node',
+            $lib_version: '1.2.3',
           },
+          timestamp: expect.any(String),
+          type: 'capture',
+          library: 'posthog-node',
+          library_version: '1.2.3',
         },
       ])
     })
@@ -97,6 +105,7 @@ describe('PostHog Node.js', () => {
           properties: expect.objectContaining({
             $groups: { other_group: 'x' },
             foo: 'bar',
+            $geoip_disable: true,
           }),
           library: 'posthog-node',
           library_version: '1.2.3',
@@ -117,6 +126,7 @@ describe('PostHog Node.js', () => {
             $set: {
               foo: 'bar',
             },
+            $geoip_disable: true,
           },
         },
       ])
@@ -135,6 +145,7 @@ describe('PostHog Node.js', () => {
             $set: {
               foo: 'other',
             },
+            $geoip_disable: true,
           },
         },
       ])
@@ -152,6 +163,7 @@ describe('PostHog Node.js', () => {
           properties: {
             distinct_id: '123',
             alias: '1234',
+            $geoip_disable: true,
           },
         },
       ])
@@ -170,6 +182,83 @@ describe('PostHog Node.js', () => {
         },
       ])
     })
+
+    it('should respect disableGeoip setting if passed in', async () => {
+      expect(mockedFetch).toHaveBeenCalledTimes(0)
+      posthog.capture({
+        distinctId: '123',
+        event: 'test-event',
+        properties: { foo: 'bar' },
+        groups: { org: 123 },
+        disableGeoip: false,
+      })
+
+      jest.runOnlyPendingTimers()
+      const batchEvents = getLastBatchEvents()
+      expect(batchEvents?.[0].properties).toEqual({
+        $groups: { org: 123 },
+        foo: 'bar',
+        $lib: 'posthog-node',
+        $lib_version: '1.2.3',
+      })
+    })
+
+    it('should use default is set, and override on specific disableGeoip calls', async () => {
+      expect(mockedFetch).toHaveBeenCalledTimes(0)
+      const client = new PostHog('TEST_API_KEY', {
+        host: 'http://example.com',
+        disableGeoip: false,
+      })
+      client.debug()
+      client.capture({ distinctId: '123', event: 'test-event', properties: { foo: 'bar' }, groups: { org: 123 } })
+
+      jest.runOnlyPendingTimers()
+      let batchEvents = getLastBatchEvents()
+      expect(batchEvents?.[0].properties).toEqual({
+        $groups: { org: 123 },
+        foo: 'bar',
+        $lib: 'posthog-node',
+        $lib_version: '1.2.3',
+      })
+
+      client.capture({
+        distinctId: '123',
+        event: 'test-event',
+        properties: { foo: 'bar' },
+        groups: { org: 123 },
+        disableGeoip: true,
+      })
+
+      jest.runOnlyPendingTimers()
+      batchEvents = getLastBatchEvents()
+      console.warn(batchEvents)
+      expect(batchEvents?.[0].properties).toEqual({
+        $groups: { org: 123 },
+        foo: 'bar',
+        $lib: 'posthog-node',
+        $lib_version: '1.2.3',
+        $geoip_disable: true,
+      })
+
+      client.capture({
+        distinctId: '123',
+        event: 'test-event',
+        properties: { foo: 'bar' },
+        groups: { org: 123 },
+        disableGeoip: false,
+      })
+
+      jest.runOnlyPendingTimers()
+      batchEvents = getLastBatchEvents()
+      expect(batchEvents?.[0].properties).toEqual({
+        $groups: { org: 123 },
+        foo: 'bar',
+        $lib: 'posthog-node',
+        $lib_version: '1.2.3',
+      })
+
+      await client.shutdownAsync()
+    })
   })
 
   describe('shutdown', () => {
@@ -243,6 +332,7 @@ describe('PostHog Node.js', () => {
             $group_key: 'team-1',
             $group_set: { analytics: true },
             $lib: 'posthog-node',
+            $geoip_disable: true,
           },
         },
       ])
@@ -266,6 +356,7 @@ describe('PostHog Node.js', () => {
             $group_key: 'team-1',
             $group_set: { analytics: true },
             $lib: 'posthog-node',
+            $geoip_disable: true,
           },
         },
       ])
@@ -292,7 +383,6 @@ describe('PostHog Node.js', () => {
 
       posthog = new PostHog('TEST_API_KEY', {
         host: 'http://example.com',
-        // flushAt: 1,
       })
     })
 
@@ -302,6 +392,10 @@ describe('PostHog Node.js', () => {
         'variant'
       )
       expect(mockedFetch).toHaveBeenCalledTimes(1)
+      expect(mockedFetch).toHaveBeenCalledWith(
+        'http://example.com/decide/?v=3',
+        expect.objectContaining({ method: 'POST', body: expect.stringContaining('"geoip_disable":true') })
+      )
     })
 
     it('should do isFeatureEnabled', async () => {
@@ -347,12 +441,57 @@ describe('PostHog Node.js', () => {
             '$feature/feature-variant': 'variant',
             $lib: 'posthog-node',
             $lib_version: '1.2.3',
+            $geoip_disable: true,
           }),
         })
       )
 
       // no calls to `/local_evaluation`
 
+      expect(mockedFetch).not.toHaveBeenCalledWith(...anyLocalEvalCall)
+      expect(mockedFetch).toHaveBeenCalledWith(
+        'http://example.com/decide/?v=3',
+        expect.objectContaining({ method: 'POST', body: expect.stringContaining('"geoip_disable":true') })
+      )
+    })
+
+    it('captures feature flags with same geoip setting as capture', async () => {
+      mockedFetch.mockClear()
+      mockedFetch.mockClear()
+      expect(mockedFetch).toHaveBeenCalledTimes(0)
+
+      posthog = new PostHog('TEST_API_KEY', {
+        host: 'http://example.com',
+        flushAt: 1,
+      })
+
+      posthog.capture({
+        distinctId: 'distinct_id',
+        event: 'node test event',
+        sendFeatureFlags: true,
+        disableGeoip: false,
+      })
+
+      expect(mockedFetch).toHaveBeenCalledWith(
+        'http://example.com/decide/?v=3',
+        expect.objectContaining({ method: 'POST', body: expect.not.stringContaining('geoip_disable') })
+      )
+
+      jest.runOnlyPendingTimers()
+
+      await waitForPromises()
+
+      expect(getLastBatchEvents()?.[0].properties).toEqual({
+        $active_feature_flags: ['feature-1', 'feature-2', 'feature-variant'],
+        '$feature/feature-1': true,
+        '$feature/feature-2': true,
+        '$feature/feature-variant': 'variant',
+        $lib: 'posthog-node',
+        $lib_version: '1.2.3',
+      })
+
+      // no calls to `/local_evaluation`
+
       expect(mockedFetch).not.toHaveBeenCalledWith(...anyLocalEvalCall)
     })
 
@@ -462,6 +601,7 @@ describe('PostHog Node.js', () => {
             $lib: 'posthog-node',
             $lib_version: '1.2.3',
             locally_evaluated: true,
+            $geoip_disable: true,
           }),
         })
       )
@@ -482,6 +622,7 @@ describe('PostHog Node.js', () => {
         await posthog.getFeatureFlag('beta-feature', 'some-distinct-id2', {
           groups: { x: 'y' },
           personProperties: { region: 'USA', name: 'Aloha' },
+          disableGeoip: false,
         })
       ).toEqual(true)
       jest.runOnlyPendingTimers()
@@ -491,16 +632,16 @@ describe('PostHog Node.js', () => {
         expect.objectContaining({
           distinct_id: 'some-distinct-id2',
           event: '$feature_flag_called',
-          properties: expect.objectContaining({
-            $feature_flag: 'beta-feature',
-            $feature_flag_response: true,
-            $lib: 'posthog-node',
-            $lib_version: '1.2.3',
-            locally_evaluated: true,
-            $groups: { x: 'y' },
-          }),
         })
       )
+      expect(getLastBatchEvents()?.[0].properties).toEqual({
+        $feature_flag: 'beta-feature',
+        $feature_flag_response: true,
+        $lib: 'posthog-node',
+        $lib_version: '1.2.3',
+        locally_evaluated: true,
+        $groups: { x: 'y' },
+      })
       mockedFetch.mockClear()
 
       // # called for different user, but send configuration is false, so should NOT call capture again
@@ -559,6 +700,10 @@ describe('PostHog Node.js', () => {
         posthog.getFeatureFlagPayload('feature-variant', '123', 'variant', { groups: { org: '123' } })
       ).resolves.toEqual(2)
       expect(mockedFetch).toHaveBeenCalledTimes(1)
+      expect(mockedFetch).toHaveBeenCalledWith(
+        'http://example.com/decide/?v=3',
+        expect.objectContaining({ method: 'POST', body: expect.stringContaining('"geoip_disable":true') })
+      )
     })
 
     it('should do getFeatureFlagPayloads without matchValue', async () => {
@@ -568,5 +713,26 @@ describe('PostHog Node.js', () => {
       ).resolves.toEqual(2)
       expect(mockedFetch).toHaveBeenCalledTimes(1)
     })
+
+    it('should do getFeatureFlags with geoip disabled and enabled', async () => {
+      expect(mockedFetch).toHaveBeenCalledTimes(0)
+      await expect(
+        posthog.getFeatureFlagPayload('feature-variant', '123', 'variant', { groups: { org: '123' } })
+      ).resolves.toEqual(2)
+      expect(mockedFetch).toHaveBeenCalledTimes(1)
+      expect(mockedFetch).toHaveBeenCalledWith(
+        'http://example.com/decide/?v=3',
+        expect.objectContaining({ method: 'POST', body: expect.stringContaining('"geoip_disable":true') })
+      )
+
+      mockedFetch.mockClear()
+
+      await expect(posthog.isFeatureEnabled('feature-variant', '123', { disableGeoip: false })).resolves.toEqual(true)
+      expect(mockedFetch).toHaveBeenCalledTimes(1)
+      expect(mockedFetch).toHaveBeenCalledWith(
+        'http://example.com/decide/?v=3',
+        expect.objectContaining({ method: 'POST', body: expect.not.stringContaining('geoip_disable') })
+      )
+    })
   })
 })