posthog-node 5.8.8 → 5.9.1

package/dist/extensions/feature-flags/feature-flags.mjs

@@ -0,0 +1,483 @@
+import { safeSetTimeout } from "@posthog/core";
+import { hashSHA1 } from "./crypto.mjs";
+const SIXTY_SECONDS = 60000;
+const LONG_SCALE = 0xfffffffffffffff;
+const NULL_VALUES_ALLOWED_OPERATORS = [
+    'is_not'
+];
+class ClientError extends Error {
+    constructor(message){
+        super();
+        Error.captureStackTrace(this, this.constructor);
+        this.name = 'ClientError';
+        this.message = message;
+        Object.setPrototypeOf(this, ClientError.prototype);
+    }
+}
+class InconclusiveMatchError extends Error {
+    constructor(message){
+        super(message);
+        this.name = this.constructor.name;
+        Error.captureStackTrace(this, this.constructor);
+        Object.setPrototypeOf(this, InconclusiveMatchError.prototype);
+    }
+}
+class FeatureFlagsPoller {
+    constructor({ pollingInterval, personalApiKey, projectApiKey, timeout, host, customHeaders, ...options }){
+        this.debugMode = false;
+        this.shouldBeginExponentialBackoff = false;
+        this.backOffCount = 0;
+        this.pollingInterval = pollingInterval;
+        this.personalApiKey = personalApiKey;
+        this.featureFlags = [];
+        this.featureFlagsByKey = {};
+        this.groupTypeMapping = {};
+        this.cohorts = {};
+        this.loadedSuccessfullyOnce = false;
+        this.timeout = timeout;
+        this.projectApiKey = projectApiKey;
+        this.host = host;
+        this.poller = void 0;
+        this.fetch = options.fetch || fetch;
+        this.onError = options.onError;
+        this.customHeaders = customHeaders;
+        this.onLoad = options.onLoad;
+        this.loadFeatureFlags();
+    }
+    debug(enabled = true) {
+        this.debugMode = enabled;
+    }
+    logMsgIfDebug(fn) {
+        if (this.debugMode) fn();
+    }
+    async getFeatureFlag(key, distinctId, groups = {}, personProperties = {}, groupProperties = {}) {
+        await this.loadFeatureFlags();
+        let response;
+        let featureFlag;
+        if (!this.loadedSuccessfullyOnce) return response;
+        featureFlag = this.featureFlagsByKey[key];
+        if (void 0 !== featureFlag) try {
+            const result = await this.computeFlagAndPayloadLocally(featureFlag, distinctId, groups, personProperties, groupProperties);
+            response = result.value;
+            this.logMsgIfDebug(()=>console.debug(`Successfully computed flag locally: ${key} -> ${response}`));
+        } catch (e) {
+            if (e instanceof InconclusiveMatchError) this.logMsgIfDebug(()=>console.debug(`InconclusiveMatchError when computing flag locally: ${key}: ${e}`));
+            else if (e instanceof Error) this.onError?.(new Error(`Error computing flag locally: ${key}: ${e}`));
+        }
+        return response;
+    }
+    async getAllFlagsAndPayloads(distinctId, groups = {}, personProperties = {}, groupProperties = {}, flagKeysToExplicitlyEvaluate) {
+        await this.loadFeatureFlags();
+        const response = {};
+        const payloads = {};
+        let fallbackToFlags = 0 == this.featureFlags.length;
+        const flagsToEvaluate = flagKeysToExplicitlyEvaluate ? flagKeysToExplicitlyEvaluate.map((key)=>this.featureFlagsByKey[key]).filter(Boolean) : this.featureFlags;
+        const sharedEvaluationCache = {};
+        await Promise.all(flagsToEvaluate.map(async (flag)=>{
+            try {
+                const { value: matchValue, payload: matchPayload } = await this.computeFlagAndPayloadLocally(flag, distinctId, groups, personProperties, groupProperties, void 0, sharedEvaluationCache);
+                response[flag.key] = matchValue;
+                if (matchPayload) payloads[flag.key] = matchPayload;
+            } catch (e) {
+                if (e instanceof InconclusiveMatchError) this.logMsgIfDebug(()=>console.debug(`InconclusiveMatchError when computing flag locally: ${flag.key}: ${e}`));
+                else if (e instanceof Error) this.onError?.(new Error(`Error computing flag locally: ${flag.key}: ${e}`));
+                fallbackToFlags = true;
+            }
+        }));
+        return {
+            response,
+            payloads,
+            fallbackToFlags
+        };
+    }
+    async computeFlagAndPayloadLocally(flag, distinctId, groups = {}, personProperties = {}, groupProperties = {}, matchValue, evaluationCache, skipLoadCheck = false) {
+        if (!skipLoadCheck) await this.loadFeatureFlags();
+        if (!this.loadedSuccessfullyOnce) return {
+            value: false,
+            payload: null
+        };
+        let flagValue;
+        flagValue = void 0 !== matchValue ? matchValue : await this.computeFlagValueLocally(flag, distinctId, groups, personProperties, groupProperties, evaluationCache);
+        const payload = this.getFeatureFlagPayload(flag.key, flagValue);
+        return {
+            value: flagValue,
+            payload
+        };
+    }
+    async computeFlagValueLocally(flag, distinctId, groups = {}, personProperties = {}, groupProperties = {}, evaluationCache = {}) {
+        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 (void 0 == aggregation_group_type_index) return await this.matchFeatureFlagProperties(flag, distinctId, personProperties, evaluationCache);
+        {
+            const groupName = this.groupTypeMapping[String(aggregation_group_type_index)];
+            if (!groupName) {
+                this.logMsgIfDebug(()=>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)) {
+                this.logMsgIfDebug(()=>console.warn(`[FEATURE FLAGS] Can't compute group feature flag: ${flag.key} without group names passed in`));
+                return false;
+            }
+            const focusedGroupProperties = groupProperties[groupName];
+            return await this.matchFeatureFlagProperties(flag, groups[groupName], focusedGroupProperties, evaluationCache);
+        }
+    }
+    getFeatureFlagPayload(key, flagValue) {
+        let payload = null;
+        if (false !== flagValue && null != flagValue) {
+            if ('boolean' == typeof flagValue) payload = this.featureFlagsByKey?.[key]?.filters?.payloads?.[flagValue.toString()] || null;
+            else if ('string' == typeof flagValue) payload = this.featureFlagsByKey?.[key]?.filters?.payloads?.[flagValue] || null;
+            if (null != payload) {
+                if ('object' == typeof payload) return payload;
+                if ('string' == typeof payload) try {
+                    return JSON.parse(payload);
+                } catch  {}
+                return payload;
+            }
+        }
+        return null;
+    }
+    async evaluateFlagDependency(property, distinctId, properties, evaluationCache) {
+        const targetFlagKey = property.key;
+        if (!this.featureFlagsByKey) throw new InconclusiveMatchError('Feature flags not available for dependency evaluation');
+        if (!('dependency_chain' in property)) throw new InconclusiveMatchError(`Flag dependency property for '${targetFlagKey}' is missing required 'dependency_chain' field`);
+        const dependencyChain = property.dependency_chain;
+        if (!Array.isArray(dependencyChain)) throw new InconclusiveMatchError(`Flag dependency property for '${targetFlagKey}' has an invalid 'dependency_chain' (expected array, got ${typeof dependencyChain})`);
+        if (0 === dependencyChain.length) throw new InconclusiveMatchError(`Circular dependency detected for flag '${targetFlagKey}' (empty dependency chain)`);
+        for (const depFlagKey of dependencyChain){
+            if (!(depFlagKey in evaluationCache)) {
+                const depFlag = this.featureFlagsByKey[depFlagKey];
+                if (depFlag) if (depFlag.active) try {
+                    const depResult = await this.matchFeatureFlagProperties(depFlag, distinctId, properties, evaluationCache);
+                    evaluationCache[depFlagKey] = depResult;
+                } catch (error) {
+                    throw new InconclusiveMatchError(`Error evaluating flag dependency '${depFlagKey}' for flag '${targetFlagKey}': ${error}`);
+                }
+                else evaluationCache[depFlagKey] = false;
+                else throw new InconclusiveMatchError(`Missing flag dependency '${depFlagKey}' for flag '${targetFlagKey}'`);
+            }
+            const cachedResult = evaluationCache[depFlagKey];
+            if (null == cachedResult) throw new InconclusiveMatchError(`Dependency '${depFlagKey}' could not be evaluated`);
+        }
+        const targetFlagValue = evaluationCache[targetFlagKey];
+        return this.flagEvaluatesToExpectedValue(property.value, targetFlagValue);
+    }
+    flagEvaluatesToExpectedValue(expectedValue, flagValue) {
+        if ('boolean' == typeof expectedValue) return expectedValue === flagValue || 'string' == typeof flagValue && '' !== flagValue && true === expectedValue;
+        if ('string' == typeof expectedValue) return flagValue === expectedValue;
+        return false;
+    }
+    async matchFeatureFlagProperties(flag, distinctId, properties, evaluationCache = {}) {
+        const flagFilters = flag.filters || {};
+        const flagConditions = flagFilters.groups || [];
+        let isInconclusive = false;
+        let result;
+        for (const condition of flagConditions)try {
+            if (await this.isConditionMatch(flag, distinctId, condition, properties, evaluationCache)) {
+                const variantOverride = condition.variant;
+                const flagVariants = flagFilters.multivariate?.variants || [];
+                result = variantOverride && flagVariants.some((variant)=>variant.key === variantOverride) ? variantOverride : await this.getMatchingVariant(flag, distinctId) || true;
+                break;
+            }
+        } catch (e) {
+            if (e instanceof InconclusiveMatchError) isInconclusive = true;
+            else throw e;
+        }
+        if (void 0 !== result) return result;
+        if (isInconclusive) throw new InconclusiveMatchError("Can't determine if feature flag is enabled or not with given properties");
+        return false;
+    }
+    async isConditionMatch(flag, distinctId, condition, properties, evaluationCache = {}) {
+        const rolloutPercentage = condition.rollout_percentage;
+        const warnFunction = (msg)=>{
+            this.logMsgIfDebug(()=>console.warn(msg));
+        };
+        if ((condition.properties || []).length > 0) {
+            for (const prop of condition.properties){
+                const propertyType = prop.type;
+                let matches = false;
+                matches = 'cohort' === propertyType ? matchCohort(prop, properties, this.cohorts, this.debugMode) : 'flag' === propertyType ? await this.evaluateFlagDependency(prop, distinctId, properties, evaluationCache) : matchProperty(prop, properties, warnFunction);
+                if (!matches) return false;
+            }
+            if (void 0 == rolloutPercentage) return true;
+        }
+        if (void 0 != rolloutPercentage && await _hash(flag.key, distinctId) > rolloutPercentage / 100.0) return false;
+        return true;
+    }
+    async getMatchingVariant(flag, distinctId) {
+        const hashValue = await _hash(flag.key, distinctId, 'variant');
+        const matchingVariant = this.variantLookupTable(flag).find((variant)=>hashValue >= variant.valueMin && hashValue < variant.valueMax);
+        if (matchingVariant) return matchingVariant.key;
+    }
+    variantLookupTable(flag) {
+        const lookupTable = [];
+        let valueMin = 0;
+        let valueMax = 0;
+        const flagFilters = flag.filters || {};
+        const multivariates = 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) {
+        if (!this.loadedSuccessfullyOnce || forceReload) await this._loadFeatureFlags();
+    }
+    isLocalEvaluationReady() {
+        return (this.loadedSuccessfullyOnce ?? false) && (this.featureFlags?.length ?? 0) > 0;
+    }
+    getPollingInterval() {
+        if (!this.shouldBeginExponentialBackoff) return this.pollingInterval;
+        return Math.min(SIXTY_SECONDS, this.pollingInterval * 2 ** this.backOffCount);
+    }
+    async _loadFeatureFlags() {
+        if (this.poller) {
+            clearTimeout(this.poller);
+            this.poller = void 0;
+        }
+        this.poller = setTimeout(()=>this._loadFeatureFlags(), this.getPollingInterval());
+        try {
+            const res = await this._requestFeatureFlagDefinitions();
+            if (!res) return;
+            switch(res.status){
+                case 401:
+                    this.shouldBeginExponentialBackoff = true;
+                    this.backOffCount += 1;
+                    throw new ClientError(`Your project key or personal API key is invalid. Setting next polling interval to ${this.getPollingInterval()}ms. More information: https://posthog.com/docs/api#rate-limiting`);
+                case 402:
+                    console.warn('[FEATURE FLAGS] Feature flags quota limit exceeded - unsetting all local flags. Learn more about billing limits at https://posthog.com/docs/billing/limits-alerts');
+                    this.featureFlags = [];
+                    this.featureFlagsByKey = {};
+                    this.groupTypeMapping = {};
+                    this.cohorts = {};
+                    return;
+                case 403:
+                    this.shouldBeginExponentialBackoff = true;
+                    this.backOffCount += 1;
+                    throw new ClientError(`Your personal API key does not have permission to fetch feature flag definitions for local evaluation. Setting next polling interval to ${this.getPollingInterval()}ms. Are you sure you're using the correct personal and Project API key pair? More information: https://posthog.com/docs/api/overview`);
+                case 429:
+                    this.shouldBeginExponentialBackoff = true;
+                    this.backOffCount += 1;
+                    throw new ClientError(`You are being rate limited. Setting next polling interval to ${this.getPollingInterval()}ms. More information: https://posthog.com/docs/api#rate-limiting`);
+                case 200:
+                    {
+                        const responseJson = await res.json() ?? {};
+                        if (!('flags' in responseJson)) return void this.onError?.(new Error(`Invalid response when getting feature flags: ${JSON.stringify(responseJson)}`));
+                        this.featureFlags = responseJson.flags ?? [];
+                        this.featureFlagsByKey = this.featureFlags.reduce((acc, curr)=>(acc[curr.key] = curr, acc), {});
+                        this.groupTypeMapping = responseJson.group_type_mapping || {};
+                        this.cohorts = responseJson.cohorts || {};
+                        this.loadedSuccessfullyOnce = true;
+                        this.shouldBeginExponentialBackoff = false;
+                        this.backOffCount = 0;
+                        this.onLoad?.(this.featureFlags.length);
+                        break;
+                    }
+                default:
+                    return;
+            }
+        } catch (err) {
+            if (err instanceof ClientError) this.onError?.(err);
+        }
+    }
+    getPersonalApiKeyRequestOptions(method = 'GET') {
+        return {
+            method,
+            headers: {
+                ...this.customHeaders,
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${this.personalApiKey}`
+            }
+        };
+    }
+    async _requestFeatureFlagDefinitions() {
+        const url = `${this.host}/api/feature_flag/local_evaluation?token=${this.projectApiKey}&send_cohorts`;
+        const options = this.getPersonalApiKeyRequestOptions();
+        let abortTimeout = null;
+        if (this.timeout && 'number' == typeof this.timeout) {
+            const controller = new AbortController();
+            abortTimeout = safeSetTimeout(()=>{
+                controller.abort();
+            }, this.timeout);
+            options.signal = controller.signal;
+        }
+        try {
+            return await this.fetch(url, options);
+        } finally{
+            clearTimeout(abortTimeout);
+        }
+    }
+    stopPoller() {
+        clearTimeout(this.poller);
+    }
+}
+async function _hash(key, distinctId, salt = '') {
+    const hashString = await hashSHA1(`${key}.${distinctId}${salt}`);
+    return parseInt(hashString.slice(0, 15), 16) / LONG_SCALE;
+}
+function matchProperty(property, propertyValues, warnFunction) {
+    const key = property.key;
+    const value = property.value;
+    const operator = property.operator || 'exact';
+    if (key in propertyValues) {
+        if ('is_not_set' === operator) throw new InconclusiveMatchError("Operator is_not_set is not supported");
+    } else throw new InconclusiveMatchError(`Property ${key} not found in propertyValues`);
+    const overrideValue = propertyValues[key];
+    if (null == overrideValue && !NULL_VALUES_ALLOWED_OPERATORS.includes(operator)) {
+        if (warnFunction) warnFunction(`Property ${key} cannot have a value of null/undefined with the ${operator} operator`);
+        return false;
+    }
+    function computeExactMatch(value, overrideValue) {
+        if (Array.isArray(value)) return value.map((val)=>String(val).toLowerCase()).includes(String(overrideValue).toLowerCase());
+        return String(value).toLowerCase() === String(overrideValue).toLowerCase();
+    }
+    function compare(lhs, rhs, operator) {
+        if ('gt' === operator) return lhs > rhs;
+        if ('gte' === operator) return lhs >= rhs;
+        if ('lt' === operator) return lhs < rhs;
+        if ('lte' === operator) return lhs <= rhs;
+        throw new Error(`Invalid operator: ${operator}`);
+    }
+    switch(operator){
+        case 'exact':
+            return computeExactMatch(value, overrideValue);
+        case 'is_not':
+            return !computeExactMatch(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)) && null !== String(overrideValue).match(String(value));
+        case 'not_regex':
+            return isValidRegex(String(value)) && null === String(overrideValue).match(String(value));
+        case 'gt':
+        case 'gte':
+        case 'lt':
+        case 'lte':
+            {
+                let parsedValue = 'number' == typeof value ? value : null;
+                if ('string' == typeof value) try {
+                    parsedValue = parseFloat(value);
+                } catch (err) {}
+                if (null == parsedValue || null == overrideValue) return compare(String(overrideValue), String(value), operator);
+                if ('string' == typeof overrideValue) return compare(overrideValue, String(value), operator);
+                return compare(overrideValue, parsedValue, operator);
+            }
+        case 'is_date_after':
+        case 'is_date_before':
+            {
+                if ('boolean' == typeof value) throw new InconclusiveMatchError("Date operations cannot be performed on boolean values");
+                let parsedDate = relativeDateParseForFeatureFlagMatching(String(value));
+                if (null == parsedDate) parsedDate = convertToDateTime(value);
+                if (null == parsedDate) throw new InconclusiveMatchError(`Invalid date: ${value}`);
+                const overrideDate = convertToDateTime(overrideValue);
+                if ([
+                    'is_date_before'
+                ].includes(operator)) return overrideDate < parsedDate;
+                return overrideDate > parsedDate;
+            }
+        default:
+            throw new InconclusiveMatchError(`Unknown operator: ${operator}`);
+    }
+}
+function matchCohort(property, propertyValues, cohortProperties, debugMode = false) {
+    const cohortId = String(property.value);
+    if (!(cohortId in cohortProperties)) throw new InconclusiveMatchError("can't match cohort without a given cohort property value");
+    const propertyGroup = cohortProperties[cohortId];
+    return matchPropertyGroup(propertyGroup, propertyValues, cohortProperties, debugMode);
+}
+function matchPropertyGroup(propertyGroup, propertyValues, cohortProperties, debugMode = false) {
+    if (!propertyGroup) return true;
+    const propertyGroupType = propertyGroup.type;
+    const properties = propertyGroup.values;
+    if (!properties || 0 === properties.length) return true;
+    let errorMatchingLocally = false;
+    if ('values' in properties[0]) {
+        for (const prop of properties)try {
+            const matches = matchPropertyGroup(prop, propertyValues, cohortProperties, debugMode);
+            if ('AND' === propertyGroupType) {
+                if (!matches) return false;
+            } else if (matches) return true;
+        } catch (err) {
+            if (err instanceof InconclusiveMatchError) {
+                if (debugMode) console.debug(`Failed to compute property ${prop} locally: ${err}`);
+                errorMatchingLocally = true;
+            } else throw err;
+        }
+        if (errorMatchingLocally) throw new InconclusiveMatchError("Can't match cohort without a given cohort property value");
+        return 'AND' === propertyGroupType;
+    }
+    for (const prop of properties)try {
+        let matches;
+        if ('cohort' === prop.type) matches = matchCohort(prop, propertyValues, cohortProperties, debugMode);
+        else if ('flag' === prop.type) {
+            if (debugMode) console.warn(`[FEATURE FLAGS] Flag dependency filters are not supported in local evaluation. Skipping condition with dependency on flag '${prop.key || 'unknown'}'`);
+            continue;
+        } else matches = matchProperty(prop, propertyValues);
+        const negation = prop.negation || false;
+        if ('AND' === propertyGroupType) {
+            if (!matches && !negation) return false;
+            if (matches && negation) return false;
+        } else {
+            if (matches && !negation) return true;
+            if (!matches && negation) return true;
+        }
+    } catch (err) {
+        if (err instanceof InconclusiveMatchError) {
+            if (debugMode) console.debug(`Failed to compute property ${prop} locally: ${err}`);
+            errorMatchingLocally = true;
+        } else throw err;
+    }
+    if (errorMatchingLocally) throw new InconclusiveMatchError("can't match cohort without a given cohort property value");
+    return 'AND' === propertyGroupType;
+}
+function isValidRegex(regex) {
+    try {
+        new RegExp(regex);
+        return true;
+    } catch (err) {
+        return false;
+    }
+}
+function convertToDateTime(value) {
+    if (value instanceof Date) return value;
+    if ('string' == typeof value || 'number' == typeof value) {
+        const date = new Date(value);
+        if (!isNaN(date.valueOf())) return date;
+        throw new InconclusiveMatchError(`${value} is in an invalid date format`);
+    }
+    throw new InconclusiveMatchError(`The date provided ${value} must be a string, number, or date object`);
+}
+function relativeDateParseForFeatureFlagMatching(value) {
+    const regex = /^-?(?<number>[0-9]+)(?<interval>[a-z])$/;
+    const match = value.match(regex);
+    const parsedDt = new Date(new Date().toISOString());
+    if (!match) return null;
+    {
+        if (!match.groups) return null;
+        const number = parseInt(match.groups['number']);
+        if (number >= 10000) return null;
+        const interval = match.groups['interval'];
+        if ('h' == interval) parsedDt.setUTCHours(parsedDt.getUTCHours() - number);
+        else if ('d' == interval) parsedDt.setUTCDate(parsedDt.getUTCDate() - number);
+        else if ('w' == interval) parsedDt.setUTCDate(parsedDt.getUTCDate() - 7 * number);
+        else if ('m' == interval) parsedDt.setUTCMonth(parsedDt.getUTCMonth() - number);
+        else {
+            if ('y' != interval) return null;
+            parsedDt.setUTCFullYear(parsedDt.getUTCFullYear() - number);
+        }
+        return parsedDt;
+    }
+}
+export { ClientError, FeatureFlagsPoller, InconclusiveMatchError, matchProperty, relativeDateParseForFeatureFlagMatching };

package/dist/extensions/feature-flags/lazy.d.ts

@@ -0,0 +1,24 @@
+/**
+ * A lazy value that is only computed when needed. Inspired by C#'s Lazy<T> class.
+ */
+export declare class Lazy<T> {
+    private value;
+    private factory;
+    private initializationPromise;
+    constructor(factory: () => Promise<T>);
+    /**
+     * Gets the value, initializing it if necessary.
+     * Multiple concurrent calls will share the same initialization promise.
+     */
+    getValue(): Promise<T>;
+    /**
+     * Returns true if the value has been initialized.
+     */
+    isInitialized(): boolean;
+    /**
+     * Returns a promise that resolves when the value is initialized.
+     * If already initialized, resolves immediately.
+     */
+    waitForInitialization(): Promise<void>;
+}
+//# sourceMappingURL=lazy.d.ts.map

package/dist/extensions/feature-flags/lazy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lazy.d.ts","sourceRoot":"","sources":["../../../src/extensions/feature-flags/lazy.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,qBAAa,IAAI,CAAC,CAAC;IACjB,OAAO,CAAC,KAAK,CAAe;IAC5B,OAAO,CAAC,OAAO,CAAkB;IACjC,OAAO,CAAC,qBAAqB,CAAwB;gBAEzC,OAAO,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC;IAIrC;;;OAGG;IACG,QAAQ,IAAI,OAAO,CAAC,CAAC,CAAC;IAqB5B;;OAEG;IACH,aAAa,IAAI,OAAO;IAIxB;;;OAGG;IACG,qBAAqB,IAAI,OAAO,CAAC,IAAI,CAAC;CAM7C"}

package/dist/extensions/feature-flags/lazy.js

@@ -0,0 +1,60 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    Lazy: ()=>Lazy
+});
+class Lazy {
+    constructor(factory){
+        this.factory = factory;
+    }
+    async getValue() {
+        if (void 0 !== this.value) return this.value;
+        if (void 0 === this.initializationPromise) this.initializationPromise = (async ()=>{
+            try {
+                const result = await this.factory();
+                this.value = result;
+                return result;
+            } finally{
+                this.initializationPromise = void 0;
+            }
+        })();
+        return this.initializationPromise;
+    }
+    isInitialized() {
+        return void 0 !== this.value;
+    }
+    async waitForInitialization() {
+        if (this.isInitialized()) return;
+        await this.getValue();
+    }
+}
+exports.Lazy = __webpack_exports__.Lazy;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "Lazy"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/extensions/feature-flags/lazy.mjs

@@ -0,0 +1,26 @@
+class Lazy {
+    constructor(factory){
+        this.factory = factory;
+    }
+    async getValue() {
+        if (void 0 !== this.value) return this.value;
+        if (void 0 === this.initializationPromise) this.initializationPromise = (async ()=>{
+            try {
+                const result = await this.factory();
+                this.value = result;
+                return result;
+            } finally{
+                this.initializationPromise = void 0;
+            }
+        })();
+        return this.initializationPromise;
+    }
+    isInitialized() {
+        return void 0 !== this.value;
+    }
+    async waitForInitialization() {
+        if (this.isInitialized()) return;
+        await this.getValue();
+    }
+}
+export { Lazy };

package/dist/extensions/sentry-integration.d.ts

@@ -0,0 +1,54 @@
+/**
+ * @file Adapted from [posthog-js](https://github.com/PostHog/posthog-js/blob/8157df935a4d0e71d2fefef7127aa85ee51c82d1/src/extensions/sentry-integration.ts) with modifications for the Node SDK.
+ */
+/**
+ * Integrate Sentry with PostHog. This will add a direct link to the person in Sentry, and an $exception event in PostHog.
+ *
+ * ### Usage
+ *
+ *     Sentry.init({
+ *          dsn: 'https://example',
+ *          integrations: [
+ *              new PostHogSentryIntegration(posthog)
+ *          ]
+ *     })
+ *
+ *     Sentry.setTag(PostHogSentryIntegration.POSTHOG_ID_TAG, 'some distinct id');
+ *
+ * @param {Object} [posthog] The posthog object
+ * @param {string} [organization] Optional: The Sentry organization, used to send a direct link from PostHog to Sentry
+ * @param {Number} [projectId] Optional: The Sentry project id, used to send a direct link from PostHog to Sentry
+ * @param {string} [prefix] Optional: Url of a self-hosted sentry instance (default: https://sentry.io/organizations/)
+ * @param {SeverityLevel[] | '*'} [severityAllowList] Optional: send events matching the provided levels. Use '*' to send all events (default: ['error'])
+ * @param {boolean} [sendExceptionsToPostHog] Optional: capture exceptions as events in PostHog (default: true)
+ */
+import { ErrorTracking as CoreErrorTracking } from '@posthog/core';
+import { type PostHogBackendClient } from '../client';
+type _SentryEvent = any;
+type _SentryEventProcessor = any;
+type _SentryHub = any;
+interface _SentryIntegration {
+    name: string;
+    processEvent(event: _SentryEvent): _SentryEvent;
+}
+interface _SentryIntegrationClass {
+    name: string;
+    setupOnce(addGlobalEventProcessor: (callback: _SentryEventProcessor) => void, getCurrentHub: () => _SentryHub): void;
+}
+export type SentryIntegrationOptions = {
+    organization?: string;
+    projectId?: number;
+    prefix?: string;
+    severityAllowList?: CoreErrorTracking.SeverityLevel[] | '*';
+    sendExceptionsToPostHog?: boolean;
+};
+export declare function createEventProcessor(_posthog: PostHogBackendClient, { organization, projectId, prefix, severityAllowList, sendExceptionsToPostHog, }?: SentryIntegrationOptions): (event: _SentryEvent) => _SentryEvent;
+export declare function sentryIntegration(_posthog: PostHogBackendClient, options?: SentryIntegrationOptions): _SentryIntegration;
+export declare class PostHogSentryIntegration implements _SentryIntegrationClass {
+    readonly name = "posthog-node";
+    static readonly POSTHOG_ID_TAG = "posthog_distinct_id";
+    setupOnce: (addGlobalEventProcessor: (callback: _SentryEventProcessor) => void, getCurrentHub: () => _SentryHub) => void;
+    constructor(_posthog: PostHogBackendClient, organization?: string, prefix?: string, severityAllowList?: CoreErrorTracking.SeverityLevel[] | '*', sendExceptionsToPostHog?: boolean);
+}
+export {};
+//# sourceMappingURL=sentry-integration.d.ts.map

package/dist/extensions/sentry-integration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sentry-integration.d.ts","sourceRoot":"","sources":["../../src/extensions/sentry-integration.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,EAAE,aAAa,IAAI,iBAAiB,EAAE,MAAM,eAAe,CAAA;AAClE,OAAO,EAAE,KAAK,oBAAoB,EAAE,MAAM,WAAW,CAAA;AAiBrD,KAAK,YAAY,GAAG,GAAG,CAAA;AACvB,KAAK,qBAAqB,GAAG,GAAG,CAAA;AAEhC,KAAK,UAAU,GAAG,GAAG,CAAA;AAGrB,UAAU,kBAAkB;IAC1B,IAAI,EAAE,MAAM,CAAA;IACZ,YAAY,CAAC,KAAK,EAAE,YAAY,GAAG,YAAY,CAAA;CAChD;AAED,UAAU,uBAAuB;IAC/B,IAAI,EAAE,MAAM,CAAA;IACZ,SAAS,CAAC,uBAAuB,EAAE,CAAC,QAAQ,EAAE,qBAAqB,KAAK,IAAI,EAAE,aAAa,EAAE,MAAM,UAAU,GAAG,IAAI,CAAA;CACrH;AAWD,MAAM,MAAM,wBAAwB,GAAG;IACrC,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,iBAAiB,CAAC,EAAE,iBAAiB,CAAC,aAAa,EAAE,GAAG,GAAG,CAAA;IAC3D,uBAAuB,CAAC,EAAE,OAAO,CAAA;CAClC,CAAA;AAID,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,oBAAoB,EAC9B,EACE,YAAY,EACZ,SAAS,EACT,MAAM,EACN,iBAA6B,EAC7B,uBAA8B,GAC/B,GAAE,wBAA6B,GAC/B,CAAC,KAAK,EAAE,YAAY,KAAK,YAAY,CA4EvC;AAGD,wBAAgB,iBAAiB,CAC/B,QAAQ,EAAE,oBAAoB,EAC9B,OAAO,CAAC,EAAE,wBAAwB,GACjC,kBAAkB,CAQpB;AAGD,qBAAa,wBAAyB,YAAW,uBAAuB;IACtE,SAAgB,IAAI,kBAAO;IAE3B,gBAAuB,cAAc,yBAAwB;IAEtD,SAAS,EAAE,CAChB,uBAAuB,EAAE,CAAC,QAAQ,EAAE,qBAAqB,KAAK,IAAI,EAClE,aAAa,EAAE,MAAM,UAAU,KAC5B,IAAI,CAAA;gBAGP,QAAQ,EAAE,oBAAoB,EAC9B,YAAY,CAAC,EAAE,MAAM,EACrB,MAAM,CAAC,EAAE,MAAM,EACf,iBAAiB,CAAC,EAAE,iBAAiB,CAAC,aAAa,EAAE,GAAG,GAAG,EAC3D,uBAAuB,CAAC,EAAE,OAAO;CAoBpC"}