@graphql-eslint/eslint-plugin 3.14.0-alpha-20221222211539-5e993f5 → 3.14.0-alpha-20221223011223-bd3e820

package/esm/configs/operations-all.js

@@ -0,0 +1,29 @@
+/*
+ * 🚨 IMPORTANT! Do not manually modify this file. Run: `yarn generate-configs`
+ */
+export default {
+    extends: ['./configs/base', './configs/operations-recommended'],
+    rules: {
+        '@graphql-eslint/alphabetize': [
+            'error',
+            {
+                selections: ['OperationDefinition', 'FragmentDefinition'],
+                variables: ['OperationDefinition'],
+                arguments: ['Field', 'Directive'],
+            },
+        ],
+        '@graphql-eslint/lone-executable-definition': 'error',
+        '@graphql-eslint/match-document-filename': [
+            'error',
+            {
+                query: 'kebab-case',
+                mutation: 'kebab-case',
+                subscription: 'kebab-case',
+                fragment: 'kebab-case',
+            },
+        ],
+        '@graphql-eslint/no-one-place-fragments': 'error',
+        '@graphql-eslint/unique-fragment-name': 'error',
+        '@graphql-eslint/unique-operation-name': 'error',
+    },
+};

package/esm/configs/operations-recommended.js

@@ -0,0 +1,53 @@
+/*
+ * 🚨 IMPORTANT! Do not manually modify this file. Run: `yarn generate-configs`
+ */
+export default {
+    extends: './configs/base',
+    rules: {
+        '@graphql-eslint/executable-definitions': 'error',
+        '@graphql-eslint/fields-on-correct-type': 'error',
+        '@graphql-eslint/fragments-on-composite-type': 'error',
+        '@graphql-eslint/known-argument-names': 'error',
+        '@graphql-eslint/known-directives': 'error',
+        '@graphql-eslint/known-fragment-names': 'error',
+        '@graphql-eslint/known-type-names': 'error',
+        '@graphql-eslint/lone-anonymous-operation': 'error',
+        '@graphql-eslint/naming-convention': [
+            'error',
+            {
+                VariableDefinition: 'camelCase',
+                OperationDefinition: {
+                    style: 'PascalCase',
+                    forbiddenPrefixes: ['Query', 'Mutation', 'Subscription', 'Get'],
+                    forbiddenSuffixes: ['Query', 'Mutation', 'Subscription'],
+                },
+                FragmentDefinition: {
+                    style: 'PascalCase',
+                    forbiddenPrefixes: ['Fragment'],
+                    forbiddenSuffixes: ['Fragment'],
+                },
+            },
+        ],
+        '@graphql-eslint/no-anonymous-operations': 'error',
+        '@graphql-eslint/no-deprecated': 'error',
+        '@graphql-eslint/no-duplicate-fields': 'error',
+        '@graphql-eslint/no-fragment-cycles': 'error',
+        '@graphql-eslint/no-undefined-variables': 'error',
+        '@graphql-eslint/no-unused-fragments': 'error',
+        '@graphql-eslint/no-unused-variables': 'error',
+        '@graphql-eslint/one-field-subscriptions': 'error',
+        '@graphql-eslint/overlapping-fields-can-be-merged': 'error',
+        '@graphql-eslint/possible-fragment-spread': 'error',
+        '@graphql-eslint/provided-required-arguments': 'error',
+        '@graphql-eslint/require-id-when-available': 'error',
+        '@graphql-eslint/scalar-leafs': 'error',
+        '@graphql-eslint/selection-set-depth': ['error', { maxDepth: 7 }],
+        '@graphql-eslint/unique-argument-names': 'error',
+        '@graphql-eslint/unique-directive-names-per-location': 'error',
+        '@graphql-eslint/unique-input-field-names': 'error',
+        '@graphql-eslint/unique-variable-names': 'error',
+        '@graphql-eslint/value-literals-of-correct-type': 'error',
+        '@graphql-eslint/variables-are-input-types': 'error',
+        '@graphql-eslint/variables-in-allowed-position': 'error',
+    },
+};

package/esm/configs/relay.js

@@ -0,0 +1,9 @@
+export default {
+    extends: './configs/base',
+    rules: {
+        '@graphql-eslint/relay-arguments': 'error',
+        '@graphql-eslint/relay-connection-types': 'error',
+        '@graphql-eslint/relay-edge-types': 'error',
+        '@graphql-eslint/relay-page-info': 'error',
+    },
+};

package/esm/configs/schema-all.js

@@ -0,0 +1,22 @@
+/*
+ * 🚨 IMPORTANT! Do not manually modify this file. Run: `yarn generate-configs`
+ */
+export default {
+    extends: ['./configs/base', './configs/schema-recommended'],
+    rules: {
+        '@graphql-eslint/alphabetize': [
+            'error',
+            {
+                fields: ['ObjectTypeDefinition', 'InterfaceTypeDefinition', 'InputObjectTypeDefinition'],
+                values: ['EnumTypeDefinition'],
+                arguments: ['FieldDefinition', 'Field', 'DirectiveDefinition', 'Directive'],
+            },
+        ],
+        '@graphql-eslint/input-name': 'error',
+        '@graphql-eslint/no-scalar-result-type-on-mutation': 'error',
+        '@graphql-eslint/require-deprecation-date': 'error',
+        '@graphql-eslint/require-field-of-type-query-in-mutation-result': 'error',
+        '@graphql-eslint/require-nullable-fields-with-oneof': 'error',
+        '@graphql-eslint/require-type-pattern-with-oneof': 'error',
+    },
+};

package/esm/configs/schema-recommended.js

@@ -0,0 +1,49 @@
+/*
+ * 🚨 IMPORTANT! Do not manually modify this file. Run: `yarn generate-configs`
+ */
+export default {
+    extends: './configs/base',
+    rules: {
+        '@graphql-eslint/description-style': 'error',
+        '@graphql-eslint/known-argument-names': 'error',
+        '@graphql-eslint/known-directives': 'error',
+        '@graphql-eslint/known-type-names': 'error',
+        '@graphql-eslint/lone-schema-definition': 'error',
+        '@graphql-eslint/naming-convention': [
+            'error',
+            {
+                types: 'PascalCase',
+                FieldDefinition: 'camelCase',
+                InputValueDefinition: 'camelCase',
+                Argument: 'camelCase',
+                DirectiveDefinition: 'camelCase',
+                EnumValueDefinition: 'UPPER_CASE',
+                'FieldDefinition[parent.name.value=Query]': {
+                    forbiddenPrefixes: ['query', 'get'],
+                    forbiddenSuffixes: ['Query'],
+                },
+                'FieldDefinition[parent.name.value=Mutation]': {
+                    forbiddenPrefixes: ['mutation'],
+                    forbiddenSuffixes: ['Mutation'],
+                },
+                'FieldDefinition[parent.name.value=Subscription]': {
+                    forbiddenPrefixes: ['subscription'],
+                    forbiddenSuffixes: ['Subscription'],
+                },
+            },
+        ],
+        '@graphql-eslint/no-case-insensitive-enum-values-duplicates': 'error',
+        '@graphql-eslint/no-hashtag-description': 'error',
+        '@graphql-eslint/no-typename-prefix': 'error',
+        '@graphql-eslint/no-unreachable-types': 'error',
+        '@graphql-eslint/provided-required-arguments': 'error',
+        '@graphql-eslint/require-deprecation-reason': 'error',
+        '@graphql-eslint/require-description': ['error', { types: true, DirectiveDefinition: true }],
+        '@graphql-eslint/strict-id-in-types': 'error',
+        '@graphql-eslint/unique-directive-names': 'error',
+        '@graphql-eslint/unique-directive-names-per-location': 'error',
+        '@graphql-eslint/unique-field-definition-names': 'error',
+        '@graphql-eslint/unique-operation-types': 'error',
+        '@graphql-eslint/unique-type-names': 'error',
+    },
+};

package/esm/documents.js

@@ -0,0 +1,144 @@
+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;
+        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
+    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 === 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 === 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;
+}

package/esm/estree-converter/converter.js

@@ -0,0 +1,58 @@
+import { TypeInfo, visit, visitWithTypeInfo, Kind, } from 'graphql';
+import { convertLocation } from './utils.js';
+export function convertToESTree(node, schema) {
+    const typeInfo = schema ? new 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 === Kind.DOCUMENT
+                    ? {
+                        ...node,
+                        definitions: node.definitions.map(definition => definition.rawNode()),
+                    }
+                    : node;
+            };
+            const commonFields = {
+                ...node,
+                type: node.kind,
+                loc: 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 visit(node, typeInfo ? visitWithTypeInfo(typeInfo, visitor) : visitor);
+}

package/esm/estree-converter/index.js

@@ -0,0 +1,3 @@
+export * from './converter.js';
+export * from './types.js';
+export * from './utils.js';

package/esm/estree-converter/types.js

@@ -0,0 +1 @@
+export {};

package/esm/estree-converter/utils.js

@@ -0,0 +1,102 @@
+import { createRequire } from 'module';
+const require = createRequire(import.meta.url);
+import { TokenKind, isNonNullType, isListType, Source, } from 'graphql';
+import { valueFromASTUntyped } from 'graphql/utilities/valueFromASTUntyped.js';
+export const valueFromNode = (...args) => {
+    return valueFromASTUntyped(...args);
+};
+export function getBaseType(type) {
+    if (isNonNullType(type) || isListType(type)) {
+        return getBaseType(type.ofType);
+    }
+    return type;
+}
+export 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],
+    };
+}
+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!');
+}
+export function extractTokens(filePath, code) {
+    const source = new Source(code, filePath);
+    const lexer = getLexer(source);
+    const tokens = [];
+    let token = lexer.advance();
+    while (token && token.kind !== TokenKind.EOF) {
+        const result = convertToken(token, token.kind);
+        tokens.push(result);
+        token = lexer.advance();
+    }
+    return tokens;
+}
+export function extractComments(loc) {
+    if (!loc) {
+        return [];
+    }
+    const comments = [];
+    let token = loc.startToken;
+    while (token) {
+        if (token.kind === 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;
+}
+export 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;
+}

package/esm/flat-configs.js

@@ -0,0 +1,33 @@
+import { parseForESLint } from './parser.js';
+import { configs } from './configs/index.js';
+const languageOptions = {
+    parser: { parseForESLint },
+};
+export const flatConfigs = {
+    'operations-all': {
+        languageOptions,
+        rules: {
+            ...configs['operations-recommended'].rules,
+            ...configs['operations-all'].rules,
+        },
+    },
+    'operations-recommended': {
+        languageOptions,
+        rules: configs['operations-recommended'].rules,
+    },
+    relay: {
+        languageOptions,
+        rules: configs.relay.rules,
+    },
+    'schema-all': {
+        languageOptions,
+        rules: {
+            ...configs['schema-recommended'].rules,
+            ...configs['schema-all'].rules,
+        },
+    },
+    'schema-recommended': {
+        languageOptions,
+        rules: configs['schema-recommended'].rules,
+    },
+};

package/esm/graphql-config.js

@@ -0,0 +1,49 @@
+import { dirname } from 'path';
+import debugFactory from 'debug';
+import { GraphQLConfig, loadConfigSync } from 'graphql-config';
+import { CodeFileLoader } from '@graphql-tools/code-file-loader';
+const debug = debugFactory('graphql-eslint:graphql-config');
+let graphQLConfig;
+export function loadOnDiskGraphQLConfig(filePath) {
+    return loadConfigSync({
+        // load config relative to the file being linted
+        rootDir: dirname(filePath),
+        throwOnEmpty: false,
+        throwOnMissing: false,
+        extensions: [codeFileLoaderExtension],
+    });
+}
+export 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 GraphQLConfig({
+                config: configOptions,
+                filepath: 'virtual-config',
+            }, [codeFileLoaderExtension]);
+    return graphQLConfig;
+}
+const codeFileLoaderExtension = api => {
+    const { schema, documents } = api.loaders;
+    schema.register(new CodeFileLoader());
+    documents.register(new CodeFileLoader());
+    return { name: 'graphql-eslint-loaders' };
+};

package/esm/index.js

@@ -0,0 +1,9 @@
+import { processor } from './processor.js';
+export { rules } from './rules/index.js';
+export { parseForESLint } from './parser.js';
+export * from './testkit.js';
+export * from './types.js';
+export { requireGraphQLSchemaFromContext, requireSiblingsOperations } from './utils.js';
+export const processors = { graphql: processor };
+export { configs } from './configs/index.js';
+export { flatConfigs } from './flat-configs.js';

package/esm/package.json

@@ -0,0 +1 @@
+{ "type": "module" }

package/esm/parser.js

@@ -0,0 +1,56 @@
+import { parseGraphQLSDL } from '@graphql-tools/utils';
+import { GraphQLError, GraphQLSchema } from 'graphql';
+import debugFactory from 'debug';
+import { convertToESTree, extractComments, extractTokens } from './estree-converter/index.js';
+import { getSchema } from './schema.js';
+import { getDocuments } from './documents.js';
+import { loadGraphQLConfig } from './graphql-config.js';
+import { CWD, VIRTUAL_DOCUMENT_REGEX } from './utils.js';
+const debug = debugFactory('graphql-eslint:parser');
+debug('cwd %o', CWD);
+export 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 } = parseGraphQLSDL(filePath, code, {
+            ...options.graphQLParserOptions,
+            noLocation: false,
+        });
+        const gqlConfig = loadGraphQLConfig(options);
+        const realFilepath = filePath.replace(VIRTUAL_DOCUMENT_REGEX, '');
+        const project = gqlConfig.getProjectForFile(realFilepath);
+        const schema = getSchema(project, options.schemaOptions);
+        const rootTree = convertToESTree(document, schema instanceof GraphQLSchema ? schema : null);
+        return {
+            services: {
+                schema,
+                siblingOperations: getDocuments(project),
+            },
+            ast: {
+                comments: extractComments(document.loc),
+                tokens: 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 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;
+    }
+}