posthog-node 2.6.0 → 3.0.0

package/lib/posthog-core/src/index.d.ts

@@ -13,6 +13,7 @@ export declare abstract class PostHogCoreStateless {
     private removeDebugCallback?;
     private debugMode;
     private pendingPromises;
+    private disableGeoip;
     private _optoutOverride;
     protected _events: SimpleEventEmitter;
     protected _flushTimer?: any;
@@ -40,7 +41,7 @@ export declare abstract class PostHogCoreStateless {
     }, options?: PosthogCaptureOptions): this;
     protected aliasStateless(alias: string, distinctId: string, properties?: {
         [key: string]: any;
-    }): this;
+    }, options?: PosthogCaptureOptions): this;
     /***
      *** GROUPS
      ***/
@@ -49,12 +50,12 @@ export declare abstract class PostHogCoreStateless {
      *** FEATURE FLAGS
      ***/
     protected getDecide(distinctId: string, groups?: Record<string, string | number>, personProperties?: Record<string, string>, groupProperties?: Record<string, Record<string, string>>, extraPayload?: Record<string, any>): Promise<PostHogDecideResponse | undefined>;
-    protected getFeatureFlagStateless(key: string, distinctId: string, groups?: Record<string, string>, personProperties?: Record<string, string>, groupProperties?: Record<string, Record<string, string>>): Promise<boolean | string | undefined>;
-    protected getFeatureFlagPayloadStateless(key: string, distinctId: string, groups?: Record<string, string>, personProperties?: Record<string, string>, groupProperties?: Record<string, Record<string, string>>): Promise<JsonType | undefined>;
-    protected getFeatureFlagPayloadsStateless(distinctId: string, groups?: Record<string, string>, personProperties?: Record<string, string>, groupProperties?: Record<string, Record<string, string>>): Promise<PostHogDecideResponse['featureFlagPayloads'] | undefined>;
+    protected getFeatureFlagStateless(key: string, distinctId: string, groups?: Record<string, string>, personProperties?: Record<string, string>, groupProperties?: Record<string, Record<string, string>>, disableGeoip?: boolean): Promise<boolean | string | undefined>;
+    protected getFeatureFlagPayloadStateless(key: string, distinctId: string, groups?: Record<string, string>, personProperties?: Record<string, string>, groupProperties?: Record<string, Record<string, string>>, disableGeoip?: boolean): Promise<JsonType | undefined>;
+    protected getFeatureFlagPayloadsStateless(distinctId: string, groups?: Record<string, string>, personProperties?: Record<string, string>, groupProperties?: Record<string, Record<string, string>>, disableGeoip?: boolean): Promise<PostHogDecideResponse['featureFlagPayloads'] | undefined>;
     protected _parsePayload(response: any): any;
-    protected getFeatureFlagsStateless(distinctId: string, groups?: Record<string, string | number>, personProperties?: Record<string, string>, groupProperties?: Record<string, Record<string, string>>): Promise<PostHogDecideResponse['featureFlags'] | undefined>;
-    protected getFeatureFlagsAndPayloadsStateless(distinctId: string, groups?: Record<string, string | number>, personProperties?: Record<string, string>, groupProperties?: Record<string, Record<string, string>>): Promise<{
+    protected getFeatureFlagsStateless(distinctId: string, groups?: Record<string, string | number>, personProperties?: Record<string, string>, groupProperties?: Record<string, Record<string, string>>, disableGeoip?: boolean): Promise<PostHogDecideResponse['featureFlags'] | undefined>;
+    protected getFeatureFlagsAndPayloadsStateless(distinctId: string, groups?: Record<string, string | number>, personProperties?: Record<string, string>, groupProperties?: Record<string, Record<string, string>>, disableGeoip?: boolean): Promise<{
         flags: PostHogDecideResponse['featureFlags'] | undefined;
         payloads: PostHogDecideResponse['featureFlagPayloads'] | undefined;
     }>;

package/lib/posthog-core/src/types.d.ts

@@ -17,6 +17,7 @@ export declare type PosthogCoreOptions = {
     requestTimeout?: number;
     sessionExpirationTimeSeconds?: number;
     captureMode?: 'json' | 'form';
+    disableGeoip?: boolean;
 };
 export declare enum PostHogPersistedProperty {
     AnonymousId = "anonymous_id",
@@ -44,6 +45,7 @@ export declare type PostHogFetchOptions = {
 };
 export declare type PosthogCaptureOptions = {
     timestamp?: Date;
+    disableGeoip?: boolean;
 };
 export declare type PostHogFetchResponse = {
     status: number;

package/lib/posthog-node/src/posthog-node.d.ts

@@ -24,11 +24,12 @@ export declare class PostHog extends PostHogCoreStateless implements PostHogNode
     enable(): void;
     disable(): void;
     debug(enabled?: boolean): void;
-    capture({ distinctId, event, properties, groups, sendFeatureFlags, timestamp }: EventMessageV1): void;
-    identify({ distinctId, properties }: IdentifyMessageV1): void;
+    capture({ distinctId, event, properties, groups, sendFeatureFlags, timestamp, disableGeoip }: EventMessageV1): void;
+    identify({ distinctId, properties, disableGeoip }: IdentifyMessageV1): void;
     alias(data: {
         distinctId: string;
         alias: string;
+        disableGeoip?: boolean;
     }): void;
     getFeatureFlag(key: string, distinctId: string, options?: {
         groups?: Record<string, string>;
@@ -36,6 +37,7 @@ export declare class PostHog extends PostHogCoreStateless implements PostHogNode
         groupProperties?: Record<string, Record<string, string>>;
         onlyEvaluateLocally?: boolean;
         sendFeatureFlagEvents?: boolean;
+        disableGeoip?: boolean;
     }): Promise<string | boolean | undefined>;
     getFeatureFlagPayload(key: string, distinctId: string, matchValue?: string | boolean, options?: {
         groups?: Record<string, string>;
@@ -43,6 +45,7 @@ export declare class PostHog extends PostHogCoreStateless implements PostHogNode
         groupProperties?: Record<string, Record<string, string>>;
         onlyEvaluateLocally?: boolean;
         sendFeatureFlagEvents?: boolean;
+        disableGeoip?: boolean;
     }): Promise<JsonType | undefined>;
     isFeatureEnabled(key: string, distinctId: string, options?: {
         groups?: Record<string, string>;
@@ -50,20 +53,23 @@ export declare class PostHog extends PostHogCoreStateless implements PostHogNode
         groupProperties?: Record<string, Record<string, string>>;
         onlyEvaluateLocally?: boolean;
         sendFeatureFlagEvents?: boolean;
+        disableGeoip?: boolean;
     }): Promise<boolean | undefined>;
     getAllFlags(distinctId: string, options?: {
         groups?: Record<string, string>;
         personProperties?: Record<string, string>;
         groupProperties?: Record<string, Record<string, string>>;
         onlyEvaluateLocally?: boolean;
+        disableGeoip?: boolean;
     }): Promise<Record<string, string | boolean>>;
     getAllFlagsAndPayloads(distinctId: string, options?: {
         groups?: Record<string, string>;
         personProperties?: Record<string, string>;
         groupProperties?: Record<string, Record<string, string>>;
         onlyEvaluateLocally?: boolean;
+        disableGeoip?: boolean;
     }): Promise<PosthogFlagsAndPayloadsResponse>;
-    groupIdentify({ groupType, groupKey, properties, distinctId }: GroupIdentifyMessage): void;
+    groupIdentify({ groupType, groupKey, properties, distinctId, disableGeoip }: GroupIdentifyMessage): void;
     reloadFeatureFlags(): Promise<void>;
     shutdown(): void;
     shutdownAsync(): Promise<void>;

package/lib/posthog-node/src/types.d.ts

@@ -2,6 +2,7 @@ import { JsonType } from '../../posthog-core/src';
 export interface IdentifyMessageV1 {
     distinctId: string;
     properties?: Record<string | number, any>;
+    disableGeoip?: boolean;
 }
 export interface EventMessageV1 extends IdentifyMessageV1 {
     event: string;
@@ -14,6 +15,7 @@ export interface GroupIdentifyMessage {
     groupKey: string;
     properties?: Record<string | number, any>;
     distinctId?: string;
+    disableGeoip?: boolean;
 }
 export declare type PropertyGroup = {
     type: 'AND' | 'OR';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "posthog-node",
-  "version": "2.6.0",
+  "version": "3.0.0",
   "description": "PostHog Node.js integration",
   "repository": "PostHog/posthog-node",
   "scripts": {

package/src/posthog-node.ts

@@ -97,13 +97,13 @@ export class PostHog extends PostHogCoreStateless implements PostHogNodeV1 {
     this.featureFlagsPoller?.debug(enabled)
   }
 
-  capture({ distinctId, event, properties, groups, sendFeatureFlags, timestamp }: EventMessageV1): void {
+  capture({ distinctId, event, properties, groups, sendFeatureFlags, timestamp, disableGeoip }: EventMessageV1): void {
     const _capture = (props: EventMessageV1['properties']): void => {
-      super.captureStateless(distinctId, event, props, { timestamp })
+      super.captureStateless(distinctId, event, props, { timestamp, disableGeoip })
     }
 
     if (sendFeatureFlags) {
-      super.getFeatureFlagsStateless(distinctId, groups).then((flags) => {
+      super.getFeatureFlagsStateless(distinctId, groups, undefined, undefined, disableGeoip).then((flags) => {
         const featureVariantProperties: Record<string, string | boolean> = {}
         if (flags) {
           for (const [feature, variant] of Object.entries(flags)) {
@@ -124,17 +124,21 @@ export class PostHog extends PostHogCoreStateless implements PostHogNodeV1 {
     }
   }
 
-  identify({ distinctId, properties }: IdentifyMessageV1): void {
+  identify({ distinctId, properties, disableGeoip }: IdentifyMessageV1): void {
     // Catch properties passed as $set and move them to the top level
     const personProperties = properties?.$set || properties
 
-    super.identifyStateless(distinctId, {
-      $set: personProperties,
-    })
+    super.identifyStateless(
+      distinctId,
+      {
+        $set: personProperties,
+      },
+      { disableGeoip }
+    )
   }
 
-  alias(data: { distinctId: string; alias: string }): void {
-    super.aliasStateless(data.alias, data.distinctId)
+  alias(data: { distinctId: string; alias: string; disableGeoip?: boolean }): void {
+    super.aliasStateless(data.alias, data.distinctId, undefined, { disableGeoip: data.disableGeoip })
   }
 
   async getFeatureFlag(
@@ -146,9 +150,10 @@ export class PostHog extends PostHogCoreStateless implements PostHogNodeV1 {
       groupProperties?: Record<string, Record<string, string>>
       onlyEvaluateLocally?: boolean
       sendFeatureFlagEvents?: boolean
+      disableGeoip?: boolean
     }
   ): Promise<string | boolean | undefined> {
-    const { groups, personProperties, groupProperties } = options || {}
+    const { groups, personProperties, groupProperties, disableGeoip } = options || {}
     let { onlyEvaluateLocally, sendFeatureFlagEvents } = options || {}
 
     // set defaults
@@ -170,7 +175,14 @@ export class PostHog extends PostHogCoreStateless implements PostHogNodeV1 {
     const flagWasLocallyEvaluated = response !== undefined
 
     if (!flagWasLocallyEvaluated && !onlyEvaluateLocally) {
-      response = await super.getFeatureFlagStateless(key, distinctId, groups, personProperties, groupProperties)
+      response = await super.getFeatureFlagStateless(
+        key,
+        distinctId,
+        groups,
+        personProperties,
+        groupProperties,
+        disableGeoip
+      )
     }
 
     const featureFlagReportedKey = `${key}_${response}`
@@ -197,6 +209,7 @@ export class PostHog extends PostHogCoreStateless implements PostHogNodeV1 {
           locally_evaluated: flagWasLocallyEvaluated,
         },
         groups,
+        disableGeoip,
       })
     }
     return response
@@ -212,9 +225,10 @@ export class PostHog extends PostHogCoreStateless implements PostHogNodeV1 {
       groupProperties?: Record<string, Record<string, string>>
       onlyEvaluateLocally?: boolean
       sendFeatureFlagEvents?: boolean
+      disableGeoip?: boolean
     }
   ): Promise<JsonType | undefined> {
-    const { groups, personProperties, groupProperties } = options || {}
+    const { groups, personProperties, groupProperties, disableGeoip } = options || {}
     let { onlyEvaluateLocally, sendFeatureFlagEvents } = options || {}
     let response = undefined
 
@@ -246,7 +260,14 @@ export class PostHog extends PostHogCoreStateless implements PostHogNodeV1 {
     const payloadWasLocallyEvaluated = response !== undefined
 
     if (!payloadWasLocallyEvaluated && !onlyEvaluateLocally) {
-      response = await super.getFeatureFlagPayloadStateless(key, distinctId, groups, personProperties, groupProperties)
+      response = await super.getFeatureFlagPayloadStateless(
+        key,
+        distinctId,
+        groups,
+        personProperties,
+        groupProperties,
+        disableGeoip
+      )
     }
 
     try {
@@ -265,6 +286,7 @@ export class PostHog extends PostHogCoreStateless implements PostHogNodeV1 {
       groupProperties?: Record<string, Record<string, string>>
       onlyEvaluateLocally?: boolean
       sendFeatureFlagEvents?: boolean
+      disableGeoip?: boolean
     }
   ): Promise<boolean | undefined> {
     const feat = await this.getFeatureFlag(key, distinctId, options)
@@ -281,6 +303,7 @@ export class PostHog extends PostHogCoreStateless implements PostHogNodeV1 {
       personProperties?: Record<string, string>
       groupProperties?: Record<string, Record<string, string>>
       onlyEvaluateLocally?: boolean
+      disableGeoip?: boolean
     }
   ): Promise<Record<string, string | boolean>> {
     const response = await this.getAllFlagsAndPayloads(distinctId, options)
@@ -294,9 +317,10 @@ export class PostHog extends PostHogCoreStateless implements PostHogNodeV1 {
       personProperties?: Record<string, string>
       groupProperties?: Record<string, Record<string, string>>
       onlyEvaluateLocally?: boolean
+      disableGeoip?: boolean
     }
   ): Promise<PosthogFlagsAndPayloadsResponse> {
-    const { groups, personProperties, groupProperties } = options || {}
+    const { groups, personProperties, groupProperties, disableGeoip } = options || {}
     let { onlyEvaluateLocally } = options || {}
 
     // set defaults
@@ -325,7 +349,8 @@ export class PostHog extends PostHogCoreStateless implements PostHogNodeV1 {
         distinctId,
         groups,
         personProperties,
-        groupProperties
+        groupProperties,
+        disableGeoip
       )
       featureFlags = {
         ...featureFlags,
@@ -340,8 +365,8 @@ export class PostHog extends PostHogCoreStateless implements PostHogNodeV1 {
     return { featureFlags, featureFlagPayloads }
   }
 
-  groupIdentify({ groupType, groupKey, properties, distinctId }: GroupIdentifyMessage): void {
-    super.groupIdentifyStateless(groupType, groupKey, properties, undefined, distinctId)
+  groupIdentify({ groupType, groupKey, properties, distinctId, disableGeoip }: GroupIdentifyMessage): void {
+    super.groupIdentifyStateless(groupType, groupKey, properties, { disableGeoip }, distinctId)
   }
 
   async reloadFeatureFlags(): Promise<void> {

package/src/types.ts

@@ -3,6 +3,7 @@ import { JsonType } from '../../posthog-core/src'
 export interface IdentifyMessageV1 {
   distinctId: string
   properties?: Record<string | number, any>
+  disableGeoip?: boolean
 }
 
 export interface EventMessageV1 extends IdentifyMessageV1 {
@@ -17,6 +18,7 @@ export interface GroupIdentifyMessage {
   groupKey: string // Unique identifier for the group
   properties?: Record<string | number, any>
   distinctId?: string // optional distinctId to associate message with a person
+  disableGeoip?: boolean
 }
 
 export type PropertyGroup = {

package/test/feature-flags.spec.ts

@@ -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,
         }),
       })
     )

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') })
+      )
+    })
   })
 })