posthog-node 2.0.2 → 2.2.0

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

@@ -26,6 +26,7 @@ export declare abstract class PostHogCore {
     private _optoutOverride;
     constructor(apiKey: string, options?: PosthogCoreOptions);
     protected getCommonEventProperties(): any;
+    protected setupBootstrap(options?: Partial<PosthogCoreOptions>): void;
     private get props();
     private set props(value);
     private clearProps;
@@ -76,6 +77,7 @@ export declare abstract class PostHogCore {
      ***/
     private decideAsync;
     private _decideAsync;
+    private setKnownFeatureFlags;
     getFeatureFlag(key: string): boolean | string | undefined;
     getFeatureFlags(): PostHogDecideResponse['featureFlags'] | undefined;
     isFeatureEnabled(key: string): boolean | undefined;

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

@@ -1,3 +1,4 @@
+/// <reference types="node" />
 export declare type PosthogCoreOptions = {
     host?: string;
     flushAt?: number;
@@ -5,6 +6,11 @@ export declare type PosthogCoreOptions = {
     enable?: boolean;
     sendFeatureFlagEvent?: boolean;
     preloadFeatureFlags?: boolean;
+    bootstrap?: {
+        distinctId?: string;
+        isIdentifiedId?: boolean;
+        featureFlags?: Record<string, boolean | string>;
+    };
     fetchRetryCount?: number;
     fetchRetryDelay?: number;
     sessionExpirationTimeSeconds?: number;
@@ -30,7 +36,8 @@ export declare type PostHogFetchOptions = {
     headers: {
         [key: string]: string;
     };
-    body: string;
+    body?: string;
+    signal?: AbortSignal;
 };
 export declare type PostHogFetchResponse = {
     status: number;

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

@@ -1,6 +1,6 @@
 /// <reference types="node" />
 import { FeatureFlagCondition, PostHogFeatureFlag } from './types';
-import { ResponseData } from 'undici/types/dispatcher';
+import { PostHogFetchOptions, PostHogFetchResponse } from 'posthog-core/src';
 declare class ClientError extends Error {
     constructor(message: string);
 }
@@ -13,6 +13,7 @@ declare type FeatureFlagsPollerOptions = {
     host: string;
     pollingInterval: number;
     timeout?: number;
+    fetch?: (url: string, options: PostHogFetchOptions) => Promise<PostHogFetchResponse>;
 };
 declare class FeatureFlagsPoller {
     pollingInterval: number;
@@ -24,7 +25,8 @@ declare class FeatureFlagsPoller {
     timeout?: number;
     host: FeatureFlagsPollerOptions['host'];
     poller?: NodeJS.Timeout;
-    constructor({ pollingInterval, personalApiKey, projectApiKey, timeout, host }: FeatureFlagsPollerOptions);
+    fetch: (url: string, options: PostHogFetchOptions) => Promise<PostHogFetchResponse>;
+    constructor({ pollingInterval, personalApiKey, projectApiKey, timeout, host, ...options }: FeatureFlagsPollerOptions);
     getFeatureFlag(key: string, distinctId: string, groups?: Record<string, string>, personProperties?: Record<string, string>, groupProperties?: Record<string, Record<string, string>>): Promise<string | boolean | undefined>;
     getAllFlags(distinctId: string, groups?: Record<string, string>, personProperties?: Record<string, string>, groupProperties?: Record<string, Record<string, string>>): Promise<{
         response: Record<string, string | boolean>;
@@ -41,7 +43,7 @@ declare class FeatureFlagsPoller {
     }[];
     loadFeatureFlags(forceReload?: boolean): Promise<void>;
     _loadFeatureFlags(): Promise<void>;
-    _requestFeatureFlagDefinitions(): Promise<ResponseData>;
+    _requestFeatureFlagDefinitions(): Promise<PostHogFetchResponse>;
     stopPoller(): void;
 }
 declare function matchProperty(property: FeatureFlagCondition['properties'][number], propertyValues: Record<string, any>): boolean;

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

@@ -0,0 +1,2 @@
+import { PostHogFetchOptions, PostHogFetchResponse } from 'posthog-core/src';
+export declare const fetch: (url: string, options: PostHogFetchOptions) => Promise<PostHogFetchResponse>;

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

@@ -1,4 +1,4 @@
-import { PosthogCoreOptions } from '../../posthog-core/src';
+import { PosthogCoreOptions, PostHogFetchOptions, PostHogFetchResponse } from '../../posthog-core/src';
 import { EventMessageV1, GroupIdentifyMessage, IdentifyMessageV1, PostHogNodeV1 } from './types';
 export declare type PostHogOptions = PosthogCoreOptions & {
     persistence?: 'memory';
@@ -6,6 +6,7 @@ export declare type PostHogOptions = PosthogCoreOptions & {
     featureFlagsPollingInterval?: number;
     requestTimeout?: number;
     maxCacheSize?: number;
+    fetch?: (url: string, options: PostHogFetchOptions) => Promise<PostHogFetchResponse>;
 };
 export declare class PostHog implements PostHogNodeV1 {
     private _sharedClient;

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

@@ -20,6 +20,7 @@ export declare type FeatureFlagCondition = {
         operator?: string;
     }[];
     rollout_percentage?: number;
+    variant?: string;
 };
 export declare type PostHogFeatureFlag = {
     id: number;

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "posthog-node",
-  "version": "2.0.2",
+  "version": "2.2.0",
   "description": "PostHog Node.js integration",
   "repository": "PostHog/posthog-node",
   "scripts": {
-    "prepublish": "cd .. && yarn build"
+    "prepublishOnly": "cd .. && yarn build"
   },
   "engines": {
-    "node": ">=10"
+    "node": ">=14.17.0"
   },
   "license": "MIT",
   "author": {
@@ -19,7 +19,7 @@
   "module": "lib/index.esm.js",
   "types": "lib/index.d.ts",
   "dependencies": {
-    "undici": "^5.8.0"
+    "axios": "^0.27.0"
   },
   "devDependencies": {
     "@types/node": "^18.0.0",

package/src/feature-flags.ts

@@ -1,8 +1,9 @@
 import { createHash } from 'crypto'
-import { request } from 'undici'
 import { FeatureFlagCondition, PostHogFeatureFlag } from './types'
 import { version } from '../package.json'
-import { ResponseData } from 'undici/types/dispatcher'
+import { PostHogFetchOptions, PostHogFetchResponse } from 'posthog-core/src'
+import { safeSetTimeout } from 'posthog-core/src/utils'
+import { fetch } from './fetch'
 
 // eslint-disable-next-line
 const LONG_SCALE = 0xfffffffffffffff
@@ -35,6 +36,7 @@ type FeatureFlagsPollerOptions = {
   host: string
   pollingInterval: number
   timeout?: number
+  fetch?: (url: string, options: PostHogFetchOptions) => Promise<PostHogFetchResponse>
 }
 
 class FeatureFlagsPoller {
@@ -47,8 +49,16 @@ class FeatureFlagsPoller {
   timeout?: number
   host: FeatureFlagsPollerOptions['host']
   poller?: NodeJS.Timeout
-
-  constructor({ pollingInterval, personalApiKey, projectApiKey, timeout, host }: FeatureFlagsPollerOptions) {
+  fetch: (url: string, options: PostHogFetchOptions) => Promise<PostHogFetchResponse>
+
+  constructor({
+    pollingInterval,
+    personalApiKey,
+    projectApiKey,
+    timeout,
+    host,
+    ...options
+  }: FeatureFlagsPollerOptions) {
     this.pollingInterval = pollingInterval
     this.personalApiKey = personalApiKey
     this.featureFlags = []
@@ -58,6 +68,8 @@ class FeatureFlagsPoller {
     this.projectApiKey = projectApiKey
     this.host = host
     this.poller = undefined
+    // NOTE: as any is required here as the AbortSignal typing is slightly misaligned but works just fine
+    this.fetch = options.fetch || fetch
 
     void this.loadFeatureFlags()
   }
@@ -178,10 +190,34 @@ class FeatureFlagsPoller {
     let isInconclusive = false
     let result = undefined
 
-    flagConditions.forEach((condition) => {
+    // # Stable sort conditions with variant overrides to the top. This ensures that if overrides are present, they are
+    // # evaluated first, and the variant override is applied to the first matching condition.
+    const sortedFlagConditions = [...flagConditions].sort((conditionA, conditionB) => {
+      const AHasVariantOverride = !!conditionA.variant
+      const BHasVariantOverride = !!conditionB.variant
+
+      if (AHasVariantOverride && BHasVariantOverride) {
+        return 0
+      } else if (AHasVariantOverride) {
+        return -1
+      } else if (BHasVariantOverride) {
+        return 1
+      } else {
+        return 0
+      }
+    })
+
+    for (const condition of sortedFlagConditions) {
       try {
         if (this.isConditionMatch(flag, distinctId, condition, properties)) {
-          result = this.getMatchingVariant(flag, distinctId) || true
+          const variantOverride = condition.variant
+          const flagVariants = flagFilters.multivariate?.variants || []
+          if (variantOverride && flagVariants.some((variant) => variant.key === variantOverride)) {
+            result = variantOverride
+          } else {
+            result = this.getMatchingVariant(flag, distinctId) || true
+          }
+          break
         }
       } catch (e) {
         if (e instanceof InconclusiveMatchError) {
@@ -190,7 +226,7 @@ class FeatureFlagsPoller {
           throw e
         }
       }
-    })
+    }
 
     if (result !== undefined) {
       return result
@@ -275,12 +311,12 @@ class FeatureFlagsPoller {
     try {
       const res = await this._requestFeatureFlagDefinitions()
 
-      if (res && res.statusCode === 401) {
+      if (res && res.status === 401) {
         throw new ClientError(
           `Your personalApiKey is invalid. Are you sure you're not using your Project API key? More information: https://posthog.com/docs/api/overview`
         )
       }
-      const responseJson = await res.body.json()
+      const responseJson = await res.json()
       if (!('flags' in responseJson)) {
         console.error(`Invalid response when getting feature flags: ${JSON.stringify(responseJson)}`)
       }
@@ -297,31 +333,35 @@ class FeatureFlagsPoller {
     }
   }
 
-  async _requestFeatureFlagDefinitions(): Promise<ResponseData> {
+  async _requestFeatureFlagDefinitions(): Promise<PostHogFetchResponse> {
     const url = `${this.host}/api/feature_flag/local_evaluation?token=${this.projectApiKey}`
-    const headers = {
-      'Content-Type': 'application/json',
-      Authorization: `Bearer ${this.personalApiKey}`,
-      'user-agent': `posthog-node/${version}`,
-    }
 
-    const options: Parameters<typeof request>[1] = {
+    const options: PostHogFetchOptions = {
       method: 'GET',
-      headers: headers,
+      headers: {
+        'Content-Type': 'application/json',
+        Authorization: `Bearer ${this.personalApiKey}`,
+        'user-agent': `posthog-node/${version}`,
+      },
     }
 
+    let abortTimeout = null
+
     if (this.timeout && typeof this.timeout === 'number') {
-      options.bodyTimeout = this.timeout
+      const controller = new AbortController()
+      abortTimeout = safeSetTimeout(() => {
+        controller.abort()
+      }, this.timeout)
+      options.signal = controller.signal
     }
 
-    let res
     try {
-      res = await request(url, options)
+      return await this.fetch(url, options)
     } catch (err) {
       throw new Error(`Request failed with error: ${err}`)
+    } finally {
+      clearTimeout(abortTimeout)
     }
-
-    return res
   }
 
   stopPoller(): void {
@@ -378,6 +418,14 @@ function matchProperty(
       return typeof overrideValue == typeof value && overrideValue < value
     case 'lte':
       return typeof overrideValue == typeof value && overrideValue <= value
+    case 'is_date_after':
+    case 'is_date_before':
+      const parsedDate = convertToDateTime(value)
+      const overrideDate = convertToDateTime(overrideValue)
+      if (operator === 'is_date_before') {
+        return overrideDate < parsedDate
+      }
+      return overrideDate > parsedDate
     default:
       console.error(`Unknown operator: ${operator}`)
       return false
@@ -393,4 +441,18 @@ function isValidRegex(regex: string): boolean {
   }
 }
 
+function convertToDateTime(value: string | number | (string | number)[] | Date): Date {
+  if (value instanceof Date) {
+    return value
+  } else if (typeof value === 'string' || typeof value === 'number') {
+    const date = new Date(value)
+    if (!isNaN(date.valueOf())) {
+      return date
+    }
+    throw new InconclusiveMatchError(`${value} is in an invalid date format`)
+  } else {
+    throw new InconclusiveMatchError(`The date provided ${value} must be a string, number, or date object`)
+  }
+}
+
 export { FeatureFlagsPoller, matchProperty, InconclusiveMatchError, ClientError }

package/src/fetch.ts

@@ -0,0 +1,20 @@
+import axios from 'axios'
+import { PostHogFetchOptions, PostHogFetchResponse } from 'posthog-core/src'
+
+// NOTE: We use axios as a reliable, well supported request library but follow the Fetch API (roughly)
+// So that alternative implementations can be used if desired
+export const fetch = async (url: string, options: PostHogFetchOptions): Promise<PostHogFetchResponse> => {
+  const res = await axios.request({
+    url,
+    headers: options.headers,
+    method: options.method.toLowerCase(),
+    data: options.body,
+    signal: options.signal,
+  })
+
+  return {
+    status: res.status,
+    text: () => res.data,
+    json: () => res.data,
+  }
+}

package/src/posthog-node.ts

@@ -1,5 +1,5 @@
 import { version } from '../package.json'
-import undici from 'undici'
+
 import {
   PostHogCore,
   PosthogCoreOptions,
@@ -10,6 +10,7 @@ import {
 import { PostHogMemoryStorage } from '../../posthog-core/src/storage-memory'
 import { EventMessageV1, GroupIdentifyMessage, IdentifyMessageV1, PostHogNodeV1 } from './types'
 import { FeatureFlagsPoller } from './feature-flags'
+import { fetch } from './fetch'
 
 export type PostHogOptions = PosthogCoreOptions & {
   persistence?: 'memory'
@@ -20,6 +21,7 @@ export type PostHogOptions = PosthogCoreOptions & {
   requestTimeout?: number
   // Maximum size of cache that deduplicates $feature_flag_called calls per user.
   maxCacheSize?: number
+  fetch?: (url: string, options: PostHogFetchOptions) => Promise<PostHogFetchResponse>
 }
 
 const THIRTY_SECONDS = 30 * 1000
@@ -28,7 +30,7 @@ const MAX_CACHE_SIZE = 50 * 1000
 class PostHogClient extends PostHogCore {
   private _memoryStorage = new PostHogMemoryStorage()
 
-  constructor(apiKey: string, options: PostHogOptions = {}) {
+  constructor(apiKey: string, private options: PostHogOptions = {}) {
     options.captureMode = options?.captureMode || 'json'
     options.preloadFeatureFlags = false // Don't preload as this makes no sense without a distinctId
     options.sendFeatureFlagEvent = false // Let `posthog-node` handle this on its own, since we're dealing with multiple distinctIDs
@@ -50,7 +52,7 @@ class PostHogClient extends PostHogCore {
   }
 
   fetch(url: string, options: PostHogFetchOptions): Promise<PostHogFetchResponse> {
-    return undici.fetch(url, options)
+    return this.options.fetch ? this.options.fetch(url, options) : fetch(url, options)
   }
 
   getLibraryId(): string {
@@ -84,6 +86,7 @@ export class PostHog implements PostHogNodeV1 {
         projectApiKey: apiKey,
         timeout: options.requestTimeout,
         host: this._sharedClient.host,
+        fetch: options.fetch,
       })
     }
     this.distinctIdHasSentFlagCalls = {}

package/src/types.ts

@@ -23,6 +23,7 @@ export type FeatureFlagCondition = {
     operator?: string
   }[]
   rollout_percentage?: number
+  variant?: string
 }
 
 export type PostHogFeatureFlag = {