@graphql-mesh/plugin-hive/esm/index.js

import { createHive, useHive } from '@graphql-hive/yoga';
import { process } from '@graphql-mesh/cross-helpers';
import { stringInterpolator } from '@graphql-mesh/string-interpolation';
import { makeAsyncDisposable } from '@graphql-mesh/utils';
export default function useMeshHive(pluginOptions) {
    const enabled = pluginOptions != null && 'enabled' in pluginOptions
        ? typeof pluginOptions.enabled === 'string'
            ? // eslint-disable-next-line no-new-func
                new Function(`return ${pluginOptions.enabled}`)()
            : pluginOptions.enabled
        : true;
    if (!enabled) {
        pluginOptions.logger?.warn('Plugin is disabled');
        return {};
    }
    const token = stringInterpolator.parse(pluginOptions.token, {
        env: process.env,
    });
    if (token) {
        pluginOptions.logger?.info('Reporting enabled');
    }
    const persistedDocuments = pluginOptions.experimental__persistedDocuments;
    if (persistedDocuments) {
        pluginOptions.logger?.info('Persisted documents enabled');
    }
    let usage = true;
    if (pluginOptions.usage) {
        usage = {
            max: pluginOptions.usage.max,
            ttl: pluginOptions.usage.ttl,
            exclude: pluginOptions.usage.exclude,
            sampleRate: pluginOptions.usage.sampleRate,
            processVariables: pluginOptions.usage.processVariables,
        };
        if (pluginOptions.usage?.clientInfo) {
            if (typeof pluginOptions.usage.clientInfo === 'function') {
                usage.clientInfo = pluginOptions.usage.clientInfo;
            }
            else {
                usage.clientInfo = function (context) {
                    return {
                        name: stringInterpolator.parse(pluginOptions.usage.clientInfo.name, {
                            context,
                            env: process.env,
                        }),
                        version: stringInterpolator.parse(pluginOptions.usage.clientInfo.version, {
                            context,
                            env: process.env,
                        }),
                    };
                };
            }
        }
    }
    let reporting;
    if (pluginOptions.reporting) {
        reporting = {
            author: stringInterpolator.parse(pluginOptions.reporting.author, { env: process.env }),
            commit: stringInterpolator.parse(pluginOptions.reporting.commit, { env: process.env }),
            serviceName: stringInterpolator.parse(pluginOptions.reporting.serviceName, {
                env: process.env,
            }),
            serviceUrl: stringInterpolator.parse(pluginOptions.reporting.serviceUrl, {
                env: process.env,
            }),
        };
    }
    let agent = {
        name: 'graphql-mesh',
        logger: pluginOptions.logger,
    };
    if (pluginOptions.agent) {
        agent = {
            name: pluginOptions.agent.name || 'graphql-mesh',
            timeout: pluginOptions.agent.timeout,
            maxRetries: pluginOptions.agent.maxRetries,
            minTimeout: pluginOptions.agent.minTimeout,
            sendInterval: pluginOptions.agent.sendInterval,
            maxSize: pluginOptions.agent.maxSize,
            logger: pluginOptions.agent?.logger || pluginOptions.logger,
        };
    }
    let selfHosting;
    if (pluginOptions.selfHosting) {
        selfHosting = {
            graphqlEndpoint: stringInterpolator.parse(pluginOptions.selfHosting.graphqlEndpoint, {
                env: process.env,
            }),
            usageEndpoint: stringInterpolator.parse(pluginOptions.selfHosting.usageEndpoint, {
                env: process.env,
            }),
            applicationUrl: stringInterpolator.parse(pluginOptions.selfHosting.applicationUrl, {
                env: process.env,
            }),
        };
    }
    const hiveClient = createHive({
        enabled: 
        // eslint-disable-next-line no-unneeded-ternary -- for brevity
        persistedDocuments && !token
            ? false // disable usage reporting if just persisted documents are configured
            : true,
        debug: ['1', 't', 'true', 'y', 'yes'].includes(process.env.DEBUG),
        token,
        agent,
        usage,
        reporting,
        selfHosting,
        // Mesh already disposes the client below on Mesh's `destroy` event
        autoDispose: false,
        experimental__persistedDocuments: persistedDocuments,
    });
    // TODO: Remove later after v0
    // Pubsub.destroy will no longer
    function onTerminate() {
        return hiveClient
            .dispose()
            .catch(e => pluginOptions.logger?.error(`Hive client failed to dispose`, e));
    }
    const id = pluginOptions.pubsub?.subscribe('destroy', () => onTerminate().finally(() => pluginOptions.pubsub.unsubscribe(id)));
    return makeAsyncDisposable(
    // @ts-expect-error - Typings are wrong
    useHive(hiveClient), onTerminate);
}