@graphql-mesh/utils/index.esm.js

import { fetchFactory } from 'fetchache';
import { fetch, Request, Response, Headers } from 'cross-fetch';
import isUrl from 'is-url';
export { default as isUrl } from 'is-url';
import { load } from 'js-yaml';
import { isAbsolute, resolve, join, dirname } from 'path';
import { promises, readFileSync } from 'fs';
import { Interpolator } from '@ardatan/string-interpolation';
import { format } from 'date-fns';
import objectHash from 'object-hash';
import { isInputType, GraphQLInt, GraphQLFloat, GraphQLBoolean, GraphQLString, GraphQLID, parse, print } from 'graphql';
import { getResolversFromSchema } from '@graphql-tools/utils';
import flatstr from 'flatstr';
import lru from 'tiny-lru';
import { compileQuery, isCompiledQuery } from 'graphql-jit';

const { readFile, stat } = promises || {};
function getCachedFetch(cache) {
    return fetchFactory({
        fetch,
        Request,
        Response,
        cache,
    });
}
async function readFileOrUrlWithCache(filePathOrUrl, cache, config) {
    if (isUrl(filePathOrUrl)) {
        return readUrlWithCache(filePathOrUrl, cache, config);
    }
    else {
        return readFileWithCache(filePathOrUrl, cache, config);
    }
}
async function readFileWithCache(filePath, cache, config) {
    const { allowUnknownExtensions, cwd, fallbackFormat } = config || {};
    const actualPath = isAbsolute(filePath) ? filePath : resolve(cwd || process.cwd(), filePath);
    const cachedObj = await cache.get(actualPath);
    const stats = await stat(actualPath);
    if (cachedObj) {
        if (stats.mtimeMs <= cachedObj.mtimeMs) {
            return cachedObj.result;
        }
    }
    let result = await readFile(actualPath, 'utf-8');
    if (/json$/.test(filePath)) {
        result = JSON.parse(result);
    }
    else if (/yaml$/.test(filePath) || /yml$/.test(filePath)) {
        result = load(result);
    }
    else if (fallbackFormat) {
        switch (fallbackFormat) {
            case 'json':
                result = JSON.parse(result);
                break;
            case 'yaml':
                result = load(result);
                break;
        }
    }
    else if (!allowUnknownExtensions) {
        throw new Error(`Failed to parse JSON/YAML. Ensure file '${filePath}' has ` +
            `the correct extension (i.e. '.json', '.yaml', or '.yml).`);
    }
    cache.set(filePath, { result, mtimeMs: stats.mtimeMs });
    return result;
}
async function readUrlWithCache(path, cache, config) {
    var _a;
    const { allowUnknownExtensions, fallbackFormat } = config || {};
    const fetch = (config === null || config === void 0 ? void 0 : config.fetch) || getCachedFetch(cache);
    const response = await fetch(path, config);
    const contentType = ((_a = response.headers) === null || _a === void 0 ? void 0 : _a.get('content-type')) || '';
    const responseText = await response.text();
    if (/json$/.test(path) || contentType.startsWith('application/json') || fallbackFormat === 'json') {
        return JSON.parse(responseText);
    }
    else if (/yaml$/.test(path) ||
        /yml$/.test(path) ||
        contentType.includes('yaml') ||
        contentType.includes('yml') ||
        fallbackFormat === 'yaml') {
        return load(responseText);
    }
    else if (!allowUnknownExtensions) {
        throw new Error(`Failed to parse JSON/YAML. Ensure URL '${path}' has ` +
            `the correct extension (i.e. '.json', '.yaml', or '.yml) or mime type in the response headers.`);
    }
    return responseText;
}

const stringInterpolator = new Interpolator({
    delimiter: ['{', '}'],
});
stringInterpolator.addAlias('typeName', 'info.parentType.name');
stringInterpolator.addAlias('type', 'info.parentType.name');
stringInterpolator.addAlias('parentType', 'info.parentType.name');
stringInterpolator.addAlias('fieldName', 'info.fieldName');
stringInterpolator.registerModifier('date', (formatStr) => format(new Date(), formatStr));
stringInterpolator.registerModifier('hash', (value) => objectHash(value, { ignoreUnknown: true }));

async function loadFromModuleExportExpression(expression, options) {
    if (typeof expression !== 'string') {
        return expression;
    }
    const { defaultExportName, cwd } = options || {};
    const [modulePath, exportName = defaultExportName] = expression.split('#');
    const mod = await tryImport(modulePath, cwd);
    if (exportName === 'default' || !exportName) {
        return mod.default || mod;
    }
    else {
        return mod[exportName] || (mod.default && mod.default[exportName]);
    }
}
async function tryImport(modulePath, cwd) {
    try {
        return await import(modulePath);
    }
    catch (e1) {
        if (!isAbsolute(modulePath)) {
            try {
                const absoluteModulePath = isAbsolute(modulePath) ? modulePath : join(cwd || process.cwd(), modulePath);
                return await import(absoluteModulePath);
            }
            catch (e2) {
                if (e2.message.includes('Cannot find module')) {
                    throw e1;
                }
                else {
                    throw e2;
                }
            }
        }
        throw e1;
    }
}
function loadFromModuleExportExpressionSync(expression, options) {
    if (typeof expression !== 'string') {
        return expression;
    }
    const { defaultExportName, cwd } = options || {};
    const [modulePath, exportName = defaultExportName] = expression.split('#');
    const mod = tryImportSync(modulePath, cwd);
    if (exportName === 'default' || !exportName) {
        return mod.default || mod;
    }
    else {
        return mod[exportName] || (mod.default && mod.default[exportName]);
    }
}
function tryImportSync(modulePath, cwd) {
    try {
        return require(modulePath);
    }
    catch (e1) {
        if (!isAbsolute(modulePath)) {
            try {
                const absoluteModulePath = isAbsolute(modulePath) ? modulePath : join(cwd || process.cwd(), modulePath);
                return require(absoluteModulePath);
            }
            catch (e2) {
                if (e2.message.includes('Cannot find module')) {
                    throw e1;
                }
                else {
                    throw e2;
                }
            }
        }
        throw e1;
    }
}

var ArgType;
(function (ArgType) {
    ArgType["ID"] = "ID";
    ArgType["String"] = "String";
    ArgType["Boolean"] = "Boolean";
    ArgType["Float"] = "Float";
    ArgType["Int"] = "Int";
})(ArgType || (ArgType = {}));
function getInputTypeFromTypeName(typeName) {
    if (isInputType(typeName)) {
        return typeName;
    }
    else {
        switch (typeName) {
            case ArgType.ID:
                return GraphQLID;
            case ArgType.String:
                return GraphQLString;
            case ArgType.Boolean:
                return GraphQLBoolean;
            case ArgType.Float:
                return GraphQLFloat;
            case ArgType.Int:
                return GraphQLInt;
        }
    }
}
function parseInterpolationStrings(interpolationStrings, argTypeMap) {
    const interpolationKeys = interpolationStrings.reduce((keys, str) => [...keys, ...(str ? stringInterpolator.parseRules(str).map((match) => match.key) : [])], []);
    const args = {};
    const contextVariables = [];
    for (const interpolationKey of interpolationKeys) {
        const interpolationKeyParts = interpolationKey.split('.');
        const varName = interpolationKeyParts[interpolationKeyParts.length - 1];
        if (interpolationKeyParts[0] === 'args') {
            const argType = argTypeMap && varName in argTypeMap ? getInputTypeFromTypeName(argTypeMap[varName]) : GraphQLID;
            args[varName] = {
                type: argType,
            };
        }
        else if (interpolationKeyParts[0] === 'context') {
            contextVariables.push(varName);
        }
    }
    return {
        args,
        contextVariables,
    };
}
function getInterpolatedStringFactory(nonInterpolatedString) {
    return resolverData => stringInterpolator.parse(nonInterpolatedString, resolverData);
}
function getInterpolatedHeadersFactory(nonInterpolatedHeaders = {}) {
    return resolverData => {
        const headers = new Headers();
        for (const headerName in nonInterpolatedHeaders) {
            const headerValue = nonInterpolatedHeaders[headerName];
            if (headerValue) {
                headers.set(headerName, stringInterpolator.parse(headerValue, resolverData));
            }
        }
        return headers;
    };
}
function getHeadersObject(headers) {
    const headersObj = {};
    headers.forEach((value, key) => {
        headersObj[key] = value;
    });
    return headersObj;
}

function withCancel(asyncIteratorLike, onCancel) {
    const asyncIterator = asyncIteratorLike[Symbol.asyncIterator]();
    if (!asyncIterator.return) {
        asyncIterator.return = () => Promise.resolve({ value: undefined, done: true });
    }
    const savedReturn = asyncIterator.return.bind(asyncIterator);
    asyncIterator.return = () => {
        onCancel();
        return savedReturn();
    };
    return asyncIterator;
}

function extractResolvers(schema) {
    const allResolvers = getResolversFromSchema(schema);
    const filteredResolvers = {};
    for (const prop in allResolvers) {
        if (!prop.startsWith('_')) {
            filteredResolvers[prop] = allResolvers[prop];
        }
    }
    return filteredResolvers;
}

function ensureDocumentNode(document) {
    return typeof document === 'string' ? parse(document) : document;
}

function groupTransforms(transforms) {
    const wrapTransforms = [];
    const noWrapTransforms = [];
    transforms === null || transforms === void 0 ? void 0 : transforms.forEach(transform => {
        if (transform.noWrap) {
            noWrapTransforms.push(transform);
        }
        else {
            wrapTransforms.push(transform);
        }
    });
    return { wrapTransforms, noWrapTransforms };
}

function applySchemaTransforms(originalWrappingSchema, subschemaConfig, transformedSchema, transforms) {
    return transforms.reduce((schema, transform) => 'transformSchema' in transform ? transform.transformSchema(schema, subschemaConfig, transformedSchema) : schema, originalWrappingSchema);
}
function applyRequestTransforms(originalRequest, delegationContext, transformationContext, transforms) {
    transformationContext.contextMap = transformationContext.contextMap || new WeakMap();
    const contextMap = transformationContext.contextMap;
    transforms === null || transforms === void 0 ? void 0 : transforms.forEach(transform => {
        if (!contextMap.has(transform)) {
            contextMap.set(transform, {
                nextIndex: 0,
                paths: {},
            });
        }
    });
    return transforms.reduceRight((request, transform) => 'transformRequest' in transform
        ? transform.transformRequest(request, delegationContext, contextMap.get(transform))
        : request, originalRequest);
}
function applyResultTransforms(originalResult, delegationContext, transformationContext, transforms) {
    const contextMap = transformationContext.contextMap;
    return transforms.reduceRight((result, transform) => 'transformResult' in transform
        ? transform.transformResult(result, delegationContext, contextMap.get(transform))
        : result, originalResult);
}

function flatString(str) {
    return flatstr(str);
}
function jsonFlatStringify(data, replacer, space) {
    return flatString(JSON.stringify(data, replacer, space));
}

const { stat: stat$1, writeFile: fsWriteFile, readFile: readFile$1, mkdir: fsMkdir } = promises || {};
async function pathExists(path) {
    if (!path) {
        return false;
    }
    try {
        await stat$1(path);
        return true;
    }
    catch (e) {
        if (e.toString().includes('ENOENT')) {
            return false;
        }
        else {
            throw e;
        }
    }
}
function readJSONSync(path) {
    const fileContent = readFileSync(path, 'utf-8');
    return JSON.parse(fileContent);
}
async function readJSON(path) {
    const fileContent = await readFile$1(path, 'utf-8');
    return JSON.parse(fileContent);
}
function writeJSON(path, data, replacer, space) {
    const stringified = jsonFlatStringify(data, replacer, space);
    return writeFile(path, stringified, 'utf-8');
}
const writeFile = async (path, ...args) => {
    if (typeof path === 'string') {
        const containingDir = dirname(path);
        if (!(await pathExists(containingDir))) {
            await mkdir(containingDir);
        }
    }
    return fsWriteFile(path, ...args);
};
async function mkdir(path, options = { recursive: true }) {
    const ifExists = await pathExists(path);
    if (!ifExists) {
        await fsMkdir(path, options);
    }
}

const globalLruCache = lru();

const jitExecutorFactory = (schema, prefix) => ({ document, variables, context }, operationName, rootValue) => {
    const documentStr = print(document);
    const cacheKey = [prefix, documentStr, operationName].join('_');
    if (!globalLruCache.has(cacheKey)) {
        const compiledQuery = compileQuery(schema, document, operationName, {
            disableLeafSerialization: true,
            customJSONSerializer: true,
        });
        globalLruCache.set(cacheKey, compiledQuery);
    }
    const cachedQuery = globalLruCache.get(cacheKey);
    if (isCompiledQuery(cachedQuery)) {
        return cachedQuery.query(rootValue, context, variables);
    }
    return cachedQuery;
};

export { ArgType, applyRequestTransforms, applyResultTransforms, applySchemaTransforms, ensureDocumentNode, extractResolvers, flatString, getCachedFetch, getHeadersObject, getInputTypeFromTypeName, getInterpolatedHeadersFactory, getInterpolatedStringFactory, globalLruCache, groupTransforms, jitExecutorFactory, jsonFlatStringify, loadFromModuleExportExpression, loadFromModuleExportExpressionSync, mkdir, parseInterpolationStrings, pathExists, readFileOrUrlWithCache, readFileWithCache, readJSON, readJSONSync, readUrlWithCache, stringInterpolator, withCancel, writeFile, writeJSON };
//# sourceMappingURL=index.esm.js.map