@graphql-eslint/eslint-plugin 2.1.0-alpha-b4cd82d.0 → 2.3.0-alpha-6ba4002.0

package/index.mjs

@@ -1,4 +1,4 @@
-import { Source, validate, Kind, TokenKind, isNonNullType, isListType, visit, visitWithTypeInfo, GraphQLObjectType, GraphQLInterfaceType, TypeInfo, isInterfaceType, GraphQLError } from 'graphql';
+import { Kind, Source, validate, isScalarType, TokenKind, isNonNullType, isListType, isObjectType as isObjectType$1, visit, visitWithTypeInfo, GraphQLObjectType, GraphQLInterfaceType, TypeInfo, isInterfaceType, GraphQLError } from 'graphql';
 import { validateSDL } from 'graphql/validation/validate';
 import { processImport, parseImportLine } from '@graphql-tools/import';
 import { statSync, existsSync, readFileSync } from 'fs';
@@ -10,6 +10,86 @@ import { parseCode } from '@graphql-tools/graphql-tag-pluck';
 import { loadConfigSync, GraphQLConfig } from 'graphql-config';
 import { CodeFileLoader } from '@graphql-tools/code-file-loader';
 
+/*
+ * 🚨 IMPORTANT! Do not manually modify this file. Run: `yarn generate-configs`
+ */
+const recommendedConfig = {
+    parser: '@graphql-eslint/eslint-plugin',
+    plugins: ['@graphql-eslint'],
+    rules: {
+        '@graphql-eslint/avoid-typename-prefix': 'error',
+        '@graphql-eslint/executable-definitions': 'error',
+        '@graphql-eslint/fields-on-correct-type': 'error',
+        '@graphql-eslint/fragments-on-composite-type': 'error',
+        '@graphql-eslint/known-argument-names': 'error',
+        '@graphql-eslint/known-directives': 'error',
+        '@graphql-eslint/known-fragment-names': 'error',
+        '@graphql-eslint/known-type-names': 'error',
+        '@graphql-eslint/lone-anonymous-operation': 'error',
+        '@graphql-eslint/lone-schema-definition': 'error',
+        '@graphql-eslint/naming-convention': 'error',
+        '@graphql-eslint/no-anonymous-operations': 'error',
+        '@graphql-eslint/no-case-insensitive-enum-values-duplicates': 'error',
+        '@graphql-eslint/no-fragment-cycles': 'error',
+        '@graphql-eslint/no-operation-name-suffix': 'error',
+        '@graphql-eslint/no-undefined-variables': 'error',
+        '@graphql-eslint/no-unused-fragments': 'error',
+        '@graphql-eslint/no-unused-variables': 'error',
+        '@graphql-eslint/one-field-subscriptions': 'error',
+        '@graphql-eslint/overlapping-fields-can-be-merged': 'error',
+        '@graphql-eslint/possible-fragment-spread': 'error',
+        '@graphql-eslint/possible-type-extension': 'error',
+        '@graphql-eslint/provided-required-arguments': 'error',
+        '@graphql-eslint/require-deprecation-reason': 'error',
+        '@graphql-eslint/scalar-leafs': 'error',
+        '@graphql-eslint/strict-id-in-types': 'error',
+        '@graphql-eslint/unique-argument-names': 'error',
+        '@graphql-eslint/unique-directive-names': 'error',
+        '@graphql-eslint/unique-directive-names-per-location': 'error',
+        '@graphql-eslint/unique-enum-value-names': 'error',
+        '@graphql-eslint/unique-field-definition-names': 'error',
+        '@graphql-eslint/unique-input-field-names': 'error',
+        '@graphql-eslint/unique-operation-types': 'error',
+        '@graphql-eslint/unique-type-names': 'error',
+        '@graphql-eslint/unique-variable-names': 'error',
+        '@graphql-eslint/value-literals-of-correct-type': 'error',
+        '@graphql-eslint/variables-are-input-types': 'error',
+        '@graphql-eslint/variables-in-allowed-position': 'error',
+    },
+};
+
+/*
+ * 🚨 IMPORTANT! Do not manually modify this file. Run: `yarn generate-configs`
+ */
+const allConfig = {
+    ...recommendedConfig,
+    rules: {
+        ...recommendedConfig.rules,
+        '@graphql-eslint/avoid-duplicate-fields': 'error',
+        '@graphql-eslint/avoid-operation-name-prefix': 'error',
+        '@graphql-eslint/avoid-scalar-result-type-on-mutation': 'error',
+        '@graphql-eslint/description-style': 'error',
+        '@graphql-eslint/input-name': 'error',
+        '@graphql-eslint/match-document-filename': 'error',
+        '@graphql-eslint/no-deprecated': 'error',
+        '@graphql-eslint/no-hashtag-description': 'error',
+        '@graphql-eslint/no-unreachable-types': 'error',
+        '@graphql-eslint/no-unused-fields': 'error',
+        '@graphql-eslint/require-deprecation-date': 'error',
+        '@graphql-eslint/require-description': 'error',
+        '@graphql-eslint/require-field-of-type-query-in-mutation-result': 'error',
+        '@graphql-eslint/require-id-when-available': 'error',
+        '@graphql-eslint/selection-set-depth': 'error',
+        '@graphql-eslint/unique-fragment-name': 'error',
+        '@graphql-eslint/unique-operation-name': 'error',
+    },
+};
+
+const configs = {
+    all: allConfig,
+    recommended: recommendedConfig,
+};
+
 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`);
@@ -95,6 +175,7 @@ const getOnDiskFilepath = (filepath) => {
     }
     return filepath;
 };
+const getTypeName = node => ('type' in node ? getTypeName(node.type) : node.name.value);
 // Small workaround for the bug in older versions of @graphql-tools/load
 // Can be removed after graphql-config bumps to a new version
 const loaderCache = new Proxy(Object.create(null), {
@@ -112,7 +193,7 @@ const loaderCache = new Proxy(Object.create(null), {
         return true;
     },
 });
-const isObjectType = (node) => ['ObjectTypeDefinition', 'ObjectTypeExtension'].includes(node.type);
+const isObjectType = (node) => [Kind.OBJECT_TYPE_DEFINITION, Kind.OBJECT_TYPE_EXTENSION].includes(node.type);
 const isQueryType = (node) => isObjectType(node) && node.name.value === 'Query';
 const isMutationType = (node) => isObjectType(node) && node.name.value === 'Mutation';
 var CaseStyle;
@@ -123,16 +204,18 @@ var CaseStyle;
     CaseStyle["upperCase"] = "UPPER_CASE";
     CaseStyle["kebabCase"] = "kebab-case";
 })(CaseStyle || (CaseStyle = {}));
+const pascalCase = (str) => lowerCase(str)
+    .split(' ')
+    .map(word => word.charAt(0).toUpperCase() + word.slice(1))
+    .join('');
+const camelCase = (str) => {
+    const result = pascalCase(str);
+    return result.charAt(0).toLowerCase() + result.slice(1);
+};
 const convertCase = (style, str) => {
-    const pascalCase = (str) => lowerCase(str)
-        .split(' ')
-        .map(word => word.charAt(0).toUpperCase() + word.slice(1))
-        .join('');
     switch (style) {
-        case CaseStyle.camelCase: {
-            const result = pascalCase(str);
-            return result.charAt(0).toLowerCase() + result.slice(1);
-        }
+        case CaseStyle.camelCase:
+            return camelCase(str);
         case CaseStyle.pascalCase:
             return pascalCase(str);
         case CaseStyle.snakeCase:
@@ -194,9 +277,10 @@ const validationToRule = (name, ruleName, docs, getDocumentNode) => {
                 docs: {
                     ...docs,
                     category: 'Validation',
+                    recommended: true,
                     requiresSchema,
                     url: `https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/${name}.md`,
-                    description: `${docs.description}\n\n> This rule is a wrapper around a \`graphql-js\` validation function. [You can find it's source code here](https://github.com/graphql/graphql-js/blob/main/src/validation/rules/${ruleName}Rule.ts).`,
+                    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) {
@@ -220,6 +304,14 @@ const validationToRule = (name, ruleName, docs, getDocumentNode) => {
         },
     };
 };
+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', {
     description: `A GraphQL document is only valid for execution if all definitions are either operation or fragment definitions.`,
 }), validationToRule('fields-on-correct-type', 'FieldsOnCorrectType', {
@@ -296,14 +388,7 @@ const GRAPHQL_JS_VALIDATIONS = Object.assign({}, validationToRule('executable-de
             \``,
         },
     ],
-}, context => {
-    const code = context.getSourceCode().text;
-    if (!isGraphQLImportFile(code)) {
-        return null;
-    }
-    // Import documents because file contains '#import' comments
-    return processImport(context.getFilename());
-}), validationToRule('known-type-names', 'KnownTypeNames', {
+}, importFiles), validationToRule('known-type-names', 'KnownTypeNames', {
     description: `A GraphQL document is only valid if referenced types (specifically variable definitions and fragment conditions) are defined by the type schema.`,
 }), validationToRule('lone-anonymous-operation', 'LoneAnonymousOperation', {
     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.`,
@@ -345,7 +430,7 @@ const GRAPHQL_JS_VALIDATIONS = Object.assign({}, validationToRule('executable-de
     return getParentNode(context.getFilename());
 }), validationToRule('no-unused-variables', 'NoUnusedVariables', {
     description: `A GraphQL operation is only valid if all variables defined by an operation are used, either directly or within a spread fragment.`,
-}), validationToRule('overlapping-fields-can-be-merged', 'OverlappingFieldsCanBeMerged', {
+}, importFiles), validationToRule('overlapping-fields-can-be-merged', 'OverlappingFieldsCanBeMerged', {
     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.`,
 }), validationToRule('possible-fragment-spread', 'PossibleFragmentSpreads', {
     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.`,
@@ -598,8 +683,59 @@ const rule$1 = {
     },
 };
 
-const AVOID_TYPENAME_PREFIX = 'AVOID_TYPENAME_PREFIX';
 const rule$2 = {
+    meta: {
+        type: 'suggestion',
+        docs: {
+            category: 'Best Practices',
+            description: 'Avoid scalar result type on mutation type to make sure to return a valid state.',
+            url: 'https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/avoid-scalar-result-type-on-mutation.md',
+            requiresSchema: true,
+            examples: [
+                {
+                    title: 'Incorrect',
+                    code: /* GraphQL */ `
+            type Mutation {
+              createUser: Boolean
+            }
+          `,
+                },
+                {
+                    title: 'Correct',
+                    code: /* GraphQL */ `
+            type Mutation {
+              createUser: User!
+            }
+          `,
+                },
+            ],
+        },
+    },
+    create(context) {
+        const schema = requireGraphQLSchemaFromContext('avoid-scalar-result-type-on-mutation', context);
+        const mutationType = schema.getMutationType();
+        if (!mutationType) {
+            return {};
+        }
+        const selector = `:matches(${Kind.OBJECT_TYPE_DEFINITION}, ${Kind.OBJECT_TYPE_EXTENSION})[name.value=${mutationType.name}] > ${Kind.FIELD_DEFINITION}`;
+        return {
+            [selector](node) {
+                const rawNode = node.rawNode();
+                const typeName = getTypeName(rawNode);
+                const graphQLType = schema.getType(typeName);
+                if (isScalarType(graphQLType)) {
+                    context.report({
+                        node,
+                        message: `Unexpected scalar result type "${typeName}".`,
+                    });
+                }
+            },
+        };
+    },
+};
+
+const AVOID_TYPENAME_PREFIX = 'AVOID_TYPENAME_PREFIX';
+const rule$3 = {
     meta: {
         type: 'suggestion',
         docs: {
@@ -653,7 +789,7 @@ const rule$2 = {
     },
 };
 
-const rule$3 = {
+const rule$4 = {
     meta: {
         type: 'suggestion',
         docs: {
@@ -713,7 +849,7 @@ const rule$3 = {
     },
 };
 
-const rule$4 = {
+const rule$5 = {
     meta: {
         type: 'suggestion',
         docs: {
@@ -838,12 +974,12 @@ const CASE_STYLES = [
 const schemaOption = {
     oneOf: [{ $ref: '#/definitions/asString' }, { $ref: '#/definitions/asObject' }],
 };
-const rule$5 = {
+const rule$6 = {
     meta: {
         type: 'suggestion',
         docs: {
             category: 'Best Practices',
-            description: 'This rule allows you to enforce that the file name should match the operation name',
+            description: 'This rule allows you to enforce that the file name should match the operation name.',
             url: `https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/match-document-filename.md`,
             examples: [
                 {
@@ -1050,7 +1186,7 @@ function checkNameFormat(params) {
             errorMessage: '{{nodeType}} name "{{nodeName}}" should have "{{suffix}}" suffix',
         };
     }
-    if (style && !acceptedStyles.some(acceptedStyle => acceptedStyle === style)) {
+    if (style && !acceptedStyles.includes(style)) {
         return {
             ok: false,
             errorMessage: `{{nodeType}} name "{{nodeName}}" should be in one of the following options: ${acceptedStyles.join(',')}`,
@@ -1083,7 +1219,7 @@ function checkNameFormat(params) {
 const schemaOption$1 = {
     oneOf: [{ $ref: '#/definitions/asString' }, { $ref: '#/definitions/asObject' }],
 };
-const rule$6 = {
+const rule$7 = {
     meta: {
         type: 'suggestion',
         docs: {
@@ -1312,7 +1448,7 @@ const rule$6 = {
 };
 
 const NO_ANONYMOUS_OPERATIONS = 'NO_ANONYMOUS_OPERATIONS';
-const rule$7 = {
+const rule$8 = {
     meta: {
         type: 'suggestion',
         docs: {
@@ -1370,13 +1506,14 @@ const rule$7 = {
 };
 
 const ERROR_MESSAGE_ID = 'NO_CASE_INSENSITIVE_ENUM_VALUES_DUPLICATES';
-const rule$8 = {
+const rule$9 = {
     meta: {
         type: 'suggestion',
         docs: {
             url: 'https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/no-case-insensitive-enum-values-duplicates.md',
             category: 'Best Practices',
             recommended: true,
+            description: 'Disallow case-insensitive enum values duplicates.',
             examples: [
                 {
                     title: 'Incorrect',
@@ -1424,7 +1561,7 @@ const rule$8 = {
 };
 
 const NO_DEPRECATED = 'NO_DEPRECATED';
-const rule$9 = {
+const rule$a = {
     meta: {
         type: 'suggestion',
         docs: {
@@ -1538,7 +1675,7 @@ const rule$9 = {
 };
 
 const HASHTAG_COMMENT = 'HASHTAG_COMMENT';
-const rule$a = {
+const rule$b = {
     meta: {
         messages: {
             [HASHTAG_COMMENT]: 'Using hashtag (#) for adding GraphQL descriptions is not allowed. Prefer using """ for multiline, or " for a single line description.',
@@ -1613,7 +1750,7 @@ const rule$a = {
 };
 
 const NO_OPERATION_NAME_SUFFIX = 'NO_OPERATION_NAME_SUFFIX';
-const rule$b = {
+const rule$c = {
     meta: {
         fixable: 'code',
         type: 'suggestion',
@@ -1668,7 +1805,7 @@ const rule$b = {
 
 const UNREACHABLE_TYPE = 'UNREACHABLE_TYPE';
 const RULE_NAME = 'no-unreachable-types';
-const rule$c = {
+const rule$d = {
     meta: {
         messages: {
             [UNREACHABLE_TYPE]: `Type "{{ typeName }}" is unreachable`,
@@ -1743,7 +1880,7 @@ const rule$c = {
 
 const UNUSED_FIELD = 'UNUSED_FIELD';
 const RULE_NAME$1 = 'no-unused-fields';
-const rule$d = {
+const rule$e = {
     meta: {
         messages: {
             [UNUSED_FIELD]: `Field "{{fieldName}}" is unused`,
@@ -1925,7 +2062,112 @@ function convertDescription(node) {
     return [];
 }
 
-const rule$e = {
+const DATE_REGEX = /^\d{2}\/\d{2}\/\d{4}$/;
+const MESSAGE_REQUIRE_DATE = 'MESSAGE_REQUIRE_DATE';
+const MESSAGE_INVALID_FORMAT = 'MESSAGE_INVALID_FORMAT';
+const MESSAGE_INVALID_DATE = 'MESSAGE_INVALID_DATE';
+const MESSAGE_CAN_BE_REMOVED = 'MESSAGE_CAN_BE_REMOVED';
+const rule$f = {
+    meta: {
+        type: 'suggestion',
+        docs: {
+            category: 'Best Practices',
+            description: 'Require deletion date on `@deprecated` directive. Suggest removing deprecated things after deprecated date.',
+            url: 'https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/require-deprecation-date.md',
+            examples: [
+                {
+                    title: 'Incorrect',
+                    code: /* GraphQL */ `
+            type User {
+              firstname: String @deprecated
+              firstName: String
+            }
+          `,
+                },
+                {
+                    title: 'Incorrect',
+                    code: /* GraphQL */ `
+            type User {
+              firstname: String @deprecated(reason: "Use 'firstName' instead")
+              firstName: String
+            }
+          `,
+                },
+                {
+                    title: 'Correct',
+                    code: /* GraphQL */ `
+            type User {
+              firstname: String @deprecated(reason: "Use 'firstName' instead", deletionDate: "25/12/2022")
+              firstName: String
+            }
+          `,
+                },
+            ],
+        },
+        messages: {
+            [MESSAGE_REQUIRE_DATE]: 'Directive "@deprecated" must have a deletion date.',
+            [MESSAGE_INVALID_FORMAT]: 'Deletion date must be in format "DD/MM/YYYY".',
+            [MESSAGE_INVALID_DATE]: 'Invalid "{{ deletionDate }}" deletion date.',
+            [MESSAGE_CAN_BE_REMOVED]: '"{{ nodeName }}" сan be removed.',
+        },
+        schema: [
+            {
+                type: 'object',
+                additionalProperties: false,
+                properties: {
+                    argumentName: {
+                        type: 'string',
+                    },
+                },
+            },
+        ],
+    },
+    create(context) {
+        return {
+            'Directive[name.value=deprecated]'(node) {
+                var _a;
+                const argName = ((_a = context.options[0]) === null || _a === void 0 ? void 0 : _a.argumentName) || 'deletionDate';
+                const deletionDateNode = node.arguments.find(arg => arg.name.value === argName);
+                if (!deletionDateNode) {
+                    context.report({ node: node.name, messageId: MESSAGE_REQUIRE_DATE });
+                    return;
+                }
+                const deletionDate = valueFromNode(deletionDateNode.value);
+                const isValidDate = DATE_REGEX.test(deletionDate);
+                if (!isValidDate) {
+                    context.report({ node: node.name, messageId: MESSAGE_INVALID_FORMAT });
+                    return;
+                }
+                let [day, month, year] = deletionDate.split('/');
+                day = day.toString().padStart(2, '0');
+                month = month.toString().padStart(2, '0');
+                const deletionDateInMS = Date.parse(`${year}-${month}-${day}`);
+                if (Number.isNaN(deletionDateInMS)) {
+                    context.report({
+                        node: node.name,
+                        messageId: MESSAGE_INVALID_DATE,
+                        data: {
+                            deletionDate,
+                        },
+                    });
+                    return;
+                }
+                const canRemove = Date.now() > deletionDateInMS;
+                if (canRemove) {
+                    context.report({
+                        node: node.name,
+                        messageId: MESSAGE_CAN_BE_REMOVED,
+                        data: {
+                            nodeName: node.parent.name.value,
+                        },
+                    });
+                }
+            },
+        };
+    },
+};
+
+const rule$g = {
     meta: {
         docs: {
             description: `Require all deprecation directives to specify a reason.`,
@@ -1967,11 +2209,11 @@ const rule$e = {
                 if (node && node.name && node.name.value === 'deprecated') {
                     const args = node.arguments || [];
                     const reasonArg = args.find(arg => arg.name && arg.name.value === 'reason');
-                    const value = reasonArg ? String(valueFromNode(reasonArg.value, {}) || '').trim() : null;
+                    const value = reasonArg ? String(valueFromNode(reasonArg.value) || '').trim() : null;
                     if (!value) {
                         context.report({
                             node: node.name,
-                            message: `Directive "@deprecated" must have a reason!`,
+                            message: 'Directive "@deprecated" must have a reason!',
                         });
                     }
                 }
@@ -2015,13 +2257,12 @@ function verifyRule(context, node) {
         }
     }
 }
-const rule$f = {
+const rule$h = {
     meta: {
         docs: {
             category: 'Best Practices',
             description: `Enforce descriptions in your type definitions.`,
             url: `https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/require-description.md`,
-            recommended: true,
             examples: [
                 {
                     title: 'Incorrect',
@@ -2080,6 +2321,74 @@ const rule$f = {
     },
 };
 
+const RULE_NAME$2 = 'require-field-of-type-query-in-mutation-result';
+const rule$i = {
+    meta: {
+        type: 'suggestion',
+        docs: {
+            category: 'Best Practices',
+            description: 'Allow the client in one round-trip not only to call mutation but also to get a wagon of data to update their application.\n> Currently, no errors are reported for result type `union`, `interface` and `scalar`.',
+            url: `https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/${RULE_NAME$2}.md`,
+            requiresSchema: true,
+            examples: [
+                {
+                    title: 'Incorrect',
+                    code: /* GraphQL */ `
+            type User { ... }
+
+            type Mutation {
+              createUser: User!
+            }
+          `,
+                },
+                {
+                    title: 'Correct',
+                    code: /* GraphQL */ `
+            type User { ... }
+
+            type Query { ... }
+
+            type CreateUserPayload {
+              user: User!
+              query: Query!
+            }
+
+            type Mutation {
+              createUser: CreateUserPayload!
+            }
+          `,
+                },
+            ],
+        },
+    },
+    create(context) {
+        const schema = requireGraphQLSchemaFromContext(RULE_NAME$2, context);
+        const mutationType = schema.getMutationType();
+        const queryType = schema.getQueryType();
+        if (!mutationType || !queryType) {
+            return {};
+        }
+        const selector = `:matches(${Kind.OBJECT_TYPE_DEFINITION}, ${Kind.OBJECT_TYPE_EXTENSION})[name.value=${mutationType.name}] > ${Kind.FIELD_DEFINITION}`;
+        return {
+            [selector](node) {
+                const rawNode = node.rawNode();
+                const typeName = getTypeName(rawNode);
+                const graphQLType = schema.getType(typeName);
+                if (isObjectType$1(graphQLType)) {
+                    const { fields } = graphQLType.astNode;
+                    const hasQueryType = fields.some(field => getTypeName(field) === queryType.name);
+                    if (!hasQueryType) {
+                        context.report({
+                            node,
+                            message: `Mutation result type "${graphQLType.name}" must contain field of type "${queryType.name}".`,
+                        });
+                    }
+                }
+            },
+        };
+    },
+};
+
 function convertToESTree(node, typeInfo) {
     const visitor = { leave: convertNode(typeInfo) };
     return {
@@ -2176,7 +2485,7 @@ const convertNode = (typeInfo) => (node, key, parent) => {
 
 const REQUIRE_ID_WHEN_AVAILABLE = 'REQUIRE_ID_WHEN_AVAILABLE';
 const DEFAULT_ID_FIELD_NAME = 'id';
-const rule$g = {
+const rule$j = {
     meta: {
         type: 'suggestion',
         docs: {
@@ -2266,13 +2575,13 @@ const rule$g = {
                                     found = true;
                                 }
                                 else if (selection.kind === 'InlineFragment') {
-                                    found = !!(((_a = selection.selectionSet) === null || _a === void 0 ? void 0 : _a.selections) || []).find(s => s.kind === 'Field' && s.name.value === fieldName);
+                                    found = (((_a = selection.selectionSet) === null || _a === void 0 ? void 0 : _a.selections) || []).some(s => s.kind === 'Field' && s.name.value === fieldName);
                                 }
                                 else if (selection.kind === 'FragmentSpread') {
                                     const foundSpread = siblings.getFragment(selection.name.value);
                                     if (foundSpread[0]) {
                                         checkedFragmentSpreads.add(foundSpread[0].document.name.value);
-                                        found = !!(((_b = foundSpread[0].document.selectionSet) === null || _b === void 0 ? void 0 : _b.selections) || []).find(s => s.kind === 'Field' && s.name.value === fieldName);
+                                        found = (((_b = foundSpread[0].document.selectionSet) === null || _b === void 0 ? void 0 : _b.selections) || []).some(s => s.kind === 'Field' && s.name.value === fieldName);
                                     }
                                 }
                                 if (found) {
@@ -2284,7 +2593,7 @@ const rule$g = {
                                 parent.kind === 'InlineFragment' &&
                                 parent.parent &&
                                 parent.parent.kind === 'SelectionSet' &&
-                                !!parent.parent.selections.find(s => s.kind === 'Field' && s.name.value === fieldName);
+                                parent.parent.selections.some(s => s.kind === 'Field' && s.name.value === fieldName);
                             if (!found && !hasIdFieldInInterfaceSelectionSet) {
                                 context.report({
                                     loc: {
@@ -2312,7 +2621,7 @@ const rule$g = {
     },
 };
 
-const rule$h = {
+const rule$k = {
     meta: {
         docs: {
             category: 'Best Practices',
@@ -2426,7 +2735,7 @@ const rule$h = {
 
 const shouldIgnoreNode = ({ node, exceptions }) => {
     const rawNode = node.rawNode();
-    if (exceptions.types && exceptions.types.some(type => rawNode.name.value === type)) {
+    if (exceptions.types && exceptions.types.includes(rawNode.name.value)) {
         return true;
     }
     if (exceptions.suffixes && exceptions.suffixes.some(suffix => rawNode.name.value.endsWith(suffix))) {
@@ -2434,7 +2743,7 @@ const shouldIgnoreNode = ({ node, exceptions }) => {
     }
     return false;
 };
-const rule$i = {
+const rule$l = {
     meta: {
         type: 'suggestion',
         docs: {
@@ -2584,7 +2893,7 @@ const rule$i = {
     },
 };
 
-const RULE_NAME$2 = 'unique-fragment-name';
+const RULE_NAME$3 = 'unique-fragment-name';
 const UNIQUE_FRAGMENT_NAME = 'UNIQUE_FRAGMENT_NAME';
 const checkNode = (context, node, ruleName, messageId) => {
     var _a;
@@ -2624,13 +2933,13 @@ const checkNode = (context, node, ruleName, messageId) => {
         });
     }
 };
-const rule$j = {
+const rule$m = {
     meta: {
         type: 'suggestion',
         docs: {
             category: 'Best Practices',
             description: `Enforce unique fragment names across your project.`,
-            url: `https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/${RULE_NAME$2}.md`,
+            url: `https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/${RULE_NAME$3}.md`,
             requiresSiblings: true,
             examples: [
                 {
@@ -2674,21 +2983,21 @@ const rule$j = {
     create(context) {
         return {
             FragmentDefinition(node) {
-                checkNode(context, node, RULE_NAME$2, UNIQUE_FRAGMENT_NAME);
+                checkNode(context, node, RULE_NAME$3, UNIQUE_FRAGMENT_NAME);
             },
         };
     },
 };
 
-const RULE_NAME$3 = 'unique-operation-name';
+const RULE_NAME$4 = 'unique-operation-name';
 const UNIQUE_OPERATION_NAME = 'UNIQUE_OPERATION_NAME';
-const rule$k = {
+const rule$n = {
     meta: {
         type: 'suggestion',
         docs: {
             category: 'Best Practices',
             description: `Enforce unique operation names across your project.`,
-            url: `https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/${RULE_NAME$3}.md`,
+            url: `https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/${RULE_NAME$4}.md`,
             requiresSiblings: true,
             examples: [
                 {
@@ -2736,35 +3045,41 @@ const rule$k = {
     create(context) {
         return {
             OperationDefinition(node) {
-                checkNode(context, node, RULE_NAME$3, UNIQUE_OPERATION_NAME);
+                checkNode(context, node, RULE_NAME$4, UNIQUE_OPERATION_NAME);
             },
         };
     },
 };
 
+/*
+ * 🚨 IMPORTANT! Do not manually modify this file. Run: `yarn generate-configs`
+ */
 const rules = {
+    ...GRAPHQL_JS_VALIDATIONS,
     'avoid-duplicate-fields': rule,
     'avoid-operation-name-prefix': rule$1,
-    'avoid-typename-prefix': rule$2,
-    'description-style': rule$3,
-    'input-name': rule$4,
-    'match-document-filename': rule$5,
-    'naming-convention': rule$6,
-    'no-anonymous-operations': rule$7,
-    'no-case-insensitive-enum-values-duplicates': rule$8,
-    'no-deprecated': rule$9,
-    'no-hashtag-description': rule$a,
-    'no-operation-name-suffix': rule$b,
-    'no-unreachable-types': rule$c,
-    'no-unused-fields': rule$d,
-    'require-deprecation-reason': rule$e,
-    'require-description': rule$f,
-    'require-id-when-available': rule$g,
-    'selection-set-depth': rule$h,
-    'strict-id-in-types': rule$i,
-    'unique-fragment-name': rule$j,
-    'unique-operation-name': rule$k,
-    ...GRAPHQL_JS_VALIDATIONS,
+    'avoid-scalar-result-type-on-mutation': rule$2,
+    'avoid-typename-prefix': rule$3,
+    'description-style': rule$4,
+    'input-name': rule$5,
+    'match-document-filename': rule$6,
+    'naming-convention': rule$7,
+    'no-anonymous-operations': rule$8,
+    'no-case-insensitive-enum-values-duplicates': rule$9,
+    'no-deprecated': rule$a,
+    'no-hashtag-description': rule$b,
+    'no-operation-name-suffix': rule$c,
+    'no-unreachable-types': rule$d,
+    'no-unused-fields': rule$e,
+    'require-deprecation-date': rule$f,
+    'require-deprecation-reason': rule$g,
+    'require-description': rule$h,
+    'require-field-of-type-query-in-mutation-result': rule$i,
+    'require-id-when-available': rule$j,
+    'selection-set-depth': rule$k,
+    'strict-id-in-types': rule$l,
+    'unique-fragment-name': rule$m,
+    'unique-operation-name': rule$n,
 };
 
 const RELEVANT_KEYWORDS = ['gql', 'graphql', '/* GraphQL */'];
@@ -3041,7 +3356,6 @@ function getReachableTypes(schema) {
         return reachableTypesCache;
     }
     const reachableTypes = new Set();
-    const getTypeName = node => ('type' in node ? getTypeName(node.type) : node.name.value);
     const collect = (node) => {
         const typeName = getTypeName(node);
         if (reachableTypes.has(typeName)) {
@@ -3177,4 +3491,4 @@ class GraphQLRuleTester extends require('eslint').RuleTester {
     }
 }
 
-export { GraphQLRuleTester, convertDescription, convertLocation, convertRange, convertToESTree, extractCommentsFromAst, getBaseType, isNodeWithDescription, parse, parseForESLint, processors, rules, valueFromNode };
+export { GraphQLRuleTester, configs, convertDescription, convertLocation, convertRange, convertToESTree, extractCommentsFromAst, getBaseType, isNodeWithDescription, parse, parseForESLint, processors, rules, valueFromNode };