posthog-node 4.1.0 → 4.2.0

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

@@ -16,6 +16,7 @@ export declare abstract class PostHogCoreStateless {
     private captureMode;
     private removeDebugCallback?;
     private disableGeoip;
+    private historicalMigration;
     disabled: boolean;
     private defaultOptIn;
     private pendingPromises;

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

@@ -40,6 +40,8 @@ export declare type PostHogCoreOptions = {
     /** Whether to post events to PostHog in JSON or compressed format. Defaults to 'form' */
     captureMode?: 'json' | 'form';
     disableGeoip?: boolean;
+    /** Special flag to indicate ingested data is for a historical migration. */
+    historicalMigration?: boolean;
 };
 export declare enum PostHogPersistedProperty {
     AnonymousId = "anonymous_id",

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

@@ -60,6 +60,6 @@ declare class FeatureFlagsPoller {
     _requestFeatureFlagDefinitions(): Promise<PostHogFetchResponse>;
     stopPoller(): void;
 }
-declare function matchProperty(property: FeatureFlagCondition['properties'][number], propertyValues: Record<string, any>): boolean;
+declare function matchProperty(property: FeatureFlagCondition['properties'][number], propertyValues: Record<string, any>, warnFunction?: (msg: string) => void): boolean;
 declare function relativeDateParseForFeatureFlagMatching(value: string): Date | null;
 export { FeatureFlagsPoller, matchProperty, relativeDateParseForFeatureFlagMatching, InconclusiveMatchError, ClientError, };

package/package.json

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

package/src/feature-flags.ts

@@ -7,6 +7,7 @@ import fetch from './fetch'
 // eslint-disable-next-line
 const LONG_SCALE = 0xfffffffffffffff
 
+const NULL_VALUES_ALLOWED_OPERATORS = ['is_not']
 class ClientError extends Error {
   constructor(message: string) {
     super()
@@ -305,7 +306,11 @@ class FeatureFlagsPoller {
     properties: Record<string, string>
   ): boolean {
     const rolloutPercentage = condition.rollout_percentage
-
+    const warnFunction = (msg: string): void => {
+      if (this.debugMode) {
+        console.warn(msg)
+      }
+    }
     if ((condition.properties || []).length > 0) {
       for (const prop of condition.properties) {
         const propertyType = prop.type
@@ -314,7 +319,7 @@ class FeatureFlagsPoller {
         if (propertyType === 'cohort') {
           matches = matchCohort(prop, properties, this.cohorts, this.debugMode)
         } else {
-          matches = matchProperty(prop, properties)
+          matches = matchProperty(prop, properties, warnFunction)
         }
 
         if (!matches) {
@@ -461,7 +466,8 @@ function _hash(key: string, distinctId: string, salt: string = ''): number {
 
 function matchProperty(
   property: FeatureFlagCondition['properties'][number],
-  propertyValues: Record<string, any>
+  propertyValues: Record<string, any>,
+  warnFunction?: (msg: string) => void
 ): boolean {
   const key = property.key
   const value = property.value
@@ -474,6 +480,15 @@ function matchProperty(
   }
 
   const overrideValue = propertyValues[key]
+  if (overrideValue == null && !NULL_VALUES_ALLOWED_OPERATORS.includes(operator)) {
+    // if the value is null, just fail the feature flag comparison
+    // this isn't an InconclusiveMatchError because the property value was provided.
+    if (warnFunction) {
+      warnFunction(`Property ${key} cannot have a value of null/undefined with the ${operator} operator`)
+    }
+
+    return false
+  }
 
   function computeExactMatch(value: any, overrideValue: any): boolean {
     if (Array.isArray(value)) {

package/test/feature-flags.spec.ts

@@ -24,6 +24,74 @@ describe('local evaluation', () => {
     await posthog.shutdown()
   })
 
+  it('evaluates person properties with undefined property values', async () => {
+    const flags = {
+      flags: [
+        {
+          id: 1,
+          name: 'Beta Feature',
+          key: 'person-flag',
+          is_simple_flag: true,
+          active: true,
+          filters: {
+            groups: [
+              {
+                variant: null,
+                properties: [
+                  {
+                    key: 'latestBuildVersion',
+                    type: 'person',
+                    value: '.+',
+                    operator: 'regex',
+                  },
+                  {
+                    key: 'latestBuildVersionMajor',
+                    type: 'person',
+                    value: '23',
+                    operator: 'gt',
+                  },
+                  {
+                    key: 'latestBuildVersionMinor',
+                    type: 'person',
+                    value: '31',
+                    operator: 'gt',
+                  },
+                  {
+                    key: 'latestBuildVersionPatch',
+                    type: 'person',
+                    value: '0',
+                    operator: 'gt',
+                  },
+                ],
+                rollout_percentage: 100,
+              },
+            ],
+          },
+        },
+      ],
+    }
+    mockedFetch.mockImplementation(apiImplementation({ localFlags: flags }))
+
+    posthog = new PostHog('TEST_API_KEY', {
+      host: 'http://example.com',
+      personalApiKey: 'TEST_PERSONAL_API_KEY',
+      ...posthogImmediateResolveOptions,
+    })
+
+    expect(
+      await posthog.getFeatureFlag('person-flag', 'some-distinct-id', {
+        personProperties: {
+          latestBuildVersion: undefined,
+          latestBuildVersionMajor: undefined,
+          latestBuildVersionMinor: undefined,
+          latestBuildVersionPatch: undefined,
+        } as unknown as Record<string, string>,
+      })
+    ).toEqual(false)
+
+    expect(mockedFetch).toHaveBeenCalledWith(...anyLocalEvalCall)
+  })
+
   it('evaluates person properties', async () => {
     const flags = {
       flags: [
@@ -1824,7 +1892,7 @@ describe('match properties', () => {
     expect(matchProperty(property_a, { key: 'value' })).toBe(true)
     expect(matchProperty(property_a, { key: 'value2' })).toBe(true)
     expect(matchProperty(property_a, { key: '' })).toBe(true)
-    expect(matchProperty(property_a, { key: undefined })).toBe(true)
+    expect(matchProperty(property_a, { key: undefined })).toBe(false)
 
     expect(() => matchProperty(property_a, { key2: 'value' })).toThrow(InconclusiveMatchError)
     expect(() => matchProperty(property_a, {})).toThrow(InconclusiveMatchError)
@@ -2065,48 +2133,109 @@ describe('match properties', () => {
     expect(matchProperty(property_a, { key: 'nul' })).toBe(true)
 
     const property_b = { key: 'key', value: 'null', operator: 'is_set' }
-    expect(matchProperty(property_b, { key: null })).toBe(true)
-    expect(matchProperty(property_b, { key: undefined })).toBe(true)
+    expect(matchProperty(property_b, { key: null })).toBe(false)
+    expect(matchProperty(property_b, { key: undefined })).toBe(false)
     expect(matchProperty(property_b, { key: 'null' })).toBe(true)
 
     const property_c = { key: 'key', value: 'undefined', operator: 'icontains' }
     expect(matchProperty(property_c, { key: null })).toBe(false)
-    expect(matchProperty(property_c, { key: undefined })).toBe(true)
+    expect(matchProperty(property_c, { key: undefined })).toBe(false)
     expect(matchProperty(property_c, { key: 'lol' })).toBe(false)
 
     const property_d = { key: 'key', value: 'undefined', operator: 'regex' }
     expect(matchProperty(property_d, { key: null })).toBe(false)
-    expect(matchProperty(property_d, { key: undefined })).toBe(true)
+    expect(matchProperty(property_d, { key: undefined })).toBe(false)
+
+    const property_e = { key: 'key', value: 1, operator: 'gt' }
+    expect(matchProperty(property_e, { key: null })).toBe(false)
+    expect(matchProperty(property_e, { key: undefined })).toBe(false)
+
+    const property_f = { key: 'key', value: 1, operator: 'lt' }
+    expect(matchProperty(property_f, { key: null })).toBe(false)
+    expect(matchProperty(property_f, { key: undefined })).toBe(false)
+
+    const property_g = { key: 'key', value: 'xyz', operator: 'gte' }
+    expect(matchProperty(property_g, { key: null })).toBe(false)
+    expect(matchProperty(property_g, { key: undefined })).toBe(false)
+
+    const property_h = { key: 'key', value: 'Oo', operator: 'lte' }
+    expect(matchProperty(property_h, { key: null })).toBe(false)
+    expect(matchProperty(property_h, { key: undefined })).toBe(false)
+
+    const property_h_lower = { key: 'key', value: 'oo', operator: 'lte' }
+    expect(matchProperty(property_h_lower, { key: null })).toBe(false)
+    expect(matchProperty(property_h_lower, { key: undefined })).toBe(false)
+
+    const property_i = { key: 'key', value: '2022-05-01', operator: 'is_date_before' }
+
+    expect(matchProperty(property_i, { key: null })).toBe(false)
+    expect(matchProperty(property_i, { key: undefined })).toBe(false)
+
+    const property_j = { key: 'key', value: '2022-05-01', operator: 'is_date_after' }
+    expect(matchProperty(property_j, { key: null })).toBe(false)
+
+    const property_k = { key: 'key', value: '2022-05-01', operator: 'is_date_before' }
+    expect(matchProperty(property_k, { key: null })).toBe(false)
+  })
+
+  it('null or undefined override value', () => {
+    const property_a = { key: 'key', value: 'ab', operator: 'is_not' }
+    expect(matchProperty(property_a, { key: null })).toBe(true)
+    expect(matchProperty(property_a, { key: undefined })).toBe(true)
+    expect(matchProperty(property_a, { key: 'null' })).toBe(true)
+    expect(matchProperty(property_a, { key: 'nul' })).toBe(true)
+
+    const property_b = { key: 'key', value: 'null', operator: 'is_set' }
+    expect(matchProperty(property_b, { key: null })).toBe(false)
+    expect(matchProperty(property_b, { key: undefined })).toBe(false)
+    expect(matchProperty(property_b, { key: 'null' })).toBe(true)
+
+    const property_c = { key: 'key', value: 'app.posthog.com', operator: 'icontains' }
+    expect(matchProperty(property_c, { key: null })).toBe(false)
+    expect(matchProperty(property_c, { key: undefined })).toBe(false)
+    expect(matchProperty(property_c, { key: 'lol' })).toBe(false)
+    expect(matchProperty(property_c, { key: 'https://app.posthog.com' })).toBe(true)
+
+    const property_d = { key: 'key', value: '.+', operator: 'regex' }
+    expect(matchProperty(property_d, { key: null })).toBe(false)
+    expect(matchProperty(property_d, { key: undefined })).toBe(false)
+    expect(matchProperty(property_d, { key: 'i_am_a_value' })).toBe(true)
 
     const property_e = { key: 'key', value: 1, operator: 'gt' }
-    expect(matchProperty(property_e, { key: null })).toBe(true)
-    expect(matchProperty(property_e, { key: undefined })).toBe(true)
+    expect(matchProperty(property_e, { key: null })).toBe(false)
+    expect(matchProperty(property_e, { key: undefined })).toBe(false)
+    expect(matchProperty(property_e, { key: 1 })).toBe(false)
+    expect(matchProperty(property_e, { key: 2 })).toBe(true)
 
     const property_f = { key: 'key', value: 1, operator: 'lt' }
     expect(matchProperty(property_f, { key: null })).toBe(false)
     expect(matchProperty(property_f, { key: undefined })).toBe(false)
+    expect(matchProperty(property_f, { key: 0 })).toBe(true)
 
     const property_g = { key: 'key', value: 'xyz', operator: 'gte' }
     expect(matchProperty(property_g, { key: null })).toBe(false)
     expect(matchProperty(property_g, { key: undefined })).toBe(false)
+    expect(matchProperty(property_g, { key: 'xyz' })).toBe(true)
 
     const property_h = { key: 'key', value: 'Oo', operator: 'lte' }
     expect(matchProperty(property_h, { key: null })).toBe(false)
     expect(matchProperty(property_h, { key: undefined })).toBe(false)
+    expect(matchProperty(property_h, { key: 'Oo' })).toBe(true)
 
     const property_h_lower = { key: 'key', value: 'oo', operator: 'lte' }
-    expect(matchProperty(property_h_lower, { key: null })).toBe(true)
+    expect(matchProperty(property_h_lower, { key: null })).toBe(false)
     expect(matchProperty(property_h_lower, { key: undefined })).toBe(false)
+    expect(matchProperty(property_h_lower, { key: 'oo' })).toBe(true)
 
     const property_i = { key: 'key', value: '2022-05-01', operator: 'is_date_before' }
-    expect(() => matchProperty(property_i, { key: null })).toThrow(InconclusiveMatchError)
-    expect(() => matchProperty(property_i, { key: undefined })).toThrow(InconclusiveMatchError)
+    expect(matchProperty(property_i, { key: null })).toBe(false)
+    expect(matchProperty(property_i, { key: undefined })).toBe(false)
 
     const property_j = { key: 'key', value: '2022-05-01', operator: 'is_date_after' }
-    expect(() => matchProperty(property_j, { key: null })).toThrow(InconclusiveMatchError)
+    expect(matchProperty(property_j, { key: null })).toBe(false)
 
     const property_k = { key: 'key', value: '2022-05-01', operator: 'is_date_before' }
-    expect(() => matchProperty(property_k, { key: null })).toThrow(InconclusiveMatchError)
+    expect(matchProperty(property_k, { key: null })).toBe(false)
   })
 
   it('with invalid operator', () => {