@graphql-eslint/eslint-plugin 3.1.0-alpha-878c908.0 → 3.2.0-alpha-6aa2721.0

package/index.js

@@ -6,7 +6,6 @@ function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'defau
 
 const graphql = require('graphql');
 const validate = require('graphql/validation/validate');
-const _import = require('@graphql-tools/import');
 const fs = require('fs');
 const path = require('path');
 const utils = require('@graphql-tools/utils');
@@ -335,59 +334,99 @@ function getLocation(loc, fieldName = '', offset) {
     };
 }
 
-function extractRuleName(stack) {
-    const match = (stack || '').match(/validation[/\\]rules[/\\](.*?)\.js:/) || [];
-    return match[1] || null;
+function validateDocument(sourceNode, context, schema, documentNode, rule) {
+    if (documentNode.definitions.length === 0) {
+        return;
+    }
+    try {
+        const validationErrors = schema
+            ? graphql.validate(schema, documentNode, [rule])
+            : validate.validateSDL(documentNode, null, [rule]);
+        for (const error of validationErrors) {
+            context.report({
+                loc: getLocation({ start: error.locations[0] }),
+                message: error.message,
+            });
+        }
+    }
+    catch (e) {
+        context.report({
+            node: sourceNode,
+            message: e.message,
+        });
+    }
 }
-function validateDoc(sourceNode, context, schema, documentNode, rules, ruleName = null) {
-    var _a;
-    if (((_a = documentNode === null || documentNode === void 0 ? void 0 : documentNode.definitions) === null || _a === void 0 ? void 0 : _a.length) > 0) {
-        try {
-            const validationErrors = schema ? graphql.validate(schema, documentNode, rules) : validate.validateSDL(documentNode, null, rules);
-            for (const error of validationErrors) {
-                const validateRuleName = ruleName || `[${extractRuleName(error.stack)}]`;
-                context.report({
-                    loc: getLocation({ start: error.locations[0] }),
-                    message: ruleName ? error.message : `${validateRuleName} ${error.message}`,
-                });
+const getFragmentDefsAndFragmentSpreads = (schema, node) => {
+    const typeInfo = new graphql.TypeInfo(schema);
+    const fragmentDefs = new Set();
+    const fragmentSpreads = new Set();
+    const visitor = graphql.visitWithTypeInfo(typeInfo, {
+        FragmentDefinition(node) {
+            fragmentDefs.add(`${node.name.value}:${node.typeCondition.name.value}`);
+        },
+        FragmentSpread(node) {
+            const parentType = typeInfo.getParentType();
+            if (parentType) {
+                fragmentSpreads.add(`${node.name.value}:${parentType.name}`);
             }
+        },
+    });
+    graphql.visit(node, visitor);
+    return { fragmentDefs, fragmentSpreads };
+};
+const getMissingFragments = (schema, node) => {
+    const { fragmentDefs, fragmentSpreads } = getFragmentDefsAndFragmentSpreads(schema, node);
+    return [...fragmentSpreads].filter(name => !fragmentDefs.has(name));
+};
+const handleMissingFragments = ({ ruleId, context, schema, node }) => {
+    const missingFragments = getMissingFragments(schema, node);
+    if (missingFragments.length > 0) {
+        const siblings = requireSiblingsOperations(ruleId, context);
+        const fragmentsToAdd = [];
+        for (const missingFragment of missingFragments) {
+            const [fragmentName, fragmentTypeName] = missingFragment.split(':');
+            const fragments = siblings
+                .getFragment(fragmentName)
+                .map(source => source.document)
+                .filter(fragment => fragment.typeCondition.name.value === fragmentTypeName);
+            fragmentsToAdd.push(fragments[0]);
         }
-        catch (e) {
-            context.report({
-                node: sourceNode,
-                message: e.message,
+        if (fragmentsToAdd.length > 0) {
+            // recall fn to make sure to add fragments inside fragments
+            return handleMissingFragments({
+                ruleId,
+                context,
+                schema,
+                node: {
+                    kind: graphql.Kind.DOCUMENT,
+                    definitions: [...node.definitions, ...fragmentsToAdd],
+                },
             });
         }
     }
-}
-const isGraphQLImportFile = rawSDL => {
-    const trimmedRawSDL = rawSDL.trimLeft();
-    return trimmedRawSDL.startsWith('# import') || trimmedRawSDL.startsWith('#import');
+    return node;
 };
-const validationToRule = (name, ruleName, docs, getDocumentNode) => {
-    var _a;
+const validationToRule = (ruleId, ruleName, docs, getDocumentNode) => {
     let ruleFn = null;
     try {
         ruleFn = require(`graphql/validation/rules/${ruleName}Rule`)[`${ruleName}Rule`];
     }
-    catch (e) {
+    catch (_a) {
         try {
             ruleFn = require(`graphql/validation/rules/${ruleName}`)[`${ruleName}Rule`];
         }
-        catch (e) {
+        catch (_b) {
             ruleFn = require('graphql/validation')[`${ruleName}Rule`];
         }
     }
-    const requiresSchema = (_a = docs.requiresSchema) !== null && _a !== void 0 ? _a : true;
     return {
-        [name]: {
+        [ruleId]: {
             meta: {
                 docs: {
                     recommended: true,
                     ...docs,
                     graphQLJSRuleName: ruleName,
-                    requiresSchema,
-                    url: `https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/${name}.md`,
+                    url: `https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/${ruleId}.md`,
                     description: `${docs.description}\n\n> This rule is a wrapper around a \`graphql-js\` validation function. [You can find its source code here](https://github.com/graphql/graphql-js/blob/main/src/validation/rules/${ruleName}Rule.ts).`,
                 },
             },
@@ -396,56 +435,53 @@ const validationToRule = (name, ruleName, docs, getDocumentNode) => {
                     Document(node) {
                         if (!ruleFn) {
                             // eslint-disable-next-line no-console
-                            console.warn(`You rule "${name}" depends on a GraphQL validation rule ("${ruleName}") but it's not available in the "graphql-js" version you are using. Skipping...`);
+                            console.warn(`You rule "${ruleId}" depends on a GraphQL validation rule "${ruleName}" but it's not available in the "graphql-js" version you are using. Skipping...`);
                             return;
                         }
-                        const schema = requiresSchema ? requireGraphQLSchemaFromContext(name, context) : null;
-                        let documentNode;
-                        const isRealFile = fs.existsSync(context.getFilename());
-                        if (isRealFile && getDocumentNode) {
-                            documentNode = getDocumentNode(context);
-                        }
-                        validateDoc(node, context, schema, documentNode || node.rawNode(), [ruleFn], ruleName);
+                        const schema = docs.requiresSchema ? requireGraphQLSchemaFromContext(ruleId, context) : null;
+                        const documentNode = getDocumentNode
+                            ? getDocumentNode({ ruleId, context, schema, node: node.rawNode() })
+                            : node.rawNode();
+                        validateDocument(node, context, schema, documentNode, ruleFn);
                     },
                 };
             },
         },
     };
 };
-const importFiles = (context) => {
-    const code = context.getSourceCode().text;
-    if (!isGraphQLImportFile(code)) {
-        return null;
-    }
-    // Import documents because file contains '#import' comments
-    return _import.processImport(context.getFilename());
-};
 const GRAPHQL_JS_VALIDATIONS = Object.assign({}, validationToRule('executable-definitions', 'ExecutableDefinitions', {
     category: 'Operations',
     description: `A GraphQL document is only valid for execution if all definitions are either operation or fragment definitions.`,
+    requiresSchema: true,
 }), validationToRule('fields-on-correct-type', 'FieldsOnCorrectType', {
     category: 'Operations',
     description: 'A GraphQL document is only valid if all fields selected are defined by the parent type, or are an allowed meta field such as `__typename`.',
+    requiresSchema: true,
 }), validationToRule('fragments-on-composite-type', 'FragmentsOnCompositeTypes', {
     category: 'Operations',
     description: `Fragments use a type condition to determine if they apply, since fragments can only be spread into a composite type (object, interface, or union), the type condition must also be a composite type.`,
+    requiresSchema: true,
 }), validationToRule('known-argument-names', 'KnownArgumentNames', {
     category: ['Schema', 'Operations'],
     description: `A GraphQL field is only valid if all supplied arguments are defined by that field.`,
+    requiresSchema: true,
 }), validationToRule('known-directives', 'KnownDirectives', {
     category: ['Schema', 'Operations'],
     description: `A GraphQL document is only valid if all \`@directives\` are known by the schema and legally positioned.`,
+    requiresSchema: true,
 }), validationToRule('known-fragment-names', 'KnownFragmentNames', {
     category: 'Operations',
     description: `A GraphQL document is only valid if all \`...Fragment\` fragment spreads refer to fragments defined in the same document.`,
+    requiresSchema: true,
+    requiresSiblings: true,
     examples: [
         {
-            title: 'Incorrect (fragment not defined in the document)',
+            title: 'Incorrect',
             code: /* GraphQL */ `
             query {
               user {
                 id
-                ...UserFields
+                ...UserFields # fragment not defined in the document
               }
             }
           `,
@@ -467,153 +503,151 @@ const GRAPHQL_JS_VALIDATIONS = Object.assign({}, validationToRule('executable-de
           `,
         },
         {
-            title: 'Correct (existing import to UserFields fragment)',
+            title: 'Correct (`UserFields` fragment located in a separate file)',
             code: /* GraphQL */ `
-            #import '../UserFields.gql'
-
+            # user.gql
             query {
               user {
                 id
                 ...UserFields
               }
             }
-          `,
-        },
-        {
-            title: "False positive case\n\nFor extracting documents from code under the hood we use [graphql-tag-pluck](https://graphql-tools.com/docs/graphql-tag-pluck) that [don't support string interpolation](https://stackoverflow.com/questions/62749847/graphql-codegen-dynamic-fields-with-interpolation/62751311#62751311) for this moment.",
-            code: `
-            const USER_FIELDS = gql\`
-              fragment UserFields on User {
-                id
-              }
-            \`
-            
-            const GET_USER = /* GraphQL */ \`
-              # eslint @graphql-eslint/known-fragment-names: 'error'
-
-              query User {
-                user {
-                  ...UserFields
-                }
-              }
 
-              # Will give false positive error 'Unknown fragment "UserFields"'
-              \${USER_FIELDS}
-            \``,
+            # user-fields.gql
+            fragment UserFields on User {
+              id
+            }
+          `,
         },
     ],
-}, importFiles), validationToRule('known-type-names', 'KnownTypeNames', {
+}, handleMissingFragments), validationToRule('known-type-names', 'KnownTypeNames', {
     category: ['Schema', 'Operations'],
     description: `A GraphQL document is only valid if referenced types (specifically variable definitions and fragment conditions) are defined by the type schema.`,
+    requiresSchema: true,
 }), validationToRule('lone-anonymous-operation', 'LoneAnonymousOperation', {
     category: 'Operations',
     description: `A GraphQL document is only valid if when it contains an anonymous operation (the query short-hand) that it contains only that one operation definition.`,
+    requiresSchema: true,
 }), validationToRule('lone-schema-definition', 'LoneSchemaDefinition', {
     category: 'Schema',
     description: `A GraphQL document is only valid if it contains only one schema definition.`,
-    requiresSchema: false,
 }), validationToRule('no-fragment-cycles', 'NoFragmentCycles', {
     category: 'Operations',
     description: `A GraphQL fragment is only valid when it does not have cycles in fragments usage.`,
+    requiresSchema: true,
 }), validationToRule('no-undefined-variables', 'NoUndefinedVariables', {
     category: 'Operations',
     description: `A GraphQL operation is only valid if all variables encountered, both directly and via fragment spreads, are defined by that operation.`,
-}, importFiles), validationToRule('no-unused-fragments', 'NoUnusedFragments', {
+    requiresSchema: true,
+    requiresSiblings: true,
+}, handleMissingFragments), validationToRule('no-unused-fragments', 'NoUnusedFragments', {
     category: 'Operations',
     description: `A GraphQL document is only valid if all fragment definitions are spread within operations, or spread within other fragments spread within operations.`,
+    requiresSchema: true,
     requiresSiblings: true,
-}, context => {
-    const siblings = requireSiblingsOperations('no-unused-fragments', context);
-    const documents = [...siblings.getOperations(), ...siblings.getFragments()]
-        .filter(({ document }) => isGraphQLImportFile(document.loc.source.body))
-        .map(({ filePath, document }) => ({
-        filePath,
-        code: document.loc.source.body,
-    }));
-    const getParentNode = (filePath) => {
-        for (const { filePath: docFilePath, code } of documents) {
-            const isFileImported = code
-                .split('\n')
-                .filter(isGraphQLImportFile)
-                .map(line => _import.parseImportLine(line.replace('#', '')))
-                .some(o => filePath === path.join(path.dirname(docFilePath), o.from));
-            if (!isFileImported) {
-                continue;
-            }
-            // Import first file that import this file
-            const document = _import.processImport(docFilePath);
-            // Import most top file that import this file
-            return getParentNode(docFilePath) || document;
+}, ({ ruleId, context, schema, node }) => {
+    const siblings = requireSiblingsOperations(ruleId, context);
+    const FilePathToDocumentsMap = [...siblings.getOperations(), ...siblings.getFragments()].reduce((map, { filePath, document }) => {
+        var _a;
+        (_a = map[filePath]) !== null && _a !== void 0 ? _a : (map[filePath] = []);
+        map[filePath].push(document);
+        return map;
+    }, Object.create(null));
+    const getParentNode = (currentFilePath, node) => {
+        const { fragmentDefs } = getFragmentDefsAndFragmentSpreads(schema, node);
+        if (fragmentDefs.size === 0) {
+            return node;
         }
-        return null;
+        // skip iteration over documents for current filepath
+        delete FilePathToDocumentsMap[currentFilePath];
+        for (const [filePath, documents] of Object.entries(FilePathToDocumentsMap)) {
+            const missingFragments = getMissingFragments(schema, {
+                kind: graphql.Kind.DOCUMENT,
+                definitions: documents,
+            });
+            const isCurrentFileImportFragment = missingFragments.some(fragment => fragmentDefs.has(fragment));
+            if (isCurrentFileImportFragment) {
+                return getParentNode(filePath, {
+                    kind: graphql.Kind.DOCUMENT,
+                    definitions: [...node.definitions, ...documents],
+                });
+            }
+        }
+        return node;
     };
-    return getParentNode(context.getFilename());
+    return getParentNode(context.getFilename(), node);
 }), validationToRule('no-unused-variables', 'NoUnusedVariables', {
     category: 'Operations',
     description: `A GraphQL operation is only valid if all variables defined by an operation are used, either directly or within a spread fragment.`,
-}, importFiles), validationToRule('overlapping-fields-can-be-merged', 'OverlappingFieldsCanBeMerged', {
+    requiresSchema: true,
+    requiresSiblings: true,
+}, handleMissingFragments), validationToRule('overlapping-fields-can-be-merged', 'OverlappingFieldsCanBeMerged', {
     category: 'Operations',
     description: `A selection set is only valid if all fields (including spreading any fragments) either correspond to distinct response names or can be merged without ambiguity.`,
+    requiresSchema: true,
 }), validationToRule('possible-fragment-spread', 'PossibleFragmentSpreads', {
     category: 'Operations',
     description: `A fragment spread is only valid if the type condition could ever possibly be true: if there is a non-empty intersection of the possible parent types, and possible types which pass the type condition.`,
+    requiresSchema: true,
 }), validationToRule('possible-type-extension', 'PossibleTypeExtensions', {
     category: 'Schema',
     description: `A type extension is only valid if the type is defined and has the same kind.`,
-    requiresSchema: false,
     recommended: false, // TODO: enable after https://github.com/dotansimha/graphql-eslint/issues/787 will be fixed
 }), validationToRule('provided-required-arguments', 'ProvidedRequiredArguments', {
     category: ['Schema', 'Operations'],
     description: `A field or directive is only valid if all required (non-null without a default value) field arguments have been provided.`,
+    requiresSchema: true,
 }), validationToRule('scalar-leafs', 'ScalarLeafs', {
     category: 'Operations',
     description: `A GraphQL document is valid only if all leaf fields (fields without sub selections) are of scalar or enum types.`,
+    requiresSchema: true,
 }), validationToRule('one-field-subscriptions', 'SingleFieldSubscriptions', {
     category: 'Operations',
     description: `A GraphQL subscription is valid only if it contains a single root field.`,
+    requiresSchema: true,
 }), validationToRule('unique-argument-names', 'UniqueArgumentNames', {
     category: 'Operations',
     description: `A GraphQL field or directive is only valid if all supplied arguments are uniquely named.`,
+    requiresSchema: true,
 }), validationToRule('unique-directive-names', 'UniqueDirectiveNames', {
     category: 'Schema',
     description: `A GraphQL document is only valid if all defined directives have unique names.`,
-    requiresSchema: false,
 }), validationToRule('unique-directive-names-per-location', 'UniqueDirectivesPerLocation', {
     category: ['Schema', 'Operations'],
     description: `A GraphQL document is only valid if all non-repeatable directives at a given location are uniquely named.`,
+    requiresSchema: true,
 }), validationToRule('unique-enum-value-names', 'UniqueEnumValueNames', {
     category: 'Schema',
     description: `A GraphQL enum type is only valid if all its values are uniquely named.`,
-    requiresSchema: false,
     recommended: false,
 }), validationToRule('unique-field-definition-names', 'UniqueFieldDefinitionNames', {
     category: 'Schema',
     description: `A GraphQL complex type is only valid if all its fields are uniquely named.`,
-    requiresSchema: false,
 }), validationToRule('unique-input-field-names', 'UniqueInputFieldNames', {
     category: 'Operations',
     description: `A GraphQL input object value is only valid if all supplied fields are uniquely named.`,
-    requiresSchema: false,
 }), validationToRule('unique-operation-types', 'UniqueOperationTypes', {
     category: 'Schema',
     description: `A GraphQL document is only valid if it has only one type per operation.`,
-    requiresSchema: false,
 }), validationToRule('unique-type-names', 'UniqueTypeNames', {
     category: 'Schema',
     description: `A GraphQL document is only valid if all defined types have unique names.`,
-    requiresSchema: false,
 }), validationToRule('unique-variable-names', 'UniqueVariableNames', {
     category: 'Operations',
     description: `A GraphQL operation is only valid if all its variables are uniquely named.`,
+    requiresSchema: true,
 }), validationToRule('value-literals-of-correct-type', 'ValuesOfCorrectType', {
     category: 'Operations',
     description: `A GraphQL document is only valid if all value literals are of the type expected at their position.`,
+    requiresSchema: true,
 }), validationToRule('variables-are-input-types', 'VariablesAreInputTypes', {
     category: 'Operations',
     description: `A GraphQL operation is only valid if all the variables it defines are of input types (scalar, enum, or input object).`,
+    requiresSchema: true,
 }), validationToRule('variables-in-allowed-position', 'VariablesInAllowedPosition', {
     category: 'Operations',
     description: `Variables passed to field arguments conform to type.`,
+    requiresSchema: true,
 }));
 
 const ALPHABETIZE = 'ALPHABETIZE';
@@ -1845,7 +1879,7 @@ const HASHTAG_COMMENT = 'HASHTAG_COMMENT';
 const rule$9 = {
     meta: {
         messages: {
-            [HASHTAG_COMMENT]: 'Using hashtag (#) for adding GraphQL descriptions is not allowed. Prefer using """ for multiline, or " for a single line description.',
+            [HASHTAG_COMMENT]: `Using hashtag (#) for adding GraphQL descriptions is not allowed. Prefer using """ for multiline, or " for a single line description.`,
         },
         docs: {
             description: 'Requires to use `"""` or `"` for adding a GraphQL description instead of `#`.\nAllows to use hashtag for comments, as long as it\'s not attached to an AST definition.',
@@ -1892,14 +1926,15 @@ const rule$9 = {
         schema: [],
     },
     create(context) {
+        const selector = `${graphql.Kind.DOCUMENT}[definitions.0.kind!=/^(${graphql.Kind.OPERATION_DEFINITION}|${graphql.Kind.FRAGMENT_DEFINITION})$/]`;
         return {
-            Document(node) {
+            [selector](node) {
                 const rawNode = node.rawNode();
                 let token = rawNode.loc.startToken;
                 while (token !== null) {
                     const { kind, prev, next, value, line, column } = token;
                     if (kind === graphql.TokenKind.COMMENT && prev && next) {
-                        const isEslintComment = value.trimLeft().startsWith('eslint');
+                        const isEslintComment = value.trimStart().startsWith('eslint');
                         const linesAfter = next.line - line;
                         if (!isEslintComment && line !== prev.line && next.kind === graphql.TokenKind.NAME && linesAfter < 2) {
                             context.report({
@@ -2106,7 +2141,22 @@ const rule$c = {
 };
 
 const UNREACHABLE_TYPE = 'UNREACHABLE_TYPE';
-const RULE_NAME = 'no-unreachable-types';
+const RULE_ID = 'no-unreachable-types';
+const KINDS = [
+    graphql.Kind.DIRECTIVE_DEFINITION,
+    graphql.Kind.OBJECT_TYPE_DEFINITION,
+    graphql.Kind.OBJECT_TYPE_EXTENSION,
+    graphql.Kind.INTERFACE_TYPE_DEFINITION,
+    graphql.Kind.INTERFACE_TYPE_EXTENSION,
+    graphql.Kind.SCALAR_TYPE_DEFINITION,
+    graphql.Kind.SCALAR_TYPE_EXTENSION,
+    graphql.Kind.INPUT_OBJECT_TYPE_DEFINITION,
+    graphql.Kind.INPUT_OBJECT_TYPE_EXTENSION,
+    graphql.Kind.UNION_TYPE_DEFINITION,
+    graphql.Kind.UNION_TYPE_EXTENSION,
+    graphql.Kind.ENUM_TYPE_DEFINITION,
+    graphql.Kind.ENUM_TYPE_EXTENSION,
+];
 const rule$d = {
     meta: {
         messages: {
@@ -2115,7 +2165,7 @@ const rule$d = {
         docs: {
             description: `Requires all types to be reachable at some level by root level fields.`,
             category: 'Schema',
-            url: `https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/${RULE_NAME}.md`,
+            url: `https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/${RULE_ID}.md`,
             requiresSchema: true,
             examples: [
                 {
@@ -2147,43 +2197,36 @@ const rule$d = {
             ],
             recommended: true,
         },
-        fixable: 'code',
         type: 'suggestion',
         schema: [],
+        hasSuggestions: true,
     },
     create(context) {
-        const reachableTypes = requireReachableTypesFromContext(RULE_NAME, context);
-        function ensureReachability(node) {
-            const typeName = node.name.value;
-            if (!reachableTypes.has(typeName)) {
-                context.report({
-                    loc: getLocation(node.name.loc, typeName, { offsetStart: node.kind === graphql.Kind.DIRECTIVE_DEFINITION ? 2 : 1 }),
-                    messageId: UNREACHABLE_TYPE,
-                    data: { typeName },
-                    fix: fixer => fixer.remove(node),
-                });
-            }
-        }
+        const reachableTypes = requireReachableTypesFromContext(RULE_ID, context);
+        const selector = KINDS.join(',');
         return {
-            DirectiveDefinition: ensureReachability,
-            ObjectTypeDefinition: ensureReachability,
-            ObjectTypeExtension: ensureReachability,
-            InterfaceTypeDefinition: ensureReachability,
-            InterfaceTypeExtension: ensureReachability,
-            ScalarTypeDefinition: ensureReachability,
-            ScalarTypeExtension: ensureReachability,
-            InputObjectTypeDefinition: ensureReachability,
-            InputObjectTypeExtension: ensureReachability,
-            UnionTypeDefinition: ensureReachability,
-            UnionTypeExtension: ensureReachability,
-            EnumTypeDefinition: ensureReachability,
-            EnumTypeExtension: ensureReachability,
+            [selector](node) {
+                const typeName = node.name.value;
+                if (!reachableTypes.has(typeName)) {
+                    context.report({
+                        loc: getLocation(node.name.loc, typeName, { offsetStart: node.kind === graphql.Kind.DIRECTIVE_DEFINITION ? 2 : 1 }),
+                        messageId: UNREACHABLE_TYPE,
+                        data: { typeName },
+                        suggest: [
+                            {
+                                desc: `Remove ${typeName}`,
+                                fix: fixer => fixer.remove(node),
+                            },
+                        ],
+                    });
+                }
+            },
         };
     },
 };
 
 const UNUSED_FIELD = 'UNUSED_FIELD';
-const RULE_NAME$1 = 'no-unused-fields';
+const RULE_ID$1 = 'no-unused-fields';
 const rule$e = {
     meta: {
         messages: {
@@ -2192,7 +2235,7 @@ const rule$e = {
         docs: {
             description: `Requires all fields to be used at some level by siblings operations.`,
             category: 'Schema',
-            url: `https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/${RULE_NAME$1}.md`,
+            url: `https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/${RULE_ID$1}.md`,
             requiresSiblings: true,
             requiresSchema: true,
             examples: [
@@ -2239,12 +2282,12 @@ const rule$e = {
                 },
             ],
         },
-        fixable: 'code',
         type: 'suggestion',
         schema: [],
+        hasSuggestions: true,
     },
     create(context) {
-        const usedFields = requireUsedFieldsFromContext(RULE_NAME$1, context);
+        const usedFields = requireUsedFieldsFromContext(RULE_ID$1, context);
         return {
             FieldDefinition(node) {
                 var _a;
@@ -2258,22 +2301,18 @@ const rule$e = {
                     loc: getLocation(node.loc, fieldName),
                     messageId: UNUSED_FIELD,
                     data: { fieldName },
-                    fix(fixer) {
-                        const sourceCode = context.getSourceCode();
-                        const tokenBefore = sourceCode.getTokenBefore(node);
-                        const tokenAfter = sourceCode.getTokenAfter(node);
-                        const isEmptyType = tokenBefore.type === '{' && tokenAfter.type === '}';
-                        if (isEmptyType) {
-                            // Remove type
-                            const { parent } = node;
-                            const parentBeforeToken = sourceCode.getTokenBefore(parent);
-                            return parentBeforeToken
-                                ? fixer.removeRange([parentBeforeToken.range[1], parent.range[1]])
-                                : fixer.remove(parent);
-                        }
-                        // Remove whitespace before token
-                        return fixer.removeRange([tokenBefore.range[1], node.range[1]]);
-                    },
+                    suggest: [
+                        {
+                            desc: `Remove "${fieldName}" field`,
+                            fix(fixer) {
+                                const sourceCode = context.getSourceCode();
+                                const tokenBefore = sourceCode.getTokenBefore(node);
+                                const tokenAfter = sourceCode.getTokenAfter(node);
+                                const isEmptyType = tokenBefore.type === '{' && tokenAfter.type === '}';
+                                return isEmptyType ? fixer.remove(node.parent) : fixer.remove(node);
+                            },
+                        },
+                    ],
                 });
             },
         };
@@ -2636,14 +2675,14 @@ const rule$h = {
     },
 };
 
-const RULE_NAME$2 = 'require-field-of-type-query-in-mutation-result';
+const RULE_NAME = 'require-field-of-type-query-in-mutation-result';
 const rule$i = {
     meta: {
         type: 'suggestion',
         docs: {
             category: 'Schema',
             description: 'Allow the client in one round-trip not only to call mutation but also to get a wagon of data to update their application.\n> Currently, no errors are reported for result type `union`, `interface` and `scalar`.',
-            url: `https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/${RULE_NAME$2}.md`,
+            url: `https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/${RULE_NAME}.md`,
             requiresSchema: true,
             examples: [
                 {
@@ -2678,7 +2717,7 @@ const rule$i = {
         schema: [],
     },
     create(context) {
-        const schema = requireGraphQLSchemaFromContext(RULE_NAME$2, context);
+        const schema = requireGraphQLSchemaFromContext(RULE_NAME, context);
         const mutationType = schema.getMutationType();
         const queryType = schema.getQueryType();
         if (!mutationType || !queryType) {
@@ -2852,22 +2891,9 @@ const rule$j = {
             recommended: true,
         },
         messages: {
-            [REQUIRE_ID_WHEN_AVAILABLE]: [
-                `Field {{ fieldName }} must be selected when it's available on a type. Please make sure to include it in your selection set!`,
-                `If you are using fragments, make sure that all used fragments {{ checkedFragments }}specifies the field {{ fieldName }}.`,
-            ].join('\n'),
+            [REQUIRE_ID_WHEN_AVAILABLE]: `Field "{{ fieldName }}" must be selected when it's available on a type. Please make sure to include it in your selection set!\nIf you are using fragments, make sure that all used fragments {{ checkedFragments }} specifies the field "{{ fieldName }}".`,
         },
         schema: {
-            definitions: {
-                asString: {
-                    type: 'string',
-                },
-                asArray: {
-                    type: 'array',
-                    minItems: 1,
-                    uniqueItems: true,
-                },
-            },
             type: 'array',
             maxItems: 1,
             items: {
@@ -2875,7 +2901,7 @@ const rule$j = {
                 additionalProperties: false,
                 properties: {
                     fieldName: {
-                        oneOf: [{ $ref: '#/definitions/asString' }, { $ref: '#/definitions/asArray' }],
+                        type: 'string',
                         default: DEFAULT_ID_FIELD_NAME,
                     },
                 },
@@ -2883,64 +2909,69 @@ const rule$j = {
         },
     },
     create(context) {
-        requireGraphQLSchemaFromContext('require-id-when-available', context);
-        const siblings = requireSiblingsOperations('require-id-when-available', context);
-        const { fieldName = DEFAULT_ID_FIELD_NAME } = context.options[0] || {};
-        const idNames = Array.isArray(fieldName) ? fieldName : [fieldName];
-        const isFound = (s) => s.kind === graphql.Kind.FIELD && idNames.includes(s.name.value);
         return {
             SelectionSet(node) {
                 var _a, _b;
-                const typeInfo = node.typeInfo();
-                if (!typeInfo.gqlType) {
-                    return;
-                }
-                const rawType = getBaseType(typeInfo.gqlType);
-                const isObjectType = rawType instanceof graphql.GraphQLObjectType;
-                const isInterfaceType = rawType instanceof graphql.GraphQLInterfaceType;
-                if (!isObjectType && !isInterfaceType) {
+                requireGraphQLSchemaFromContext('require-id-when-available', context);
+                const siblings = requireSiblingsOperations('require-id-when-available', context);
+                const fieldName = (context.options[0] || {}).fieldName || DEFAULT_ID_FIELD_NAME;
+                if (!node.selections || node.selections.length === 0) {
                     return;
                 }
-                const fields = rawType.getFields();
-                const hasIdFieldInType = idNames.some(name => fields[name]);
-                if (!hasIdFieldInType) {
-                    return;
-                }
-                const checkedFragmentSpreads = new Set();
-                let found = false;
-                for (const selection of node.selections) {
-                    if (isFound(selection)) {
-                        found = true;
-                    }
-                    else if (selection.kind === graphql.Kind.INLINE_FRAGMENT) {
-                        found = (_a = selection.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.some(s => isFound(s));
-                    }
-                    else if (selection.kind === graphql.Kind.FRAGMENT_SPREAD) {
-                        const [foundSpread] = siblings.getFragment(selection.name.value);
-                        if (foundSpread) {
-                            checkedFragmentSpreads.add(foundSpread.document.name.value);
-                            found = (_b = foundSpread.document.selectionSet) === null || _b === void 0 ? void 0 : _b.selections.some(s => isFound(s));
+                const typeInfo = node.typeInfo();
+                if (typeInfo && typeInfo.gqlType) {
+                    const rawType = getBaseType(typeInfo.gqlType);
+                    if (rawType instanceof graphql.GraphQLObjectType || rawType instanceof graphql.GraphQLInterfaceType) {
+                        const fields = rawType.getFields();
+                        const hasIdFieldInType = !!fields[fieldName];
+                        const checkedFragmentSpreads = new Set();
+                        if (hasIdFieldInType) {
+                            let found = false;
+                            for (const selection of node.selections) {
+                                if (selection.kind === 'Field' && selection.name.value === fieldName) {
+                                    found = true;
+                                }
+                                else if (selection.kind === 'InlineFragment') {
+                                    found = (((_a = selection.selectionSet) === null || _a === void 0 ? void 0 : _a.selections) || []).some(s => s.kind === 'Field' && s.name.value === fieldName);
+                                }
+                                else if (selection.kind === 'FragmentSpread') {
+                                    const foundSpread = siblings.getFragment(selection.name.value);
+                                    if (foundSpread[0]) {
+                                        checkedFragmentSpreads.add(foundSpread[0].document.name.value);
+                                        found = (((_b = foundSpread[0].document.selectionSet) === null || _b === void 0 ? void 0 : _b.selections) || []).some(s => s.kind === 'Field' && s.name.value === fieldName);
+                                    }
+                                }
+                                if (found) {
+                                    break;
+                                }
+                            }
+                            const { parent } = node;
+                            const hasIdFieldInInterfaceSelectionSet = parent &&
+                                parent.kind === 'InlineFragment' &&
+                                parent.parent &&
+                                parent.parent.kind === 'SelectionSet' &&
+                                parent.parent.selections.some(s => s.kind === 'Field' && s.name.value === fieldName);
+                            if (!found && !hasIdFieldInInterfaceSelectionSet) {
+                                context.report({
+                                    loc: {
+                                        start: {
+                                            line: node.loc.start.line,
+                                            column: node.loc.start.column - 1,
+                                        },
+                                        end: {
+                                            line: node.loc.end.line,
+                                            column: node.loc.end.column - 1,
+                                        },
+                                    },
+                                    messageId: REQUIRE_ID_WHEN_AVAILABLE,
+                                    data: {
+                                        checkedFragments: checkedFragmentSpreads.size === 0 ? '' : `(${Array.from(checkedFragmentSpreads).join(', ')})`,
+                                        fieldName,
+                                    },
+                                });
+                            }
                         }
                     }
-                    if (found) {
-                        break;
-                    }
-                }
-                const { parent } = node;
-                const hasIdFieldInInterfaceSelectionSet = parent &&
-                    parent.kind === graphql.Kind.INLINE_FRAGMENT &&
-                    parent.parent &&
-                    parent.parent.kind === graphql.Kind.SELECTION_SET &&
-                    parent.parent.selections.some(s => isFound(s));
-                if (!found && !hasIdFieldInInterfaceSelectionSet) {
-                    context.report({
-                        loc: getLocation(node.loc),
-                        messageId: REQUIRE_ID_WHEN_AVAILABLE,
-                        data: {
-                            checkedFragments: checkedFragmentSpreads.size === 0 ? '' : `(${[...checkedFragmentSpreads].join(', ')}) `,
-                            fieldName: idNames.map(name => `"${name}"`).join(' or '),
-                        },
-                    });
                 }
             },
         };
@@ -3032,7 +3063,7 @@ const rule$k = {
             // eslint-disable-next-line no-console
             console.warn(`Rule "selection-set-depth" works best with siblings operations loaded. For more info: http://bit.ly/graphql-eslint-operations`);
         }
-        const { maxDepth } = context.options[0];
+        const maxDepth = context.options[0].maxDepth;
         const ignore = context.options[0].ignore || [];
         const checkFn = depthLimit(maxDepth, { ignore });
         return {
@@ -3229,7 +3260,7 @@ const rule$l = {
     },
 };
 
-const RULE_NAME$3 = 'unique-fragment-name';
+const RULE_NAME$1 = 'unique-fragment-name';
 const UNIQUE_FRAGMENT_NAME = 'UNIQUE_FRAGMENT_NAME';
 const checkNode = (context, node, ruleName, messageId) => {
     const documentName = node.name.value;
@@ -3261,7 +3292,7 @@ const rule$m = {
         docs: {
             category: 'Operations',
             description: `Enforce unique fragment names across your project.`,
-            url: `https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/${RULE_NAME$3}.md`,
+            url: `https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/${RULE_NAME$1}.md`,
             requiresSiblings: true,
             examples: [
                 {
@@ -3306,13 +3337,13 @@ const rule$m = {
     create(context) {
         return {
             FragmentDefinition(node) {
-                checkNode(context, node, RULE_NAME$3, UNIQUE_FRAGMENT_NAME);
+                checkNode(context, node, RULE_NAME$1, UNIQUE_FRAGMENT_NAME);
             },
         };
     },
 };
 
-const RULE_NAME$4 = 'unique-operation-name';
+const RULE_NAME$2 = 'unique-operation-name';
 const UNIQUE_OPERATION_NAME = 'UNIQUE_OPERATION_NAME';
 const rule$n = {
     meta: {
@@ -3320,7 +3351,7 @@ const rule$n = {
         docs: {
             category: 'Operations',
             description: `Enforce unique operation names across your project.`,
-            url: `https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/${RULE_NAME$4}.md`,
+            url: `https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/${RULE_NAME$2}.md`,
             requiresSiblings: true,
             examples: [
                 {
@@ -3369,7 +3400,7 @@ const rule$n = {
     create(context) {
         return {
             'OperationDefinition[name!=undefined]'(node) {
-                checkNode(context, node, RULE_NAME$4, UNIQUE_OPERATION_NAME);
+                checkNode(context, node, RULE_NAME$2, UNIQUE_OPERATION_NAME);
             },
         };
     },