@graphql-eslint/eslint-plugin 3.14.0-alpha-20221221142641-4e1a924 → 3.14.0-alpha-20221222124206-b82954b

package/cjs/documents.js

@@ -0,0 +1,149 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDocuments = void 0;
+const tslib_1 = require("tslib");
+const path_1 = require("path");
+const graphql_1 = require("graphql");
+const debug_1 = tslib_1.__importDefault(require("debug"));
+const fast_glob_1 = tslib_1.__importDefault(require("fast-glob"));
+const utils_1 = require("./utils");
+const cache_1 = require("./cache");
+const debug = (0, debug_1.default)('graphql-eslint:operations');
+const handleVirtualPath = (documents) => {
+    const filepathMap = Object.create(null);
+    return documents.map(source => {
+        var _a;
+        const { location } = source;
+        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: (0, path_1.resolve)(location, `${index}_document.graphql`),
+        };
+    });
+};
+const operationsCache = new cache_1.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 = fast_glob_1.default.sync(project.documents, { absolute: true });
+            debug('Operations pointers %O', operationsPaths);
+        }
+        siblings = handleVirtualPath(documents);
+        operationsCache.set(documentsKey, siblings);
+    }
+    return siblings;
+};
+function getDocuments(project) {
+    const siblings = getSiblings(project);
+    if (siblings.length === 0) {
+        let printed = false;
+        const noopWarn = () => {
+            if (!printed) {
+                utils_1.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
+    if (siblingOperationsCache.has(siblings)) {
+        return siblingOperationsCache.get(siblings);
+    }
+    let fragmentsCache = null;
+    const getFragments = () => {
+        if (fragmentsCache === null) {
+            const result = [];
+            for (const source of siblings) {
+                for (const definition of source.document.definitions) {
+                    if (definition.kind === graphql_1.Kind.FRAGMENT_DEFINITION) {
+                        result.push({
+                            filePath: source.location,
+                            document: definition,
+                        });
+                    }
+                }
+            }
+            fragmentsCache = result;
+        }
+        return fragmentsCache;
+    };
+    let cachedOperations = null;
+    const getOperations = () => {
+        if (cachedOperations === null) {
+            const result = [];
+            for (const source of siblings) {
+                for (const definition of source.document.definitions) {
+                    if (definition.kind === graphql_1.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()) => {
+        (0, graphql_1.visit)(selectable, {
+            FragmentSpread(spread) {
+                const fragmentName = spread.name.value;
+                const [fragment] = getFragment(fragmentName);
+                if (!fragment) {
+                    utils_1.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;
+}
+exports.getDocuments = getDocuments;

package/cjs/estree-converter/converter.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertToESTree = void 0;
+const graphql_1 = require("graphql");
+const utils_1 = require("./utils");
+function convertToESTree(node, schema) {
+    const typeInfo = schema ? new graphql_1.TypeInfo(schema) : null;
+    const visitor = {
+        leave(node, key, parent) {
+            const leadingComments = 'description' in node && node.description
+                ? [
+                    {
+                        type: node.description.block ? 'Block' : 'Line',
+                        value: node.description.value,
+                    },
+                ]
+                : [];
+            const calculatedTypeInfo = typeInfo
+                ? {
+                    argument: typeInfo.getArgument(),
+                    defaultValue: typeInfo.getDefaultValue(),
+                    directive: typeInfo.getDirective(),
+                    enumValue: typeInfo.getEnumValue(),
+                    fieldDef: typeInfo.getFieldDef(),
+                    inputType: typeInfo.getInputType(),
+                    parentInputType: typeInfo.getParentInputType(),
+                    parentType: typeInfo.getParentType(),
+                    gqlType: typeInfo.getType(),
+                }
+                : {};
+            const rawNode = () => {
+                if (parent && key !== undefined) {
+                    return parent[key];
+                }
+                return node.kind === graphql_1.Kind.DOCUMENT
+                    ? {
+                        ...node,
+                        definitions: node.definitions.map(definition => definition.rawNode()),
+                    }
+                    : node;
+            };
+            const commonFields = {
+                ...node,
+                type: node.kind,
+                loc: (0, utils_1.convertLocation)(node.loc),
+                range: [node.loc.start, node.loc.end],
+                leadingComments,
+                // Use function to prevent RangeError: Maximum call stack size exceeded
+                typeInfo: () => calculatedTypeInfo,
+                rawNode,
+            };
+            return 'type' in node
+                ? {
+                    ...commonFields,
+                    gqlType: node.type,
+                }
+                : commonFields;
+        },
+    };
+    return (0, graphql_1.visit)(node, typeInfo ? (0, graphql_1.visitWithTypeInfo)(typeInfo, visitor) : visitor);
+}
+exports.convertToESTree = convertToESTree;

package/cjs/estree-converter/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./converter"), exports);
+tslib_1.__exportStar(require("./types"), exports);
+tslib_1.__exportStar(require("./utils"), exports);

package/cjs/estree-converter/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/estree-converter/utils.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertLocation = exports.extractComments = exports.extractTokens = exports.convertToken = exports.getBaseType = exports.valueFromNode = void 0;
+const graphql_1 = require("graphql");
+const valueFromASTUntyped_1 = require("graphql/utilities/valueFromASTUntyped");
+const valueFromNode = (...args) => {
+    return (0, valueFromASTUntyped_1.valueFromASTUntyped)(...args);
+};
+exports.valueFromNode = valueFromNode;
+function getBaseType(type) {
+    if ((0, graphql_1.isNonNullType)(type) || (0, graphql_1.isListType)(type)) {
+        return getBaseType(type.ofType);
+    }
+    return type;
+}
+exports.getBaseType = getBaseType;
+function convertToken(token, type) {
+    const { line, column, end, start, value } = token;
+    return {
+        type,
+        value,
+        /*
+         * ESLint has 0-based column number
+         * https://eslint.org/docs/developer-guide/working-with-rules#contextreport
+         */
+        loc: {
+            start: {
+                line,
+                column: column - 1,
+            },
+            end: {
+                line,
+                column: column - 1 + (end - start),
+            },
+        },
+        range: [start, end],
+    };
+}
+exports.convertToken = convertToken;
+function getLexer(source) {
+    // GraphQL v14
+    const gqlLanguage = require('graphql/language');
+    if (gqlLanguage && gqlLanguage.createLexer) {
+        return gqlLanguage.createLexer(source, {});
+    }
+    // GraphQL v15
+    const { Lexer: LexerCls } = require('graphql');
+    if (LexerCls && typeof LexerCls === 'function') {
+        return new LexerCls(source);
+    }
+    throw new Error('Unsupported GraphQL version! Please make sure to use GraphQL v14 or newer!');
+}
+function extractTokens(filePath, code) {
+    const source = new graphql_1.Source(code, filePath);
+    const lexer = getLexer(source);
+    const tokens = [];
+    let token = lexer.advance();
+    while (token && token.kind !== graphql_1.TokenKind.EOF) {
+        const result = convertToken(token, token.kind);
+        tokens.push(result);
+        token = lexer.advance();
+    }
+    return tokens;
+}
+exports.extractTokens = extractTokens;
+function extractComments(loc) {
+    if (!loc) {
+        return [];
+    }
+    const comments = [];
+    let token = loc.startToken;
+    while (token) {
+        if (token.kind === graphql_1.TokenKind.COMMENT) {
+            const comment = convertToken(token, 
+            // `eslint-disable` directive works only with `Block` type comment
+            token.value.trimStart().startsWith('eslint') ? 'Block' : 'Line');
+            comments.push(comment);
+        }
+        token = token.next;
+    }
+    return comments;
+}
+exports.extractComments = extractComments;
+function convertLocation(location) {
+    const { startToken, endToken, source, start, end } = location;
+    /*
+     * ESLint has 0-based column number
+     * https://eslint.org/docs/developer-guide/working-with-rules#contextreport
+     */
+    const loc = {
+        start: {
+            /*
+             * Kind.Document has startToken: { line: 0, column: 0 }, we set line as 1 and column as 0
+             */
+            line: startToken.line === 0 ? 1 : startToken.line,
+            column: startToken.column === 0 ? 0 : startToken.column - 1,
+        },
+        end: {
+            line: endToken.line,
+            column: endToken.column - 1,
+        },
+        source: source.body,
+    };
+    if (loc.start.column === loc.end.column) {
+        loc.end.column += end - start;
+    }
+    return loc;
+}
+exports.convertLocation = convertLocation;

package/cjs/graphql-config.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadGraphQLConfig = exports.loadOnDiskGraphQLConfig = void 0;
+const tslib_1 = require("tslib");
+const path_1 = require("path");
+const debug_1 = tslib_1.__importDefault(require("debug"));
+const graphql_config_1 = require("graphql-config");
+const code_file_loader_1 = require("@graphql-tools/code-file-loader");
+const debug = (0, debug_1.default)('graphql-eslint:graphql-config');
+let graphQLConfig;
+function loadOnDiskGraphQLConfig(filePath) {
+    return (0, graphql_config_1.loadConfigSync)({
+        // load config relative to the file being linted
+        rootDir: (0, path_1.dirname)(filePath),
+        throwOnEmpty: false,
+        throwOnMissing: false,
+        extensions: [codeFileLoaderExtension],
+    });
+}
+exports.loadOnDiskGraphQLConfig = loadOnDiskGraphQLConfig;
+function loadGraphQLConfig(options) {
+    // We don't want cache config on test environment
+    // Otherwise schema and documents will be same for all tests
+    if (process.env.NODE_ENV !== 'test' && graphQLConfig) {
+        return graphQLConfig;
+    }
+    const onDiskConfig = !options.skipGraphQLConfig && loadOnDiskGraphQLConfig(options.filePath);
+    debug('options.skipGraphQLConfig: %o', options.skipGraphQLConfig);
+    if (onDiskConfig) {
+        debug('Graphql-config path %o', onDiskConfig.filepath);
+    }
+    const configOptions = options.projects
+        ? { projects: options.projects }
+        : {
+            schema: (options.schema || ''),
+            documents: options.documents || options.operations,
+            extensions: options.extensions,
+            include: options.include,
+            exclude: options.exclude,
+        };
+    graphQLConfig =
+        onDiskConfig ||
+            new graphql_config_1.GraphQLConfig({
+                config: configOptions,
+                filepath: 'virtual-config',
+            }, [codeFileLoaderExtension]);
+    return graphQLConfig;
+}
+exports.loadGraphQLConfig = loadGraphQLConfig;
+const codeFileLoaderExtension = api => {
+    const { schema, documents } = api.loaders;
+    schema.register(new code_file_loader_1.CodeFileLoader());
+    documents.register(new code_file_loader_1.CodeFileLoader());
+    return { name: 'graphql-eslint-loaders' };
+};

package/cjs/index.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configs = exports.processors = exports.requireSiblingsOperations = exports.requireGraphQLSchemaFromContext = exports.parseForESLint = exports.rules = void 0;
+const tslib_1 = require("tslib");
+const processor_1 = require("./processor");
+var rules_1 = require("./rules");
+Object.defineProperty(exports, "rules", { enumerable: true, get: function () { return rules_1.rules; } });
+var parser_1 = require("./parser");
+Object.defineProperty(exports, "parseForESLint", { enumerable: true, get: function () { return parser_1.parseForESLint; } });
+tslib_1.__exportStar(require("./testkit"), exports);
+tslib_1.__exportStar(require("./types"), exports);
+var utils_1 = require("./utils");
+Object.defineProperty(exports, "requireGraphQLSchemaFromContext", { enumerable: true, get: function () { return utils_1.requireGraphQLSchemaFromContext; } });
+Object.defineProperty(exports, "requireSiblingsOperations", { enumerable: true, get: function () { return utils_1.requireSiblingsOperations; } });
+exports.processors = { graphql: processor_1.processor };
+var configs_1 = require("./configs");
+Object.defineProperty(exports, "configs", { enumerable: true, get: function () { return configs_1.configs; } });

package/cjs/parser.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseForESLint = void 0;
+const tslib_1 = require("tslib");
+const utils_1 = require("@graphql-tools/utils");
+const graphql_1 = require("graphql");
+const debug_1 = tslib_1.__importDefault(require("debug"));
+const estree_converter_1 = require("./estree-converter");
+const schema_1 = require("./schema");
+const documents_1 = require("./documents");
+const graphql_config_1 = require("./graphql-config");
+const utils_2 = require("./utils");
+const debug = (0, debug_1.default)('graphql-eslint:parser');
+debug('cwd %o', utils_2.CWD);
+function parseForESLint(code, options) {
+    try {
+        const { filePath } = options;
+        // First parse code from file, in case of syntax error do not try load schema,
+        // documents or even graphql-config instance
+        const { document } = (0, utils_1.parseGraphQLSDL)(filePath, code, {
+            ...options.graphQLParserOptions,
+            noLocation: false,
+        });
+        const gqlConfig = (0, graphql_config_1.loadGraphQLConfig)(options);
+        const realFilepath = filePath.replace(utils_2.VIRTUAL_DOCUMENT_REGEX, '');
+        const project = gqlConfig.getProjectForFile(realFilepath);
+        const schema = (0, schema_1.getSchema)(project, options.schemaOptions);
+        const rootTree = (0, estree_converter_1.convertToESTree)(document, schema instanceof graphql_1.GraphQLSchema ? schema : null);
+        return {
+            services: {
+                schema,
+                siblingOperations: (0, documents_1.getDocuments)(project),
+            },
+            ast: {
+                comments: (0, estree_converter_1.extractComments)(document.loc),
+                tokens: (0, estree_converter_1.extractTokens)(filePath, code),
+                loc: rootTree.loc,
+                range: rootTree.range,
+                type: 'Program',
+                sourceType: 'script',
+                body: [rootTree],
+            },
+        };
+    }
+    catch (error) {
+        error.message = `[graphql-eslint] ${error.message}`;
+        // In case of GraphQL parser error, we report it to ESLint as a parser error that matches the requirements
+        // of ESLint. This will make sure to display it correctly in IDEs and lint results.
+        if (error instanceof graphql_1.GraphQLError) {
+            const eslintError = {
+                index: error.positions[0],
+                lineNumber: error.locations[0].line,
+                column: error.locations[0].column - 1,
+                message: error.message,
+            };
+            throw eslintError;
+        }
+        throw error;
+    }
+}
+exports.parseForESLint = parseForESLint;

package/cjs/processor.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processor = void 0;
+const graphql_tag_pluck_1 = require("@graphql-tools/graphql-tag-pluck");
+const utils_1 = require("@graphql-tools/utils");
+const graphql_config_1 = require("./graphql-config");
+const blocksMap = new Map();
+let onDiskConfig;
+let onDiskConfigLoaded = false;
+const RELEVANT_KEYWORDS = ['gql', 'graphql', 'GraphQL'];
+exports.processor = {
+    supportsAutofix: true,
+    preprocess(code, filePath) {
+        if (!onDiskConfigLoaded) {
+            onDiskConfig = (0, graphql_config_1.loadOnDiskGraphQLConfig)(filePath);
+            onDiskConfigLoaded = true;
+        }
+        let keywords = RELEVANT_KEYWORDS;
+        const pluckConfig = onDiskConfig === null || onDiskConfig === void 0 ? void 0 : onDiskConfig.getProjectForFile(filePath).extensions.pluckConfig;
+        if (pluckConfig) {
+            const { modules = [], globalGqlIdentifierName = ['gql', 'graphql'], gqlMagicComment = 'GraphQL', } = pluckConfig;
+            keywords = [
+                ...new Set([
+                    ...modules.map(({ identifier }) => identifier),
+                    ...(0, utils_1.asArray)(globalGqlIdentifierName),
+                    gqlMagicComment,
+                ].filter(Boolean)),
+            ];
+        }
+        if (keywords.every(keyword => !code.includes(keyword))) {
+            return [code];
+        }
+        try {
+            const sources = (0, graphql_tag_pluck_1.gqlPluckFromCodeStringSync)(filePath, code, {
+                skipIndent: true,
+                ...pluckConfig,
+            });
+            const isSvelte = filePath.endsWith('.svelte');
+            const blocks = sources.map(item => ({
+                filename: 'document.graphql',
+                text: item.body,
+                lineOffset: item.locationOffset.line - (isSvelte ? 3 : 1),
+                // @ts-expect-error -- `index` field exist but show ts error
+                offset: item.locationOffset.index + (isSvelte ? -52 : 1),
+            }));
+            blocksMap.set(filePath, blocks);
+            return [...blocks, code /* source code must be provided and be last */];
+        }
+        catch (_a) {
+            // in case of parsing error return code as is
+            return [code];
+        }
+    },
+    postprocess(messages, filePath) {
+        const blocks = blocksMap.get(filePath) || [];
+        for (let i = 0; i < blocks.length; i += 1) {
+            const { lineOffset, offset } = blocks[i];
+            for (const message of messages[i]) {
+                message.line += lineOffset;
+                // endLine can not exist if only `loc: { start, column }` was provided to context.report
+                if (typeof message.endLine === 'number') {
+                    message.endLine += lineOffset;
+                }
+                if (message.fix) {
+                    message.fix.range[0] += offset;
+                    message.fix.range[1] += offset;
+                }
+                for (const suggestion of message.suggestions || []) {
+                    suggestion.fix.range[0] += offset;
+                    suggestion.fix.range[1] += offset;
+                }
+            }
+        }
+        const result = messages.flat();
+        // sort eslint/graphql-eslint messages by line/column
+        return result.sort((a, b) => a.line - b.line || a.column - b.column);
+    },
+};