@graphql-eslint/eslint-plugin 3.2.0-alpha-2e742a6.0 → 3.2.0-alpha-4ca7218.0

package/index.js

@@ -334,7 +334,7 @@ function getLocation(loc, fieldName = '', offset) {
     };
 }
 
-function validateDoc(sourceNode, context, schema, documentNode, rule) {
+function validateDocument(sourceNode, context, schema, documentNode, rule) {
     if (documentNode.definitions.length === 0) {
         return;
     }
@@ -365,9 +365,9 @@ const getFragmentDefsAndFragmentSpreads = (schema, node) => {
             fragmentDefs.add(`${node.name.value}:${node.typeCondition.name.value}`);
         },
         FragmentSpread(node) {
-            const fieldDef = typeInfo.getFieldDef();
-            if (fieldDef) {
-                fragmentSpreads.add(`${node.name.value}:${typeInfo.getParentType().name}`);
+            const parentType = typeInfo.getParentType();
+            if (parentType) {
+                fragmentSpreads.add(`${node.name.value}:${parentType.name}`);
             }
         },
     });
@@ -378,56 +378,57 @@ const getMissingFragments = (schema, node) => {
     const { fragmentDefs, fragmentSpreads } = getFragmentDefsAndFragmentSpreads(schema, node);
     return [...fragmentSpreads].filter(name => !fragmentDefs.has(name));
 };
-const handleMissingFragments = ({ schema, node, ruleId, context }) => {
+const handleMissingFragments = ({ ruleId, context, schema, node }) => {
     const missingFragments = getMissingFragments(schema, node);
     if (missingFragments.length > 0) {
         const siblings = requireSiblingsOperations(ruleId, context);
         const fragmentsToAdd = [];
         for (const missingFragment of missingFragments) {
             const [fragmentName, fragmentTypeName] = missingFragment.split(':');
-            const fragments = siblings
+            const [foundFragment] = siblings
                 .getFragment(fragmentName)
                 .map(source => source.document)
                 .filter(fragment => fragment.typeCondition.name.value === fragmentTypeName);
-            if (fragments.length > 1) {
-                // eslint-disable-next-line no-console
-                console.warn(`You have ${fragments.length} fragments that have same name ${fragmentName} and same type ${fragmentTypeName}. That can provoke unexpected result for "${ruleId}" rule.`);
+            if (foundFragment) {
+                fragmentsToAdd.push(foundFragment);
             }
-            fragmentsToAdd.push(fragments[0]);
         }
         if (fragmentsToAdd.length > 0) {
-            return {
-                kind: graphql.Kind.DOCUMENT,
-                definitions: [...node.definitions, ...fragmentsToAdd],
-            };
+            // 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 = (name, ruleName, docs, getDocumentNode) => {
-    var _a;
+const validationToRule = (ruleId, ruleName, docs, getDocumentNode) => {
     let ruleFn = null;
     try {
         ruleFn = require(`graphql/validation/rules/${ruleName}Rule`)[`${ruleName}Rule`];
     }
-    catch (_b) {
+    catch (_a) {
         try {
             ruleFn = require(`graphql/validation/rules/${ruleName}`)[`${ruleName}Rule`];
         }
-        catch (_c) {
+        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).`,
                 },
             },
@@ -436,19 +437,14 @@ const validationToRule = (name, ruleName, docs, getDocumentNode) => {
                     Document(node) {
                         if (!ruleFn) {
                             // eslint-disable-next-line no-console
-                            console.warn(`You rule "${name}" depends on a GraphQL validation rule "${ruleName}" but it's not available in the "graphql-js" version you are using. Skipping...`);
+                            console.warn(`You rule "${ruleId}" depends on a GraphQL validation rule "${ruleName}" but it's not available in the "graphql-js" version you are using. Skipping...`);
                             return;
                         }
-                        const schema = requiresSchema ? requireGraphQLSchemaFromContext(name, context) : null;
-                        const documentNode = node.rawNode();
-                        validateDoc(node, context, schema, getDocumentNode
-                            ? getDocumentNode({
-                                schema,
-                                node: documentNode,
-                                ruleId: name,
-                                context,
-                            })
-                            : documentNode, ruleFn);
+                        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);
                     },
                 };
             },
@@ -458,21 +454,27 @@ const validationToRule = (name, ruleName, docs, getDocumentNode) => {
 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: [
         {
@@ -523,27 +525,31 @@ const GRAPHQL_JS_VALIDATIONS = Object.assign({}, validationToRule('executable-de
 }, 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.`,
+    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, node, schema, ruleId }) => {
+}, ({ ruleId, context, schema, node }) => {
     const siblings = requireSiblingsOperations(ruleId, context);
-    const filePathForDocumentsMap = [...siblings.getOperations(), ...siblings.getFragments()].reduce((map, { filePath, document }) => {
+    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);
@@ -555,8 +561,8 @@ const GRAPHQL_JS_VALIDATIONS = Object.assign({}, validationToRule('executable-de
             return node;
         }
         // skip iteration over documents for current filepath
-        delete filePathForDocumentsMap[currentFilePath];
-        for (const [filePath, documents] of Object.entries(filePathForDocumentsMap)) {
+        delete FilePathToDocumentsMap[currentFilePath];
+        for (const [filePath, documents] of Object.entries(FilePathToDocumentsMap)) {
             const missingFragments = getMissingFragments(schema, {
                 kind: graphql.Kind.DOCUMENT,
                 definitions: documents,
@@ -575,70 +581,75 @@ const GRAPHQL_JS_VALIDATIONS = Object.assign({}, validationToRule('executable-de
 }), 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.`,
+    requiresSchema: true,
     requiresSiblings: true,
 }, handleMissingFragments), validationToRule('overlapping-fields-can-be-merged', 'OverlappingFieldsCanBeMerged', {
     category: 'Operations',
     description: `A selection set is only valid if all fields (including spreading any fragments) either correspond to distinct response names or can be merged without ambiguity.`,
+    requiresSchema: true,
 }), validationToRule('possible-fragment-spread', 'PossibleFragmentSpreads', {
     category: 'Operations',
     description: `A fragment spread is only valid if the type condition could ever possibly be true: if there is a non-empty intersection of the possible parent types, and possible types which pass the type condition.`,
+    requiresSchema: true,
 }), validationToRule('possible-type-extension', 'PossibleTypeExtensions', {
     category: 'Schema',
     description: `A type extension is only valid if the type is defined and has the same kind.`,
-    requiresSchema: false,
     recommended: false, // TODO: enable after https://github.com/dotansimha/graphql-eslint/issues/787 will be fixed
 }), validationToRule('provided-required-arguments', 'ProvidedRequiredArguments', {
     category: ['Schema', 'Operations'],
     description: `A field or directive is only valid if all required (non-null without a default value) field arguments have been provided.`,
+    requiresSchema: true,
 }), validationToRule('scalar-leafs', 'ScalarLeafs', {
     category: 'Operations',
     description: `A GraphQL document is valid only if all leaf fields (fields without sub selections) are of scalar or enum types.`,
+    requiresSchema: true,
 }), validationToRule('one-field-subscriptions', 'SingleFieldSubscriptions', {
     category: 'Operations',
     description: `A GraphQL subscription is valid only if it contains a single root field.`,
+    requiresSchema: true,
 }), validationToRule('unique-argument-names', 'UniqueArgumentNames', {
     category: 'Operations',
     description: `A GraphQL field or directive is only valid if all supplied arguments are uniquely named.`,
+    requiresSchema: true,
 }), validationToRule('unique-directive-names', 'UniqueDirectiveNames', {
     category: 'Schema',
     description: `A GraphQL document is only valid if all defined directives have unique names.`,
-    requiresSchema: false,
 }), validationToRule('unique-directive-names-per-location', 'UniqueDirectivesPerLocation', {
     category: ['Schema', 'Operations'],
     description: `A GraphQL document is only valid if all non-repeatable directives at a given location are uniquely named.`,
+    requiresSchema: true,
 }), validationToRule('unique-enum-value-names', 'UniqueEnumValueNames', {
     category: 'Schema',
     description: `A GraphQL enum type is only valid if all its values are uniquely named.`,
-    requiresSchema: false,
     recommended: false,
 }), validationToRule('unique-field-definition-names', 'UniqueFieldDefinitionNames', {
     category: 'Schema',
     description: `A GraphQL complex type is only valid if all its fields are uniquely named.`,
-    requiresSchema: false,
 }), validationToRule('unique-input-field-names', 'UniqueInputFieldNames', {
     category: 'Operations',
     description: `A GraphQL input object value is only valid if all supplied fields are uniquely named.`,
-    requiresSchema: false,
 }), validationToRule('unique-operation-types', 'UniqueOperationTypes', {
     category: 'Schema',
     description: `A GraphQL document is only valid if it has only one type per operation.`,
-    requiresSchema: false,
 }), validationToRule('unique-type-names', 'UniqueTypeNames', {
     category: 'Schema',
     description: `A GraphQL document is only valid if all defined types have unique names.`,
-    requiresSchema: false,
 }), validationToRule('unique-variable-names', 'UniqueVariableNames', {
     category: 'Operations',
     description: `A GraphQL operation is only valid if all its variables are uniquely named.`,
+    requiresSchema: true,
 }), validationToRule('value-literals-of-correct-type', 'ValuesOfCorrectType', {
     category: 'Operations',
     description: `A GraphQL document is only valid if all value literals are of the type expected at their position.`,
+    requiresSchema: true,
 }), validationToRule('variables-are-input-types', 'VariablesAreInputTypes', {
     category: 'Operations',
     description: `A GraphQL operation is only valid if all the variables it defines are of input types (scalar, enum, or input object).`,
+    requiresSchema: true,
 }), validationToRule('variables-in-allowed-position', 'VariablesInAllowedPosition', {
     category: 'Operations',
     description: `Variables passed to field arguments conform to type.`,
+    requiresSchema: true,
 }));
 
 const ALPHABETIZE = 'ALPHABETIZE';

package/index.mjs

@@ -328,7 +328,7 @@ function getLocation(loc, fieldName = '', offset) {
     };
 }
 
-function validateDoc(sourceNode, context, schema, documentNode, rule) {
+function validateDocument(sourceNode, context, schema, documentNode, rule) {
     if (documentNode.definitions.length === 0) {
         return;
     }
@@ -359,9 +359,9 @@ const getFragmentDefsAndFragmentSpreads = (schema, node) => {
             fragmentDefs.add(`${node.name.value}:${node.typeCondition.name.value}`);
         },
         FragmentSpread(node) {
-            const fieldDef = typeInfo.getFieldDef();
-            if (fieldDef) {
-                fragmentSpreads.add(`${node.name.value}:${typeInfo.getParentType().name}`);
+            const parentType = typeInfo.getParentType();
+            if (parentType) {
+                fragmentSpreads.add(`${node.name.value}:${parentType.name}`);
             }
         },
     });
@@ -372,56 +372,57 @@ const getMissingFragments = (schema, node) => {
     const { fragmentDefs, fragmentSpreads } = getFragmentDefsAndFragmentSpreads(schema, node);
     return [...fragmentSpreads].filter(name => !fragmentDefs.has(name));
 };
-const handleMissingFragments = ({ schema, node, ruleId, context }) => {
+const handleMissingFragments = ({ ruleId, context, schema, node }) => {
     const missingFragments = getMissingFragments(schema, node);
     if (missingFragments.length > 0) {
         const siblings = requireSiblingsOperations(ruleId, context);
         const fragmentsToAdd = [];
         for (const missingFragment of missingFragments) {
             const [fragmentName, fragmentTypeName] = missingFragment.split(':');
-            const fragments = siblings
+            const [foundFragment] = siblings
                 .getFragment(fragmentName)
                 .map(source => source.document)
                 .filter(fragment => fragment.typeCondition.name.value === fragmentTypeName);
-            if (fragments.length > 1) {
-                // eslint-disable-next-line no-console
-                console.warn(`You have ${fragments.length} fragments that have same name ${fragmentName} and same type ${fragmentTypeName}. That can provoke unexpected result for "${ruleId}" rule.`);
+            if (foundFragment) {
+                fragmentsToAdd.push(foundFragment);
             }
-            fragmentsToAdd.push(fragments[0]);
         }
         if (fragmentsToAdd.length > 0) {
-            return {
-                kind: Kind.DOCUMENT,
-                definitions: [...node.definitions, ...fragmentsToAdd],
-            };
+            // 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 = (name, ruleName, docs, getDocumentNode) => {
-    var _a;
+const validationToRule = (ruleId, ruleName, docs, getDocumentNode) => {
     let ruleFn = null;
     try {
         ruleFn = require(`graphql/validation/rules/${ruleName}Rule`)[`${ruleName}Rule`];
     }
-    catch (_b) {
+    catch (_a) {
         try {
             ruleFn = require(`graphql/validation/rules/${ruleName}`)[`${ruleName}Rule`];
         }
-        catch (_c) {
+        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).`,
                 },
             },
@@ -430,19 +431,14 @@ const validationToRule = (name, ruleName, docs, getDocumentNode) => {
                     Document(node) {
                         if (!ruleFn) {
                             // eslint-disable-next-line no-console
-                            console.warn(`You rule "${name}" depends on a GraphQL validation rule "${ruleName}" but it's not available in the "graphql-js" version you are using. Skipping...`);
+                            console.warn(`You rule "${ruleId}" depends on a GraphQL validation rule "${ruleName}" but it's not available in the "graphql-js" version you are using. Skipping...`);
                             return;
                         }
-                        const schema = requiresSchema ? requireGraphQLSchemaFromContext(name, context) : null;
-                        const documentNode = node.rawNode();
-                        validateDoc(node, context, schema, getDocumentNode
-                            ? getDocumentNode({
-                                schema,
-                                node: documentNode,
-                                ruleId: name,
-                                context,
-                            })
-                            : documentNode, ruleFn);
+                        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);
                     },
                 };
             },
@@ -452,21 +448,27 @@ const validationToRule = (name, ruleName, docs, getDocumentNode) => {
 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: [
         {
@@ -517,27 +519,31 @@ const GRAPHQL_JS_VALIDATIONS = Object.assign({}, validationToRule('executable-de
 }, 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.`,
+    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, node, schema, ruleId }) => {
+}, ({ ruleId, context, schema, node }) => {
     const siblings = requireSiblingsOperations(ruleId, context);
-    const filePathForDocumentsMap = [...siblings.getOperations(), ...siblings.getFragments()].reduce((map, { filePath, document }) => {
+    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);
@@ -549,8 +555,8 @@ const GRAPHQL_JS_VALIDATIONS = Object.assign({}, validationToRule('executable-de
             return node;
         }
         // skip iteration over documents for current filepath
-        delete filePathForDocumentsMap[currentFilePath];
-        for (const [filePath, documents] of Object.entries(filePathForDocumentsMap)) {
+        delete FilePathToDocumentsMap[currentFilePath];
+        for (const [filePath, documents] of Object.entries(FilePathToDocumentsMap)) {
             const missingFragments = getMissingFragments(schema, {
                 kind: Kind.DOCUMENT,
                 definitions: documents,
@@ -569,70 +575,75 @@ const GRAPHQL_JS_VALIDATIONS = Object.assign({}, validationToRule('executable-de
 }), 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.`,
+    requiresSchema: true,
     requiresSiblings: true,
 }, handleMissingFragments), validationToRule('overlapping-fields-can-be-merged', 'OverlappingFieldsCanBeMerged', {
     category: 'Operations',
     description: `A selection set is only valid if all fields (including spreading any fragments) either correspond to distinct response names or can be merged without ambiguity.`,
+    requiresSchema: true,
 }), validationToRule('possible-fragment-spread', 'PossibleFragmentSpreads', {
     category: 'Operations',
     description: `A fragment spread is only valid if the type condition could ever possibly be true: if there is a non-empty intersection of the possible parent types, and possible types which pass the type condition.`,
+    requiresSchema: true,
 }), validationToRule('possible-type-extension', 'PossibleTypeExtensions', {
     category: 'Schema',
     description: `A type extension is only valid if the type is defined and has the same kind.`,
-    requiresSchema: false,
     recommended: false, // TODO: enable after https://github.com/dotansimha/graphql-eslint/issues/787 will be fixed
 }), validationToRule('provided-required-arguments', 'ProvidedRequiredArguments', {
     category: ['Schema', 'Operations'],
     description: `A field or directive is only valid if all required (non-null without a default value) field arguments have been provided.`,
+    requiresSchema: true,
 }), validationToRule('scalar-leafs', 'ScalarLeafs', {
     category: 'Operations',
     description: `A GraphQL document is valid only if all leaf fields (fields without sub selections) are of scalar or enum types.`,
+    requiresSchema: true,
 }), validationToRule('one-field-subscriptions', 'SingleFieldSubscriptions', {
     category: 'Operations',
     description: `A GraphQL subscription is valid only if it contains a single root field.`,
+    requiresSchema: true,
 }), validationToRule('unique-argument-names', 'UniqueArgumentNames', {
     category: 'Operations',
     description: `A GraphQL field or directive is only valid if all supplied arguments are uniquely named.`,
+    requiresSchema: true,
 }), validationToRule('unique-directive-names', 'UniqueDirectiveNames', {
     category: 'Schema',
     description: `A GraphQL document is only valid if all defined directives have unique names.`,
-    requiresSchema: false,
 }), validationToRule('unique-directive-names-per-location', 'UniqueDirectivesPerLocation', {
     category: ['Schema', 'Operations'],
     description: `A GraphQL document is only valid if all non-repeatable directives at a given location are uniquely named.`,
+    requiresSchema: true,
 }), validationToRule('unique-enum-value-names', 'UniqueEnumValueNames', {
     category: 'Schema',
     description: `A GraphQL enum type is only valid if all its values are uniquely named.`,
-    requiresSchema: false,
     recommended: false,
 }), validationToRule('unique-field-definition-names', 'UniqueFieldDefinitionNames', {
     category: 'Schema',
     description: `A GraphQL complex type is only valid if all its fields are uniquely named.`,
-    requiresSchema: false,
 }), validationToRule('unique-input-field-names', 'UniqueInputFieldNames', {
     category: 'Operations',
     description: `A GraphQL input object value is only valid if all supplied fields are uniquely named.`,
-    requiresSchema: false,
 }), validationToRule('unique-operation-types', 'UniqueOperationTypes', {
     category: 'Schema',
     description: `A GraphQL document is only valid if it has only one type per operation.`,
-    requiresSchema: false,
 }), validationToRule('unique-type-names', 'UniqueTypeNames', {
     category: 'Schema',
     description: `A GraphQL document is only valid if all defined types have unique names.`,
-    requiresSchema: false,
 }), validationToRule('unique-variable-names', 'UniqueVariableNames', {
     category: 'Operations',
     description: `A GraphQL operation is only valid if all its variables are uniquely named.`,
+    requiresSchema: true,
 }), validationToRule('value-literals-of-correct-type', 'ValuesOfCorrectType', {
     category: 'Operations',
     description: `A GraphQL document is only valid if all value literals are of the type expected at their position.`,
+    requiresSchema: true,
 }), validationToRule('variables-are-input-types', 'VariablesAreInputTypes', {
     category: 'Operations',
     description: `A GraphQL operation is only valid if all the variables it defines are of input types (scalar, enum, or input object).`,
+    requiresSchema: true,
 }), validationToRule('variables-in-allowed-position', 'VariablesInAllowedPosition', {
     category: 'Operations',
     description: `Variables passed to field arguments conform to type.`,
+    requiresSchema: true,
 }));
 
 const ALPHABETIZE = 'ALPHABETIZE';

package/package.json

@@ -1,20 +1,27 @@
 {
   "name": "@graphql-eslint/eslint-plugin",
-  "version": "3.2.0-alpha-2e742a6.0",
+  "version": "3.2.0-alpha-4ca7218.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"
   },
   "dependencies": {
     "@babel/code-frame": "7.16.0",
-    "@graphql-tools/code-file-loader": "7.2.2",
+    "@graphql-tools/code-file-loader": "7.2.3",
     "@graphql-tools/graphql-tag-pluck": "7.1.4",
-    "@graphql-tools/utils": "8.5.3",
+    "@graphql-tools/utils": "8.5.4",
     "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",

package/types.d.ts

@@ -49,8 +49,8 @@ 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;
         examples?: {
             title: string;
             code: string;