@graphql-codegen/graphql-modules-preset/cjs/utils.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.createObject = exports.uniqueByKey = exports.concatByKey = exports.pushUnique = exports.normalize = exports.stripFilename = exports.groupSourcesByModule = exports.buildBlock = exports.indent = exports.withQuotes = exports.unique = exports.isGraphQLPrimitive = exports.resolveTypeNode = exports.collectUsedTypes = void 0;
const tslib_1 = require("tslib");
const graphql_1 = require("graphql");
const parse_filepath_1 = tslib_1.__importDefault(require("parse-filepath"));
const sep = '/';
/**
 * Searches every node to collect used types
 */
function collectUsedTypes(doc) {
    const used = [];
    doc.definitions.forEach(findRelated);
    function markAsUsed(type) {
        pushUnique(used, type);
    }
    function findRelated(node) {
        if (node.kind === graphql_1.Kind.OBJECT_TYPE_DEFINITION || node.kind === graphql_1.Kind.OBJECT_TYPE_EXTENSION) {
            // Object
            markAsUsed(node.name.value);
            if (node.fields) {
                node.fields.forEach(findRelated);
            }
            if (node.interfaces) {
                node.interfaces.forEach(findRelated);
            }
        }
        else if (node.kind === graphql_1.Kind.INPUT_OBJECT_TYPE_DEFINITION || node.kind === graphql_1.Kind.INPUT_OBJECT_TYPE_EXTENSION) {
            // Input
            markAsUsed(node.name.value);
            if (node.fields) {
                node.fields.forEach(findRelated);
            }
        }
        else if (node.kind === graphql_1.Kind.INTERFACE_TYPE_DEFINITION || node.kind === graphql_1.Kind.INTERFACE_TYPE_EXTENSION) {
            // Interface
            markAsUsed(node.name.value);
            if (node.fields) {
                node.fields.forEach(findRelated);
            }
            if (node.interfaces) {
                node.interfaces.forEach(findRelated);
            }
        }
        else if (node.kind === graphql_1.Kind.UNION_TYPE_DEFINITION || node.kind === graphql_1.Kind.UNION_TYPE_EXTENSION) {
            // Union
            markAsUsed(node.name.value);
            if (node.types) {
                node.types.forEach(findRelated);
            }
        }
        else if (node.kind === graphql_1.Kind.ENUM_TYPE_DEFINITION || node.kind === graphql_1.Kind.ENUM_TYPE_EXTENSION) {
            // Enum
            markAsUsed(node.name.value);
        }
        else if (node.kind === graphql_1.Kind.SCALAR_TYPE_DEFINITION || node.kind === graphql_1.Kind.SCALAR_TYPE_EXTENSION) {
            // Scalar
            if (!isGraphQLPrimitive(node.name.value)) {
                markAsUsed(node.name.value);
            }
        }
        else if (node.kind === graphql_1.Kind.INPUT_VALUE_DEFINITION) {
            // Argument
            findRelated(resolveTypeNode(node.type));
        }
        else if (node.kind === graphql_1.Kind.FIELD_DEFINITION) {
            // Field
            findRelated(resolveTypeNode(node.type));
            if (node.arguments) {
                node.arguments.forEach(findRelated);
            }
        }
        else if (node.kind === graphql_1.Kind.NAMED_TYPE &&
            // Named type
            !isGraphQLPrimitive(node.name.value)) {
            markAsUsed(node.name.value);
        }
    }
    return used;
}
exports.collectUsedTypes = collectUsedTypes;
function resolveTypeNode(node) {
    if (node.kind === graphql_1.Kind.LIST_TYPE) {
        return resolveTypeNode(node.type);
    }
    if (node.kind === graphql_1.Kind.NON_NULL_TYPE) {
        return resolveTypeNode(node.type);
    }
    return node;
}
exports.resolveTypeNode = resolveTypeNode;
function isGraphQLPrimitive(name) {
    return ['String', 'Boolean', 'ID', 'Float', 'Int'].includes(name);
}
exports.isGraphQLPrimitive = isGraphQLPrimitive;
function unique(val, i, all) {
    return i === all.indexOf(val);
}
exports.unique = unique;
function withQuotes(val) {
    return `'${val}'`;
}
exports.withQuotes = withQuotes;
function indent(size) {
    const space = new Array(size).fill(' ').join('');
    function indentInner(val) {
        return val
            .split('\n')
            .map(line => `${space}${line}`)
            .join('\n');
    }
    return indentInner;
}
exports.indent = indent;
function buildBlock({ name, lines }) {
    if (!lines.length) {
        return '';
    }
    return [`${name} {`, ...lines.map(indent(2)), '};'].join('\n');
}
exports.buildBlock = buildBlock;
const getRelativePath = function (filepath, basePath) {
    const normalizedFilepath = normalize(filepath);
    const normalizedBasePath = ensureStartsWithSeparator(normalize(ensureEndsWithSeparator(basePath)));
    const [, relativePath] = normalizedFilepath.split(normalizedBasePath);
    return relativePath;
};
function groupSourcesByModule(sources, basePath) {
    const grouped = {};
    sources.forEach(source => {
        const relativePath = getRelativePath(source.location, basePath);
        if (relativePath) {
            // PERF: we could guess the module by matching source.location with a list of already resolved paths
            const mod = extractModuleDirectory(source.location, basePath);
            if (!grouped[mod]) {
                grouped[mod] = [];
            }
            grouped[mod].push(source);
        }
    });
    return grouped;
}
exports.groupSourcesByModule = groupSourcesByModule;
function extractModuleDirectory(filepath, basePath) {
    const relativePath = getRelativePath(filepath, basePath);
    const [moduleDirectory] = relativePath.split(sep);
    return moduleDirectory;
}
function stripFilename(path) {
    const parsedPath = (0, parse_filepath_1.default)(path);
    return normalize(parsedPath.dir);
}
exports.stripFilename = stripFilename;
function normalize(path) {
    return path.replace(/\\/g, '/');
}
exports.normalize = normalize;
function ensureEndsWithSeparator(path) {
    return path.endsWith(sep) ? path : path + sep;
}
function ensureStartsWithSeparator(path) {
    return path.startsWith('.') ? path.replace(/^(..\/)|(.\/)/, '/') : path.startsWith('/') ? path : '/' + path;
}
/**
 * Pushes an item to a list only if the list doesn't include the item
 */
function pushUnique(list, item) {
    if (!list.includes(item)) {
        list.push(item);
    }
}
exports.pushUnique = pushUnique;
function concatByKey(left, right, key) {
    // Remove duplicate, if an element is in right & left, it will be only once in the returned array.
    return [...new Set([...left[key], ...right[key]])];
}
exports.concatByKey = concatByKey;
function uniqueByKey(left, right, key) {
    return left[key].filter(item => !right[key].includes(item));
}
exports.uniqueByKey = uniqueByKey;
function createObject(keys, valueFn) {
    const obj = {};
    keys.forEach(key => {
        obj[key] = valueFn(key);
    });
    return obj;
}
exports.createObject = createObject;