@graphql-eslint/eslint-plugin 3.2.0-alpha-4ca7218.0 → 3.3.0-alpha-b07557f.0

package/index.mjs

@@ -4,10 +4,10 @@ import { statSync, existsSync, readFileSync } from 'fs';
 import { dirname, extname, basename, relative, resolve } from 'path';
 import { asArray, parseGraphQLSDL } from '@graphql-tools/utils';
 import lowerCase from 'lodash.lowercase';
-import depthLimit from 'graphql-depth-limit';
-import { parseCode } from '@graphql-tools/graphql-tag-pluck';
 import { loadConfigSync, GraphQLConfig } from 'graphql-config';
 import { CodeFileLoader } from '@graphql-tools/code-file-loader';
+import depthLimit from 'graphql-depth-limit';
+import { parseCode } from '@graphql-tools/graphql-tag-pluck';
 import { RuleTester, Linter } from 'eslint';
 import { codeFrameColumns } from '@babel/code-frame';
 
@@ -168,6 +168,47 @@ const configs = {
     'operations-all': operationsAllConfig,
 };
 
+let graphQLConfig;
+function loadCachedGraphQLConfig(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;
+    }
+    graphQLConfig = loadGraphQLConfig(options);
+    return graphQLConfig;
+}
+function loadGraphQLConfig(options) {
+    const onDiskConfig = options.skipGraphQLConfig
+        ? null
+        : loadConfigSync({
+            throwOnEmpty: false,
+            throwOnMissing: false,
+            extensions: [addCodeFileLoaderExtension],
+        });
+    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',
+            }, [addCodeFileLoaderExtension]);
+    return graphQLConfig;
+}
+const addCodeFileLoaderExtension = api => {
+    api.loaders.schema.register(new CodeFileLoader());
+    api.loaders.documents.register(new CodeFileLoader());
+    return { name: 'graphql-eslint-loaders' };
+};
+
 function requireSiblingsOperations(ruleName, context) {
     if (!context.parserServices) {
         throw new Error(`Rule '${ruleName}' requires 'parserOptions.operations' to be set and loaded. See http://bit.ly/graphql-eslint-operations for more info`);
@@ -186,6 +227,32 @@ function requireGraphQLSchemaFromContext(ruleName, context) {
     }
     return context.parserServices.schema;
 }
+const schemaToExtendCache = new Map();
+function getGraphQLSchemaToExtend(context) {
+    // If parserOptions.schema not set or not loaded, there is no reason to make partial schema aka schemaToExtend
+    if (!context.parserServices.hasTypeInfo) {
+        return null;
+    }
+    const filename = context.getPhysicalFilename();
+    if (!schemaToExtendCache.has(filename)) {
+        const { schema, schemaOptions } = context.parserOptions;
+        const gqlConfig = loadGraphQLConfig({ schema });
+        const projectForFile = gqlConfig.getProjectForFile(filename);
+        let schemaToExtend;
+        try {
+            schemaToExtend = projectForFile.loadSchemaSync(projectForFile.schema, 'GraphQLSchema', {
+                ...schemaOptions,
+                ignore: filename,
+            });
+        }
+        catch (_a) {
+            // If error throws just ignore it because maybe schema is located in 1 file
+            schemaToExtend = null;
+        }
+        schemaToExtendCache.set(filename, schemaToExtend);
+    }
+    return schemaToExtendCache.get(filename);
+}
 function requireReachableTypesFromContext(ruleName, context) {
     const schema = requireGraphQLSchemaFromContext(ruleName, context);
     return context.parserServices.reachableTypes(schema);
@@ -279,14 +346,6 @@ const TYPES_KINDS = [
     Kind.INPUT_OBJECT_TYPE_DEFINITION,
     Kind.UNION_TYPE_DEFINITION,
 ];
-var CaseStyle;
-(function (CaseStyle) {
-    CaseStyle["camelCase"] = "camelCase";
-    CaseStyle["pascalCase"] = "PascalCase";
-    CaseStyle["snakeCase"] = "snake_case";
-    CaseStyle["upperCase"] = "UPPER_CASE";
-    CaseStyle["kebabCase"] = "kebab-case";
-})(CaseStyle || (CaseStyle = {}));
 const pascalCase = (str) => lowerCase(str)
     .split(' ')
     .map(word => word.charAt(0).toUpperCase() + word.slice(1))
@@ -297,15 +356,15 @@ const camelCase = (str) => {
 };
 const convertCase = (style, str) => {
     switch (style) {
-        case CaseStyle.camelCase:
+        case 'camelCase':
             return camelCase(str);
-        case CaseStyle.pascalCase:
+        case 'PascalCase':
             return pascalCase(str);
-        case CaseStyle.snakeCase:
+        case 'snake_case':
             return lowerCase(str).replace(/ /g, '_');
-        case CaseStyle.upperCase:
+        case 'UPPER_CASE':
             return lowerCase(str).replace(/ /g, '_').toUpperCase();
-        case CaseStyle.kebabCase:
+        case 'kebab-case':
             return lowerCase(str).replace(/ /g, '-');
     }
 };
@@ -328,17 +387,32 @@ function getLocation(loc, fieldName = '', offset) {
     };
 }
 
-function validateDocument(sourceNode, context, schema, documentNode, rule) {
+function validateDocument(sourceNode, context, schema = null, documentNode, rule, isSchemaToExtend = false) {
     if (documentNode.definitions.length === 0) {
         return;
     }
     try {
-        const validationErrors = schema
+        const validationErrors = schema && !isSchemaToExtend
             ? validate(schema, documentNode, [rule])
-            : validateSDL(documentNode, null, [rule]);
+            : validateSDL(documentNode, schema, [rule]);
         for (const error of validationErrors) {
+            /*
+             * TODO: Fix ESTree-AST converter because currently it's incorrectly convert loc.end
+             * Example: loc.end always equal loc.start
+             *  {
+             *    token: {
+             *      type: 'Name',
+             *      loc: { start: { line: 4, column: 13 }, end: { line: 4, column: 13 } },
+             *      value: 'veryBad',
+             *      range: [ 40, 47 ]
+             *    }
+             *  }
+             */
+            const { line, column } = error.locations[0];
+            const ancestors = context.getAncestors();
+            const token = ancestors[0].tokens.find(token => token.loc.start.line === line && token.loc.start.column === column);
             context.report({
-                loc: getLocation({ start: error.locations[0] }),
+                loc: getLocation({ start: error.locations[0] }, token === null || token === void 0 ? void 0 : token.value),
                 message: error.message,
             });
         }
@@ -427,18 +501,24 @@ const validationToRule = (ruleId, ruleName, docs, getDocumentNode) => {
                 },
             },
             create(context) {
+                if (!ruleFn) {
+                    // eslint-disable-next-line no-console
+                    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 {};
+                }
+                let schema;
+                if (docs.requiresSchemaToExtend) {
+                    schema = getGraphQLSchemaToExtend(context);
+                }
+                if (docs.requiresSchema) {
+                    schema = requireGraphQLSchemaFromContext(ruleId, context);
+                }
                 return {
                     Document(node) {
-                        if (!ruleFn) {
-                            // eslint-disable-next-line no-console
-                            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 = docs.requiresSchema ? requireGraphQLSchemaFromContext(ruleId, context) : null;
                         const documentNode = getDocumentNode
                             ? getDocumentNode({ ruleId, context, schema, node: node.rawNode() })
                             : node.rawNode();
-                        validateDocument(node, context, schema, documentNode, ruleFn);
+                        validateDocument(node, context, schema, documentNode, ruleFn, docs.requiresSchemaToExtend);
                     },
                 };
             },
@@ -588,7 +668,8 @@ const GRAPHQL_JS_VALIDATIONS = Object.assign({}, validationToRule('executable-de
 }), validationToRule('possible-type-extension', 'PossibleTypeExtensions', {
     category: 'Schema',
     description: `A type extension is only valid if the type is defined and has the same kind.`,
-    recommended: false, // TODO: enable after https://github.com/dotansimha/graphql-eslint/issues/787 will be fixed
+    recommended: false,
+    requiresSchemaToExtend: true,
 }), 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.`,
@@ -1077,13 +1158,7 @@ const rule$2 = {
 const MATCH_EXTENSION = 'MATCH_EXTENSION';
 const MATCH_STYLE = 'MATCH_STYLE';
 const ACCEPTED_EXTENSIONS = ['.gql', '.graphql'];
-const CASE_STYLES = [
-    CaseStyle.camelCase,
-    CaseStyle.pascalCase,
-    CaseStyle.snakeCase,
-    CaseStyle.upperCase,
-    CaseStyle.kebabCase,
-];
+const CASE_STYLES = ['camelCase', 'PascalCase', 'snake_case', 'UPPER_CASE', 'kebab-case'];
 const schemaOption = {
     oneOf: [{ $ref: '#/definitions/asString' }, { $ref: '#/definitions/asObject' }],
 };
@@ -1107,7 +1182,7 @@ const rule$3 = {
                 },
                 {
                     title: 'Correct',
-                    usage: [{ query: CaseStyle.snakeCase }],
+                    usage: [{ query: 'snake_case' }],
                     code: /* GraphQL */ `
             # user_by_id.gql
             query UserById {
@@ -1121,7 +1196,7 @@ const rule$3 = {
                 },
                 {
                     title: 'Correct',
-                    usage: [{ fragment: { style: CaseStyle.kebabCase, suffix: '.fragment' } }],
+                    usage: [{ fragment: { style: 'kebab-case', suffix: '.fragment' } }],
                     code: /* GraphQL */ `
             # user-fields.fragment.gql
             fragment user_fields on User {
@@ -1132,7 +1207,7 @@ const rule$3 = {
                 },
                 {
                     title: 'Correct',
-                    usage: [{ mutation: { style: CaseStyle.pascalCase, suffix: 'Mutation' } }],
+                    usage: [{ mutation: { style: 'PascalCase', suffix: 'Mutation' } }],
                     code: /* GraphQL */ `
             # DeleteUserMutation.gql
             mutation DELETE_USER {
@@ -1152,7 +1227,7 @@ const rule$3 = {
                 },
                 {
                     title: 'Incorrect',
-                    usage: [{ query: CaseStyle.pascalCase }],
+                    usage: [{ query: 'PascalCase' }],
                     code: /* GraphQL */ `
             # user-by-id.gql
             query UserById {
@@ -1167,10 +1242,10 @@ const rule$3 = {
             ],
             configOptions: [
                 {
-                    query: CaseStyle.kebabCase,
-                    mutation: CaseStyle.kebabCase,
-                    subscription: CaseStyle.kebabCase,
-                    fragment: CaseStyle.kebabCase,
+                    query: 'kebab-case',
+                    mutation: 'kebab-case',
+                    subscription: 'kebab-case',
+                    fragment: 'kebab-case',
                 },
             ],
         },
@@ -1187,25 +1262,22 @@ const rule$3 = {
                 asObject: {
                     type: 'object',
                     additionalProperties: false,
+                    minProperties: 1,
                     properties: {
-                        style: {
-                            enum: CASE_STYLES,
-                        },
-                        suffix: {
-                            type: 'string',
-                        },
+                        style: { enum: CASE_STYLES },
+                        suffix: { type: 'string' },
                     },
                 },
             },
             type: 'array',
+            minItems: 1,
             maxItems: 1,
             items: {
                 type: 'object',
                 additionalProperties: false,
+                minProperties: 1,
                 properties: {
-                    fileExtension: {
-                        enum: ACCEPTED_EXTENSIONS,
-                    },
+                    fileExtension: { enum: ACCEPTED_EXTENSIONS },
                     query: schemaOption,
                     mutation: schemaOption,
                     subscription: schemaOption,
@@ -1260,7 +1332,7 @@ const rule$3 = {
                     option = { style: option };
                 }
                 const expectedExtension = options.fileExtension || fileExtension;
-                const expectedFilename = convertCase(option.style, docName) + (option.suffix || '') + expectedExtension;
+                const expectedFilename = (option.style ? convertCase(option.style, docName) : filename) + (option.suffix || '') + expectedExtension;
                 const filenameWithExtension = filename + expectedExtension;
                 if (expectedFilename !== filenameWithExtension) {
                     context.report({
@@ -1412,6 +1484,7 @@ const rule$4 = {
                 ],
             },
         },
+        hasSuggestions: true,
         schema: {
             definitions: {
                 asString: {
@@ -1486,65 +1559,90 @@ const rule$4 = {
             const style = restOptions[kind] || types;
             return typeof style === 'object' ? style : { style };
         }
-        const checkNode = (selector) => (node) => {
-            const { name } = node.kind === Kind.VARIABLE_DEFINITION ? node.variable : node;
-            if (!name) {
+        const checkNode = (selector) => (n) => {
+            const { name: node } = n.kind === Kind.VARIABLE_DEFINITION ? n.variable : n;
+            if (!node) {
                 return;
             }
             const { prefix, suffix, forbiddenPrefixes, forbiddenSuffixes, style } = normalisePropertyOption(selector);
-            const nodeType = KindToDisplayName[node.kind] || node.kind;
-            const nodeName = name.value;
-            const errorMessage = getErrorMessage();
-            if (errorMessage) {
+            const nodeType = KindToDisplayName[n.kind] || n.kind;
+            const nodeName = node.value;
+            const error = getError();
+            if (error) {
+                const { errorMessage, renameToName } = error;
+                const [leadingUnderscore] = nodeName.match(/^_*/);
+                const [trailingUnderscore] = nodeName.match(/_*$/);
+                const suggestedName = leadingUnderscore + renameToName + trailingUnderscore;
                 context.report({
-                    loc: getLocation(name.loc, name.value),
+                    loc: getLocation(node.loc, node.value),
                     message: `${nodeType} "${nodeName}" should ${errorMessage}`,
+                    suggest: [
+                        {
+                            desc: `Rename to "${suggestedName}"`,
+                            fix: fixer => fixer.replaceText(node, suggestedName),
+                        },
+                    ],
                 });
             }
-            function getErrorMessage() {
-                let name = nodeName;
-                if (allowLeadingUnderscore) {
-                    name = name.replace(/^_*/, '');
-                }
-                if (allowTrailingUnderscore) {
-                    name = name.replace(/_*$/, '');
-                }
+            function getError() {
+                const name = nodeName.replace(/(^_+)|(_+$)/g, '');
                 if (prefix && !name.startsWith(prefix)) {
-                    return `have "${prefix}" prefix`;
+                    return {
+                        errorMessage: `have "${prefix}" prefix`,
+                        renameToName: prefix + name,
+                    };
                 }
                 if (suffix && !name.endsWith(suffix)) {
-                    return `have "${suffix}" suffix`;
+                    return {
+                        errorMessage: `have "${suffix}" suffix`,
+                        renameToName: name + suffix,
+                    };
                 }
                 const forbiddenPrefix = forbiddenPrefixes === null || forbiddenPrefixes === void 0 ? void 0 : forbiddenPrefixes.find(prefix => name.startsWith(prefix));
                 if (forbiddenPrefix) {
-                    return `not have "${forbiddenPrefix}" prefix`;
+                    return {
+                        errorMessage: `not have "${forbiddenPrefix}" prefix`,
+                        renameToName: name.replace(new RegExp(`^${forbiddenPrefix}`), ''),
+                    };
                 }
                 const forbiddenSuffix = forbiddenSuffixes === null || forbiddenSuffixes === void 0 ? void 0 : forbiddenSuffixes.find(suffix => name.endsWith(suffix));
                 if (forbiddenSuffix) {
-                    return `not have "${forbiddenSuffix}" suffix`;
-                }
-                if (style && !ALLOWED_STYLES.includes(style)) {
-                    return `be in one of the following options: ${ALLOWED_STYLES.join(', ')}`;
+                    return {
+                        errorMessage: `not have "${forbiddenSuffix}" suffix`,
+                        renameToName: name.replace(new RegExp(`${forbiddenSuffix}$`), ''),
+                    };
                 }
                 const caseRegex = StyleToRegex[style];
                 if (caseRegex && !caseRegex.test(name)) {
-                    return `be in ${style} format`;
+                    return {
+                        errorMessage: `be in ${style} format`,
+                        renameToName: convertCase(style, name),
+                    };
                 }
             }
         };
-        const checkUnderscore = (node) => {
+        const checkUnderscore = (isLeading) => (node) => {
             const name = node.value;
+            const renameToName = name.replace(new RegExp(isLeading ? '^_+' : '_+$'), '');
             context.report({
                 loc: getLocation(node.loc, name),
-                message: `${name.startsWith('_') ? 'Leading' : 'Trailing'} underscores are not allowed`,
+                message: `${isLeading ? 'Leading' : 'Trailing'} underscores are not allowed`,
+                suggest: [
+                    {
+                        desc: `Rename to "${renameToName}"`,
+                        fix: fixer => fixer.replaceText(node, renameToName),
+                    },
+                ],
             });
         };
         const listeners = {};
         if (!allowLeadingUnderscore) {
-            listeners['Name[value=/^_/]:matches([parent.kind!=Field], [parent.kind=Field][parent.alias])'] = checkUnderscore;
+            listeners['Name[value=/^_/]:matches([parent.kind!=Field], [parent.kind=Field][parent.alias])'] =
+                checkUnderscore(true);
         }
         if (!allowTrailingUnderscore) {
-            listeners['Name[value=/_$/]:matches([parent.kind!=Field], [parent.kind=Field][parent.alias])'] = checkUnderscore;
+            listeners['Name[value=/_$/]:matches([parent.kind!=Field], [parent.kind=Field][parent.alias])'] =
+                checkUnderscore(false);
         }
         const selectors = new Set([types && TYPES_KINDS, Object.keys(restOptions)].flat().filter(Boolean));
         for (const selector of selectors) {
@@ -2887,9 +2985,22 @@ 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!\nIf you are using fragments, make sure that all used fragments {{ checkedFragments }} specifies the field "{{ fieldName }}".`,
+            [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'),
         },
         schema: {
+            definitions: {
+                asString: {
+                    type: 'string',
+                },
+                asArray: {
+                    type: 'array',
+                    minItems: 1,
+                    uniqueItems: true,
+                },
+            },
             type: 'array',
             maxItems: 1,
             items: {
@@ -2897,7 +3008,7 @@ const rule$j = {
                 additionalProperties: false,
                 properties: {
                     fieldName: {
-                        type: 'string',
+                        oneOf: [{ $ref: '#/definitions/asString' }, { $ref: '#/definitions/asArray' }],
                         default: DEFAULT_ID_FIELD_NAME,
                     },
                 },
@@ -2905,69 +3016,64 @@ 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 === Kind.FIELD && idNames.includes(s.name.value);
         return {
             SelectionSet(node) {
                 var _a, _b;
-                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) {
+                const typeInfo = node.typeInfo();
+                if (!typeInfo.gqlType) {
                     return;
                 }
-                const typeInfo = node.typeInfo();
-                if (typeInfo && typeInfo.gqlType) {
-                    const rawType = getBaseType(typeInfo.gqlType);
-                    if (rawType instanceof GraphQLObjectType || rawType instanceof 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,
-                                    },
-                                });
-                            }
+                const rawType = getBaseType(typeInfo.gqlType);
+                const isObjectType = rawType instanceof GraphQLObjectType;
+                const isInterfaceType = rawType instanceof GraphQLInterfaceType;
+                if (!isObjectType && !isInterfaceType) {
+                    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 === Kind.INLINE_FRAGMENT) {
+                        found = (_a = selection.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.some(s => isFound(s));
+                    }
+                    else if (selection.kind === 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));
                         }
                     }
+                    if (found) {
+                        break;
+                    }
+                }
+                const { parent } = node;
+                const hasIdFieldInInterfaceSelectionSet = parent &&
+                    parent.kind === Kind.INLINE_FRAGMENT &&
+                    parent.parent &&
+                    parent.parent.kind === 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 '),
+                        },
+                    });
                 }
             },
         };
@@ -3059,7 +3165,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].maxDepth;
+        const { maxDepth } = context.options[0];
         const ignore = context.options[0].ignore || [];
         const checkFn = depthLimit(maxDepth, { ignore });
         return {
@@ -3663,42 +3769,6 @@ function getSiblingOperations(options, gqlConfig) {
     return siblingOperations;
 }
 
-let graphqlConfig;
-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
-        ? null
-        : loadConfigSync({
-            throwOnEmpty: false,
-            throwOnMissing: false,
-            extensions: [addCodeFileLoaderExtension],
-        });
-    graphqlConfig =
-        onDiskConfig ||
-            new GraphQLConfig({
-                config: options.projects
-                    ? { projects: options.projects }
-                    : {
-                        schema: (options.schema || ''),
-                        documents: options.documents || options.operations,
-                        extensions: options.extensions,
-                        include: options.include,
-                        exclude: options.exclude,
-                    },
-                filepath: 'virtual-config',
-            }, [addCodeFileLoaderExtension]);
-    return graphqlConfig;
-}
-const addCodeFileLoaderExtension = api => {
-    api.loaders.schema.register(new CodeFileLoader());
-    api.loaders.documents.register(new CodeFileLoader());
-    return { name: 'graphql-eslint-loaders' };
-};
-
 let reachableTypesCache;
 function getReachableTypes(schema) {
     // We don't want cache reachableTypes on test environment
@@ -3781,7 +3851,7 @@ function parse(code, options) {
     return parseForESLint(code, options).ast;
 }
 function parseForESLint(code, options = {}) {
-    const gqlConfig = loadGraphqlConfig(options);
+    const gqlConfig = loadCachedGraphQLConfig(options);
     const schema = getSchema(options, gqlConfig);
     const parserServices = {
         hasTypeInfo: schema !== null,