@graphql-hive/client/index.mjs

import axios from 'axios';
import { Kind, TypeInfo, visit, visitWithTypeInfo, isNonNullType, isListType, isScalarType, isEnumType, isInputObjectType, stripIgnoredCharacters, print, parse } from 'graphql';
import LRU from 'tiny-lru';
import { normalizeOperation } from '@graphql-hive/core';
import retry from 'async-retry';
import { createHash } from 'crypto';
import { getDocumentNodeFromSchema } from '@graphql-tools/utils';

const version = '0.18.5';

function createAgent(pluginOptions, { prefix, data, body, headers = () => ({}), }) {
    const options = Object.assign({ timeout: 30000, debug: false, enabled: true, minTimeout: 200, maxRetries: 3, sendInterval: 10000, maxSize: 25, logger: console, name: 'Hive' }, pluginOptions);
    const enabled = options.enabled !== false;
    let timeoutID = null;
    function schedule() {
        if (timeoutID) {
            clearTimeout(timeoutID);
        }
        timeoutID = setTimeout(send, options.sendInterval);
    }
    function debugLog(msg) {
        if (options.debug) {
            options.logger.info(`[hive][${prefix}]${enabled ? '' : '[DISABLED]'} ${msg}`);
        }
    }
    let scheduled = false;
    function capture(event) {
        // Calling capture starts the schedule
        if (!scheduled) {
            scheduled = true;
            schedule();
        }
        data.set(event);
        if (data.size() >= options.maxSize) {
            debugLog('Sending immediately');
            setImmediate(() => send({ runOnce: true, throwOnError: false }));
        }
    }
    function sendImmediately(event) {
        data.set(event);
        debugLog('Sending immediately');
        return send({ runOnce: true, throwOnError: true });
    }
    async function send(sendOptions) {
        var _a;
        const runOnce = (_a = sendOptions === null || sendOptions === void 0 ? void 0 : sendOptions.runOnce) !== null && _a !== void 0 ? _a : false;
        if (!data.size()) {
            if (!runOnce) {
                schedule();
            }
            return null;
        }
        try {
            const buffer = await body();
            const dataToSend = data.size();
            data.clear();
            const sendReport = async (_bail, attempt) => {
                debugLog(`Sending (queue ${dataToSend}) (attempt ${attempt})`);
                if (!enabled) {
                    return {
                        status: 200,
                        data: null,
                    };
                }
                const response = await axios
                    .post(options.endpoint, buffer, {
                    headers: Object.assign({ accept: 'application/json', 'content-type': 'application/json', Authorization: `Bearer ${options.token}`, 'User-Agent': `${options.name}@${version}` }, headers()),
                    responseType: 'json',
                    timeout: options.timeout,
                })
                    .catch(error => {
                    debugLog(`Attempt ${attempt} failed: ${error.message}`);
                    return Promise.reject(error);
                });
                if (response.status >= 200 && response.status < 300) {
                    return response;
                }
                debugLog(`Attempt ${attempt} failed: ${response.status}`);
                throw new Error(`${response.status}: ${response.statusText}`);
            };
            const response = await retry(sendReport, {
                retries: options.maxRetries,
                minTimeout: options.minTimeout,
                factor: 2,
            });
            if (response.status < 200 || response.status >= 300) {
                throw new Error(`[hive][${prefix}] Failed to send data (HTTP status ${response.status}): ${response.data}`);
            }
            debugLog(`Sent!`);
            if (!runOnce) {
                schedule();
            }
            return response.data;
        }
        catch (error) {
            if (!runOnce) {
                schedule();
            }
            if (sendOptions === null || sendOptions === void 0 ? void 0 : sendOptions.throwOnError) {
                throw error;
            }
            options.logger.error(`[hive][${prefix}] Failed to send data: ${error.message}`);
            return null;
        }
    }
    async function dispose() {
        debugLog('Disposing');
        if (timeoutID) {
            clearTimeout(timeoutID);
        }
        await send({
            runOnce: true,
            throwOnError: false,
        });
    }
    return {
        capture,
        sendImmediately,
        dispose,
    };
}

function randomSampling(sampleRate) {
    if (sampleRate > 1 || sampleRate < 0) {
        throw new Error(`Expected usage.sampleRate to be 0 <= x <= 1, received ${sampleRate}`);
    }
    return function shouldInclude() {
        return Math.random() <= sampleRate;
    };
}

function isAsyncIterableIterator(value) {
    return typeof (value === null || value === void 0 ? void 0 : value[Symbol.asyncIterator]) === 'function';
}
function memo(fn, cacheKeyFn) {
    let memoizedResult = null;
    let memoizedKey = null;
    return (arg) => {
        const currentKey = cacheKeyFn(arg);
        if (memoizedKey === currentKey) {
            return memoizedResult;
        }
        memoizedKey = currentKey;
        memoizedResult = fn(arg);
        return memoizedResult;
    };
}
function cache(fn, cacheKeyFn, cacheMap) {
    return (arg, arg2) => {
        const key = cacheKeyFn(arg, arg2);
        const cachedValue = cacheMap.get(key);
        if (cachedValue !== null && typeof cachedValue !== 'undefined') {
            return {
                key,
                value: cachedValue,
                cacheHit: true,
            };
        }
        const value = fn(arg, arg2);
        cacheMap.set(key, value);
        return {
            key,
            value,
            cacheHit: false,
        };
    };
}
function cacheDocumentKey(doc, variables) {
    const hasher = createHash('md5').update(JSON.stringify(doc));
    if (variables) {
        hasher.update(JSON.stringify(variables, (_, value) => {
            if ((value && typeof value === 'object' && Object.keys(value).length) ||
                (Array.isArray(value) && value.length)) {
                return value;
            }
            return '';
        }));
    }
    return hasher.digest('hex');
}
const HR_TO_NS = 1e9;
const NS_TO_MS = 1e6;
function deltaFrom(hrtime) {
    const delta = process.hrtime(hrtime);
    const ns = delta[0] * HR_TO_NS + delta[1];
    return {
        ns,
        get ms() {
            return ns / NS_TO_MS;
        },
    };
}
function measureDuration() {
    const startAt = process.hrtime();
    return function end() {
        return deltaFrom(startAt).ns;
    };
}
function isHiveClient(clientOrOptions) {
    return 'operationsStore' in clientOrOptions;
}
function logIf(condition, message, logFn) {
    if (condition) {
        logFn(message);
    }
}

function createUsage(pluginOptions) {
    var _a, _b, _c, _d, _e, _f;
    if (!pluginOptions.usage || pluginOptions.enabled === false) {
        return {
            collect() {
                return () => { };
            },
            async dispose() { },
        };
    }
    let report = {
        size: 0,
        map: {},
        operations: [],
    };
    const options = typeof pluginOptions.usage === 'boolean' ? {} : pluginOptions.usage;
    const logger = (_b = (_a = pluginOptions.agent) === null || _a === void 0 ? void 0 : _a.logger) !== null && _b !== void 0 ? _b : console;
    const collector = memo(createCollector, arg => arg.schema);
    const excludeSet = new Set((_c = options.exclude) !== null && _c !== void 0 ? _c : []);
    const agent = createAgent(Object.assign(Object.assign({ logger }, ((_d = pluginOptions.agent) !== null && _d !== void 0 ? _d : {
        maxSize: 1500,
    })), { endpoint: (_e = options.endpoint) !== null && _e !== void 0 ? _e : 'https://app.graphql-hive.com/usage', token: pluginOptions.token, enabled: pluginOptions.enabled, debug: pluginOptions.debug }), {
        prefix: 'usage',
        data: {
            set(operation) {
                report.operations.push({
                    operationMapKey: operation.key,
                    timestamp: operation.timestamp,
                    execution: {
                        ok: operation.execution.ok,
                        duration: operation.execution.duration,
                        errorsTotal: operation.execution.errorsTotal,
                        errors: operation.execution.errors,
                    },
                    metadata: {
                        client: operation.client,
                    },
                });
                report.size += 1;
                if (!report.map[operation.key]) {
                    report.map[operation.key] = {
                        operation: operation.operation,
                        operationName: operation.operationName,
                        fields: operation.fields,
                    };
                }
            },
            size() {
                return report.size;
            },
            clear() {
                report = {
                    size: 0,
                    map: {},
                    operations: [],
                };
            },
        },
        headers() {
            return {
                'Content-Type': 'application/json',
                'graphql-client-name': 'Hive Client',
                'graphql-client-version': version,
            };
        },
        body() {
            return JSON.stringify(report);
        },
    });
    logIf(typeof pluginOptions.token !== 'string' || pluginOptions.token.length === 0, '[hive][usage] token is missing', logger.error);
    const shouldInclude = randomSampling((_f = options.sampleRate) !== null && _f !== void 0 ? _f : 1.0);
    return {
        dispose: agent.dispose,
        collect(args) {
            const finish = measureDuration();
            return function complete(result) {
                var _a, _b, _c, _d, _e, _f;
                try {
                    if (isAsyncIterableIterator(result)) {
                        logger.info('@stream @defer is not supported');
                        finish();
                        return;
                    }
                    const rootOperation = args.document.definitions.find(o => o.kind === Kind.OPERATION_DEFINITION);
                    const document = args.document;
                    const operationName = args.operationName || ((_a = rootOperation.name) === null || _a === void 0 ? void 0 : _a.value) || 'anonymous';
                    const duration = finish();
                    if (!excludeSet.has(operationName) && shouldInclude()) {
                        const errors = (_c = (_b = result.errors) === null || _b === void 0 ? void 0 : _b.map(error => {
                            var _a;
                            return ({
                                message: error.message,
                                path: (_a = error.path) === null || _a === void 0 ? void 0 : _a.join('.'),
                            });
                        })) !== null && _c !== void 0 ? _c : [];
                        const collect = collector({
                            schema: args.schema,
                            max: (_d = options.max) !== null && _d !== void 0 ? _d : 1000,
                            ttl: options.ttl,
                            processVariables: (_e = options.processVariables) !== null && _e !== void 0 ? _e : false,
                        });
                        const { key, value: info } = collect(document, (_f = args.variableValues) !== null && _f !== void 0 ? _f : null);
                        agent.capture({
                            key,
                            timestamp: Date.now(),
                            operationName,
                            operation: info.document,
                            fields: info.fields,
                            execution: {
                                ok: errors.length === 0,
                                duration,
                                errorsTotal: errors.length,
                                errors,
                            },
                            // TODO: operationHash is ready to accept hashes of persisted operations
                            client: typeof args.contextValue !== 'undefined' && typeof options.clientInfo !== 'undefined'
                                ? options.clientInfo(args.contextValue)
                                : null,
                        });
                    }
                }
                catch (error) {
                    logger.error(`Failed to collect operation`, error);
                }
            };
        },
    };
}
function createCollector({ schema, max, ttl, processVariables = false, }) {
    const typeInfo = new TypeInfo(schema);
    function collect(doc, variables) {
        const entries = new Set();
        const collected_entire_named_types = new Set();
        const shouldAnalyzeVariableValues = processVariables === true && variables !== null;
        function markAsUsed(id) {
            if (!entries.has(id)) {
                entries.add(id);
            }
        }
        function makeId(...names) {
            return names.join('.');
        }
        const collectedInputTypes = {};
        function collectInputType(inputType, fieldName) {
            if (!collectedInputTypes[inputType]) {
                collectedInputTypes[inputType] = {
                    all: false,
                    fields: new Set(),
                };
            }
            if (fieldName) {
                collectedInputTypes[inputType].fields.add(fieldName);
            }
            else {
                collectedInputTypes[inputType].all = true;
            }
        }
        function collectNode(node) {
            const inputType = typeInfo.getInputType();
            const inputTypeName = resolveTypeName(inputType);
            if (node.value.kind === Kind.ENUM) {
                // Collect only a specific enum value
                collectInputType(inputTypeName, node.value.value);
            }
            else if (node.value.kind !== Kind.OBJECT && node.value.kind !== Kind.LIST) {
                // When processing of variables is enabled,
                // we want to skip collecting full input types of variables
                // and only collect specific fields.
                // That's why the following condition is added.
                // Otherwise we would mark entire input types as used, and not granular fields.
                if (node.value.kind === Kind.VARIABLE && shouldAnalyzeVariableValues) {
                    return;
                }
                collectInputType(inputTypeName);
            }
        }
        function markEntireTypeAsUsed(type) {
            const namedType = unwrapType(type);
            if (collected_entire_named_types.has(namedType.name)) {
                // No need to mark this type as used again
                return;
            }
            else {
                // Add this type to the set of types that have been marked as used
                // to avoid infinite loops
                collected_entire_named_types.add(namedType.name);
            }
            if (isScalarType(namedType)) {
                markAsUsed(makeId(namedType.name));
                return;
            }
            if (isEnumType(namedType)) {
                namedType.getValues().forEach(value => {
                    markAsUsed(makeId(namedType.name, value.name));
                });
                return;
            }
            const fieldsMap = namedType.getFields();
            for (const fieldName in fieldsMap) {
                const field = fieldsMap[fieldName];
                markAsUsed(makeId(namedType.name, field.name));
                markEntireTypeAsUsed(field.type);
            }
        }
        function collectVariable(namedType, variableValue) {
            const variableValueArray = Array.isArray(variableValue) ? variableValue : [variableValue];
            if (isInputObjectType(namedType)) {
                variableValueArray.forEach(variable => {
                    if (variable) {
                        // Collect only the used fields
                        for (const fieldName in variable) {
                            const field = namedType.getFields()[fieldName];
                            if (field) {
                                collectInputType(namedType.name, fieldName);
                                collectVariable(unwrapType(field.type), variable[fieldName]);
                            }
                        }
                    }
                    else {
                        // Collect the entire type
                        collectInputType(namedType.name);
                    }
                });
            }
            else {
                collectInputType(namedType.name);
            }
        }
        visit(doc, visitWithTypeInfo(typeInfo, {
            Field() {
                const parent = typeInfo.getParentType();
                const field = typeInfo.getFieldDef();
                markAsUsed(makeId(parent.name, field.name));
            },
            VariableDefinition(node) {
                const inputType = typeInfo.getInputType();
                if (shouldAnalyzeVariableValues) {
                    // Granular collection of variable values is enabled
                    const variableName = node.variable.name.value;
                    const variableValue = variables[variableName];
                    const namedType = unwrapType(inputType);
                    collectVariable(namedType, variableValue);
                }
                else {
                    // Collect the entire type without processing the variables
                    collectInputType(resolveTypeName(inputType));
                }
            },
            Argument(node) {
                const parent = typeInfo.getParentType();
                const field = typeInfo.getFieldDef();
                const arg = typeInfo.getArgument();
                markAsUsed(makeId(parent.name, field.name, arg.name));
                collectNode(node);
            },
            ListValue(node) {
                const inputType = typeInfo.getInputType();
                const inputTypeName = resolveTypeName(inputType);
                node.values.forEach(value => {
                    if (value.kind !== Kind.OBJECT) {
                        // if a value is not an object we need to collect all fields
                        collectInputType(inputTypeName);
                    }
                });
            },
            ObjectField(node) {
                const parentInputType = typeInfo.getParentInputType();
                const parentInputTypeName = resolveTypeName(parentInputType);
                collectNode(node);
                collectInputType(parentInputTypeName, node.name.value);
            },
        }));
        for (const inputTypeName in collectedInputTypes) {
            const { fields, all } = collectedInputTypes[inputTypeName];
            if (all) {
                markEntireTypeAsUsed(schema.getType(inputTypeName));
            }
            else {
                fields.forEach(field => {
                    markAsUsed(makeId(inputTypeName, field));
                });
            }
        }
        return {
            document: normalizeOperation({
                document: doc,
                hideLiterals: true,
                removeAliases: true,
            }),
            fields: Array.from(entries),
        };
    }
    return cache(collect, function cacheKey(doc, variables) {
        return cacheDocumentKey(doc, processVariables === true ? variables : null);
    }, LRU(max, ttl));
}
function resolveTypeName(inputType) {
    return unwrapType(inputType).name;
}
function unwrapType(type) {
    if (isNonNullType(type) || isListType(type)) {
        return unwrapType(type.ofType);
    }
    return type;
}

function createReporting(pluginOptions) {
    var _a, _b, _c, _d;
    if (!pluginOptions.reporting || pluginOptions.enabled === false) {
        return {
            async report() { },
            async dispose() { },
        };
    }
    const token = pluginOptions.token;
    const reportingOptions = pluginOptions.reporting;
    const logger = (_b = (_a = pluginOptions.agent) === null || _a === void 0 ? void 0 : _a.logger) !== null && _b !== void 0 ? _b : console;
    logIf(typeof reportingOptions.author !== 'string' || reportingOptions.author.length === 0, '[hive][reporting] author is missing', logger.error);
    logIf(typeof reportingOptions.commit !== 'string' || reportingOptions.commit.length === 0, '[hive][reporting] commit is missing', logger.error);
    logIf(typeof token !== 'string' || token.length === 0, '[hive][reporting] token is missing', logger.error);
    let currentSchema = null;
    const agent = createAgent(Object.assign(Object.assign({ logger }, ((_c = pluginOptions.agent) !== null && _c !== void 0 ? _c : {})), { endpoint: (_d = reportingOptions.endpoint) !== null && _d !== void 0 ? _d : 'https://app.graphql-hive.com/graphql', token: token, enabled: pluginOptions.enabled, debug: pluginOptions.debug }), {
        prefix: 'reporting',
        data: {
            set(incomingSchema) {
                currentSchema = incomingSchema;
            },
            size() {
                return currentSchema ? 1 : 0;
            },
            clear() {
                currentSchema = null;
            },
        },
        headers() {
            return {
                'Content-Type': 'application/json',
                'graphql-client-name': 'Hive Client',
                'graphql-client-version': version,
            };
        },
        async body() {
            var _a, _b;
            return JSON.stringify({
                query,
                operationName: 'schemaPublish',
                variables: {
                    input: {
                        sdl: await printToSDL(currentSchema),
                        author: reportingOptions.author,
                        commit: reportingOptions.commit,
                        service: (_a = reportingOptions.serviceName) !== null && _a !== void 0 ? _a : null,
                        url: (_b = reportingOptions.serviceUrl) !== null && _b !== void 0 ? _b : null,
                        force: true,
                    },
                },
            });
        },
    });
    return {
        async report({ schema }) {
            var _a;
            try {
                const result = await agent.sendImmediately(schema);
                if (result === null) {
                    throw new Error('Empty response');
                }
                if (Array.isArray(result.errors)) {
                    throw new Error(result.errors.map(error => error.message).join('\n'));
                }
                const data = result.data.schemaPublish;
                switch (data.__typename) {
                    case 'SchemaPublishSuccess': {
                        logger.info(`[hive][reporting] ${(_a = data.successMessage) !== null && _a !== void 0 ? _a : 'Published schema'}`);
                        return;
                    }
                    case 'SchemaPublishMissingServiceError': {
                        throw new Error('Service name is not defined');
                    }
                    case 'SchemaPublishMissingUrlError': {
                        throw new Error('Service url is not defined');
                    }
                    case 'SchemaPublishError': {
                        logger.info(`[hive][reporting] Published schema (forced with ${data.errors.total} errors)`);
                        data.errors.nodes.slice(0, 5).forEach(error => {
                            logger.info(` - ${error.message}`);
                        });
                        return;
                    }
                }
            }
            catch (error) {
                logger.error(`[hive][reporting] Failed to report schema: ${error instanceof Error && 'message' in error ? error.message : error}`);
            }
        },
        dispose: agent.dispose,
    };
}
const query = stripIgnoredCharacters(/* GraphQL */ `
  mutation schemaPublish($input: SchemaPublishInput!) {
    schemaPublish(input: $input) {
      __typename
      ... on SchemaPublishSuccess {
        initial
        valid
        successMessage: message
      }
      ... on SchemaPublishError {
        valid
        errors {
          nodes {
            message
          }
          total
        }
      }
      ... on SchemaPublishMissingServiceError {
        missingServiceError: message
      }
      ... on SchemaPublishMissingUrlError {
        missingUrlError: message
      }
    }
  }
`);
/**
 * It's a bit tricky to detect if a schema is federated or not.
 * For now, we just check if the schema has a _service that resolves to `_Service!` (as described in federation spec).
 * This may lead to issues if the schema is not a federated schema but something made by the user (I don't think we will hit that issue soon).
 */
function isFederatedSchema(schema) {
    const queryType = schema.getQueryType();
    if (queryType) {
        const fields = queryType.getFields();
        if (fields._service && fields._service.type.toString() === `_Service!`) {
            return true;
        }
    }
    return false;
}
/**
 * Extracts the SDL of a federated service from a GraphQLSchema object
 * We do it to not send federated schema to the registry but only the original schema provided by user
 */
async function extractFederationServiceSDL(schema) {
    const queryType = schema.getQueryType();
    const serviceField = queryType.getFields()._service;
    const resolved = await serviceField.resolve();
    return resolved.sdl;
}
function isSchemaOfCommonNames(schema) {
    const queryType = schema.getQueryType();
    if (queryType && queryType.name !== 'Query') {
        return false;
    }
    const mutationType = schema.getMutationType();
    if (mutationType && mutationType.name !== 'Mutation') {
        return false;
    }
    const subscriptionType = schema.getSubscriptionType();
    if (subscriptionType && subscriptionType.name !== 'Subscription') {
        return false;
    }
    return true;
}
function printSchemaWithDirectives(schema) {
    const doc = getDocumentNodeFromSchema(schema);
    if (schema.description == null && isSchemaOfCommonNames(schema)) {
        // remove the schema definition if it's the default one
        // We do it to avoid sending schema definition to the registry, which may be unwanted by federated services or something
        return print({
            kind: Kind.DOCUMENT,
            definitions: doc.definitions.filter(def => def.kind !== Kind.SCHEMA_DEFINITION),
        });
    }
    return print(doc);
}
async function printToSDL(schema) {
    return stripIgnoredCharacters(isFederatedSchema(schema) ? await extractFederationServiceSDL(schema) : printSchemaWithDirectives(schema));
}

function createOperationsStore(pluginOptions) {
    const operationsStoreOptions = pluginOptions.operationsStore;
    const token = pluginOptions.token;
    if (!operationsStoreOptions || pluginOptions.enabled === false) {
        return {
            canHandle() {
                return false;
            },
            get() {
                return null;
            },
            async load() { },
            async reload() { },
        };
    }
    const store = new Map();
    const canHandle = key => {
        return typeof key === 'string' && !key.includes('{');
    };
    const get = key => {
        return store.get(key);
    };
    const load = async () => {
        var _a;
        const response = await axios.post((_a = operationsStoreOptions.endpoint) !== null && _a !== void 0 ? _a : 'https://app.graphql-hive.com/graphql', {
            query: query$1,
            operationName: 'loadStoredOperations',
        }, {
            responseType: 'json',
            headers: {
                'content-type': 'application/json',
                Authorization: `Bearer ${token}`,
            },
        });
        const parsedData = await response.data;
        store.clear();
        parsedData.data.storedOperations.forEach(({ key, document }) => {
            store.set(key, parse(document, {
                noLocation: true,
            }));
        });
    };
    const reload = load;
    return {
        canHandle,
        get,
        load,
        reload,
    };
}
const query$1 = stripIgnoredCharacters(/* GraphQL */ `
  query loadStoredOperations {
    storedOperations {
      key: operationHash
      document: content
    }
  }
`);

function createHive(options) {
    var _a, _b;
    const logger = (_b = (_a = options === null || options === void 0 ? void 0 : options.agent) === null || _a === void 0 ? void 0 : _a.logger) !== null && _b !== void 0 ? _b : console;
    if (!options.enabled) {
        logIf(options.debug === true, '[hive] is not enabled.', logger.info);
    }
    if (!options.token && options.enabled) {
        options.enabled = false;
        logger.info('[hive] Missing token, disabling.');
    }
    const usage = createUsage(options);
    const schemaReporter = createReporting(options);
    const operationsStore = createOperationsStore(options);
    function reportSchema({ schema }) {
        void schemaReporter.report({ schema });
    }
    function collectUsage(args) {
        return usage.collect(args);
    }
    async function dispose() {
        await Promise.all([schemaReporter.dispose(), usage.dispose()]);
    }
    async function info() {
        var _a, _b, _c, _d;
        if (options.enabled !== true) {
            return;
        }
        try {
            let endpoint = 'https://app.graphql-hive.com/graphql';
            if (options.reporting && options.reporting.endpoint) {
                endpoint = options.reporting.endpoint;
            }
            const query = /* GraphQL */ `
        query myTokenInfo {
          tokenInfo {
            __typename
            ... on TokenInfo {
              token {
                name
              }
              organization {
                name
                cleanId
              }
              project {
                name
                type
                cleanId
              }
              target {
                name
                cleanId
              }
              canReportSchema: hasTargetScope(scope: REGISTRY_WRITE)
              canCollectUsage: hasTargetScope(scope: REGISTRY_WRITE)
              canReadOperations: hasProjectScope(scope: OPERATIONS_STORE_READ)
            }
            ... on TokenNotFoundError {
              message
            }
          }
        }
      `;
            const response = await axios.post(endpoint, JSON.stringify({
                query,
                operationName: 'myTokenInfo',
            }), {
                headers: {
                    'content-type': 'application/json',
                    Authorization: `Bearer ${options.token}`,
                },
                timeout: 30000,
                decompress: true,
                responseType: 'json',
            });
            if (response.status >= 200 && response.status < 300) {
                const result = await response.data;
                if (((_a = result.data) === null || _a === void 0 ? void 0 : _a.tokenInfo.__typename) === 'TokenInfo') {
                    const { tokenInfo } = result.data;
                    const { organization, project, target, canReportSchema, canCollectUsage, canReadOperations } = tokenInfo;
                    const print = createPrinter([tokenInfo.token.name, organization.name, project.name, target.name]);
                    const organizationUrl = `https://app.graphql-hive.com/${organization.cleanId}`;
                    const projectUrl = `${organizationUrl}/${project.cleanId}`;
                    const targetUrl = `${projectUrl}/${target.cleanId}`;
                    logger.info([
                        '[hive][info] Token details',
                        '',
                        `Token name:            ${print(tokenInfo.token.name)}`,
                        `Organization:          ${print(organization.name, organizationUrl)}`,
                        `Project:               ${print(project.name, projectUrl)}`,
                        `Target:                ${print(target.name, targetUrl)}`,
                        '',
                        `Can report schema?     ${print(canReportSchema ? 'Yes' : 'No')}`,
                        `Can collect usage?     ${print(canCollectUsage ? 'Yes' : 'No')}`,
                        `Can read operations?   ${print(canReadOperations ? 'Yes' : 'No')}`,
                        '',
                    ].join('\n'));
                }
                else if ((_b = result.data) === null || _b === void 0 ? void 0 : _b.tokenInfo.message) {
                    logger.error(`[hive][info] Token not found. Reason: ${(_c = result.data) === null || _c === void 0 ? void 0 : _c.tokenInfo.message}`);
                    logger.info(`[hive][info] How to create a token? https://docs.graphql-hive.com/features/tokens`);
                }
                else {
                    logger.error(`[hive][info] ${result.errors[0].message}`);
                    logger.info(`[hive][info] How to create a token? https://docs.graphql-hive.com/features/tokens`);
                }
            }
            else {
                logger.error(`[hive][info] Error ${response.status}: ${response.statusText}`);
            }
        }
        catch (error) {
            logger.error(`[hive][info] Error ${(_d = error === null || error === void 0 ? void 0 : error.message) !== null && _d !== void 0 ? _d : error}`);
        }
    }
    return {
        info,
        reportSchema,
        collectUsage,
        operationsStore,
        dispose,
    };
}
function createPrinter(values) {
    const maxLen = Math.max(...values.map(v => v.length)) + 4;
    return (base, extra) => {
        return base.padEnd(maxLen, ' ') + (extra || '');
    };
}

function useHive(clientOrOptions) {
    var _a;
    const hive = isHiveClient(clientOrOptions)
        ? clientOrOptions
        : createHive(Object.assign(Object.assign({}, clientOrOptions), { agent: Object.assign({ name: 'HiveEnvelop' }, ((_a = clientOrOptions.agent) !== null && _a !== void 0 ? _a : {})) }));
    void hive.info();
    return {
        onSchemaChange({ schema }) {
            hive.reportSchema({ schema });
        },
        onExecute({ args }) {
            const complete = hive.collectUsage(args);
            return {
                onExecuteDone({ result }) {
                    complete(result);
                },
            };
        },
    };
}

function createSupergraphSDLFetcher({ endpoint, key }) {
    return function supergraphSDLFetcher() {
        return axios
            .get(endpoint + '/supergraph', {
            headers: {
                'X-Hive-CDN-Key': key,
            },
        })
            .then(response => {
            if (response.status >= 200 && response.status < 300) {
                return response.data;
            }
            return Promise.reject(new Error(`Failed to fetch supergraph [${response.status}]`));
        })
            .then(supergraphSdl => ({
            id: createHash('sha256').update(supergraphSdl).digest('base64'),
            supergraphSdl,
        }));
    };
}
function createSupergraphManager(options) {
    var _a;
    const pollIntervalInMs = (_a = options.pollIntervalInMs) !== null && _a !== void 0 ? _a : 30000;
    const fetchSupergraph = createSupergraphSDLFetcher({ endpoint: options.endpoint, key: options.key });
    let timer = null;
    return {
        async initialize(hooks) {
            const initialResult = await fetchSupergraph();
            function poll() {
                timer = setTimeout(async () => {
                    var _a;
                    try {
                        const result = await fetchSupergraph();
                        if (result.supergraphSdl) {
                            (_a = hooks.update) === null || _a === void 0 ? void 0 : _a.call(hooks, result.supergraphSdl);
                        }
                    }
                    catch (error) {
                        console.error(`Failed to update supergraph: ${error instanceof Error ? error.message : error}`);
                    }
                    poll();
                }, pollIntervalInMs);
            }
            poll();
            return {
                supergraphSdl: initialResult.supergraphSdl,
                cleanup: async () => {
                    if (timer) {
                        clearTimeout(timer);
                    }
                },
            };
        },
    };
}
function hiveApollo(clientOrOptions) {
    var _a;
    const hive = isHiveClient(clientOrOptions)
        ? clientOrOptions
        : createHive(Object.assign(Object.assign({}, clientOrOptions), { agent: Object.assign({ name: 'HiveApollo' }, ((_a = clientOrOptions.agent) !== null && _a !== void 0 ? _a : {})) }));
    void hive.info();
    return {
        requestDidStart(context) {
            // `overallCachePolicy` does not exist in v0
            const isLegacyV0 = !('overallCachePolicy' in context);
            let doc;
            const complete = hive.collectUsage({
                schema: context.schema,
                get document() {
                    return doc;
                },
                operationName: context.operationName,
                contextValue: context.context,
                variableValues: context.request.variables,
            });
            if (isLegacyV0) {
                return {
                    willSendResponse(ctx) {
                        doc = ctx.document;
                        complete(ctx.response);
                    },
                };
            }
            return Promise.resolve({
                async willSendResponse(ctx) {
                    doc = ctx.document;
                    complete(ctx.response);
                },
            });
        },
        serverWillStart(ctx) {
            // `engine` does not exist in v3
            const isLegacyV0 = 'engine' in ctx;
            hive.reportSchema({ schema: ctx.schema });
            if (isLegacyV0) {
                return {
                    async serverWillStop() {
                        await hive.dispose();
                    },
                };
            }
            return Promise.resolve({
                async serverWillStop() {
                    await hive.dispose();
                },
                schemaDidLoadOrUpdate(schemaContext) {
                    if (ctx.schema !== schemaContext.apiSchema) {
                        hive.reportSchema({ schema: schemaContext.apiSchema });
                    }
                },
            });
        },
    };
}

function createFetcher({ endpoint, key }) {
    return function fetcher() {
        return axios
            .get(endpoint + '/schema', {
            headers: {
                'X-Hive-CDN-Key': key,
                accept: 'application/json',
            },
            responseType: 'json',
        })
            .then(response => {
            if (response.status >= 200 && response.status < 300) {
                return response.data;
            }
            return Promise.reject(new Error(`Failed to fetch [${response.status}]`));
        });
    };
}
function createSchemaFetcher({ endpoint, key }) {
    const fetcher = createFetcher({ endpoint, key });
    return function schemaFetcher() {
        return fetcher().then(schema => (Object.assign({ id: createHash('sha256').update(schema.sdl).update(schema.url).update(schema.name).digest('base64') }, schema)));
    };
}
function createServicesFetcher({ endpoint, key }) {
    const fetcher = createFetcher({ endpoint, key });
    return function schemaFetcher() {
        return fetcher().then(services => services.map(service => (Object.assign({ id: createHash('sha256').update(service.sdl).update(service.url).update(service.name).digest('base64') }, service))));
    };
}

export { createHive, createSchemaFetcher, createServicesFetcher, createSupergraphManager, createSupergraphSDLFetcher, hiveApollo, useHive };