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

'use strict';

Object.defineProperty(exports, '__esModule', { value: true });

function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }

function _interopNamespace(e) {
    if (e && e.__esModule) { return e; } else {
        var n = {};
        if (e) {
            Object.keys(e).forEach(function (k) {
                var d = Object.getOwnPropertyDescriptor(e, k);
                Object.defineProperty(n, k, d.get ? d : {
                    enumerable: true,
                    get: function () {
                        return e[k];
                    }
                });
            });
        }
        n['default'] = e;
        return n;
    }
}

const fetchache = require('fetchache');
const crossFetch = require('cross-fetch');
const isUrl = _interopDefault(require('is-url'));
const jsYaml = require('js-yaml');
const path = require('path');
const fs = require('fs');
const stringInterpolation = require('@ardatan/string-interpolation');
const dateFns = require('date-fns');
const objectHash = _interopDefault(require('object-hash'));
const graphql = require('graphql');
const utils = require('@graphql-tools/utils');
const flatstr = _interopDefault(require('flatstr'));
const lru = _interopDefault(require('tiny-lru'));
const graphqlJit = require('graphql-jit');

const { readFile, stat } = fs.promises || {};
function getCachedFetch(cache) {
    return fetchache.fetchFactory({
        fetch: crossFetch.fetch,
        Request: crossFetch.Request,
        Response: crossFetch.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 = path.isAbsolute(filePath) ? filePath : path.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 = jsYaml.load(result);
    }
    else if (fallbackFormat) {
        switch (fallbackFormat) {
            case 'json':
                result = JSON.parse(result);
                break;
            case 'yaml':
                result = jsYaml.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 jsYaml.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 stringInterpolation.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) => dateFns.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 new Promise(function (resolve) { resolve(_interopNamespace(require(modulePath))); });
    }
    catch (e1) {
        if (!path.isAbsolute(modulePath)) {
            try {
                const absoluteModulePath = path.isAbsolute(modulePath) ? modulePath : path.join(cwd || process.cwd(), modulePath);
                return await new Promise(function (resolve) { resolve(_interopNamespace(require(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 (!path.isAbsolute(modulePath)) {
            try {
                const absoluteModulePath = path.isAbsolute(modulePath) ? modulePath : path.join(cwd || process.cwd(), modulePath);
                return require(absoluteModulePath);
            }
            catch (e2) {
                if (e2.message.includes('Cannot find module')) {
                    throw e1;
                }
                else {
                    throw e2;
                }
            }
        }
        throw e1;
    }
}

(function (ArgType) {
    ArgType["ID"] = "ID";
    ArgType["String"] = "String";
    ArgType["Boolean"] = "Boolean";
    ArgType["Float"] = "Float";
    ArgType["Int"] = "Int";
})(exports.ArgType || (exports.ArgType = {}));
function getInputTypeFromTypeName(typeName) {
    if (graphql.isInputType(typeName)) {
        return typeName;
    }
    else {
        switch (typeName) {
            case exports.ArgType.ID:
                return graphql.GraphQLID;
            case exports.ArgType.String:
                return graphql.GraphQLString;
            case exports.ArgType.Boolean:
                return graphql.GraphQLBoolean;
            case exports.ArgType.Float:
                return graphql.GraphQLFloat;
            case exports.ArgType.Int:
                return graphql.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]) : graphql.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 crossFetch.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 = utils.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' ? graphql.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 } = fs.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 = fs.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$1, ...args) => {
    if (typeof path$1 === 'string') {
        const containingDir = path.dirname(path$1);
        if (!(await pathExists(containingDir))) {
            await mkdir(containingDir);
        }
    }
    return fsWriteFile(path$1, ...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 = graphql.print(document);
    const cacheKey = [prefix, documentStr, operationName].join('_');
    if (!globalLruCache.has(cacheKey)) {
        const compiledQuery = graphqlJit.compileQuery(schema, document, operationName, {
            disableLeafSerialization: true,
            customJSONSerializer: true,
        });
        globalLruCache.set(cacheKey, compiledQuery);
    }
    const cachedQuery = globalLruCache.get(cacheKey);
    if (graphqlJit.isCompiledQuery(cachedQuery)) {
        return cachedQuery.query(rootValue, context, variables);
    }
    return cachedQuery;
};

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