@graphql-eslint/eslint-plugin 3.2.0 → 3.3.0-alpha-d23e9e2.0

package/docs/rules/known-fragment-names.md

@@ -5,7 +5,7 @@
 - Category: `Operations`
 - Rule name: `@graphql-eslint/known-fragment-names`
 - Requires GraphQL Schema: `true` [ℹ️](../../README.md#extended-linting-rules-with-graphql-schema)
-- Requires GraphQL Operations: `false` [ℹ️](../../README.md#extended-linting-rules-with-siblings-operations)
+- Requires GraphQL Operations: `true` [ℹ️](../../README.md#extended-linting-rules-with-siblings-operations)
 
 A GraphQL document is only valid if all `...Fragment` fragment spreads refer to fragments defined in the same document.
 
@@ -13,7 +13,7 @@ A GraphQL document is only valid if all `...Fragment` fragment spreads refer to
 
 ## Usage Examples
 
-### Incorrect (fragment not defined in the document)
+### Incorrect
 
 ```graphql
 # eslint @graphql-eslint/known-fragment-names: 'error'
@@ -21,7 +21,7 @@ A GraphQL document is only valid if all `...Fragment` fragment spreads refer to
 query {
   user {
     id
-    ...UserFields
+    ...UserFields # fragment not defined in the document
   }
 }
 ```
@@ -44,44 +44,23 @@ query {
 }
 ```
 
-### Correct (existing import to UserFields fragment)
+### Correct (`UserFields` fragment located in a separate file)
 
 ```graphql
 # eslint @graphql-eslint/known-fragment-names: 'error'
 
-#import '../UserFields.gql'
-
+# user.gql
 query {
   user {
     id
     ...UserFields
   }
 }
-```
-
-### False positive case
 
-For 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.
-
-```js
-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
+}
 ```
 
 ## Resources

package/docs/rules/no-undefined-variables.md

@@ -5,7 +5,7 @@
 - Category: `Operations`
 - Rule name: `@graphql-eslint/no-undefined-variables`
 - Requires GraphQL Schema: `true` [ℹ️](../../README.md#extended-linting-rules-with-graphql-schema)
-- Requires GraphQL Operations: `false` [ℹ️](../../README.md#extended-linting-rules-with-siblings-operations)
+- Requires GraphQL Operations: `true` [ℹ️](../../README.md#extended-linting-rules-with-siblings-operations)
 
 A GraphQL operation is only valid if all variables encountered, both directly and via fragment spreads, are defined by that operation.
 

package/docs/rules/no-unused-variables.md

@@ -5,7 +5,7 @@
 - Category: `Operations`
 - Rule name: `@graphql-eslint/no-unused-variables`
 - Requires GraphQL Schema: `true` [ℹ️](../../README.md#extended-linting-rules-with-graphql-schema)
-- Requires GraphQL Operations: `false` [ℹ️](../../README.md#extended-linting-rules-with-siblings-operations)
+- Requires GraphQL Operations: `true` [ℹ️](../../README.md#extended-linting-rules-with-siblings-operations)
 
 A GraphQL operation is only valid if all variables defined by an operation are used, either directly or within a spread fragment.
 

package/docs/rules/possible-type-extension.md

@@ -2,7 +2,7 @@
 
 - Category: `Schema`
 - Rule name: `@graphql-eslint/possible-type-extension`
-- Requires GraphQL Schema: `false` [ℹ️](../../README.md#extended-linting-rules-with-graphql-schema)
+- Requires GraphQL Schema: `true` [ℹ️](../../README.md#extended-linting-rules-with-graphql-schema)
 - Requires GraphQL Operations: `false` [ℹ️](../../README.md#extended-linting-rules-with-siblings-operations)
 
 A type extension is only valid if the type is defined and has the same kind.

package/graphql-config.d.ts

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

package/index.js

@@ -6,14 +6,13 @@ 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');
 const lowerCase = _interopDefault(require('lodash.lowercase'));
 const depthLimit = _interopDefault(require('graphql-depth-limit'));
 const graphqlTagPluck = require('@graphql-tools/graphql-tag-pluck');
-const graphqlConfig$1 = require('graphql-config');
+const graphqlConfig = require('graphql-config');
 const codeFileLoader = require('@graphql-tools/code-file-loader');
 const eslint = require('eslint');
 const codeFrame = require('@babel/code-frame');
@@ -327,14 +326,14 @@ function getLocation(loc, fieldName = '', offset) {
     };
 }
 
-function validateDoc(sourceNode, context, schema, documentNode, rules) {
+function validateDocument(context, schema = null, documentNode, rule, isSchemaToExtend = false) {
     if (documentNode.definitions.length === 0) {
         return;
     }
     try {
-        const validationErrors = schema
-            ? graphql.validate(schema, documentNode, rules)
-            : validate.validateSDL(documentNode, null, rules);
+        const validationErrors = schema && !isSchemaToExtend
+            ? graphql.validate(schema, documentNode, [rule])
+            : validate.validateSDL(documentNode, schema, [rule]);
         for (const error of validationErrors) {
             /*
              * TODO: Fix ESTree-AST converter because currently it's incorrectly convert loc.end
@@ -359,97 +358,140 @@ function validateDoc(sourceNode, context, schema, documentNode, rules) {
     }
     catch (e) {
         context.report({
-            node: sourceNode,
+            // Report on first character
+            loc: { column: 0, line: 1 },
             message: e.message,
         });
     }
 }
-const isGraphQLImportFile = rawSDL => {
-    const trimmedRawSDL = rawSDL.trimLeft();
-    return trimmedRawSDL.startsWith('# import') || trimmedRawSDL.startsWith('#import');
+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 validationToRule = (name, ruleName, docs, getDocumentNode) => {
-    var _a;
+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 [foundFragment] = siblings
+                .getFragment(fragmentName)
+                .map(source => source.document)
+                .filter(fragment => fragment.typeCondition.name.value === fragmentTypeName);
+            if (foundFragment) {
+                fragmentsToAdd.push(foundFragment);
+            }
+        }
+        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],
+                },
+            });
+        }
+    }
+    return node;
+};
+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).`,
                 },
             },
             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 {};
+                }
+                const schema = docs.requiresSchema ? requireGraphQLSchemaFromContext(ruleId, context) : null;
                 return {
                     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...`);
-                            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]);
+                        const documentNode = getDocumentNode
+                            ? getDocumentNode({ ruleId, context, schema, node: node.rawNode() })
+                            : node.rawNode();
+                        validateDocument(context, schema, documentNode, ruleFn, docs.requiresSchemaToExtend);
                     },
                 };
             },
         },
     };
 };
-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
               }
             }
           `,
@@ -471,153 +513,153 @@ 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
+    recommended: false,
+    requiresSchema: true,
+    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.`,
+    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';
@@ -3662,35 +3704,36 @@ function getSiblingOperations(options, gqlConfig) {
     return siblingOperations;
 }
 
-let graphqlConfig;
-function loadGraphqlConfig(options) {
+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;
+    if (process.env.NODE_ENV !== 'test' && graphQLConfig) {
+        return graphQLConfig;
     }
     const onDiskConfig = options.skipGraphQLConfig
         ? null
-        : graphqlConfig$1.loadConfigSync({
+        : graphqlConfig.loadConfigSync({
             throwOnEmpty: false,
             throwOnMissing: false,
             extensions: [addCodeFileLoaderExtension],
         });
-    graphqlConfig =
+    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$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,
-                    },
+            new graphqlConfig.GraphQLConfig({
+                config: configOptions,
                 filepath: 'virtual-config',
             }, [addCodeFileLoaderExtension]);
-    return graphqlConfig;
+    return graphQLConfig;
 }
 const addCodeFileLoaderExtension = api => {
     api.loaders.schema.register(new codeFileLoader.CodeFileLoader());
@@ -3780,7 +3823,7 @@ function parse(code, options) {
     return parseForESLint(code, options).ast;
 }
 function parseForESLint(code, options = {}) {
-    const gqlConfig = loadGraphqlConfig(options);
+    const gqlConfig = loadGraphQLConfig(options);
     const schema = getSchema(options, gqlConfig);
     const parserServices = {
         hasTypeInfo: schema !== null,

package/index.mjs

@@ -1,8 +1,7 @@
-import { Kind, validate, TokenKind, isScalarType, isNonNullType, isListType, isObjectType as isObjectType$1, visit, visitWithTypeInfo, GraphQLObjectType, GraphQLInterfaceType, TypeInfo, isInterfaceType, Source, GraphQLError } from 'graphql';
+import { Kind, validate, TypeInfo, visitWithTypeInfo, visit, TokenKind, isScalarType, isNonNullType, isListType, isObjectType as isObjectType$1, GraphQLObjectType, GraphQLInterfaceType, isInterfaceType, Source, GraphQLError } from 'graphql';
 import { validateSDL } from 'graphql/validation/validate';
-import { processImport, parseImportLine } from '@graphql-tools/import';
 import { statSync, existsSync, readFileSync } from 'fs';
-import { dirname, join, extname, basename, relative, resolve } from 'path';
+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';
@@ -321,14 +320,14 @@ function getLocation(loc, fieldName = '', offset) {
     };
 }
 
-function validateDoc(sourceNode, context, schema, documentNode, rules) {
+function validateDocument(context, schema = null, documentNode, rule, isSchemaToExtend = false) {
     if (documentNode.definitions.length === 0) {
         return;
     }
     try {
-        const validationErrors = schema
-            ? validate(schema, documentNode, rules)
-            : validateSDL(documentNode, null, rules);
+        const validationErrors = schema && !isSchemaToExtend
+            ? validate(schema, documentNode, [rule])
+            : validateSDL(documentNode, schema, [rule]);
         for (const error of validationErrors) {
             /*
              * TODO: Fix ESTree-AST converter because currently it's incorrectly convert loc.end
@@ -353,97 +352,140 @@ function validateDoc(sourceNode, context, schema, documentNode, rules) {
     }
     catch (e) {
         context.report({
-            node: sourceNode,
+            // Report on first character
+            loc: { column: 0, line: 1 },
             message: e.message,
         });
     }
 }
-const isGraphQLImportFile = rawSDL => {
-    const trimmedRawSDL = rawSDL.trimLeft();
-    return trimmedRawSDL.startsWith('# import') || trimmedRawSDL.startsWith('#import');
+const getFragmentDefsAndFragmentSpreads = (schema, node) => {
+    const typeInfo = new TypeInfo(schema);
+    const fragmentDefs = new Set();
+    const fragmentSpreads = new Set();
+    const visitor = 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}`);
+            }
+        },
+    });
+    visit(node, visitor);
+    return { fragmentDefs, fragmentSpreads };
 };
-const validationToRule = (name, ruleName, docs, getDocumentNode) => {
-    var _a;
+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 [foundFragment] = siblings
+                .getFragment(fragmentName)
+                .map(source => source.document)
+                .filter(fragment => fragment.typeCondition.name.value === fragmentTypeName);
+            if (foundFragment) {
+                fragmentsToAdd.push(foundFragment);
+            }
+        }
+        if (fragmentsToAdd.length > 0) {
+            // recall fn to make sure to add fragments inside fragments
+            return handleMissingFragments({
+                ruleId,
+                context,
+                schema,
+                node: {
+                    kind: Kind.DOCUMENT,
+                    definitions: [...node.definitions, ...fragmentsToAdd],
+                },
+            });
+        }
+    }
+    return node;
+};
+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).`,
                 },
             },
             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 {};
+                }
+                const schema = docs.requiresSchema ? requireGraphQLSchemaFromContext(ruleId, context) : null;
                 return {
                     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...`);
-                            return;
-                        }
-                        const schema = requiresSchema ? requireGraphQLSchemaFromContext(name, context) : null;
-                        let documentNode;
-                        const isRealFile = existsSync(context.getFilename());
-                        if (isRealFile && getDocumentNode) {
-                            documentNode = getDocumentNode(context);
-                        }
-                        validateDoc(node, context, schema, documentNode || node.rawNode(), [ruleFn]);
+                        const documentNode = getDocumentNode
+                            ? getDocumentNode({ ruleId, context, schema, node: node.rawNode() })
+                            : node.rawNode();
+                        validateDocument(context, schema, documentNode, ruleFn, docs.requiresSchemaToExtend);
                     },
                 };
             },
         },
     };
 };
-const importFiles = (context) => {
-    const code = context.getSourceCode().text;
-    if (!isGraphQLImportFile(code)) {
-        return null;
-    }
-    // Import documents because file contains '#import' comments
-    return 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
               }
             }
           `,
@@ -465,153 +507,153 @@ 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 => parseImportLine(line.replace('#', '')))
-                .some(o => filePath === join(dirname(docFilePath), o.from));
-            if (!isFileImported) {
-                continue;
-            }
-            // Import first file that import this file
-            const document = 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: Kind.DOCUMENT,
+                definitions: documents,
+            });
+            const isCurrentFileImportFragment = missingFragments.some(fragment => fragmentDefs.has(fragment));
+            if (isCurrentFileImportFragment) {
+                return getParentNode(filePath, {
+                    kind: 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
+    recommended: false,
+    requiresSchema: true,
+    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.`,
+    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';
@@ -3656,12 +3698,12 @@ function getSiblingOperations(options, gqlConfig) {
     return siblingOperations;
 }
 
-let graphqlConfig;
-function loadGraphqlConfig(options) {
+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;
+    if (process.env.NODE_ENV !== 'test' && graphQLConfig) {
+        return graphQLConfig;
     }
     const onDiskConfig = options.skipGraphQLConfig
         ? null
@@ -3670,21 +3712,22 @@ function loadGraphqlConfig(options) {
             throwOnMissing: false,
             extensions: [addCodeFileLoaderExtension],
         });
-    graphqlConfig =
+    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: options.projects
-                    ? { projects: options.projects }
-                    : {
-                        schema: (options.schema || ''),
-                        documents: options.documents || options.operations,
-                        extensions: options.extensions,
-                        include: options.include,
-                        exclude: options.exclude,
-                    },
+                config: configOptions,
                 filepath: 'virtual-config',
             }, [addCodeFileLoaderExtension]);
-    return graphqlConfig;
+    return graphQLConfig;
 }
 const addCodeFileLoaderExtension = api => {
     api.loaders.schema.register(new CodeFileLoader());
@@ -3774,7 +3817,7 @@ function parse(code, options) {
     return parseForESLint(code, options).ast;
 }
 function parseForESLint(code, options = {}) {
-    const gqlConfig = loadGraphqlConfig(options);
+    const gqlConfig = loadGraphQLConfig(options);
     const schema = getSchema(options, gqlConfig);
     const parserServices = {
         hasTypeInfo: schema !== null,

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "@graphql-eslint/eslint-plugin",
-  "version": "3.2.0",
+  "version": "3.3.0-alpha-d23e9e2.0",
+  "description": "GraphQL plugin for ESLint",
   "sideEffects": false,
   "peerDependencies": {
     "graphql": "^0.8.0 || ^0.9.0 || ^0.10.0 || ^0.11.0 || ^0.12.0 || ^0.13.0 || ^14.0.0 || ^15.0.0 || ^16.0.0"
@@ -9,13 +10,18 @@
     "@babel/code-frame": "7.16.0",
     "@graphql-tools/code-file-loader": "7.2.3",
     "@graphql-tools/graphql-tag-pluck": "7.1.4",
-    "@graphql-tools/import": "6.6.2",
-    "@graphql-tools/utils": "8.5.4",
+    "@graphql-tools/utils": "8.5.5",
     "graphql-config": "4.1.0",
     "graphql-depth-limit": "1.1.0",
     "lodash.lowercase": "4.3.0"
   },
   "repository": "https://github.com/dotansimha/graphql-eslint",
+  "keywords": [
+    "eslint",
+    "eslintplugin",
+    "eslint-plugin",
+    "graphql"
+  ],
   "author": "Dotan Simha <dotansimha@gmail.com>",
   "license": "MIT",
   "main": "index.js",
@@ -25,6 +31,7 @@
     "definition": "index.d.ts"
   },
   "exports": {
+    "./package.json": "./package.json",
     ".": {
       "require": "./index.js",
       "import": "./index.mjs"

package/rules/graphql-js-validation.d.ts

@@ -1,5 +1,2 @@
-import { GraphQLSchema, DocumentNode, ASTNode, ValidationRule } from 'graphql';
-import { GraphQLESLintRule, GraphQLESLintRuleContext } from '../types';
-import { GraphQLESTreeNode } from '../estree-parser';
-export declare function validateDoc(sourceNode: GraphQLESTreeNode<ASTNode>, context: GraphQLESLintRuleContext, schema: GraphQLSchema | null, documentNode: DocumentNode, rules: ReadonlyArray<ValidationRule>): void;
-export declare const GRAPHQL_JS_VALIDATIONS: Record<string, GraphQLESLintRule<any[], false>>;
+import { GraphQLESLintRule } from '../types';
+export declare const GRAPHQL_JS_VALIDATIONS: Record<string, GraphQLESLintRule>;

package/types.d.ts

@@ -49,8 +49,9 @@ export declare type CategoryType = 'Schema' | 'Operations';
 export declare type RuleDocsInfo<T> = {
     docs: Omit<Rule.RuleMetaData['docs'], 'category'> & {
         category: CategoryType | CategoryType[];
-        requiresSchema?: boolean;
-        requiresSiblings?: boolean;
+        requiresSchema?: true;
+        requiresSiblings?: true;
+        requiresSchemaToExtend?: true;
         examples?: {
             title: string;
             code: string;