posthog-node 4.5.1 → 4.6.0

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

@@ -58,8 +58,10 @@ declare class FeatureFlagsPoller {
     }[];
     loadFeatureFlags(forceReload?: boolean): Promise<void>;
     _loadFeatureFlags(): Promise<void>;
+    private getPersonalApiKeyRequestOptions;
     _requestFeatureFlagDefinitions(): Promise<PostHogFetchResponse>;
     stopPoller(): void;
+    _requestRemoteConfigPayload(flagKey: string): Promise<PostHogFetchResponse>;
 }
 declare function matchProperty(property: FeatureFlagCondition['properties'][number], propertyValues: Record<string, any>, warnFunction?: (msg: string) => void): boolean;
 declare function relativeDateParseForFeatureFlagMatching(value: string): Date | null;

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

@@ -50,6 +50,7 @@ export declare class PostHog extends PostHogCoreStateless implements PostHogNode
         sendFeatureFlagEvents?: boolean;
         disableGeoip?: boolean;
     }): Promise<JsonType | undefined>;
+    getRemoteConfigPayload(flagKey: string): Promise<JsonType | undefined>;
     isFeatureEnabled(key: string, distinctId: string, options?: {
         groups?: Record<string, string>;
         personProperties?: Record<string, string>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "posthog-node",
-  "version": "4.5.1",
+  "version": "4.6.0",
   "description": "PostHog Node.js integration",
   "repository": {
     "type": "git",

package/src/feature-flags.ts

@@ -419,17 +419,21 @@ class FeatureFlagsPoller {
     }
   }
 
-  async _requestFeatureFlagDefinitions(): Promise<PostHogFetchResponse> {
-    const url = `${this.host}/api/feature_flag/local_evaluation?token=${this.projectApiKey}&send_cohorts`
-
-    const options: PostHogFetchOptions = {
-      method: 'GET',
+  private getPersonalApiKeyRequestOptions(method: 'GET' | 'POST' | 'PUT' | 'PATCH' = 'GET'): PostHogFetchOptions {
+    return {
+      method,
       headers: {
         ...this.customHeaders,
         'Content-Type': 'application/json',
         Authorization: `Bearer ${this.personalApiKey}`,
       },
     }
+  }
+
+  async _requestFeatureFlagDefinitions(): Promise<PostHogFetchResponse> {
+    const url = `${this.host}/api/feature_flag/local_evaluation?token=${this.projectApiKey}&send_cohorts`
+
+    const options = this.getPersonalApiKeyRequestOptions()
 
     let abortTimeout = null
 
@@ -451,6 +455,26 @@ class FeatureFlagsPoller {
   stopPoller(): void {
     clearTimeout(this.poller)
   }
+
+  _requestRemoteConfigPayload(flagKey: string): Promise<PostHogFetchResponse> {
+    const url = `${this.host}/api/projects/@current/feature_flags/${flagKey}/remote_config/`
+
+    const options = this.getPersonalApiKeyRequestOptions()
+
+    let abortTimeout = null
+    if (this.timeout && typeof this.timeout === 'number') {
+      const controller = new AbortController()
+      abortTimeout = safeSetTimeout(() => {
+        controller.abort()
+      }, this.timeout)
+      options.signal = controller.signal
+    }
+    try {
+      return this.fetch(url, options)
+    } finally {
+      clearTimeout(abortTimeout)
+    }
+  }
 }
 
 // # This function takes a distinct_id and a feature flag key and returns a float between 0 and 1.

package/src/posthog-node.ts

@@ -135,8 +135,13 @@ export class PostHog extends PostHogCoreStateless implements PostHogNodeV1 {
           return await _getFlags(distinctId, groups, disableGeoip)
         }
 
+        if (event === '$feature_flag_called') {
+          // If we're capturing a $feature_flag_called event, we don't want to enrich the event with cached flags that may be out of date.
+          return {}
+        }
+
         if ((this.featureFlagsPoller?.featureFlags?.length || 0) > 0) {
-          // Otherwise we may as well check for the flags locally and include them if there
+          // Otherwise we may as well check for the flags locally and include them if they are already loaded
           const groupsWithStringValues: Record<string, string> = {}
           for (const [key, value] of Object.entries(groups || {})) {
             groupsWithStringValues[key] = String(value)
@@ -354,6 +359,10 @@ export class PostHog extends PostHogCoreStateless implements PostHogNodeV1 {
     return response
   }
 
+  async getRemoteConfigPayload(flagKey: string): Promise<JsonType | undefined> {
+    return (await this.featureFlagsPoller?._requestRemoteConfigPayload(flagKey))?.json()
+  }
+
   async isFeatureEnabled(
     key: string,
     distinctId: string,

package/test/feature-flags.spec.ts

@@ -5,6 +5,7 @@ import { matchProperty, InconclusiveMatchError, relativeDateParseForFeatureFlagM
 jest.mock('../src/fetch')
 import fetch from '../src/fetch'
 import { anyDecideCall, anyLocalEvalCall, apiImplementation } from './test-utils'
+import { waitForPromises } from 'posthog-core/test/test-utils/test-utils'
 
 jest.spyOn(console, 'debug').mockImplementation()
 
@@ -1796,6 +1797,84 @@ describe('local evaluation', () => {
   })
 })
 
+describe('getFeatureFlag', () => {
+  it('should capture $feature_flag_called when called, but not add all cached flags', async () => {
+    const flags = {
+      flags: [
+        {
+          id: 1,
+          name: 'Beta Feature',
+          key: 'complex-flag',
+          active: true,
+          filters: {
+            groups: [
+              {
+                variant: null,
+                properties: [{ key: 'region', type: 'person', value: 'USA', operator: 'exact' }],
+                rollout_percentage: 100,
+              },
+            ],
+          },
+        },
+        {
+          id: 2,
+          name: 'Gamma Feature',
+          key: 'simple-flag',
+          active: true,
+          filters: {
+            groups: [
+              {
+                variant: null,
+                properties: [],
+                rollout_percentage: 100,
+              },
+            ],
+          },
+        },
+      ],
+    }
+    mockedFetch.mockImplementation(apiImplementation({ localFlags: flags }))
+    const posthog = new PostHog('TEST_API_KEY', {
+      host: 'http://example.com',
+      personalApiKey: 'TEST_PERSONAL_API_KEY',
+      ...posthogImmediateResolveOptions,
+    })
+    let capturedMessage: any
+    posthog.on('capture', (message) => {
+      capturedMessage = message
+    })
+
+    expect(
+      await posthog.getFeatureFlag('complex-flag', 'some-distinct-id', {
+        personProperties: {
+          region: 'USA',
+        } as unknown as Record<string, string>,
+      })
+    ).toEqual(true)
+
+    await waitForPromises()
+
+    expect(capturedMessage).toMatchObject({
+      distinct_id: 'some-distinct-id',
+      event: '$feature_flag_called',
+      library: posthog.getLibraryId(),
+      library_version: posthog.getLibraryVersion(),
+      properties: {
+        '$feature/complex-flag': true,
+        $feature_flag: 'complex-flag',
+        $feature_flag_response: true,
+        $groups: undefined,
+        $lib: posthog.getLibraryId(),
+        $lib_version: posthog.getLibraryVersion(),
+        locally_evaluated: true,
+      },
+    })
+
+    expect(capturedMessage.properties).not.toHaveProperty('$active_feature_flags')
+    expect(capturedMessage.properties).not.toHaveProperty('$feature/simple-flag')
+  })
+})
+
 describe('match properties', () => {
   jest.useFakeTimers()
 

package/test/posthog-node.spec.ts

@@ -1078,7 +1078,9 @@ describe('PostHog Node.js', () => {
       expect(mockedFetch).toHaveBeenCalledTimes(0)
 
       await expect(posthog.getFeatureFlagPayload('false-flag', '123', true)).resolves.toEqual(300)
-      expect(mockedFetch).toHaveBeenCalledTimes(0)
+      // Check no non-batch API calls were made
+      const additionalNonBatchCalls = mockedFetch.mock.calls.filter((call) => !call[0].includes('/batch'))
+      expect(additionalNonBatchCalls.length).toBe(0)
     })
 
     it('should not double parse json with getFeatureFlagPayloads and server eval', async () => {