posthog-node 1.2.0 → 2.0.0-alpha2

package/feature-flags.js

@@ -1,165 +0,0 @@
-const axios = require('axios')
-const crypto = require('crypto')
-const ms = require('ms')
-const version = require('./package.json').version
-
-const LONG_SCALE = 0xfffffffffffffff
-
-class ClientError extends Error {
-    constructor(message, extra) {
-        super()
-        Error.captureStackTrace(this, this.constructor)
-        this.name = 'ClientError'
-        this.message = message
-        if (extra) {
-            this.extra = extra
-        }
-    }
-}
-
-class FeatureFlagsPoller {
-    constructor({ pollingInterval, personalApiKey, projectApiKey, timeout, host, featureFlagCalledCallback }) {
-        this.pollingInterval = pollingInterval
-        this.personalApiKey = personalApiKey
-        this.featureFlags = []
-        this.loadedSuccessfullyOnce = false
-        this.timeout = timeout
-        this.projectApiKey = projectApiKey
-        this.featureFlagCalledCallback = featureFlagCalledCallback
-        this.host = host
-        this.poller = null
-
-        void this.loadFeatureFlags()
-    }
-
-    async isFeatureEnabled(key, distinctId, defaultResult = false) {
-        await this.loadFeatureFlags()
-
-        if (!this.loadedSuccessfullyOnce) {
-            return defaultResult
-        }
-
-        let featureFlag = null
-
-        for (const flag of this.featureFlags) {
-            if (key === flag.key) {
-                featureFlag = flag
-                break
-            }
-        }
-
-        if (!featureFlag) {
-            return defaultResult
-        }
-
-        let isFlagEnabledResponse
-
-        if (featureFlag.is_simple_flag) {
-            isFlagEnabledResponse = this._isSimpleFlagEnabled({
-                key,
-                distinctId,
-                rolloutPercentage: featureFlag.rolloutPercentage,
-            })
-        } else {
-            const res = await this._request({ path: 'decide', method: 'POST', data: { distinct_id: distinctId } })
-            isFlagEnabledResponse = res.data.featureFlags.indexOf(key) >= 0
-        }
-
-        this.featureFlagCalledCallback(key, distinctId, isFlagEnabledResponse)
-        return isFlagEnabledResponse
-    }
-
-    async loadFeatureFlags(forceReload = false) {
-        if (!this.loadedSuccessfullyOnce || forceReload) {
-            await this._loadFeatureFlags()
-        }
-    }
-
-    /* istanbul ignore next */
-    async _loadFeatureFlags() {
-        if (this.poller) {
-            clearTimeout(this.poller)
-            this.poller = null
-        }
-        this.poller = setTimeout(() => this._loadFeatureFlags(), this.pollingInterval)
-
-        try {
-            const res = await this._request({ path: 'api/feature_flag', usePersonalApiKey: true })
-            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`
-                )
-            }
-
-            this.featureFlags = res.data.results.filter(flag => flag.active)
-
-            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
-            }
-        }
-    }
-
-    // sha1('a.b') should equal '69f6642c9d71b463485b4faf4e989dc3fe77a8c6'
-    // integerRepresentationOfHashSubset / LONG_SCALE for sha1('a.b') should equal 0.4139158829615955
-    _isSimpleFlagEnabled({ key, distinctId, rolloutPercentage }) {
-        if (!rolloutPercentage) {
-            return true
-        }
-        const sha1Hash = crypto.createHash('sha1')
-        sha1Hash.update(`${key}.${distinctId}`)
-        const integerRepresentationOfHashSubset = parseInt(sha1Hash.digest('hex').slice(0, 15), 16)
-        return integerRepresentationOfHashSubset / LONG_SCALE <= rolloutPercentage / 100
-    }
-
-    /* istanbul ignore next */
-    async _request({ path, method = 'GET', usePersonalApiKey = false, data = {} }) {
-        let url = `${this.host}/${path}/`
-        let headers = {
-            'Content-Type': 'application/json',
-        }
-
-        if (usePersonalApiKey) {
-            headers = { ...headers, Authorization: `Bearer ${this.personalApiKey}` }
-            url = url + `?token=${this.projectApiKey}`
-        } else {
-            data = { ...data, token: this.projectApiKey }
-        }
-
-        if (typeof window === 'undefined') {
-            headers['user-agent'] = `posthog-node/${version}`
-        }
-
-        const req = {
-            method: method,
-            url: url,
-            headers: headers,
-            data: JSON.stringify(data),
-        }
-
-        if (this.timeout) {
-            req.timeout = typeof this.timeout === 'string' ? ms(this.timeout) : this.timeout
-        }
-
-
-        let res
-        try {
-            res = await axios(req)
-        } catch (err) {
-            throw new Error(`Request to ${path} failed with error: ${err.message}`)
-        }
-
-        return res
-    }
-
-    stopPoller() {
-        clearTimeout(this.poller)
-    }
-}
-
-module.exports = {
-    FeatureFlagsPoller,
-}

package/index.d.ts

@@ -1,102 +0,0 @@
-// Type definitions for posthog-node
-// Project: Posthog
-
-declare module 'posthog-node' {
-    interface Option {
-        flushAt?: number
-        flushInterval?: number
-        host?: string
-        enable?: boolean
-        personalApiKey?: string
-        featureFlagsPollingInterval?: number
-    }
-    interface IdentifyMessage {
-        distinctId: string
-        properties?: Record<string | number, any>
-    }
-
-    interface EventMessage extends IdentifyMessage {
-        event: string
-        groups?: Record<string, string | number> // Mapping of group type to group id
-    }
-
-    interface GroupIdentifyMessage {
-        groupType: string
-        groupKey: string // Unique identifier for the group
-        properties?: Record<string | number, any>
-    }
-
-    export default class PostHog {
-        constructor(apiKey: string, options?: Option)
-        /**
-         * @description Capture allows you to capture anything a user does within your system,
-         * which you can later use in PostHog to find patterns in usage,
-         * work out which features to improve or where people are giving up.
-         * A capture call requires:
-         * @param distinctId which uniquely identifies your user
-         * @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.
-         */
-        capture({ distinctId, event, properties, groups }: EventMessage): void
-
-        /**
-         * @description Identify lets you add metadata on your users so you can more easily identify who they are in PostHog,
-         * and even do things like segment users by these properties.
-         * An identify call requires:
-         * @param distinctId which uniquely identifies your user
-         * @param properties with a dict with any key: value pairs
-         */
-        identify({ distinctId, properties }: IdentifyMessage): void
-
-        /**
-         * @description To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call.
-         * This will allow you to answer questions like "Which marketing channels leads to users churning after a month?"
-         * or "What do users do on our website before signing up?"
-         * In a purely back-end implementation, this means whenever an anonymous user does something, you'll want to send a session ID with the capture call.
-         * Then, when that users signs up, you want to do an alias call with the session ID and the newly created user ID.
-         * The same concept applies for when a user logs in. If you're using PostHog in the front-end and back-end,
-         *  doing the identify call in the frontend will be enough.:
-         * @param distinctId the current unique id
-         * @param alias the unique ID of the user before
-         */
-        alias(data: { distinctId: string; alias: string }): void
-
-
-        /**
-         * @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.
-         * 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
-        */
-        isFeatureEnabled(key: string, distinctId: string, defaultResult?: boolean): Promise<boolean>
-
-
-        /**
-         * @description Sets a groups properties, which allows asking questions like "Who are the most active companies"
-         * using my product in PostHog.
-         *
-         * @param groupType Type of group (ex: 'company'). Limited to 5 per project
-         * @param groupKey Unique identifier for that type of group (ex: 'id:5')
-         * @param properties OPTIONAL | which can be a object with any information you'd like to add
-        */
-       groupIdentify({ groupType, groupKey, properties }: GroupIdentifyMessage): void
-
-        /**
-         * @description Force an immediate reload of the polled feature flags. Please note that they are
-         * already polled automatically at a regular interval.
-        */
-        reloadFeatureFlags(): Promise<void>
-
-        /**
-         * @description Flushes the events still in the queue and clears the feature flags poller to allow for
-         * a clean shutdown.
-        */
-        shutdown(): void
-    }
-
-}

package/index.js

@@ -1,360 +0,0 @@
-'use strict'
-
-const assert = require('assert')
-const removeSlash = require('remove-trailing-slash')
-const axios = require('axios')
-const axiosRetry = require('axios-retry')
-const ms = require('ms')
-const version = require('./package.json').version
-const looselyValidate = require('./event-validation')
-const { FeatureFlagsPoller } = require('./feature-flags')
-
-const setImmediate = global.setImmediate || process.nextTick.bind(process)
-const noop = () => {}
-
-const FIVE_MINUTES = 5 * 60 * 1000
-class PostHog {
-    /**
-     * Initialize a new `PostHog` with your PostHog project's `apiKey` and an
-     * optional dictionary of `options`.
-     *
-     * @param {String} apiKey
-     * @param {Object} [options] (optional)
-     *   @property {Number} flushAt (default: 20)
-     *   @property {Number} flushInterval (default: 10000)
-     *   @property {String} host (default: 'https://app.posthog.com')
-     *   @property {Boolean} enable (default: true)
-     *   @property {String} featureFlagsPollingInterval (default: 300000)
-     *   @property {String} personalApiKey
-     */
-
-    constructor(apiKey, options) {
-        options = options || {}
-
-        assert(apiKey, "You must pass your PostHog project's api key.")
-
-        this.queue = []
-        this.apiKey = apiKey
-        this.host = removeSlash(options.host || 'https://app.posthog.com')
-        this.timeout = options.timeout || false
-        this.flushAt = Math.max(options.flushAt, 1) || 20
-        this.flushInterval = typeof options.flushInterval === 'number' ? options.flushInterval : 10000
-        this.flushed = false
-        this.personalApiKey = options.personalApiKey
-
-        Object.defineProperty(this, 'enable', {
-            configurable: false,
-            writable: false,
-            enumerable: true,
-            value: typeof options.enable === 'boolean' ? options.enable : true,
-        })
-
-        axiosRetry(axios, {
-            retries: options.retryCount || 3,
-            retryCondition: this._isErrorRetryable,
-            retryDelay: axiosRetry.exponentialDelay,
-        })
-
-        if (this.personalApiKey) {
-            const featureFlagCalledCallback = (key, distinctId, isFlagEnabledResponse) => {
-                this.capture({
-                    distinctId,
-                    event: '$feature_flag_called',
-                    properties: {
-                        $feature_flag: key,
-                        $feature_flag_response: isFlagEnabledResponse,
-                    },
-                })
-            }
-
-            this.featureFlagsPoller = new FeatureFlagsPoller({
-                pollingInterval:
-                    typeof options.featureFlagsPollingInterval === 'number'
-                        ? options.featureFlagsPollingInterval
-                        : FIVE_MINUTES,
-                personalApiKey: options.personalApiKey,
-                projectApiKey: apiKey,
-                timeout: options.timeout || false,
-                host: this.host,
-                featureFlagCalledCallback,
-            })
-        }
-    }
-
-    _validate(message, type) {
-        try {
-            looselyValidate(message, type)
-        } catch (e) {
-            if (e.message === 'Your message must be < 32 kB.') {
-                console.log(
-                    'Your message must be < 32 kB.',
-                    JSON.stringify(message)
-                )
-                return
-            }
-            throw e
-        }
-    }
-
-    /**
-     * Send an identify `message`.
-     *
-     * @param {Object} message
-     * @param {Function} [callback] (optional)
-     * @return {PostHog}
-     */
-
-    identify(message, callback) {
-        this._validate(message, 'identify')
-
-        const apiMessage = Object.assign({}, message, {
-            $set: message.properties || {},
-            event: '$identify',
-            properties: {
-                $lib: 'posthog-node',
-                $lib_version: version,
-            },
-        })
-
-        this.enqueue('identify', apiMessage, callback)
-        return this
-    }
-
-    /**
-     * Send a capture `message`.
-     *
-     * @param {Object} message
-     * @param {Function} [callback] (optional)
-     * @return {PostHog}
-     */
-
-    capture(message, callback) {
-        this._validate(message, 'capture')
-
-        const properties = Object.assign({}, message.properties, {
-            $lib: 'posthog-node',
-            $lib_version: version,
-        })
-
-        if ('groups' in message) {
-            properties.$groups = message.groups
-            delete message.groups
-        }
-
-        const apiMessage = Object.assign({}, message, { properties })
-
-        this.enqueue('capture', apiMessage, callback)
-        return this
-    }
-
-    /**
-     * Send an alias `message`.
-     *
-     * @param {Object} message
-     * @param {Function} [callback] (optional)
-     * @return {PostHog}
-     */
-
-    alias(message, callback) {
-        this._validate(message, 'alias')
-
-        const apiMessage = Object.assign({}, message, {
-            event: '$create_alias',
-            properties: {
-                distinct_id: message.distinctId || message.distinct_id,
-                alias: message.alias,
-                $lib: 'posthog-node',
-                $lib_version: version,
-            },
-        })
-        delete apiMessage.alias
-        delete apiMessage.distinctId
-        apiMessage.distinct_id = message.distinctId || message.distinct_id
-
-        this.enqueue('alias', apiMessage, callback)
-        return this
-    }
-
-    /**
-     * @description Sets a groups properties, which allows asking questions like "Who are the most active companies"
-     * using my product in PostHog.
-     *
-     * @param groupType Type of group (ex: 'company'). Limited to 5 per project
-     * @param groupKey Unique identifier for that type of group (ex: 'id:5')
-     * @param properties OPTIONAL | which can be a object with any information you'd like to add
-     */
-    groupIdentify(message, callback) {
-        this._validate(message, 'groupIdentify')
-
-        const captureMessage = {
-            event: '$groupidentify',
-            distinctId: `\$${message.groupType}_${message.groupKey}`,
-            properties: {
-                $group_type: message.groupType,
-                $group_key: message.groupKey,
-                $group_set: message.properties || {}
-            }
-        }
-
-        return this.capture(captureMessage, callback)
-    }
-
-    /**
-     * Add a `message` of type `type` to the queue and
-     * check whether it should be flushed.
-     *
-     * @param {String} type
-     * @param {Object} message
-     * @param {Function} [callback] (optional)
-     * @api private
-     */
-
-    enqueue(type, message, callback) {
-        callback = callback || noop
-
-        if (!this.enable) {
-            return setImmediate(callback)
-        }
-
-        message = Object.assign({}, message)
-        message.type = type
-        message.library = 'posthog-node'
-        message.library_version = version
-
-        if (!message.timestamp) {
-            message.timestamp = new Date()
-        }
-
-        if (message.distinctId) {
-            message.distinct_id = message.distinctId
-            delete message.distinctId
-        }
-
-        this.queue.push({ message, callback })
-
-        if (!this.flushed) {
-            this.flushed = true
-            this.flush()
-            return
-        }
-
-        if (this.queue.length >= this.flushAt) {
-            this.flush()
-        }
-
-        if (this.flushInterval && !this.timer) {
-            this.timer = setTimeout(() => this.flush(), this.flushInterval)
-        }
-    }
-
-    async isFeatureEnabled(key, distinctId, defaultResult) {
-        assert(this.personalApiKey, 'You have to specify the option personalApiKey to use feature flags.')
-        return await this.featureFlagsPoller.isFeatureEnabled(key, distinctId, defaultResult)
-    }
-
-    async reloadFeatureFlags() {
-        await this.featureFlagsPoller.loadFeatureFlags(true)
-    }
-
-    /**
-     * Flush the current queue
-     *
-     * @param {Function} [callback] (optional)
-     * @return {PostHog}
-     */
-
-    flush(callback) {
-        callback = callback || noop
-
-        if (!this.enable) {
-            return setImmediate(callback)
-        }
-
-        if (this.timer) {
-            clearTimeout(this.timer)
-            this.timer = null
-        }
-
-        if (!this.queue.length) {
-            return setImmediate(callback)
-        }
-
-        const items = this.queue.splice(0, this.flushAt)
-        const callbacks = items.map((item) => item.callback)
-        const messages = items.map((item) => item.message)
-
-        const data = {
-            api_key: this.apiKey,
-            batch: messages,
-        }
-
-        const done = (err) => {
-            callbacks.forEach((callback) => callback(err))
-            callback(err, data)
-        }
-
-        // Don't set the user agent if we're not on a browser. The latest spec allows
-        // the User-Agent header (see https://fetch.spec.whatwg.org/#terminology-headers
-        // and https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/setRequestHeader),
-        // but browsers such as Chrome and Safari have not caught up.
-        const headers = {}
-        if (typeof window === 'undefined') {
-            headers['user-agent'] = `posthog-node/${version}`
-        }
-
-        const req = {
-            method: 'POST',
-            url: `${this.host}/batch/`,
-            data,
-            headers,
-        }
-
-        if (this.timeout) {
-            req.timeout = typeof this.timeout === 'string' ? ms(this.timeout) : this.timeout
-        }
-
-        axios(req)
-            .then(() => done())
-            .catch((err) => {
-                if (err.response) {
-                    const error = new Error(err.response.statusText)
-                    return done(error)
-                }
-
-                done(err)
-            })
-    }
-
-    shutdown() {
-        if (this.personalApiKey) {
-            this.featureFlagsPoller.stopPoller()
-        }
-        this.flush()
-    }
-
-    _isErrorRetryable(error) {
-        // Retry Network Errors.
-        if (axiosRetry.isNetworkError(error)) {
-            return true
-        }
-
-        if (!error.response) {
-            // Cannot determine if the request can be retried
-            return false
-        }
-
-        // Retry Server Errors (5xx).
-        if (error.response.status >= 500 && error.response.status <= 599) {
-            return true
-        }
-
-        // Retry if rate limited.
-        if (error.response.status === 429) {
-            return true
-        }
-
-        return false
-    }
-}
-
-module.exports = PostHog