posthog-node 1.1.5

package/LICENSE

@@ -0,0 +1,21 @@
+Copyright (c) 2020 PostHog (part of Hiberly Inc)
+
+Copyright (c) 2013 Segment Inc. friends@segment.com
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,24 @@
+# PostHog Node.js Library
+
+[![npm package](https://img.shields.io/npm/v/posthog-node?style=flat-square)](https://www.npmjs.com/package/posthog-node)
+[![MIT License](https://img.shields.io/badge/License-MIT-red.svg?style=flat-square)](https://opensource.org/licenses/MIT)
+
+Please see [PostHog Docs](https://posthog.com/docs).
+Specifically, [Node.js library details](https://posthog.com/docs/libraries/node).
+
+## Releasing a new version
+
+Just bump up `version` in `package.json` on the main branch and the new version will be published automatically.
+
+It's advised to use `bump patch/minor/major` label on PRs - that way the above will be done automatically
+when the PR is merged.
+
+Courtesy of GitHub Actions.
+
+## Thanks
+
+This library is largely based on the `analytics-node` package.
+
+## Questions?
+
+### [Join our Slack community.](https://posthog.com/slack)

package/cli.js

@@ -0,0 +1,72 @@
+#!/usr/bin/env node
+'use strict'
+
+const program = require('commander')
+const PostHog = require('.')
+const pkg = require('./package')
+
+const toObject = (str) => JSON.parse(str)
+
+program
+    .version(pkg.version)
+    .option('-k, --apiKey <key>', 'the PostHog api key to use')
+    .option('-h, --host <host>', 'the PostHog API hostname to use')
+    .option('-t, --type <type>', 'the PostHog message type')
+
+    .option('-d, --distinctId <id>', 'the distinct id to send the event as')
+
+    .option('-e, --event <event>', 'the event name to send with the event')
+    .option('-p, --properties <properties>', 'the event properties to send (JSON-encoded)', toObject)
+
+    .option('-a, --alias <previousId>', 'alias for the distinct id')
+
+    .parse(process.argv)
+
+if (program.args.length !== 0) {
+    program.help()
+}
+
+const apiKey = program.apiKey
+const host = program.host
+const type = program.type
+
+const distinctId = program.distinctId
+
+const event = program.event
+const properties = program.properties
+const alias = program.alias
+
+const run = (method, args) => {
+    const posthog = new PostHog(apiKey, { host, flushAt: 1 })
+    posthog[method](args, (err) => {
+        if (err) {
+            console.error(err.stack)
+            process.exit(1)
+        }
+    })
+}
+
+switch (type) {
+    case 'capture':
+        run('capture', {
+            event,
+            properties,
+            distinctId,
+        })
+        break
+    case 'identify':
+        run('identify', {
+            properties,
+            distinctId,
+        })
+        break
+    case 'alias':
+        run('alias', {
+            alias,
+            distinctId,
+        })
+        break
+    default:
+        console.error('invalid type:', type)
+        process.exit(1)
+}

package/event-validation.js

@@ -0,0 +1,94 @@
+var type = require('component-type')
+var join = require('join-component')
+var assert = require('assert')
+
+// PostHog messages can be a maximum of 32 kB.
+var MAX_SIZE = 32 << 10
+
+module.exports = eventValidation
+
+/**
+ * Validate an event.
+ */
+
+function eventValidation(event, type) {
+    validateGenericEvent(event)
+    type = type || event.type
+    assert(type, 'You must pass an event type.')
+    switch (type) {
+        case 'capture':
+            return validateCaptureEvent(event)
+        case 'identify':
+            return validateIdentifyEvent(event)
+        case 'alias':
+            return validateAliasEvent(event)
+        default:
+            assert(0, 'Invalid event type: "' + type + '"')
+    }
+}
+
+/**
+ * Validate a "capture" event.
+ */
+
+function validateCaptureEvent(event) {
+    assert(event.distinctId, 'You must pass a "distinctId".')
+    assert(event.event, 'You must pass an "event".')
+}
+
+/**
+ * Validate a "identify" event.
+ */
+
+function validateIdentifyEvent(event) {
+    assert(event.distinctId, 'You must pass a "distinctId".')
+}
+
+/**
+ * Validate an "alias" event.
+ */
+
+function validateAliasEvent(event) {
+    assert(event.distinctId, 'You must pass a "distinctId".')
+    assert(event.alias, 'You must pass a "alias".')
+}
+
+/**
+ * Validation rules.
+ */
+
+var genericValidationRules = {
+    event: 'string',
+    properties: 'object',
+    alias: 'string',
+    timestamp: 'date',
+    distinctId: 'string',
+    type: 'string',
+}
+
+/**
+ * Validate an event object.
+ */
+
+function validateGenericEvent(event) {
+    assert(type(event) === 'object', 'You must pass a message object.')
+    var json = JSON.stringify(event)
+    // Strings are variable byte encoded, so json.length is not sufficient.
+    assert(Buffer.byteLength(json, 'utf8') < MAX_SIZE, 'Your message must be < 32 kB.')
+
+    for (var key in genericValidationRules) {
+        var val = event[key]
+        if (!val) continue
+        var rule = genericValidationRules[key]
+        if (type(rule) !== 'array') {
+            rule = [rule]
+        }
+        var a = rule[0] === 'object' ? 'an' : 'a'
+        assert(
+            rule.some(function (e) {
+                return type(val) === e
+            }),
+            '"' + key + '" must be ' + a + ' ' + join(rule, 'or') + '.'
+        )
+    }
+}

package/feature-flags.js

@@ -0,0 +1,145 @@
+const axios = require('axios')
+const crypto = require('crypto')
+const ms = require('ms')
+const version = require('./package.json').version
+
+const LONG_SCALE = 0xfffffffffffffff
+
+
+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)
+
+        const res = await this._request({ path: 'api/feature_flag', usePersonalApiKey: true })
+
+        if (res && res.status === 401) {
+            throw new Error(
+                `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
+    }
+
+    // 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

@@ -0,0 +1,84 @@
+// 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
+    }
+
+    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 dict with any information you'd like to add
+         */
+        capture({ distinctId, event, properties }: 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 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

@@ -0,0 +1,331 @@
+'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 apiMessage = Object.assign({}, message, {
+            properties: Object.assign({}, message.properties, {
+                $lib: 'posthog-node',
+                $lib_version: version,
+            }),
+        })
+
+        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
+    }
+
+    /**
+     * 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

package/package.json

@@ -0,0 +1,69 @@
+{
+    "name": "posthog-node",
+    "version": "1.1.5",
+    "description": "PostHog Node.js integration",
+    "license": "MIT",
+    "repository": "PostHog/posthog-node",
+    "author": {
+        "name": "PostHog",
+        "email": "hey@posthog.com",
+        "url": "https://posthog.com"
+    },
+    "engines": {
+        "node": ">=4"
+    },
+    "size-limit": [
+        {
+            "limit": "25 KB",
+            "path": "index.js"
+        }
+    ],
+    "scripts": {
+        "dependencies": "yarn",
+        "size": "size-limit",
+        "test": "nyc ava tests/*.js",
+        "report-coverage": "nyc report --reporter=lcov > coverage.lcov && codecov",
+        "format": "prettier --write ."
+    },
+    "files": [
+        "index.js",
+        "index.d.ts",
+        "event-validation.js",
+        "cli.js",
+        "feature-flags.js"
+    ],
+    "bin": {
+        "posthog": "cli.js"
+    },
+    "keywords": [
+        "posthog",
+        "stats",
+        "analysis",
+        "funnels"
+    ],
+    "dependencies": {
+        "axios": "^0.21.1",
+        "axios-retry": "^3.1.9",
+        "component-type": "^1.2.1",
+        "join-component": "^1.1.0",
+        "md5": "^2.3.0",
+        "ms": "^2.1.3",
+        "remove-trailing-slash": "^0.1.1",
+        "uuid": "^8.3.2"
+    },
+    "devDependencies": {
+        "ava": "^0.25.0",
+        "basic-auth": "^2.0.1",
+        "body-parser": "^1.17.1",
+        "codecov": "^3.0.0",
+        "commander": "^2.9.0",
+        "delay": "^4.2.0",
+        "express": "^4.15.2",
+        "nyc": "^14.1.1",
+        "pify": "^4.0.1",
+        "prettier": "^2.3.1",
+        "sinon": "^7.3.2",
+        "size-limit": "^1.3.5",
+        "snyk": "^1.171.1"
+    }
+}