@graphql-eslint/eslint-plugin/esm/documents.js

GraphQL plugin for ESLint

import { resolve } from 'path';
import { Kind, visit, } from 'graphql';
import debugFactory from 'debug';
import fg from 'fast-glob';
import { logger } from './utils.js';
import { ModuleCache } from './cache.js';
const debug = debugFactory('graphql-eslint:operations');
const handleVirtualPath = (documents) => {
    const filepathMap = Object.create(null);
    return documents.map(source => {
        var _a;
        const location = source.location;
        if (['.gql', '.graphql'].some(extension => location.endsWith(extension))) {
            return source;
        }
        (_a = filepathMap[location]) !== null && _a !== void 0 ? _a : (filepathMap[location] = -1);
        const index = (filepathMap[location] += 1);
        return {
            ...source,
            location: resolve(location, `${index}_document.graphql`),
        };
    });
};
const operationsCache = new ModuleCache();
const siblingOperationsCache = new Map();
const getSiblings = (project) => {
    const documentsKey = project.documents;
    if (!documentsKey) {
        return [];
    }
    let siblings = operationsCache.get(documentsKey);
    if (!siblings) {
        debug('Loading operations from %o', project.documents);
        const documents = project.loadDocumentsSync(project.documents, {
            skipGraphQLImport: true,
            pluckConfig: project.extensions.pluckConfig,
        });
        if (debug.enabled) {
            debug('Loaded %d operations', documents.length);
            const operationsPaths = fg.sync(project.documents, { absolute: true });
            debug('Operations pointers %O', operationsPaths);
        }
        siblings = handleVirtualPath(documents);
        operationsCache.set(documentsKey, siblings);
    }
    return siblings;
};
export function getDocuments(project) {
    const siblings = getSiblings(project);
    if (siblings.length === 0) {
        let printed = false;
        const noopWarn = () => {
            if (!printed) {
                logger.warn('getSiblingOperations was called without any operations. Make sure to set "parserOptions.operations" to make this feature available!');
                printed = true;
            }
            return [];
        };
        return {
            available: false,
            getFragment: noopWarn,
            getFragments: noopWarn,
            getFragmentByType: noopWarn,
            getFragmentsInUse: noopWarn,
            getOperation: noopWarn,
            getOperations: noopWarn,
            getOperationByType: noopWarn,
        };
    }
    // Since the siblings array is cached, we can use it as cache key.
    // We should get the same array reference each time we get
    // to this point for the same graphql project
    const value = siblingOperationsCache.get(siblings);
    if (value) {
        return value;
    }
    let fragmentsCache = null;
    const getFragments = () => {
        var _a;
        if (fragmentsCache === null) {
            const result = [];
            for (const source of siblings) {
                for (const definition of ((_a = source.document) === null || _a === void 0 ? void 0 : _a.definitions) || []) {
                    if (definition.kind === Kind.FRAGMENT_DEFINITION) {
                        result.push({
                            filePath: source.location,
                            document: definition,
                        });
                    }
                }
            }
            fragmentsCache = result;
        }
        return fragmentsCache;
    };
    let cachedOperations = null;
    const getOperations = () => {
        var _a;
        if (cachedOperations === null) {
            const result = [];
            for (const source of siblings) {
                for (const definition of ((_a = source.document) === null || _a === void 0 ? void 0 : _a.definitions) || []) {
                    if (definition.kind === Kind.OPERATION_DEFINITION) {
                        result.push({
                            filePath: source.location,
                            document: definition,
                        });
                    }
                }
            }
            cachedOperations = result;
        }
        return cachedOperations;
    };
    const getFragment = (name) => getFragments().filter(f => { var _a; return ((_a = f.document.name) === null || _a === void 0 ? void 0 : _a.value) === name; });
    const collectFragments = (selectable, recursive, collected = new Map()) => {
        visit(selectable, {
            FragmentSpread(spread) {
                const fragmentName = spread.name.value;
                const [fragment] = getFragment(fragmentName);
                if (!fragment) {
                    logger.warn(`Unable to locate fragment named "${fragmentName}", please make sure it's loaded using "parserOptions.operations"`);
                    return;
                }
                if (!collected.has(fragmentName)) {
                    collected.set(fragmentName, fragment.document);
                    if (recursive) {
                        collectFragments(fragment.document, recursive, collected);
                    }
                }
            },
        });
        return collected;
    };
    const siblingOperations = {
        available: true,
        getFragment,
        getFragments,
        getFragmentByType: typeName => getFragments().filter(f => { var _a, _b; return ((_b = (_a = f.document.typeCondition) === null || _a === void 0 ? void 0 : _a.name) === null || _b === void 0 ? void 0 : _b.value) === typeName; }),
        getFragmentsInUse: (selectable, recursive = true) => Array.from(collectFragments(selectable, recursive).values()),
        getOperation: name => getOperations().filter(o => { var _a; return ((_a = o.document.name) === null || _a === void 0 ? void 0 : _a.value) === name; }),
        getOperations,
        getOperationByType: type => getOperations().filter(o => o.document.operation === type),
    };
    siblingOperationsCache.set(siblings, siblingOperations);
    return siblingOperations;
}