posthog-node 2.2.2 → 2.3.0

package/test/feature-flags.spec.ts

@@ -12,10 +12,12 @@ const mockedFetch = jest.mocked(fetch, true)
 export const apiImplementation = ({
   localFlags,
   decideFlags,
+  decideFlagPayloads,
   decideStatus = 200,
 }: {
   localFlags?: any
   decideFlags?: any
+  decideFlagPayloads?: any
   decideStatus?: number
 }) => {
   return (url: any): Promise<any> => {
@@ -29,6 +31,7 @@ export const apiImplementation = ({
           } else {
             return Promise.resolve({
               featureFlags: decideFlags,
+              featureFlagPayloads: decideFlagPayloads,
             })
           }
         },
@@ -58,7 +61,7 @@ export const anyLocalEvalCall = [
   'http://example.com/api/feature_flag/local_evaluation?token=TEST_API_KEY',
   expect.any(Object),
 ]
-export const anyDecideCall = ['http://example.com/decide/?v=2', expect.any(Object)]
+export const anyDecideCall = ['http://example.com/decide/?v=3', expect.any(Object)]
 
 describe('local evaluation', () => {
   let posthog: PostHog
@@ -325,7 +328,7 @@ describe('local evaluation', () => {
       })
     ).toEqual('decide-fallback-value')
     expect(mockedFetch).toHaveBeenCalledWith(
-      'http://example.com/decide/?v=2',
+      'http://example.com/decide/?v=3',
       expect.objectContaining({
         body: JSON.stringify({
           token: 'TEST_API_KEY',
@@ -343,7 +346,7 @@ describe('local evaluation', () => {
       await posthog.getFeatureFlag('complex-flag', 'some-distinct-id', { personProperties: { doesnt_matter: '1' } })
     ).toEqual('decide-fallback-value')
     expect(mockedFetch).toHaveBeenCalledWith(
-      'http://example.com/decide/?v=2',
+      'http://example.com/decide/?v=3',
       expect.objectContaining({
         body: JSON.stringify({
           token: 'TEST_API_KEY',
@@ -687,6 +690,88 @@ describe('local evaluation', () => {
     mockedFetch.mockClear()
   })
 
+  it('get all payloads with fallback', async () => {
+    const flags = {
+      flags: [
+        {
+          id: 1,
+          name: 'Beta Feature',
+          key: 'beta-feature',
+          is_simple_flag: false,
+          active: true,
+          rollout_percentage: 100,
+          filters: {
+            groups: [
+              {
+                properties: [],
+                rollout_percentage: 100,
+              },
+            ],
+            payloads: {
+              true: 'some-payload',
+            },
+          },
+        },
+        {
+          id: 2,
+          name: 'Beta Feature',
+          key: 'disabled-feature',
+          is_simple_flag: false,
+          active: true,
+          filters: {
+            groups: [
+              {
+                properties: [],
+                rollout_percentage: 0,
+              },
+            ],
+            payloads: {
+              true: 'another-payload',
+            },
+          },
+        },
+        {
+          id: 3,
+          name: 'Beta Feature',
+          key: 'beta-feature2',
+          is_simple_flag: false,
+          active: true,
+          filters: {
+            groups: [
+              {
+                properties: [{ key: 'country', value: 'US' }],
+                rollout_percentage: 0,
+              },
+            ],
+            payloads: {
+              true: 'payload-3',
+            },
+          },
+        },
+      ],
+    }
+    mockedFetch.mockImplementation(
+      apiImplementation({
+        localFlags: flags,
+        decideFlags: { 'beta-feature': 'variant-1', 'beta-feature2': 'variant-2' },
+        decideFlagPayloads: { 'beta-feature': 100, 'beta-feature2': 300 },
+      })
+    )
+
+    posthog = new PostHog('TEST_API_KEY', {
+      host: 'http://example.com',
+      personalApiKey: 'TEST_PERSONAL_API_KEY',
+    })
+
+    // # beta-feature value overridden by /decide
+    expect((await posthog.getAllFlagsAndPayloads('distinct-id')).featureFlagPayloads).toEqual({
+      'beta-feature': 100,
+      'beta-feature2': 300,
+    })
+    expect(mockedFetch).toHaveBeenCalledWith(...anyDecideCall)
+    mockedFetch.mockClear()
+  })
+
   it('get all flags with fallback but only_locally_evaluated set', async () => {
     const flags = {
       flags: [
@@ -758,6 +843,87 @@ describe('local evaluation', () => {
     expect(mockedFetch).not.toHaveBeenCalledWith(...anyDecideCall)
   })
 
+  it('get all payloads with fallback but only_evaluate_locally set', async () => {
+    const flags = {
+      flags: [
+        {
+          id: 1,
+          name: 'Beta Feature',
+          key: 'beta-feature',
+          is_simple_flag: false,
+          active: true,
+          rollout_percentage: 100,
+          filters: {
+            groups: [
+              {
+                properties: [],
+                rollout_percentage: 100,
+              },
+            ],
+            payloads: {
+              true: 'some-payload',
+            },
+          },
+        },
+        {
+          id: 2,
+          name: 'Beta Feature',
+          key: 'disabled-feature',
+          is_simple_flag: false,
+          active: true,
+          filters: {
+            groups: [
+              {
+                properties: [],
+                rollout_percentage: 0,
+              },
+            ],
+            payloads: {
+              true: 'another-payload',
+            },
+          },
+        },
+        {
+          id: 3,
+          name: 'Beta Feature',
+          key: 'beta-feature2',
+          is_simple_flag: false,
+          active: true,
+          filters: {
+            groups: [
+              {
+                properties: [{ key: 'country', value: 'US' }],
+                rollout_percentage: 0,
+              },
+            ],
+            payloads: {
+              true: 'payload-3',
+            },
+          },
+        },
+      ],
+    }
+    mockedFetch.mockImplementation(
+      apiImplementation({
+        localFlags: flags,
+        decideFlags: { 'beta-feature': 'variant-1', 'beta-feature2': 'variant-2' },
+        decideFlagPayloads: { 'beta-feature': 100, 'beta-feature2': 300 },
+      })
+    )
+
+    posthog = new PostHog('TEST_API_KEY', {
+      host: 'http://example.com',
+      personalApiKey: 'TEST_PERSONAL_API_KEY',
+    })
+
+    expect(
+      (await posthog.getAllFlagsAndPayloads('distinct-id', { onlyEvaluateLocally: true })).featureFlagPayloads
+    ).toEqual({
+      'beta-feature': 'some-payload',
+    })
+    expect(mockedFetch).not.toHaveBeenCalledWith(...anyDecideCall)
+  })
+
   it('get all flags with fallback, with no local flags', async () => {
     const flags = {
       flags: [],
@@ -782,6 +948,31 @@ describe('local evaluation', () => {
     mockedFetch.mockClear()
   })
 
+  it('get all payloads with fallback, with no local payloads', async () => {
+    const flags = {
+      flags: [],
+    }
+    mockedFetch.mockImplementation(
+      apiImplementation({
+        localFlags: flags,
+        decideFlags: { 'beta-feature': 'variant-1', 'beta-feature2': 'variant-2' },
+        decideFlagPayloads: { 'beta-feature': 100, 'beta-feature2': 300 },
+      })
+    )
+
+    posthog = new PostHog('TEST_API_KEY', {
+      host: 'http://example.com',
+      personalApiKey: 'TEST_PERSONAL_API_KEY',
+    })
+
+    expect((await posthog.getAllFlagsAndPayloads('distinct-id')).featureFlagPayloads).toEqual({
+      'beta-feature': 100,
+      'beta-feature2': 300,
+    })
+    expect(mockedFetch).toHaveBeenCalledWith(...anyDecideCall)
+    mockedFetch.mockClear()
+  })
+
   it('get all flags with no fallback', async () => {
     const flags = {
       flags: [
@@ -834,6 +1025,64 @@ describe('local evaluation', () => {
     expect(mockedFetch).not.toHaveBeenCalledWith(...anyDecideCall)
   })
 
+  it('get all payloads with no fallback', async () => {
+    const flags = {
+      flags: [
+        {
+          id: 1,
+          name: 'Beta Feature',
+          key: 'beta-feature',
+          is_simple_flag: false,
+          active: true,
+          rollout_percentage: 100,
+          filters: {
+            groups: [
+              {
+                properties: [],
+                rollout_percentage: 100,
+              },
+            ],
+            payloads: {
+              true: 'new',
+            },
+          },
+        },
+        {
+          id: 2,
+          name: 'Beta Feature',
+          key: 'disabled-feature',
+          is_simple_flag: false,
+          active: true,
+          filters: {
+            groups: [
+              {
+                properties: [],
+                rollout_percentage: 0,
+              },
+            ],
+            payloads: {
+              true: 'some-payload',
+            },
+          },
+        },
+      ],
+    }
+    mockedFetch.mockImplementation(
+      apiImplementation({
+        localFlags: flags,
+        decideFlags: { 'beta-feature': 'variant-1', 'beta-feature2': 'variant-2' },
+      })
+    )
+
+    posthog = new PostHog('TEST_API_KEY', {
+      host: 'http://example.com',
+      personalApiKey: 'TEST_PERSONAL_API_KEY',
+    })
+
+    expect((await posthog.getAllFlagsAndPayloads('distinct-id')).featureFlagPayloads).toEqual({ 'beta-feature': 'new' })
+    expect(mockedFetch).not.toHaveBeenCalledWith(...anyDecideCall)
+  })
+
   it('computes inactive flags locally as well', async () => {
     const flags = {
       flags: [
@@ -1222,6 +1471,136 @@ describe('local evaluation', () => {
     // decide not called
     expect(mockedFetch).not.toHaveBeenCalledWith(...anyDecideCall)
   })
+
+  it('get feature flag payload based on boolean flag', async () => {
+    const flags = {
+      flags: [
+        {
+          id: 1,
+          name: 'Beta Feature',
+          key: 'person-flag',
+          is_simple_flag: true,
+          active: true,
+          filters: {
+            groups: [
+              {
+                properties: [
+                  {
+                    key: 'region',
+                    operator: 'exact',
+                    value: ['USA'],
+                    type: 'person',
+                  },
+                ],
+                rollout_percentage: null,
+              },
+            ],
+            payloads: {
+              true: {
+                log: 'all',
+              },
+            },
+          },
+        },
+      ],
+    }
+    mockedFetch.mockImplementation(apiImplementation({ localFlags: flags }))
+
+    posthog = new PostHog('TEST_API_KEY', {
+      host: 'http://example.com',
+      personalApiKey: 'TEST_PERSONAL_API_KEY',
+    })
+
+    expect(
+      await posthog.getFeatureFlagPayload('person-flag', 'some-distinct-id', true, {
+        personProperties: { region: 'USA' },
+      })
+    ).toEqual({
+      log: 'all',
+    })
+    expect(
+      await posthog.getFeatureFlagPayload('person-flag', 'some-distinct-id', undefined, {
+        personProperties: { region: 'USA' },
+      })
+    ).toEqual({
+      log: 'all',
+    })
+    expect(mockedFetch).toHaveBeenCalledWith(...anyLocalEvalCall)
+    // decide not called
+    expect(mockedFetch).not.toHaveBeenCalledWith(...anyDecideCall)
+  })
+
+  it('get feature flag payload on a multivariate', async () => {
+    const flags = {
+      flags: [
+        {
+          id: 1,
+          name: 'Beta Feature',
+          key: 'beta-feature',
+          is_simple_flag: true,
+          active: true,
+          filters: {
+            groups: [
+              {
+                properties: [
+                  {
+                    key: 'email',
+                    operator: 'exact',
+                    value: 'test@posthog.com',
+                    type: 'person',
+                  },
+                ],
+                rollout_percentage: 100,
+                variant: 'second-variant',
+              },
+              {
+                rollout_percentage: 50,
+                variant: 'first-variant',
+              },
+            ],
+            multivariate: {
+              variants: [
+                {
+                  key: 'first-variant',
+                  name: 'First Variant',
+                  rollout_percentage: 50,
+                },
+                {
+                  key: 'second-variant',
+                  name: 'Second Variant',
+                  rollout_percentage: 25,
+                },
+                {
+                  key: 'third-variant',
+                  name: 'Third Variant',
+                  rollout_percentage: 25,
+                },
+              ],
+            },
+            payloads: {
+              'second-variant': 2500,
+            },
+          },
+        },
+      ],
+    }
+    mockedFetch.mockImplementation(apiImplementation({ localFlags: flags }))
+
+    posthog = new PostHog('TEST_API_KEY', {
+      host: 'http://example.com',
+      personalApiKey: 'TEST_PERSONAL_API_KEY',
+    })
+
+    expect(
+      await posthog.getFeatureFlagPayload('beta-feature', 'test_id', 'second-variant', {
+        personProperties: { email: 'test@posthog.com' },
+      })
+    ).toEqual(2500)
+
+    expect(mockedFetch).toHaveBeenCalledWith(...anyLocalEvalCall)
+    // decide not called
+    expect(mockedFetch).not.toHaveBeenCalledWith(...anyDecideCall)
+  })
 })
 
 describe('match properties', () => {

package/test/posthog-node.spec.ts

@@ -138,6 +138,27 @@ describe('PostHog Node.js', () => {
     })
   })
 
+  describe('groupIdentify', () => {
+    it('should identify group with unique id', () => {
+      posthog.groupIdentify({ groupType: 'posthog', groupKey: 'team-1', properties: { analytics: true } })
+      jest.runOnlyPendingTimers()
+      const batchEvents = getLastBatchEvents()
+      console.log(batchEvents)
+      expect(batchEvents).toMatchObject([
+        {
+          distinct_id: '$posthog_team-1',
+          event: '$groupidentify',
+          properties: {
+            $group_type: 'posthog',
+            $group_key: 'team-1',
+            $group_set: { analytics: true },
+            $lib: 'posthog-node',
+          },
+        },
+      ])
+    })
+  })
+
   describe('feature flags', () => {
     beforeEach(() => {
       const mockFeatureFlags = {
@@ -146,7 +167,14 @@ describe('PostHog Node.js', () => {
         'feature-variant': 'variant',
       }
 
-      mockedFetch.mockImplementation(apiImplementation({ decideFlags: mockFeatureFlags }))
+      const mockFeatureFlagPayloads = {
+        'feature-1': { color: 'blue' },
+        'feature-variant': 2,
+      }
+
+      mockedFetch.mockImplementation(
+        apiImplementation({ decideFlags: mockFeatureFlags, decideFlagPayloads: mockFeatureFlagPayloads })
+      )
 
       posthog = new PostHog('TEST_API_KEY', {
         host: 'http://example.com',
@@ -186,7 +214,7 @@ describe('PostHog Node.js', () => {
       })
 
       expect(mockedFetch).toHaveBeenCalledWith(
-        'http://example.com/decide/?v=2',
+        'http://example.com/decide/?v=3',
         expect.objectContaining({ method: 'POST' })
       )
 
@@ -410,5 +438,21 @@ describe('PostHog Node.js', () => {
       expect(mockedFetch).toHaveBeenCalledWith(...anyDecideCall)
       expect(mockedFetch).not.toHaveBeenCalledWith('http://example.com/batch/', expect.any(Object))
     })
+
+    it('should do getFeatureFlagPayloads', async () => {
+      expect(mockedFetch).toHaveBeenCalledTimes(0)
+      await expect(
+        posthog.getFeatureFlagPayload('feature-variant', '123', 'variant', { groups: { org: '123' } })
+      ).resolves.toEqual(2)
+      expect(mockedFetch).toHaveBeenCalledTimes(1)
+    })
+
+    it('should do getFeatureFlagPayloads without matchValue', async () => {
+      expect(mockedFetch).toHaveBeenCalledTimes(0)
+      await expect(
+        posthog.getFeatureFlagPayload('feature-variant', '123', undefined, { groups: { org: '123' } })
+      ).resolves.toEqual(2)
+      expect(mockedFetch).toHaveBeenCalledTimes(1)
+    })
   })
 })