@graphql-eslint/eslint-plugin 3.3.0-alpha-0df1b98.0 → 3.3.0-alpha-b07557f.0

package/docs/rules/require-id-when-available.md

@@ -23,7 +23,7 @@ type User {
 }
 
 # Query
-query {
+query user {
   user {
     name
   }
@@ -42,7 +42,7 @@ type User {
 }
 
 # Query
-query {
+query user {
   user {
     id
     name

package/graphql-config.d.ts

@@ -1,3 +1,4 @@
 import { GraphQLConfig } from 'graphql-config';
 import { ParserOptions } from './types';
-export declare function loadGraphqlConfig(options: ParserOptions): GraphQLConfig;
+export declare function loadCachedGraphQLConfig(options: ParserOptions): GraphQLConfig;
+export declare function loadGraphQLConfig(options: ParserOptions): GraphQLConfig;

package/index.js

@@ -10,10 +10,10 @@ const fs = require('fs');
 const path = require('path');
 const utils = require('@graphql-tools/utils');
 const lowerCase = _interopDefault(require('lodash.lowercase'));
+const graphqlConfig = require('graphql-config');
+const codeFileLoader = require('@graphql-tools/code-file-loader');
 const depthLimit = _interopDefault(require('graphql-depth-limit'));
 const graphqlTagPluck = require('@graphql-tools/graphql-tag-pluck');
-const graphqlConfig$1 = require('graphql-config');
-const codeFileLoader = require('@graphql-tools/code-file-loader');
 const eslint = require('eslint');
 const codeFrame = require('@babel/code-frame');
 
@@ -174,6 +174,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
+        : graphqlConfig.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.GraphQLConfig({
+                config: configOptions,
+                filepath: 'virtual-config',
+            }, [addCodeFileLoaderExtension]);
+    return graphQLConfig;
+}
+const addCodeFileLoaderExtension = api => {
+    api.loaders.schema.register(new codeFileLoader.CodeFileLoader());
+    api.loaders.documents.register(new codeFileLoader.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`);
@@ -192,6 +233,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);
@@ -326,14 +393,14 @@ 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
             ? graphql.validate(schema, documentNode, [rule])
-            : validate.validateSDL(documentNode, null, [rule]);
+            : validate.validateSDL(documentNode, schema, [rule]);
         for (const error of validationErrors) {
             /*
              * TODO: Fix ESTree-AST converter because currently it's incorrectly convert loc.end
@@ -440,18 +507,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);
                     },
                 };
             },
@@ -601,7 +674,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.`,
@@ -2866,8 +2940,7 @@ const convertNode = (typeInfo) => (node, key, parent) => {
     }
 };
 
-const RULE_ID$2 = 'require-id-when-available';
-const MESSAGE_ID = 'REQUIRE_ID_WHEN_AVAILABLE';
+const REQUIRE_ID_WHEN_AVAILABLE = 'REQUIRE_ID_WHEN_AVAILABLE';
 const DEFAULT_ID_FIELD_NAME = 'id';
 const rule$j = {
     meta: {
@@ -2875,7 +2948,7 @@ const rule$j = {
         docs: {
             category: 'Operations',
             description: 'Enforce selecting specific fields when they are available on the GraphQL type.',
-            url: `https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/${RULE_ID$2}.md`,
+            url: 'https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/require-id-when-available.md',
             requiresSchema: true,
             requiresSiblings: true,
             examples: [
@@ -2889,7 +2962,7 @@ const rule$j = {
             }
 
             # Query
-            query {
+            query user {
               user {
                 name
               }
@@ -2906,7 +2979,7 @@ const rule$j = {
             }
 
             # Query
-            query {
+            query user {
               user {
                 id
                 name
@@ -2918,7 +2991,7 @@ const rule$j = {
             recommended: true,
         },
         messages: {
-            [MESSAGE_ID]: [
+            [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'),
@@ -2949,16 +3022,14 @@ const rule$j = {
         },
     },
     create(context) {
-        requireGraphQLSchemaFromContext(RULE_ID$2, context);
-        const siblings = requireSiblingsOperations(RULE_ID$2, 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 = utils.asArray(fieldName);
+        const idNames = Array.isArray(fieldName) ? fieldName : [fieldName];
         const isFound = (s) => s.kind === graphql.Kind.FIELD && idNames.includes(s.name.value);
-        // Skip check selections in FragmentDefinition
-        const selector = 'OperationDefinition SelectionSet[parent.kind!=OperationDefinition]';
         return {
-            [selector](node) {
-                var _a;
+            SelectionSet(node) {
+                var _a, _b;
                 const typeInfo = node.typeInfo();
                 if (!typeInfo.gqlType) {
                     return;
@@ -2975,38 +3046,41 @@ const rule$j = {
                     return;
                 }
                 const checkedFragmentSpreads = new Set();
+                let found = false;
                 for (const selection of node.selections) {
                     if (isFound(selection)) {
-                        return;
+                        found = true;
                     }
-                    if (selection.kind === graphql.Kind.INLINE_FRAGMENT && selection.selectionSet.selections.some(isFound)) {
-                        return;
+                    else if (selection.kind === graphql.Kind.INLINE_FRAGMENT) {
+                        found = (_a = selection.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.some(s => isFound(s));
                     }
-                    if (selection.kind === graphql.Kind.FRAGMENT_SPREAD) {
+                    else if (selection.kind === graphql.Kind.FRAGMENT_SPREAD) {
                         const [foundSpread] = siblings.getFragment(selection.name.value);
                         if (foundSpread) {
                             checkedFragmentSpreads.add(foundSpread.document.name.value);
-                            if (foundSpread.document.selectionSet.selections.some(isFound)) {
-                                return;
-                            }
+                            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 === null || parent === void 0 ? void 0 : parent.kind) === graphql.Kind.INLINE_FRAGMENT &&
-                    ((_a = parent.parent) === null || _a === void 0 ? void 0 : _a.kind) === graphql.Kind.SELECTION_SET &&
-                    parent.parent.selections.some(isFound);
-                if (hasIdFieldInInterfaceSelectionSet) {
-                    return;
+                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 '),
+                        },
+                    });
                 }
-                context.report({
-                    loc: getLocation(node.loc),
-                    messageId: MESSAGE_ID,
-                    data: {
-                        checkedFragments: checkedFragmentSpreads.size === 0 ? '' : `(${[...checkedFragmentSpreads].join(', ')}) `,
-                        fieldName: idNames.map(name => `"${name}"`).join(' or '),
-                    },
-                });
             },
         };
     },
@@ -3701,42 +3775,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
-        : graphqlConfig$1.loadConfigSync({
-            throwOnEmpty: false,
-            throwOnMissing: false,
-            extensions: [addCodeFileLoaderExtension],
-        });
-    graphqlConfig =
-        onDiskConfig ||
-            new graphqlConfig$1.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.CodeFileLoader());
-    api.loaders.documents.register(new codeFileLoader.CodeFileLoader());
-    return { name: 'graphql-eslint-loaders' };
-};
-
 let reachableTypesCache;
 function getReachableTypes(schema) {
     // We don't want cache reachableTypes on test environment
@@ -3819,7 +3857,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,

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);
@@ -320,14 +387,14 @@ 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
@@ -434,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);
                     },
                 };
             },
@@ -595,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.`,
@@ -2860,8 +2934,7 @@ const convertNode = (typeInfo) => (node, key, parent) => {
     }
 };
 
-const RULE_ID$2 = 'require-id-when-available';
-const MESSAGE_ID = 'REQUIRE_ID_WHEN_AVAILABLE';
+const REQUIRE_ID_WHEN_AVAILABLE = 'REQUIRE_ID_WHEN_AVAILABLE';
 const DEFAULT_ID_FIELD_NAME = 'id';
 const rule$j = {
     meta: {
@@ -2869,7 +2942,7 @@ const rule$j = {
         docs: {
             category: 'Operations',
             description: 'Enforce selecting specific fields when they are available on the GraphQL type.',
-            url: `https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/${RULE_ID$2}.md`,
+            url: 'https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/require-id-when-available.md',
             requiresSchema: true,
             requiresSiblings: true,
             examples: [
@@ -2883,7 +2956,7 @@ const rule$j = {
             }
 
             # Query
-            query {
+            query user {
               user {
                 name
               }
@@ -2900,7 +2973,7 @@ const rule$j = {
             }
 
             # Query
-            query {
+            query user {
               user {
                 id
                 name
@@ -2912,7 +2985,7 @@ const rule$j = {
             recommended: true,
         },
         messages: {
-            [MESSAGE_ID]: [
+            [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'),
@@ -2943,16 +3016,14 @@ const rule$j = {
         },
     },
     create(context) {
-        requireGraphQLSchemaFromContext(RULE_ID$2, context);
-        const siblings = requireSiblingsOperations(RULE_ID$2, 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 = asArray(fieldName);
+        const idNames = Array.isArray(fieldName) ? fieldName : [fieldName];
         const isFound = (s) => s.kind === Kind.FIELD && idNames.includes(s.name.value);
-        // Skip check selections in FragmentDefinition
-        const selector = 'OperationDefinition SelectionSet[parent.kind!=OperationDefinition]';
         return {
-            [selector](node) {
-                var _a;
+            SelectionSet(node) {
+                var _a, _b;
                 const typeInfo = node.typeInfo();
                 if (!typeInfo.gqlType) {
                     return;
@@ -2969,38 +3040,41 @@ const rule$j = {
                     return;
                 }
                 const checkedFragmentSpreads = new Set();
+                let found = false;
                 for (const selection of node.selections) {
                     if (isFound(selection)) {
-                        return;
+                        found = true;
                     }
-                    if (selection.kind === Kind.INLINE_FRAGMENT && selection.selectionSet.selections.some(isFound)) {
-                        return;
+                    else if (selection.kind === Kind.INLINE_FRAGMENT) {
+                        found = (_a = selection.selectionSet) === null || _a === void 0 ? void 0 : _a.selections.some(s => isFound(s));
                     }
-                    if (selection.kind === Kind.FRAGMENT_SPREAD) {
+                    else if (selection.kind === Kind.FRAGMENT_SPREAD) {
                         const [foundSpread] = siblings.getFragment(selection.name.value);
                         if (foundSpread) {
                             checkedFragmentSpreads.add(foundSpread.document.name.value);
-                            if (foundSpread.document.selectionSet.selections.some(isFound)) {
-                                return;
-                            }
+                            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 === null || parent === void 0 ? void 0 : parent.kind) === Kind.INLINE_FRAGMENT &&
-                    ((_a = parent.parent) === null || _a === void 0 ? void 0 : _a.kind) === Kind.SELECTION_SET &&
-                    parent.parent.selections.some(isFound);
-                if (hasIdFieldInInterfaceSelectionSet) {
-                    return;
+                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 '),
+                        },
+                    });
                 }
-                context.report({
-                    loc: getLocation(node.loc),
-                    messageId: MESSAGE_ID,
-                    data: {
-                        checkedFragments: checkedFragmentSpreads.size === 0 ? '' : `(${[...checkedFragmentSpreads].join(', ')}) `,
-                        fieldName: idNames.map(name => `"${name}"`).join(' or '),
-                    },
-                });
             },
         };
     },
@@ -3695,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
@@ -3813,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,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@graphql-eslint/eslint-plugin",
-  "version": "3.3.0-alpha-0df1b98.0",
+  "version": "3.3.0-alpha-b07557f.0",
   "description": "GraphQL plugin for ESLint",
   "sideEffects": false,
   "peerDependencies": {

package/rules/index.d.ts

@@ -48,7 +48,9 @@ export declare const rules: {
         DirectiveDefinition?: boolean;
     }], false>;
     'require-field-of-type-query-in-mutation-result': import("..").GraphQLESLintRule<any[], false>;
-    'require-id-when-available': import("..").GraphQLESLintRule<[import("./require-id-when-available").RequireIdWhenAvailableRuleConfig], true>;
+    'require-id-when-available': import("..").GraphQLESLintRule<[{
+        fieldName: string;
+    }], true>;
     'selection-set-depth': import("..").GraphQLESLintRule<[{
         maxDepth: number;
         ignore?: string[];

package/rules/require-id-when-available.d.ts

@@ -1,6 +1,6 @@
 import { GraphQLESLintRule } from '../types';
-export declare type RequireIdWhenAvailableRuleConfig = {
-    fieldName: string | string[];
+declare type RequireIdWhenAvailableRuleConfig = {
+    fieldName: string;
 };
 declare const rule: GraphQLESLintRule<[RequireIdWhenAvailableRuleConfig], true>;
 export default rule;

package/types.d.ts

@@ -51,6 +51,7 @@ export declare type RuleDocsInfo<T> = {
         category: CategoryType | CategoryType[];
         requiresSchema?: true;
         requiresSiblings?: true;
+        requiresSchemaToExtend?: true;
         examples?: {
             title: string;
             code: string;

package/utils.d.ts

@@ -6,6 +6,7 @@ import { SiblingOperations } from './sibling-operations';
 import { UsedFields, ReachableTypes } from './graphql-ast';
 export declare function requireSiblingsOperations(ruleName: string, context: GraphQLESLintRuleContext): SiblingOperations | never;
 export declare function requireGraphQLSchemaFromContext(ruleName: string, context: GraphQLESLintRuleContext): GraphQLSchema | never;
+export declare function getGraphQLSchemaToExtend(context: GraphQLESLintRuleContext): GraphQLSchema | null;
 export declare function requireReachableTypesFromContext(ruleName: string, context: GraphQLESLintRuleContext): ReachableTypes | never;
 export declare function requireUsedFieldsFromContext(ruleName: string, context: GraphQLESLintRuleContext): UsedFields | never;
 export declare function extractTokens(source: Source): AST.Token[];