posthog-node 2.0.0-alpha9 → 2.0.1

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

@@ -5,7 +5,7 @@ import { LZString } from './lz-string';
 import { SimpleEventEmitter } from './eventemitter';
 export declare abstract class PostHogCore {
     private apiKey;
-    private host;
+    host: string;
     private flushAt;
     private flushInterval;
     private captureMode;
@@ -28,12 +28,13 @@ export declare abstract class PostHogCore {
     protected getCommonEventProperties(): any;
     private get props();
     private set props(value);
+    private clearProps;
     private _props;
     get optedOut(): boolean;
     optIn(): void;
     optOut(): void;
     on(event: string, cb: (...args: any[]) => void): () => void;
-    reset(): void;
+    reset(propertiesToKeep?: PostHogPersistedProperty[]): void;
     debug(enabled?: boolean): void;
     private buildPayload;
     getSessionId(): string | undefined;
@@ -50,7 +51,7 @@ export declare abstract class PostHogCore {
     identify(distinctId?: string, properties?: PostHogEventProperties): this;
     capture(event: string, properties?: {
         [key: string]: any;
-    }): this;
+    }, forceSendFeatureFlags?: boolean): this;
     alias(alias: string): this;
     autocapture(eventType: string, elements: PostHogAutocaptureElement[], properties?: PostHogEventProperties): this;
     /***
@@ -61,18 +62,30 @@ export declare abstract class PostHogCore {
     }): this;
     group(groupType: string, groupKey: string | number, groupProperties?: PostHogEventProperties): this;
     groupIdentify(groupType: string, groupKey: string | number, groupProperties?: PostHogEventProperties): this;
+    /***
+     * PROPERTIES
+     ***/
+    personProperties(properties: {
+        [type: string]: string;
+    }): this;
+    groupProperties(properties: {
+        [type: string]: Record<string, string>;
+    }): this;
     /***
      *** FEATURE FLAGS
      ***/
     private decideAsync;
     private _decideAsync;
-    getFeatureFlag(key: string, defaultResult?: string | boolean): boolean | string | undefined;
+    getFeatureFlag(key: string): boolean | string | undefined;
     getFeatureFlags(): PostHogDecideResponse['featureFlags'] | undefined;
-    isFeatureEnabled(key: string, defaultResult?: boolean): boolean;
-    reloadFeatureFlagsAsync(): Promise<PostHogDecideResponse['featureFlags']>;
+    isFeatureEnabled(key: string): boolean | undefined;
+    reloadFeatureFlagsAsync(sendAnonDistinctId?: boolean): Promise<PostHogDecideResponse['featureFlags']>;
     onFeatureFlags(cb: (flags: PostHogDecideResponse['featureFlags']) => void): () => void;
     onFeatureFlag(key: string, cb: (value: string | boolean) => void): () => void;
     overrideFeatureFlag(flags: PostHogDecideResponse['featureFlags'] | null): void;
+    _sendFeatureFlags(event: string, properties?: {
+        [key: string]: any;
+    }): void;
     /***
      *** QUEUEING AND FLUSHING
      ***/

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

@@ -19,7 +19,9 @@ export declare enum PostHogPersistedProperty {
     Queue = "queue",
     OptedOut = "opted_out",
     SessionId = "session_id",
-    SessionLastTimestamp = "session_timestamp"
+    SessionLastTimestamp = "session_timestamp",
+    PersonProperties = "person_properties",
+    GroupProperties = "group_properties"
 }
 export declare type PostHogFetchOptions = {
     method: 'GET' | 'POST' | 'PUT' | 'PATCH';

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

@@ -0,0 +1,48 @@
+/// <reference types="node" />
+import { FeatureFlagCondition, PostHogFeatureFlag } from './types';
+import { ResponseData } from 'undici/types/dispatcher';
+declare class ClientError extends Error {
+    constructor(message: string);
+}
+declare class InconclusiveMatchError extends Error {
+    constructor(message: string);
+}
+declare type FeatureFlagsPollerOptions = {
+    personalApiKey: string;
+    projectApiKey: string;
+    host: string;
+    pollingInterval: number;
+    timeout?: number;
+};
+declare class FeatureFlagsPoller {
+    pollingInterval: number;
+    personalApiKey: string;
+    projectApiKey: string;
+    featureFlags: Array<PostHogFeatureFlag>;
+    groupTypeMapping: Record<string, string>;
+    loadedSuccessfullyOnce: boolean;
+    timeout?: number;
+    host: FeatureFlagsPollerOptions['host'];
+    poller?: NodeJS.Timeout;
+    constructor({ pollingInterval, personalApiKey, projectApiKey, timeout, host }: 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>;
+        fallbackToDecide: boolean;
+    }>;
+    computeFlagLocally(flag: PostHogFeatureFlag, distinctId: string, groups?: Record<string, string>, personProperties?: Record<string, string>, groupProperties?: Record<string, Record<string, string>>): string | boolean;
+    matchFeatureFlagProperties(flag: PostHogFeatureFlag, distinctId: string, properties: Record<string, string>): string | boolean;
+    isConditionMatch(flag: PostHogFeatureFlag, distinctId: string, condition: FeatureFlagCondition, properties: Record<string, string>): boolean;
+    getMatchingVariant(flag: PostHogFeatureFlag, distinctId: string): string | boolean | undefined;
+    variantLookupTable(flag: PostHogFeatureFlag): {
+        valueMin: number;
+        valueMax: number;
+        key: string;
+    }[];
+    loadFeatureFlags(forceReload?: boolean): Promise<void>;
+    _loadFeatureFlags(): Promise<void>;
+    _requestFeatureFlagDefinitions(): Promise<ResponseData>;
+    stopPoller(): void;
+}
+declare function matchProperty(property: FeatureFlagCondition['properties'][number], propertyValues: Record<string, any>): boolean;
+export { FeatureFlagsPoller, matchProperty, InconclusiveMatchError, ClientError };

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

@@ -2,23 +2,49 @@ import { PosthogCoreOptions } from '../../posthog-core/src';
 import { EventMessageV1, GroupIdentifyMessage, IdentifyMessageV1, PostHogNodeV1 } from './types';
 export declare type PostHogOptions = PosthogCoreOptions & {
     persistence?: 'memory';
+    personalApiKey?: string;
+    featureFlagsPollingInterval?: number;
+    requestTimeout?: number;
+    maxCacheSize?: number;
 };
 export declare class PostHogGlobal implements PostHogNodeV1 {
     private _sharedClient;
+    private featureFlagsPoller?;
+    private maxCacheSize;
+    distinctIdHasSentFlagCalls: Record<string, string[]>;
     constructor(apiKey: string, options?: PostHogOptions);
     private reInit;
     enable(): void;
     disable(): void;
-    capture({ distinctId, event, properties, groups }: EventMessageV1): void;
+    capture({ distinctId, event, properties, groups, sendFeatureFlags }: EventMessageV1): void;
     identify({ distinctId, properties }: IdentifyMessageV1): void;
     alias(data: {
         distinctId: string;
         alias: string;
     }): void;
-    getFeatureFlag(key: string, distinctId: string, groups?: Record<string, string> | undefined): Promise<string | boolean | undefined>;
-    isFeatureEnabled(key: string, distinctId: string, defaultResult?: boolean | undefined, groups?: Record<string, string> | undefined): Promise<boolean>;
+    getFeatureFlag(key: string, distinctId: string, options?: {
+        groups?: Record<string, string>;
+        personProperties?: Record<string, string>;
+        groupProperties?: Record<string, Record<string, string>>;
+        onlyEvaluateLocally?: boolean;
+        sendFeatureFlagEvents?: boolean;
+    }): Promise<string | boolean | undefined>;
+    isFeatureEnabled(key: string, distinctId: string, options?: {
+        groups?: Record<string, string>;
+        personProperties?: Record<string, string>;
+        groupProperties?: Record<string, Record<string, string>>;
+        onlyEvaluateLocally?: boolean;
+        sendFeatureFlagEvents?: boolean;
+    }): Promise<boolean | undefined>;
+    getAllFlags(distinctId: string, options?: {
+        groups?: Record<string, string>;
+        personProperties?: Record<string, string>;
+        groupProperties?: Record<string, Record<string, string>>;
+        onlyEvaluateLocally?: boolean;
+    }): Promise<Record<string, string | boolean>>;
     groupIdentify({ groupType, groupKey, properties }: GroupIdentifyMessage): void;
     reloadFeatureFlags(): Promise<void>;
+    flush(): void;
     shutdown(): void;
     shutdownAsync(): Promise<void>;
     debug(enabled?: boolean): void;

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

@@ -12,6 +12,36 @@ export interface GroupIdentifyMessage {
     groupKey: string;
     properties?: Record<string | number, any>;
 }
+export declare type FeatureFlagCondition = {
+    properties: {
+        key: string;
+        type?: string;
+        value: string | number | (string | number)[];
+        operator?: string;
+    }[];
+    rollout_percentage?: number;
+};
+export declare type PostHogFeatureFlag = {
+    id: number;
+    name: string;
+    key: string;
+    filters?: {
+        aggregation_group_type_index?: number;
+        groups?: FeatureFlagCondition[];
+        multivariate?: {
+            variants: {
+                key: string;
+                rollout_percentage: number;
+            }[];
+        };
+    };
+    deleted: boolean;
+    active: boolean;
+    is_simple_flag: boolean;
+    rollout_percentage: null | number;
+    ensure_experience_continuity: boolean;
+    experiment_set: number[];
+};
 export declare type PostHogNodeV1 = {
     /**
      * @description Capture allows you to capture anything a user does within your system,
@@ -22,7 +52,7 @@ export declare type PostHogNodeV1 = {
      * @param event We recommend using [verb] [noun], like movie played or movie updated to easily identify what your events mean later on.
      * @param properties OPTIONAL | which can be a object with any information you'd like to add
      * @param groups OPTIONAL | object of what groups are related to this event, example: { company: 'id:5' }. Can be used to analyze companies instead of users.
-     * @param sendFeatureFlags OPTIONAL | Used with experiments
+     * @param sendFeatureFlags OPTIONAL | Used with experiments. Determines whether to send feature flag values with the event.
      */
     capture({ distinctId, event, properties, groups, sendFeatureFlags }: EventMessageV1): void;
     /**
@@ -53,14 +83,47 @@ export declare type PostHogNodeV1 = {
      * allow you to safely deploy and roll back new features. Once you've created a feature flag in PostHog,
      * you can use this method to check if the flag is on for a given user, allowing you to create logic to turn
      * features on and off for different user groups or individual users.
-     * IMPORTANT: To use this method, you need to specify `personalApiKey` in your config! More info: https://posthog.com/docs/api/overview
      * @param key the unique key of your feature flag
      * @param distinctId the current unique id
-     * @param defaultResult optional - default value to be returned if the feature flag is not on for the user
-     * @param groups optional - what groups are currently active (group analytics)
+     * @param options: dict with optional parameters below
+     * @param groups optional - what groups are currently active (group analytics). Required if the flag depends on groups.
+     * @param personProperties optional - what person properties are known. Used to compute flags locally, if personalApiKey is present.
+     * @param groupProperties optional - what group properties are known. Used to compute flags locally, if personalApiKey is present.
+     * @param onlyEvaluateLocally optional - whether to only evaluate the flag locally. Defaults to false.
+     * @param sendFeatureFlagEvents optional - whether to send feature flag events. Used for Experiments. Defaults to true.
+     *
+     * @returns true if the flag is on, false if the flag is off, undefined if there was an error.
+     */
+    isFeatureEnabled(key: string, distinctId: string, options?: {
+        groups?: Record<string, string>;
+        personProperties?: Record<string, string>;
+        groupProperties?: Record<string, Record<string, string>>;
+        onlyEvaluateLocally?: boolean;
+        sendFeatureFlagEvents?: boolean;
+    }): Promise<boolean | undefined>;
+    /**
+     * @description PostHog feature flags (https://posthog.com/docs/features/feature-flags)
+     * allow you to safely deploy and roll back new features. Once you've created a feature flag in PostHog,
+     * you can use this method to check if the flag is on for a given user, allowing you to create logic to turn
+     * features on and off for different user groups or individual users.
+     * @param key the unique key of your feature flag
+     * @param distinctId the current unique id
+     * @param options: dict with optional parameters below
+     * @param groups optional - what groups are currently active (group analytics). Required if the flag depends on groups.
+     * @param personProperties optional - what person properties are known. Used to compute flags locally, if personalApiKey is present.
+     * @param groupProperties optional - what group properties are known. Used to compute flags locally, if personalApiKey is present.
+     * @param onlyEvaluateLocally optional - whether to only evaluate the flag locally. Defaults to false.
+     * @param sendFeatureFlagEvents optional - whether to send feature flag events. Used for Experiments. Defaults to true.
+     *
+     * @returns true or string(for multivariates) if the flag is on, false if the flag is off, undefined if there was an error.
      */
-    isFeatureEnabled(key: string, distinctId: string, defaultResult?: boolean, groups?: Record<string, string>): Promise<boolean>;
-    getFeatureFlag(key: string, distinctId: string, groups?: Record<string, string>): Promise<string | boolean | undefined>;
+    getFeatureFlag(key: string, distinctId: string, options?: {
+        groups?: Record<string, string>;
+        personProperties?: Record<string, string>;
+        groupProperties?: Record<string, Record<string, string>>;
+        onlyEvaluateLocally?: boolean;
+        sendFeatureFlagEvents?: boolean;
+    }): Promise<string | boolean | undefined>;
     /**
      * @description Sets a groups properties, which allows asking questions like "Who are the most active companies"
      * using my product in PostHog.

package/package.json

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

package/src/feature-flags.ts

@@ -0,0 +1,396 @@
+import { createHash } from 'crypto'
+import { request } from 'undici'
+import { FeatureFlagCondition, PostHogFeatureFlag } from './types'
+import { version } from '../package.json'
+import { ResponseData } from 'undici/types/dispatcher'
+
+// eslint-disable-next-line
+const LONG_SCALE = 0xfffffffffffffff
+
+class ClientError extends Error {
+  constructor(message: string) {
+    super()
+    Error.captureStackTrace(this, this.constructor)
+    this.name = 'ClientError'
+    this.message = message
+    Object.setPrototypeOf(this, ClientError.prototype)
+  }
+}
+
+class InconclusiveMatchError extends Error {
+  constructor(message: string) {
+    super(message)
+    this.name = this.constructor.name
+    Error.captureStackTrace(this, this.constructor)
+    // instanceof doesn't work in ES3 or ES5
+    // https://www.dannyguo.com/blog/how-to-fix-instanceof-not-working-for-custom-errors-in-typescript/
+    // this is the workaround
+    Object.setPrototypeOf(this, InconclusiveMatchError.prototype)
+  }
+}
+
+type FeatureFlagsPollerOptions = {
+  personalApiKey: string
+  projectApiKey: string
+  host: string
+  pollingInterval: number
+  timeout?: number
+}
+
+class FeatureFlagsPoller {
+  pollingInterval: number
+  personalApiKey: string
+  projectApiKey: string
+  featureFlags: Array<PostHogFeatureFlag>
+  groupTypeMapping: Record<string, string>
+  loadedSuccessfullyOnce: boolean
+  timeout?: number
+  host: FeatureFlagsPollerOptions['host']
+  poller?: NodeJS.Timeout
+
+  constructor({ pollingInterval, personalApiKey, projectApiKey, timeout, host }: FeatureFlagsPollerOptions) {
+    this.pollingInterval = pollingInterval
+    this.personalApiKey = personalApiKey
+    this.featureFlags = []
+    this.groupTypeMapping = {}
+    this.loadedSuccessfullyOnce = false
+    this.timeout = timeout
+    this.projectApiKey = projectApiKey
+    this.host = host
+    this.poller = undefined
+
+    void this.loadFeatureFlags()
+  }
+
+  async getFeatureFlag(
+    key: string,
+    distinctId: string,
+    groups: Record<string, string> = {},
+    personProperties: Record<string, string> = {},
+    groupProperties: Record<string, Record<string, string>> = {}
+  ): Promise<string | boolean | undefined> {
+    await this.loadFeatureFlags()
+
+    let response = undefined
+    let featureFlag = undefined
+
+    if (!this.loadedSuccessfullyOnce) {
+      return response
+    }
+
+    for (const flag of this.featureFlags) {
+      if (key === flag.key) {
+        featureFlag = flag
+        break
+      }
+    }
+
+    if (featureFlag !== undefined) {
+      try {
+        response = this.computeFlagLocally(featureFlag, distinctId, groups, personProperties, groupProperties)
+        console.debug(`Successfully computed flag locally: ${key} -> ${response}`)
+      } catch (e) {
+        if (e instanceof InconclusiveMatchError) {
+          console.debug(`Can't compute flag locally: ${key}: ${e}`)
+        } else if (e instanceof Error) {
+          console.error(`Error computing flag locally: ${key}: ${e}`)
+        }
+      }
+    }
+
+    return response
+  }
+
+  async getAllFlags(
+    distinctId: string,
+    groups: Record<string, string> = {},
+    personProperties: Record<string, string> = {},
+    groupProperties: Record<string, Record<string, string>> = {}
+  ): Promise<{ response: Record<string, string | boolean>; fallbackToDecide: boolean }> {
+    await this.loadFeatureFlags()
+
+    const response: Record<string, string | boolean> = {}
+    let fallbackToDecide = this.featureFlags.length == 0
+
+    this.featureFlags.map((flag) => {
+      try {
+        response[flag.key] = this.computeFlagLocally(flag, distinctId, groups, personProperties, groupProperties)
+      } catch (e) {
+        if (e instanceof InconclusiveMatchError) {
+          // do nothing
+        } else if (e instanceof Error) {
+          console.error(`Error computing flag locally: ${flag.key}: ${e}`)
+        }
+        fallbackToDecide = true
+      }
+    })
+
+    return { response, fallbackToDecide }
+  }
+
+  computeFlagLocally(
+    flag: PostHogFeatureFlag,
+    distinctId: string,
+    groups: Record<string, string> = {},
+    personProperties: Record<string, string> = {},
+    groupProperties: Record<string, Record<string, string>> = {}
+  ): string | boolean {
+    if (flag.ensure_experience_continuity) {
+      throw new InconclusiveMatchError('Flag has experience continuity enabled')
+    }
+
+    if (!flag.active) {
+      return false
+    }
+
+    const flagFilters = flag.filters || {}
+    const aggregation_group_type_index = flagFilters.aggregation_group_type_index
+
+    if (aggregation_group_type_index != undefined) {
+      const groupName = this.groupTypeMapping[String(aggregation_group_type_index)]
+
+      if (!groupName) {
+        console.warn(
+          `[FEATURE FLAGS] Unknown group type index ${aggregation_group_type_index} for feature flag ${flag.key}`
+        )
+        throw new InconclusiveMatchError('Flag has unknown group type index')
+      }
+
+      if (!(groupName in groups)) {
+        console.warn(`[FEATURE FLAGS] Can't compute group feature flag: ${flag.key} without group names passed in`)
+        return false
+      }
+
+      const focusedGroupProperties = groupProperties[groupName]
+      return this.matchFeatureFlagProperties(flag, groups[groupName], focusedGroupProperties)
+    } else {
+      return this.matchFeatureFlagProperties(flag, distinctId, personProperties)
+    }
+  }
+
+  matchFeatureFlagProperties(
+    flag: PostHogFeatureFlag,
+    distinctId: string,
+    properties: Record<string, string>
+  ): string | boolean {
+    const flagFilters = flag.filters || {}
+    const flagConditions = flagFilters.groups || []
+    let isInconclusive = false
+    let result = undefined
+
+    flagConditions.forEach((condition) => {
+      try {
+        if (this.isConditionMatch(flag, distinctId, condition, properties)) {
+          result = this.getMatchingVariant(flag, distinctId) || true
+        }
+      } catch (e) {
+        if (e instanceof InconclusiveMatchError) {
+          isInconclusive = true
+        } else {
+          throw e
+        }
+      }
+    })
+
+    if (result !== undefined) {
+      return result
+    } else if (isInconclusive) {
+      throw new InconclusiveMatchError("Can't determine if feature flag is enabled or not with given properties")
+    }
+
+    // We can only return False when all conditions are False
+    return false
+  }
+
+  isConditionMatch(
+    flag: PostHogFeatureFlag,
+    distinctId: string,
+    condition: FeatureFlagCondition,
+    properties: Record<string, string>
+  ): boolean {
+    const rolloutPercentage = condition.rollout_percentage
+
+    if ((condition.properties || []).length > 0) {
+      const matchAll = condition.properties.every((property) => {
+        return matchProperty(property, properties)
+      })
+      if (!matchAll) {
+        return false
+      } else if (rolloutPercentage == undefined) {
+        // == to include `null` as a match, not just `undefined`
+        return true
+      }
+    }
+
+    if (rolloutPercentage != undefined && _hash(flag.key, distinctId) > rolloutPercentage / 100.0) {
+      return false
+    }
+
+    return true
+  }
+
+  getMatchingVariant(flag: PostHogFeatureFlag, distinctId: string): string | boolean | undefined {
+    const hashValue = _hash(flag.key, distinctId, 'variant')
+    const matchingVariant = this.variantLookupTable(flag).find((variant) => {
+      return hashValue >= variant.valueMin && hashValue < variant.valueMax
+    })
+
+    if (matchingVariant) {
+      return matchingVariant.key
+    }
+    return undefined
+  }
+
+  variantLookupTable(flag: PostHogFeatureFlag): { valueMin: number; valueMax: number; key: string }[] {
+    const lookupTable: { valueMin: number; valueMax: number; key: string }[] = []
+    let valueMin = 0
+    let valueMax = 0
+    const flagFilters = flag.filters || {}
+    const multivariates: {
+      key: string
+      rollout_percentage: number
+    }[] = flagFilters.multivariate?.variants || []
+
+    multivariates.forEach((variant) => {
+      valueMax = valueMin + variant.rollout_percentage / 100.0
+      lookupTable.push({ valueMin, valueMax, key: variant.key })
+      valueMin = valueMax
+    })
+    return lookupTable
+  }
+
+  async loadFeatureFlags(forceReload = false): Promise<void> {
+    if (!this.loadedSuccessfullyOnce || forceReload) {
+      await this._loadFeatureFlags()
+    }
+  }
+
+  async _loadFeatureFlags(): Promise<void> {
+    if (this.poller) {
+      clearTimeout(this.poller)
+      this.poller = undefined
+    }
+    this.poller = setTimeout(() => this._loadFeatureFlags(), this.pollingInterval)
+
+    try {
+      const res = await this._requestFeatureFlagDefinitions()
+
+      if (res && res.statusCode === 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()
+      if (!('flags' in responseJson)) {
+        console.error(`Invalid response when getting feature flags: ${JSON.stringify(responseJson)}`)
+      }
+
+      this.featureFlags = responseJson.flags || []
+      this.groupTypeMapping = responseJson.group_type_mapping || {}
+      this.loadedSuccessfullyOnce = true
+    } catch (err) {
+      // if an error that is not an instance of ClientError is thrown
+      // we silently ignore the error when reloading feature flags
+      if (err instanceof ClientError) {
+        throw err
+      }
+    }
+  }
+
+  async _requestFeatureFlagDefinitions(): Promise<ResponseData> {
+    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] = {
+      method: 'GET',
+      headers: headers,
+    }
+
+    if (this.timeout && typeof this.timeout === 'number') {
+      options.bodyTimeout = this.timeout
+    }
+
+    let res
+    try {
+      res = await request(url, options)
+    } catch (err) {
+      throw new Error(`Request failed with error: ${err}`)
+    }
+
+    return res
+  }
+
+  stopPoller(): void {
+    clearTimeout(this.poller)
+  }
+}
+
+// # This function takes a distinct_id and a feature flag key and returns a float between 0 and 1.
+// # Given the same distinct_id and key, it'll always return the same float. These floats are
+// # uniformly distributed between 0 and 1, so if we want to show this feature to 20% of traffic
+// # we can do _hash(key, distinct_id) < 0.2
+function _hash(key: string, distinctId: string, salt: string = ''): number {
+  const sha1Hash = createHash('sha1')
+  sha1Hash.update(`${key}.${distinctId}${salt}`)
+  return parseInt(sha1Hash.digest('hex').slice(0, 15), 16) / LONG_SCALE
+}
+
+function matchProperty(
+  property: FeatureFlagCondition['properties'][number],
+  propertyValues: Record<string, any>
+): boolean {
+  const key = property.key
+  const value = property.value
+  const operator = property.operator || 'exact'
+
+  if (!(key in propertyValues)) {
+    throw new InconclusiveMatchError(`Property ${key} not found in propertyValues`)
+  } else if (operator === 'is_not_set') {
+    throw new InconclusiveMatchError(`Operator is_not_set is not supported`)
+  }
+
+  const overrideValue = propertyValues[key]
+
+  switch (operator) {
+    case 'exact':
+      return Array.isArray(value) ? value.indexOf(overrideValue) !== -1 : value === overrideValue
+    case 'is_not':
+      return Array.isArray(value) ? value.indexOf(overrideValue) === -1 : value !== overrideValue
+    case 'is_set':
+      return key in propertyValues
+    case 'icontains':
+      return String(overrideValue).toLowerCase().includes(String(value).toLowerCase())
+    case 'not_icontains':
+      return !String(overrideValue).toLowerCase().includes(String(value).toLowerCase())
+    case 'regex':
+      return isValidRegex(String(value)) && String(overrideValue).match(String(value)) !== null
+    case 'not_regex':
+      return isValidRegex(String(value)) && String(overrideValue).match(String(value)) === null
+    case 'gt':
+      return typeof overrideValue == typeof value && overrideValue > value
+    case 'gte':
+      return typeof overrideValue == typeof value && overrideValue >= value
+    case 'lt':
+      return typeof overrideValue == typeof value && overrideValue < value
+    case 'lte':
+      return typeof overrideValue == typeof value && overrideValue <= value
+    default:
+      console.error(`Unknown operator: ${operator}`)
+      return false
+  }
+}
+
+function isValidRegex(regex: string): boolean {
+  try {
+    new RegExp(regex)
+    return true
+  } catch (err) {
+    return false
+  }
+}
+
+export { FeatureFlagsPoller, matchProperty, InconclusiveMatchError, ClientError }