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

GraphQL Code Generator preset for modularized schema

import { Kind, } from 'graphql';
import parse from 'parse-filepath';
const sep = '/';
/**
 * Searches every node to collect used types
 */
export function collectUsedTypes(doc) {
    const used = [];
    for (const node of doc.definitions) {
        findRelated(node);
    }
    function markAsUsed(type) {
        pushUnique(used, type);
    }
    function findRelated(node) {
        if (node.kind === Kind.OBJECT_TYPE_DEFINITION || node.kind === Kind.OBJECT_TYPE_EXTENSION) {
            // Object
            markAsUsed(node.name.value);
            if (node.fields) {
                for (const n of node.fields) {
                    findRelated(n);
                }
            }
            if (node.interfaces) {
                for (const n of node.interfaces) {
                    findRelated(n);
                }
            }
        }
        else if (node.kind === Kind.INPUT_OBJECT_TYPE_DEFINITION || node.kind === Kind.INPUT_OBJECT_TYPE_EXTENSION) {
            // Input
            markAsUsed(node.name.value);
            if (node.fields) {
                for (const n of node.fields) {
                    findRelated(n);
                }
            }
        }
        else if (node.kind === Kind.INTERFACE_TYPE_DEFINITION || node.kind === Kind.INTERFACE_TYPE_EXTENSION) {
            // Interface
            markAsUsed(node.name.value);
            if (node.fields) {
                for (const n of node.fields) {
                    findRelated(n);
                }
            }
            if (node.interfaces) {
                for (const n of node.interfaces) {
                    findRelated(n);
                }
            }
        }
        else if (node.kind === Kind.UNION_TYPE_DEFINITION || node.kind === Kind.UNION_TYPE_EXTENSION) {
            // Union
            markAsUsed(node.name.value);
            if (node.types) {
                for (const n of node.types) {
                    findRelated(n);
                }
            }
        }
        else if (node.kind === Kind.ENUM_TYPE_DEFINITION || node.kind === Kind.ENUM_TYPE_EXTENSION) {
            // Enum
            markAsUsed(node.name.value);
        }
        else if (node.kind === Kind.SCALAR_TYPE_DEFINITION || node.kind === Kind.SCALAR_TYPE_EXTENSION) {
            // Scalar
            if (!isGraphQLPrimitive(node.name.value)) {
                markAsUsed(node.name.value);
            }
        }
        else if (node.kind === Kind.INPUT_VALUE_DEFINITION) {
            // Argument
            findRelated(resolveTypeNode(node.type));
        }
        else if (node.kind === Kind.FIELD_DEFINITION) {
            // Field
            findRelated(resolveTypeNode(node.type));
            if (node.arguments) {
                for (const n of node.arguments) {
                    findRelated(n);
                }
            }
        }
        else if (node.kind === Kind.NAMED_TYPE &&
            // Named type
            !isGraphQLPrimitive(node.name.value)) {
            markAsUsed(node.name.value);
        }
    }
    return used;
}
export function resolveTypeNode(node) {
    if (node.kind === Kind.LIST_TYPE) {
        return resolveTypeNode(node.type);
    }
    if (node.kind === Kind.NON_NULL_TYPE) {
        return resolveTypeNode(node.type);
    }
    return node;
}
export function isGraphQLPrimitive(name) {
    return ['String', 'Boolean', 'ID', 'Float', 'Int'].includes(name);
}
export function unique(val, i, all) {
    return i === all.indexOf(val);
}
export function withQuotes(val) {
    return `'${val}'`;
}
export 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;
}
export function buildBlock({ name, lines }) {
    if (!lines.length) {
        return '';
    }
    return [`${name} {`, ...lines.map(indent(2)), '};'].join('\n');
}
const getRelativePath = function (filepath, basePath) {
    const normalizedFilepath = normalize(filepath);
    const normalizedBasePath = ensureStartsWithSeparator(normalize(ensureEndsWithSeparator(basePath)));
    const [, relativePath] = normalizedFilepath.split(normalizedBasePath);
    return relativePath;
};
export function groupSourcesByModule(sources, basePath) {
    const grouped = {};
    for (const source of sources) {
        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);
            grouped[mod] ||= [];
            grouped[mod].push(source);
        }
    }
    return grouped;
}
function extractModuleDirectory(filepath, basePath) {
    const relativePath = getRelativePath(filepath, basePath);
    const [moduleDirectory] = relativePath.split(sep);
    return moduleDirectory;
}
export function stripFilename(path) {
    const parsedPath = parse(path);
    return normalize(parsedPath.dir);
}
export function normalize(path) {
    return path.replace(/\\/g, '/');
}
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
 */
export function pushUnique(list, item) {
    if (!list.includes(item)) {
        list.push(item);
    }
}
export 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]])];
}
export function uniqueByKey(left, right, key) {
    return left[key].filter(item => !right[key].includes(item));
}
export function createObject(keys, valueFn) {
    const obj = {};
    for (const key of keys) {
        obj[key] = valueFn(key);
    }
    return obj;
}