@graphql-eslint/eslint-plugin 3.14.0-alpha-20221220004017-f1f0904 → 3.14.0-alpha-20221220160018-ba4832c

package/index.mjs

@@ -1,5 +1,5 @@
 import { gqlPluckFromCodeStringSync } from '@graphql-tools/graphql-tag-pluck';
-import { asArray, getDocumentNodeFromSchema, parseGraphQLSDL } from '@graphql-tools/utils';
+import { asArray, getDocumentNodeFromSchema, getRootTypeNames, parseGraphQLSDL } from '@graphql-tools/utils';
 import { dirname, extname, basename, relative, resolve } from 'path';
 import debugFactory from 'debug';
 import { loadConfigSync, GraphQLConfig } from 'graphql-config';
@@ -328,7 +328,7 @@ const validationToRule = ({ ruleId, ruleName, getDocumentNode, schema = [], hasD
                     ...docs,
                     graphQLJSRuleName: ruleName,
                     url: `https://github.com/B2o5T/graphql-eslint/blob/master/docs/rules/${ruleId}.md`,
-                    description: `${docs.description}\n\n> This rule is a wrapper around a \`graphql-js\` validation function.`,
+                    description: `${docs.description}\n> This rule is a wrapper around a \`graphql-js\` validation function.`,
                 },
                 schema,
                 hasSuggestions: hasDidYouMeanSuggestions,
@@ -503,7 +503,7 @@ const GRAPHQL_JS_VALIDATIONS = Object.assign({}, validationToRule({
     ruleName: '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.',
+    description: 'A GraphQL document that contains an anonymous operation (the `query` short-hand) is only valid if it contains only that one operation definition.',
     requiresSchema: true,
 }), validationToRule({
     ruleId: 'lone-schema-definition',
@@ -727,6 +727,58 @@ const argumentsEnum = [
     Kind.DIRECTIVE_DEFINITION,
     Kind.DIRECTIVE,
 ];
+const schema = {
+    type: 'array',
+    minItems: 1,
+    maxItems: 1,
+    items: {
+        type: 'object',
+        additionalProperties: false,
+        minProperties: 1,
+        properties: {
+            fields: {
+                ...ARRAY_DEFAULT_OPTIONS,
+                items: {
+                    enum: fieldsEnum,
+                },
+                description: 'Fields of `type`, `interface`, and `input`.',
+            },
+            values: {
+                ...ARRAY_DEFAULT_OPTIONS,
+                items: {
+                    enum: valuesEnum,
+                },
+                description: 'Values of `enum`.',
+            },
+            selections: {
+                ...ARRAY_DEFAULT_OPTIONS,
+                items: {
+                    enum: selectionsEnum,
+                },
+                description: 'Selections of `fragment` and operations `query`, `mutation` and `subscription`.',
+            },
+            variables: {
+                ...ARRAY_DEFAULT_OPTIONS,
+                items: {
+                    enum: variablesEnum,
+                },
+                description: 'Variables of operations `query`, `mutation` and `subscription`.',
+            },
+            arguments: {
+                ...ARRAY_DEFAULT_OPTIONS,
+                items: {
+                    enum: argumentsEnum,
+                },
+                description: 'Arguments of fields and directives.',
+            },
+            definitions: {
+                type: 'boolean',
+                description: 'Definitions – `type`, `interface`, `enum`, `scalar`, `input`, `union` and `directive`.',
+                default: false,
+            },
+        },
+    },
+};
 const rule = {
     meta: {
         type: 'suggestion',
@@ -833,58 +885,7 @@ const rule = {
         messages: {
             [RULE_ID]: '`{{ currName }}` should be before {{ prevName }}.',
         },
-        schema: {
-            type: 'array',
-            minItems: 1,
-            maxItems: 1,
-            items: {
-                type: 'object',
-                additionalProperties: false,
-                minProperties: 1,
-                properties: {
-                    fields: {
-                        ...ARRAY_DEFAULT_OPTIONS,
-                        items: {
-                            enum: fieldsEnum,
-                        },
-                        description: 'Fields of `type`, `interface`, and `input`.',
-                    },
-                    values: {
-                        ...ARRAY_DEFAULT_OPTIONS,
-                        items: {
-                            enum: valuesEnum,
-                        },
-                        description: 'Values of `enum`.',
-                    },
-                    selections: {
-                        ...ARRAY_DEFAULT_OPTIONS,
-                        items: {
-                            enum: selectionsEnum,
-                        },
-                        description: 'Selections of `fragment` and operations `query`, `mutation` and `subscription`.',
-                    },
-                    variables: {
-                        ...ARRAY_DEFAULT_OPTIONS,
-                        items: {
-                            enum: variablesEnum,
-                        },
-                        description: 'Variables of operations `query`, `mutation` and `subscription`.',
-                    },
-                    arguments: {
-                        ...ARRAY_DEFAULT_OPTIONS,
-                        items: {
-                            enum: argumentsEnum,
-                        },
-                        description: 'Arguments of fields and directives.',
-                    },
-                    definitions: {
-                        type: 'boolean',
-                        description: 'Definitions – `type`, `interface`, `enum`, `scalar`, `input`, `union` and `directive`.',
-                        default: false,
-                    },
-                },
-            },
-        },
+        schema,
     },
     create(context) {
         var _a, _b, _c, _d, _e;
@@ -1027,6 +1028,21 @@ const rule = {
     },
 };
 
+const schema$1 = {
+    type: 'array',
+    maxItems: 1,
+    items: {
+        type: 'object',
+        additionalProperties: false,
+        minProperties: 1,
+        properties: {
+            style: {
+                enum: ['block', 'inline'],
+                default: 'block',
+            },
+        },
+    },
+};
 const rule$1 = {
     meta: {
         type: 'suggestion',
@@ -1059,18 +1075,7 @@ const rule$1 = {
             url: 'https://github.com/B2o5T/graphql-eslint/blob/master/docs/rules/description-style.md',
             recommended: true,
         },
-        schema: [
-            {
-                type: 'object',
-                additionalProperties: false,
-                properties: {
-                    style: {
-                        enum: ['block', 'inline'],
-                        default: 'block',
-                    },
-                },
-            },
-        ],
+        schema: schema$1,
     },
     create(context) {
         const { style = 'block' } = context.options[0] || {};
@@ -1099,6 +1104,36 @@ const rule$1 = {
     },
 };
 
+const schema$2 = {
+    type: 'array',
+    maxItems: 1,
+    items: {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+            checkInputType: {
+                type: 'boolean',
+                default: false,
+                description: 'Check that the input type name follows the convention <mutationName>Input',
+            },
+            caseSensitiveInputType: {
+                type: 'boolean',
+                default: true,
+                description: 'Allow for case discrepancies in the input type name',
+            },
+            checkQueries: {
+                type: 'boolean',
+                default: false,
+                description: 'Apply the rule to Queries',
+            },
+            checkMutations: {
+                type: 'boolean',
+                default: true,
+                description: 'Apply the rule to Mutations',
+            },
+        },
+    },
+};
 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';
@@ -1140,34 +1175,7 @@ const rule$2 = {
                 },
             ],
         },
-        schema: [
-            {
-                type: 'object',
-                additionalProperties: false,
-                properties: {
-                    checkInputType: {
-                        type: 'boolean',
-                        default: false,
-                        description: 'Check that the input type name follows the convention <mutationName>Input',
-                    },
-                    caseSensitiveInputType: {
-                        type: 'boolean',
-                        default: true,
-                        description: 'Allow for case discrepancies in the input type name',
-                    },
-                    checkQueries: {
-                        type: 'boolean',
-                        default: false,
-                        description: 'Apply the rule to Queries',
-                    },
-                    checkMutations: {
-                        type: 'boolean',
-                        default: true,
-                        description: 'Apply the rule to Mutations',
-                    },
-                },
-            },
-        ],
+        schema: schema$2,
     },
     create(context) {
         const options = {
@@ -1229,9 +1237,92 @@ const rule$2 = {
     },
 };
 
+const RULE_ID$1 = 'lone-executable-definition';
+const schema$3 = {
+    type: 'array',
+    maxItems: 1,
+    items: {
+        type: 'object',
+        minProperties: 1,
+        additionalProperties: false,
+        properties: {
+            ignore: {
+                ...ARRAY_DEFAULT_OPTIONS,
+                maxItems: 3,
+                items: {
+                    enum: ['fragment', 'query', 'mutation', 'subscription'],
+                },
+                description: 'Allow certain definitions to be placed alongside others.',
+            },
+        },
+    },
+};
+const rule$3 = {
+    meta: {
+        type: 'suggestion',
+        docs: {
+            category: 'Operations',
+            description: 'Require all queries, mutations, subscriptions and fragments to be located in separate files.',
+            url: `https://github.com/B2o5T/graphql-eslint/blob/master/docs/rules/${RULE_ID$1}.md`,
+            examples: [
+                {
+                    title: 'Incorrect',
+                    code: /* GraphQL */ `
+            query Foo {
+              id
+            }
+            fragment Bar on Baz {
+              id
+            }
+          `,
+                },
+                {
+                    title: 'Correct',
+                    code: /* GraphQL */ `
+            query Foo {
+              id
+            }
+          `,
+                },
+            ],
+        },
+        messages: {
+            [RULE_ID$1]: '{{name}} should be in a separate file.',
+        },
+        schema: schema$3,
+    },
+    create(context) {
+        var _a;
+        const ignore = new Set(((_a = context.options[0]) === null || _a === void 0 ? void 0 : _a.ignore) || []);
+        const definitions = [];
+        return {
+            ':matches(OperationDefinition, FragmentDefinition)'(node) {
+                const type = 'operation' in node ? node.operation : 'fragment';
+                if (!ignore.has(type)) {
+                    definitions.push({ type, node });
+                }
+            },
+            'Program:exit'() {
+                var _a, _b;
+                for (const { node, type } of definitions.slice(1) /* ignore first definition */) {
+                    let name = pascalCase(type);
+                    const definitionName = (_a = node.name) === null || _a === void 0 ? void 0 : _a.value;
+                    if (definitionName) {
+                        name += ` "${definitionName}"`;
+                    }
+                    context.report({
+                        loc: ((_b = node.name) === null || _b === void 0 ? void 0 : _b.loc) || getLocation(node.loc.start, type),
+                        messageId: RULE_ID$1,
+                        data: { name },
+                    });
+                }
+            },
+        };
+    },
+};
+
 const MATCH_EXTENSION = 'MATCH_EXTENSION';
 const MATCH_STYLE = 'MATCH_STYLE';
-const ACCEPTED_EXTENSIONS = ['.gql', '.graphql'];
 const CASE_STYLES = [
     'camelCase',
     'PascalCase',
@@ -1243,7 +1334,39 @@ const CASE_STYLES = [
 const schemaOption = {
     oneOf: [{ $ref: '#/definitions/asString' }, { $ref: '#/definitions/asObject' }],
 };
-const rule$3 = {
+const schema$4 = {
+    definitions: {
+        asString: {
+            enum: CASE_STYLES,
+            description: `One of: ${CASE_STYLES.map(t => `\`${t}\``).join(', ')}`,
+        },
+        asObject: {
+            type: 'object',
+            additionalProperties: false,
+            minProperties: 1,
+            properties: {
+                style: { enum: CASE_STYLES },
+                suffix: { type: 'string' },
+            },
+        },
+    },
+    type: 'array',
+    minItems: 1,
+    maxItems: 1,
+    items: {
+        type: 'object',
+        additionalProperties: false,
+        minProperties: 1,
+        properties: {
+            fileExtension: { enum: ['.gql', '.graphql'] },
+            query: schemaOption,
+            mutation: schemaOption,
+            subscription: schemaOption,
+            fragment: schemaOption,
+        },
+    },
+};
+const rule$4 = {
     meta: {
         type: 'suggestion',
         docs: {
@@ -1334,38 +1457,7 @@ const rule$3 = {
             [MATCH_EXTENSION]: 'File extension "{{ fileExtension }}" don\'t match extension "{{ expectedFileExtension }}"',
             [MATCH_STYLE]: 'Unexpected filename "{{ filename }}". Rename it to "{{ expectedFilename }}"',
         },
-        schema: {
-            definitions: {
-                asString: {
-                    enum: CASE_STYLES,
-                    description: `One of: ${CASE_STYLES.map(t => `\`${t}\``).join(', ')}`,
-                },
-                asObject: {
-                    type: 'object',
-                    additionalProperties: false,
-                    minProperties: 1,
-                    properties: {
-                        style: { enum: CASE_STYLES },
-                        suffix: { type: 'string' },
-                    },
-                },
-            },
-            type: 'array',
-            minItems: 1,
-            maxItems: 1,
-            items: {
-                type: 'object',
-                additionalProperties: false,
-                minProperties: 1,
-                properties: {
-                    fileExtension: { enum: ACCEPTED_EXTENSIONS },
-                    query: schemaOption,
-                    mutation: schemaOption,
-                    subscription: schemaOption,
-                    fragment: schemaOption,
-                },
-            },
-        },
+        schema: schema$4,
     },
     create(context) {
         const options = context.options[0] || {
@@ -1467,7 +1559,67 @@ const ALLOWED_STYLES = Object.keys(StyleToRegex);
 const schemaOption$1 = {
     oneOf: [{ $ref: '#/definitions/asString' }, { $ref: '#/definitions/asObject' }],
 };
-const rule$4 = {
+const schema$5 = {
+    definitions: {
+        asString: {
+            enum: ALLOWED_STYLES,
+            description: `One of: ${ALLOWED_STYLES.map(t => `\`${t}\``).join(', ')}`,
+        },
+        asObject: {
+            type: 'object',
+            additionalProperties: false,
+            properties: {
+                style: { enum: ALLOWED_STYLES },
+                prefix: { type: 'string' },
+                suffix: { type: 'string' },
+                forbiddenPrefixes: ARRAY_DEFAULT_OPTIONS,
+                forbiddenSuffixes: ARRAY_DEFAULT_OPTIONS,
+                ignorePattern: {
+                    type: 'string',
+                    description: 'Option to skip validation of some words, e.g. acronyms',
+                },
+            },
+        },
+    },
+    type: 'array',
+    maxItems: 1,
+    items: {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+            types: {
+                ...schemaOption$1,
+                description: `Includes:\n${TYPES_KINDS.map(kind => `- \`${kind}\``).join('\n')}`,
+            },
+            ...Object.fromEntries(ALLOWED_KINDS.map(kind => [
+                kind,
+                {
+                    ...schemaOption$1,
+                    description: `Read more about this kind on [spec.graphql.org](https://spec.graphql.org/October2021/#${kind}).`,
+                },
+            ])),
+            allowLeadingUnderscore: {
+                type: 'boolean',
+                default: false,
+            },
+            allowTrailingUnderscore: {
+                type: 'boolean',
+                default: false,
+            },
+        },
+        patternProperties: {
+            [`^(${ALLOWED_KINDS.join('|')})(.+)?$`]: schemaOption$1,
+        },
+        description: [
+            "> It's possible to use a [`selector`](https://eslint.org/docs/developer-guide/selectors) that starts with allowed `ASTNode` names which are described below.",
+            '>',
+            '> Paste or drop code into the editor in [ASTExplorer](https://astexplorer.net) and inspect the generated AST to compose your selector.',
+            '>',
+            '> Example: pattern property `FieldDefinition[parent.name.value=Query]` will match only fields for type `Query`.',
+        ].join('\n'),
+    },
+};
+const rule$5 = {
     meta: {
         type: 'suggestion',
         docs: {
@@ -1583,66 +1735,7 @@ const rule$4 = {
             },
         },
         hasSuggestions: true,
-        schema: {
-            definitions: {
-                asString: {
-                    enum: ALLOWED_STYLES,
-                    description: `One of: ${ALLOWED_STYLES.map(t => `\`${t}\``).join(', ')}`,
-                },
-                asObject: {
-                    type: 'object',
-                    additionalProperties: false,
-                    properties: {
-                        style: { enum: ALLOWED_STYLES },
-                        prefix: { type: 'string' },
-                        suffix: { type: 'string' },
-                        forbiddenPrefixes: ARRAY_DEFAULT_OPTIONS,
-                        forbiddenSuffixes: ARRAY_DEFAULT_OPTIONS,
-                        ignorePattern: {
-                            type: 'string',
-                            description: 'Option to skip validation of some words, e.g. acronyms',
-                        },
-                    },
-                },
-            },
-            type: 'array',
-            maxItems: 1,
-            items: {
-                type: 'object',
-                additionalProperties: false,
-                properties: {
-                    types: {
-                        ...schemaOption$1,
-                        description: `Includes:\n\n${TYPES_KINDS.map(kind => `- \`${kind}\``).join('\n')}`,
-                    },
-                    ...Object.fromEntries(ALLOWED_KINDS.map(kind => [
-                        kind,
-                        {
-                            ...schemaOption$1,
-                            description: `Read more about this kind on [spec.graphql.org](https://spec.graphql.org/October2021/#${kind}).`,
-                        },
-                    ])),
-                    allowLeadingUnderscore: {
-                        type: 'boolean',
-                        default: false,
-                    },
-                    allowTrailingUnderscore: {
-                        type: 'boolean',
-                        default: false,
-                    },
-                },
-                patternProperties: {
-                    [`^(${ALLOWED_KINDS.join('|')})(.+)?$`]: schemaOption$1,
-                },
-                description: [
-                    "> It's possible to use a [`selector`](https://eslint.org/docs/developer-guide/selectors) that starts with allowed `ASTNode` names which are described below.",
-                    '>',
-                    '> Paste or drop code into the editor in [ASTExplorer](https://astexplorer.net) and inspect the generated AST to compose your selector.',
-                    '>',
-                    '> Example: pattern property `FieldDefinition[parent.name.value=Query]` will match only fields for type `Query`.',
-                ].join('\n'),
-            },
-        },
+        schema: schema$5,
     },
     create(context) {
         const options = context.options[0] || {};
@@ -1742,8 +1835,8 @@ const rule$4 = {
     },
 };
 
-const RULE_ID$1 = 'no-anonymous-operations';
-const rule$5 = {
+const RULE_ID$2 = 'no-anonymous-operations';
+const rule$6 = {
     meta: {
         type: 'suggestion',
         hasSuggestions: true,
@@ -1751,7 +1844,7 @@ const rule$5 = {
             category: 'Operations',
             description: 'Require name for your GraphQL operations. This is useful since most GraphQL client libraries are using the operation name for caching purposes.',
             recommended: true,
-            url: `https://github.com/B2o5T/graphql-eslint/blob/master/docs/rules/${RULE_ID$1}.md`,
+            url: `https://github.com/B2o5T/graphql-eslint/blob/master/docs/rules/${RULE_ID$2}.md`,
             examples: [
                 {
                     title: 'Incorrect',
@@ -1772,7 +1865,7 @@ const rule$5 = {
             ],
         },
         messages: {
-            [RULE_ID$1]: 'Anonymous GraphQL operations are forbidden. Make sure to name your {{ operation }}!',
+            [RULE_ID$2]: 'Anonymous GraphQL operations are forbidden. Make sure to name your {{ operation }}!',
         },
         schema: [],
     },
@@ -1785,7 +1878,7 @@ const rule$5 = {
                     : node.operation;
                 context.report({
                     loc: getLocation(node.loc.start, node.operation),
-                    messageId: RULE_ID$1,
+                    messageId: RULE_ID$2,
                     data: {
                         operation: node.operation,
                     },
@@ -1805,7 +1898,7 @@ const rule$5 = {
     },
 };
 
-const rule$6 = {
+const rule$7 = {
     meta: {
         type: 'suggestion',
         hasSuggestions: true,
@@ -1863,15 +1956,15 @@ const rule$6 = {
     },
 };
 
-const RULE_ID$2 = 'no-deprecated';
-const rule$7 = {
+const RULE_ID$3 = 'no-deprecated';
+const rule$8 = {
     meta: {
         type: 'suggestion',
         hasSuggestions: true,
         docs: {
             category: 'Operations',
             description: 'Enforce that deprecated fields or enum values are not in use by operations.',
-            url: `https://github.com/B2o5T/graphql-eslint/blob/master/docs/rules/${RULE_ID$2}.md`,
+            url: `https://github.com/B2o5T/graphql-eslint/blob/master/docs/rules/${RULE_ID$3}.md`,
             requiresSchema: true,
             examples: [
                 {
@@ -1938,18 +2031,18 @@ const rule$7 = {
             recommended: true,
         },
         messages: {
-            [RULE_ID$2]: 'This {{ type }} is marked as deprecated in your GraphQL schema (reason: {{ reason }})',
+            [RULE_ID$3]: 'This {{ type }} is marked as deprecated in your GraphQL schema (reason: {{ reason }})',
         },
         schema: [],
     },
     create(context) {
-        requireGraphQLSchemaFromContext(RULE_ID$2, context);
+        requireGraphQLSchemaFromContext(RULE_ID$3, context);
         function report(node, reason) {
             const nodeName = node.kind === Kind.ENUM ? node.value : node.name.value;
             const nodeType = node.kind === Kind.ENUM ? 'enum value' : 'field';
             context.report({
                 node,
-                messageId: RULE_ID$2,
+                messageId: RULE_ID$3,
                 data: {
                     type: nodeType,
                     reason,
@@ -1983,15 +2076,15 @@ const rule$7 = {
     },
 };
 
-const RULE_ID$3 = 'no-duplicate-fields';
-const rule$8 = {
+const RULE_ID$4 = 'no-duplicate-fields';
+const rule$9 = {
     meta: {
         type: 'suggestion',
         hasSuggestions: true,
         docs: {
             description: 'Checks for duplicate fields in selection set, variables in operation definition, or in arguments set of a field.',
             category: 'Operations',
-            url: `https://github.com/B2o5T/graphql-eslint/blob/master/docs/rules/${RULE_ID$3}.md`,
+            url: `https://github.com/B2o5T/graphql-eslint/blob/master/docs/rules/${RULE_ID$4}.md`,
             recommended: true,
             examples: [
                 {
@@ -2037,7 +2130,7 @@ const rule$8 = {
             ],
         },
         messages: {
-            [RULE_ID$3]: '{{ type }} `{{ fieldName }}` defined multiple times.',
+            [RULE_ID$4]: '{{ type }} `{{ fieldName }}` defined multiple times.',
         },
         schema: [],
     },
@@ -2048,7 +2141,7 @@ const rule$8 = {
                 const { parent } = node;
                 context.report({
                     node,
-                    messageId: RULE_ID$3,
+                    messageId: RULE_ID$4,
                     data: {
                         type: parent.type,
                         fieldName,
@@ -2093,7 +2186,7 @@ const rule$8 = {
 };
 
 const HASHTAG_COMMENT = 'HASHTAG_COMMENT';
-const rule$9 = {
+const rule$a = {
     meta: {
         type: 'suggestion',
         hasSuggestions: true,
@@ -2178,8 +2271,25 @@ const rule$9 = {
     },
 };
 
-const ROOT_TYPES = ['mutation', 'subscription'];
-const rule$a = {
+const schema$6 = {
+    type: 'array',
+    minItems: 1,
+    maxItems: 1,
+    items: {
+        type: 'object',
+        additionalProperties: false,
+        required: ['disallow'],
+        properties: {
+            disallow: {
+                ...ARRAY_DEFAULT_OPTIONS,
+                items: {
+                    enum: ['mutation', 'subscription'],
+                },
+            },
+        },
+    },
+};
+const rule$b = {
     meta: {
         type: 'suggestion',
         hasSuggestions: true,
@@ -2210,24 +2320,7 @@ const rule$a = {
                 },
             ],
         },
-        schema: {
-            type: 'array',
-            minItems: 1,
-            maxItems: 1,
-            items: {
-                type: 'object',
-                additionalProperties: false,
-                required: ['disallow'],
-                properties: {
-                    disallow: {
-                        ...ARRAY_DEFAULT_OPTIONS,
-                        items: {
-                            enum: ROOT_TYPES,
-                        },
-                    },
-                },
-            },
-        },
+        schema: schema$6,
     },
     create(context) {
         const schema = requireGraphQLSchemaFromContext('no-root-type', context);
@@ -2261,15 +2354,15 @@ const rule$a = {
     },
 };
 
-const RULE_ID$4 = 'no-scalar-result-type-on-mutation';
-const rule$b = {
+const RULE_ID$5 = 'no-scalar-result-type-on-mutation';
+const rule$c = {
     meta: {
         type: 'suggestion',
         hasSuggestions: true,
         docs: {
             category: 'Schema',
             description: 'Avoid scalar result type on mutation type to make sure to return a valid state.',
-            url: `https://github.com/B2o5T/graphql-eslint/blob/master/docs/rules/${RULE_ID$4}.md`,
+            url: `https://github.com/B2o5T/graphql-eslint/blob/master/docs/rules/${RULE_ID$5}.md`,
             requiresSchema: true,
             examples: [
                 {
@@ -2293,7 +2386,7 @@ const rule$b = {
         schema: [],
     },
     create(context) {
-        const schema = requireGraphQLSchemaFromContext(RULE_ID$4, context);
+        const schema = requireGraphQLSchemaFromContext(RULE_ID$5, context);
         const mutationType = schema.getMutationType();
         if (!mutationType) {
             return {};
@@ -2324,7 +2417,7 @@ const rule$b = {
 };
 
 const NO_TYPENAME_PREFIX = 'NO_TYPENAME_PREFIX';
-const rule$c = {
+const rule$d = {
     meta: {
         type: 'suggestion',
         hasSuggestions: true,
@@ -2386,7 +2479,7 @@ const rule$c = {
     },
 };
 
-const RULE_ID$5 = 'no-unreachable-types';
+const RULE_ID$6 = 'no-unreachable-types';
 const KINDS = [
     Kind.DIRECTIVE_DEFINITION,
     Kind.OBJECT_TYPE_DEFINITION,
@@ -2466,15 +2559,15 @@ function getReachableTypes(schema) {
     reachableTypesCache = reachableTypes;
     return reachableTypesCache;
 }
-const rule$d = {
+const rule$e = {
     meta: {
         messages: {
-            [RULE_ID$5]: '{{ type }} `{{ typeName }}` is unreachable.',
+            [RULE_ID$6]: '{{ type }} `{{ typeName }}` is unreachable.',
         },
         docs: {
             description: 'Requires all types to be reachable at some level by root level fields.',
             category: 'Schema',
-            url: `https://github.com/B2o5T/graphql-eslint/blob/master/docs/rules/${RULE_ID$5}.md`,
+            url: `https://github.com/B2o5T/graphql-eslint/blob/master/docs/rules/${RULE_ID$6}.md`,
             requiresSchema: true,
             examples: [
                 {
@@ -2511,7 +2604,7 @@ const rule$d = {
         hasSuggestions: true,
     },
     create(context) {
-        const schema = requireGraphQLSchemaFromContext(RULE_ID$5, context);
+        const schema = requireGraphQLSchemaFromContext(RULE_ID$6, context);
         const reachableTypes = getReachableTypes(schema);
         return {
             [`:matches(${KINDS}) > .name`](node) {
@@ -2520,7 +2613,7 @@ const rule$d = {
                     const type = lowerCase(node.parent.kind.replace(/(Extension|Definition)$/, ''));
                     context.report({
                         node,
-                        messageId: RULE_ID$5,
+                        messageId: RULE_ID$6,
                         data: {
                             type: type[0].toUpperCase() + type.slice(1),
                             typeName,
@@ -2538,7 +2631,7 @@ const rule$d = {
     },
 };
 
-const RULE_ID$6 = 'no-unused-fields';
+const RULE_ID$7 = 'no-unused-fields';
 let usedFieldsCache;
 function getUsedFields(schema, operations) {
     // We don't want cache usedFields on test environment
@@ -2569,15 +2662,15 @@ function getUsedFields(schema, operations) {
     usedFieldsCache = usedFields;
     return usedFieldsCache;
 }
-const rule$e = {
+const rule$f = {
     meta: {
         messages: {
-            [RULE_ID$6]: 'Field "{{fieldName}}" is unused',
+            [RULE_ID$7]: 'Field "{{fieldName}}" is unused',
         },
         docs: {
             description: 'Requires all fields to be used at some level by siblings operations.',
             category: 'Schema',
-            url: `https://github.com/B2o5T/graphql-eslint/blob/master/docs/rules/${RULE_ID$6}.md`,
+            url: `https://github.com/B2o5T/graphql-eslint/blob/master/docs/rules/${RULE_ID$7}.md`,
             requiresSiblings: true,
             requiresSchema: true,
             isDisabledForAllConfig: true,
@@ -2630,8 +2723,8 @@ const rule$e = {
         hasSuggestions: true,
     },
     create(context) {
-        const schema = requireGraphQLSchemaFromContext(RULE_ID$6, context);
-        const siblingsOperations = requireSiblingsOperations(RULE_ID$6, context);
+        const schema = requireGraphQLSchemaFromContext(RULE_ID$7, context);
+        const siblingsOperations = requireSiblingsOperations(RULE_ID$7, context);
         const usedFields = getUsedFields(schema, siblingsOperations);
         return {
             FieldDefinition(node) {
@@ -2644,7 +2737,7 @@ const rule$e = {
                 }
                 context.report({
                     node: node.name,
-                    messageId: RULE_ID$6,
+                    messageId: RULE_ID$7,
                     data: { fieldName },
                     suggest: [
                         {
@@ -2664,9 +2757,25 @@ const rule$e = {
     },
 };
 
-const RULE_ID$7 = 'relay-arguments';
+const RULE_ID$8 = 'relay-arguments';
 const MISSING_ARGUMENTS = 'MISSING_ARGUMENTS';
-const rule$f = {
+const schema$7 = {
+    type: 'array',
+    maxItems: 1,
+    items: {
+        type: 'object',
+        additionalProperties: false,
+        minProperties: 1,
+        properties: {
+            includeBoth: {
+                type: 'boolean',
+                default: true,
+                description: 'Enforce including both forward and backward pagination arguments',
+            },
+        },
+    },
+};
+const rule$g = {
     meta: {
         type: 'problem',
         docs: {
@@ -2686,7 +2795,7 @@ const rule$f = {
                 '- `last` takes a non-negative integer',
                 '- `before` takes the Cursor type',
             ].join('\n'),
-            url: `https://github.com/B2o5T/graphql-eslint/blob/master/docs/rules/${RULE_ID$7}.md`,
+            url: `https://github.com/B2o5T/graphql-eslint/blob/master/docs/rules/${RULE_ID$8}.md`,
             examples: [
                 {
                     title: 'Incorrect',
@@ -2710,25 +2819,10 @@ const rule$f = {
         messages: {
             [MISSING_ARGUMENTS]: 'A field that returns a Connection type must include forward pagination arguments (`first` and `after`), backward pagination arguments (`last` and `before`), or both.',
         },
-        schema: {
-            type: 'array',
-            maxItems: 1,
-            items: {
-                type: 'object',
-                additionalProperties: false,
-                minProperties: 1,
-                properties: {
-                    includeBoth: {
-                        type: 'boolean',
-                        default: true,
-                        description: 'Enforce including both forward and backward pagination arguments',
-                    },
-                },
-            },
-        },
+        schema: schema$7,
     },
     create(context) {
-        const schema = requireGraphQLSchemaFromContext(RULE_ID$7, context);
+        const schema = requireGraphQLSchemaFromContext(RULE_ID$8, context);
         const { includeBoth = true } = context.options[0] || {};
         return {
             'FieldDefinition > .gqlType Name[value=/Connection$/]'(node) {
@@ -2800,7 +2894,7 @@ const NON_OBJECT_TYPES = [
 const notConnectionTypesSelector = `:matches(${NON_OBJECT_TYPES})[name.value=/Connection$/] > .name`;
 const hasEdgesField = (node) => node.fields.some(field => field.name.value === 'edges');
 const hasPageInfoField = (node) => node.fields.some(field => field.name.value === 'pageInfo');
-const rule$g = {
+const rule$h = {
     meta: {
         type: 'problem',
         docs: {
@@ -2884,7 +2978,7 @@ const rule$g = {
     },
 };
 
-const RULE_ID$8 = 'relay-edge-types';
+const RULE_ID$9 = 'relay-edge-types';
 const MESSAGE_MUST_BE_OBJECT_TYPE = 'MESSAGE_MUST_BE_OBJECT_TYPE';
 const MESSAGE_MISSING_EDGE_SUFFIX = 'MESSAGE_MISSING_EDGE_SUFFIX';
 const MESSAGE_LIST_TYPE_ONLY_EDGE_TYPE = 'MESSAGE_LIST_TYPE_ONLY_EDGE_TYPE';
@@ -2919,7 +3013,33 @@ function getEdgeTypes(schema) {
     edgeTypesCache = edgeTypes;
     return edgeTypesCache;
 }
-const rule$h = {
+const schema$8 = {
+    type: 'array',
+    maxItems: 1,
+    items: {
+        type: 'object',
+        additionalProperties: false,
+        minProperties: 1,
+        properties: {
+            withEdgeSuffix: {
+                type: 'boolean',
+                default: true,
+                description: 'Edge type name must end in "Edge".',
+            },
+            shouldImplementNode: {
+                type: 'boolean',
+                default: true,
+                description: "Edge type's field `node` must implement `Node` interface.",
+            },
+            listTypeCanWrapOnlyEdgeType: {
+                type: 'boolean',
+                default: true,
+                description: 'A list type should only wrap an edge type.',
+            },
+        },
+    },
+};
+const rule$i = {
     meta: {
         type: 'problem',
         docs: {
@@ -2935,7 +3055,7 @@ const rule$h = {
                 "- Edge type's field `node` must implement `Node` interface _(optional)_",
                 '- A list type should only wrap an edge type _(optional)_',
             ].join('\n'),
-            url: `https://github.com/B2o5T/graphql-eslint/blob/master/docs/rules/${RULE_ID$8}.md`,
+            url: `https://github.com/B2o5T/graphql-eslint/blob/master/docs/rules/${RULE_ID$9}.md`,
             isDisabledForAllConfig: true,
             requiresSchema: true,
             examples: [
@@ -2956,35 +3076,10 @@ const rule$h = {
             [MESSAGE_LIST_TYPE_ONLY_EDGE_TYPE]: 'A list type should only wrap an edge type.',
             [MESSAGE_SHOULD_IMPLEMENTS_NODE]: "Edge type's field `node` must implement `Node` interface.",
         },
-        schema: {
-            type: 'array',
-            maxItems: 1,
-            items: {
-                type: 'object',
-                additionalProperties: false,
-                minProperties: 1,
-                properties: {
-                    withEdgeSuffix: {
-                        type: 'boolean',
-                        default: true,
-                        description: 'Edge type name must end in "Edge".',
-                    },
-                    shouldImplementNode: {
-                        type: 'boolean',
-                        default: true,
-                        description: "Edge type's field `node` must implement `Node` interface.",
-                    },
-                    listTypeCanWrapOnlyEdgeType: {
-                        type: 'boolean',
-                        default: true,
-                        description: 'A list type should only wrap an edge type.',
-                    },
-                },
-            },
-        },
+        schema: schema$8,
     },
     create(context) {
-        const schema = requireGraphQLSchemaFromContext(RULE_ID$8, context);
+        const schema = requireGraphQLSchemaFromContext(RULE_ID$9, context);
         const edgeTypes = getEdgeTypes(schema);
         const options = {
             withEdgeSuffix: true,
@@ -3067,12 +3162,12 @@ const rule$h = {
     },
 };
 
-const RULE_ID$9 = 'relay-page-info';
+const RULE_ID$a = 'relay-page-info';
 const MESSAGE_MUST_EXIST = 'MESSAGE_MUST_EXIST';
 const MESSAGE_MUST_BE_OBJECT_TYPE$1 = 'MESSAGE_MUST_BE_OBJECT_TYPE';
 const notPageInfoTypesSelector = `:matches(${NON_OBJECT_TYPES})[name.value=PageInfo] > .name`;
 let hasPageInfoChecked = false;
-const rule$i = {
+const rule$j = {
     meta: {
         type: 'problem',
         docs: {
@@ -3084,7 +3179,7 @@ const rule$i = {
                 '- `PageInfo` must contain fields `hasPreviousPage` and `hasNextPage`, that return non-null Boolean',
                 '- `PageInfo` must contain fields `startCursor` and `endCursor`, that return either String or Scalar, which can be null if there are no results',
             ].join('\n'),
-            url: `https://github.com/B2o5T/graphql-eslint/blob/master/docs/rules/${RULE_ID$9}.md`,
+            url: `https://github.com/B2o5T/graphql-eslint/blob/master/docs/rules/${RULE_ID$a}.md`,
             examples: [
                 {
                     title: 'Correct',
@@ -3108,7 +3203,7 @@ const rule$i = {
         schema: [],
     },
     create(context) {
-        const schema = requireGraphQLSchemaFromContext(RULE_ID$9, context);
+        const schema = requireGraphQLSchemaFromContext(RULE_ID$a, context);
         if (process.env.NODE_ENV === 'test' || !hasPageInfoChecked) {
             const pageInfoType = schema.getType('PageInfo');
             if (!pageInfoType) {
@@ -3324,7 +3419,20 @@ 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$j = {
+const schema$9 = {
+    type: 'array',
+    maxItems: 1,
+    items: {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+            argumentName: {
+                type: 'string',
+            },
+        },
+    },
+};
+const rule$k = {
     meta: {
         type: 'suggestion',
         hasSuggestions: true,
@@ -3369,17 +3477,7 @@ const rule$j = {
             [MESSAGE_INVALID_DATE]: 'Invalid "{{ deletionDate }}" deletion date',
             [MESSAGE_CAN_BE_REMOVED]: '"{{ nodeName }}" сan be removed',
         },
-        schema: [
-            {
-                type: 'object',
-                additionalProperties: false,
-                properties: {
-                    argumentName: {
-                        type: 'string',
-                    },
-                },
-            },
-        ],
+        schema: schema$9,
     },
     create(context) {
         return {
@@ -3435,7 +3533,7 @@ const rule$j = {
     },
 };
 
-const rule$k = {
+const rule$l = {
     meta: {
         docs: {
             description: 'Require all deprecation directives to specify a reason.',
@@ -3488,7 +3586,7 @@ const rule$k = {
     },
 };
 
-const RULE_ID$a = 'require-description';
+const RULE_ID$b = 'require-description';
 const ALLOWED_KINDS$1 = [
     ...TYPES_KINDS,
     Kind.DIRECTIVE_DEFINITION,
@@ -3525,12 +3623,40 @@ function getNodeName(node) {
             return node.name ? `${node.operation} ${node.name.value}` : node.operation;
     }
 }
-const rule$l = {
+const schema$a = {
+    type: 'array',
+    minItems: 1,
+    maxItems: 1,
+    items: {
+        type: 'object',
+        additionalProperties: false,
+        minProperties: 1,
+        properties: {
+            types: {
+                type: 'boolean',
+                description: `Includes:\n${TYPES_KINDS.map(kind => `- \`${kind}\``).join('\n')}`,
+            },
+            rootField: {
+                type: 'boolean',
+                description: 'Definitions within `Query`, `Mutation`, and `Subscription` root types.',
+            },
+            ...Object.fromEntries([...ALLOWED_KINDS$1].sort().map(kind => {
+                let description = `Read more about this kind on [spec.graphql.org](https://spec.graphql.org/October2021/#${kind}).`;
+                if (kind === Kind.OPERATION_DEFINITION) {
+                    description +=
+                        '\n> You must use only comment syntax `#` and not description syntax `"""` or `"`.';
+                }
+                return [kind, { type: 'boolean', description }];
+            })),
+        },
+    },
+};
+const rule$m = {
     meta: {
         docs: {
             category: 'Schema',
             description: 'Enforce descriptions in type definitions and operations.',
-            url: `https://github.com/B2o5T/graphql-eslint/blob/master/docs/rules/${RULE_ID$a}.md`,
+            url: `https://github.com/B2o5T/graphql-eslint/blob/master/docs/rules/${RULE_ID$b}.md`,
             examples: [
                 {
                     title: 'Incorrect',
@@ -3564,6 +3690,20 @@ const rule$l = {
             mutation createUser {
               # ...
             }
+          `,
+                },
+                {
+                    title: 'Correct',
+                    usage: [{ rootField: true }],
+                    code: /* GraphQL */ `
+            type Mutation {
+              "Create a new user"
+              createUser: User
+            }
+
+            type User {
+              name: String
+            }
           `,
                 },
             ],
@@ -3571,41 +3711,19 @@ const rule$l = {
                 {
                     types: true,
                     [Kind.DIRECTIVE_DEFINITION]: true,
+                    // rootField: true TODO enable in graphql-eslint v4
                 },
             ],
             recommended: true,
         },
         type: 'suggestion',
         messages: {
-            [RULE_ID$a]: 'Description is required for `{{ nodeName }}`.',
-        },
-        schema: {
-            type: 'array',
-            minItems: 1,
-            maxItems: 1,
-            items: {
-                type: 'object',
-                additionalProperties: false,
-                minProperties: 1,
-                properties: {
-                    types: {
-                        type: 'boolean',
-                        description: `Includes:\n\n${TYPES_KINDS.map(kind => `- \`${kind}\``).join('\n')}`,
-                    },
-                    ...Object.fromEntries([...ALLOWED_KINDS$1].sort().map(kind => {
-                        let description = `Read more about this kind on [spec.graphql.org](https://spec.graphql.org/October2021/#${kind}).`;
-                        if (kind === Kind.OPERATION_DEFINITION) {
-                            description +=
-                                '\n\n> You must use only comment syntax `#` and not description syntax `"""` or `"`.';
-                        }
-                        return [kind, { type: 'boolean', description }];
-                    })),
-                },
-            },
+            [RULE_ID$b]: 'Description is required for `{{ nodeName }}`.',
         },
+        schema: schema$a,
     },
     create(context) {
-        const { types, ...restOptions } = context.options[0] || {};
+        const { types, rootField, ...restOptions } = context.options[0] || {};
         const kinds = new Set(types ? TYPES_KINDS : []);
         for (const [kind, isEnabled] of Object.entries(restOptions)) {
             if (isEnabled) {
@@ -3615,6 +3733,13 @@ const rule$l = {
                 kinds.delete(kind);
             }
         }
+        if (rootField) {
+            const schema = requireGraphQLSchemaFromContext(RULE_ID$b, context);
+            const rootTypeNames = getRootTypeNames(schema);
+            kinds.add(`:matches(ObjectTypeDefinition, ObjectTypeExtension)[name.value=/^(${[
+                ...rootTypeNames,
+            ].join(',')})$/] > FieldDefinition`);
+        }
         const selector = [...kinds].join(',');
         return {
             [selector](node) {
@@ -3638,7 +3763,7 @@ const rule$l = {
                 if (description.length === 0) {
                     context.report({
                         loc: isOperation ? getLocation(node.loc.start, node.operation) : node.name.loc,
-                        messageId: RULE_ID$a,
+                        messageId: RULE_ID$b,
                         data: {
                             nodeName: getNodeName(node),
                         },
@@ -3649,14 +3774,14 @@ const rule$l = {
     },
 };
 
-const RULE_ID$b = 'require-field-of-type-query-in-mutation-result';
-const rule$m = {
+const RULE_ID$c = 'require-field-of-type-query-in-mutation-result';
+const rule$n = {
     meta: {
         type: 'suggestion',
         docs: {
             category: 'Schema',
             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/B2o5T/graphql-eslint/blob/master/docs/rules/${RULE_ID$b}.md`,
+            url: `https://github.com/B2o5T/graphql-eslint/blob/master/docs/rules/${RULE_ID$c}.md`,
             requiresSchema: true,
             examples: [
                 {
@@ -3691,7 +3816,7 @@ const rule$m = {
         schema: [],
     },
     create(context) {
-        const schema = requireGraphQLSchemaFromContext(RULE_ID$b, context);
+        const schema = requireGraphQLSchemaFromContext(RULE_ID$c, context);
         const mutationType = schema.getMutationType();
         const queryType = schema.getQueryType();
         if (!mutationType || !queryType) {
@@ -3717,17 +3842,36 @@ const rule$m = {
     },
 };
 
-const RULE_ID$c = 'require-id-when-available';
+const RULE_ID$d = 'require-id-when-available';
 const DEFAULT_ID_FIELD_NAME = 'id';
-const rule$n = {
+const schema$b = {
+    definitions: {
+        asString: {
+            type: 'string',
+        },
+        asArray: ARRAY_DEFAULT_OPTIONS,
+    },
+    type: 'array',
+    maxItems: 1,
+    items: {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+            fieldName: {
+                oneOf: [{ $ref: '#/definitions/asString' }, { $ref: '#/definitions/asArray' }],
+                default: DEFAULT_ID_FIELD_NAME,
+            },
+        },
+    },
+};
+const rule$o = {
     meta: {
         type: 'suggestion',
-        // eslint-disable-next-line eslint-plugin/require-meta-has-suggestions
         hasSuggestions: true,
         docs: {
             category: 'Operations',
             description: 'Enforce selecting specific fields when they are available on the GraphQL type.',
-            url: `https://github.com/B2o5T/graphql-eslint/blob/master/docs/rules/${RULE_ID$c}.md`,
+            url: `https://github.com/B2o5T/graphql-eslint/blob/master/docs/rules/${RULE_ID$d}.md`,
             requiresSchema: true,
             requiresSiblings: true,
             examples: [
@@ -3777,32 +3921,13 @@ const rule$n = {
             recommended: true,
         },
         messages: {
-            [RULE_ID$c]: "Field{{ pluralSuffix }} {{ fieldName }} must be selected when it's available on a type.\nInclude it in your selection set{{ addition }}.",
-        },
-        schema: {
-            definitions: {
-                asString: {
-                    type: 'string',
-                },
-                asArray: ARRAY_DEFAULT_OPTIONS,
-            },
-            type: 'array',
-            maxItems: 1,
-            items: {
-                type: 'object',
-                additionalProperties: false,
-                properties: {
-                    fieldName: {
-                        oneOf: [{ $ref: '#/definitions/asString' }, { $ref: '#/definitions/asArray' }],
-                        default: DEFAULT_ID_FIELD_NAME,
-                    },
-                },
-            },
+            [RULE_ID$d]: "Field{{ pluralSuffix }} {{ fieldName }} must be selected when it's available on a type.\nInclude it in your selection set{{ addition }}.",
         },
+        schema: schema$b,
     },
     create(context) {
-        const schema = requireGraphQLSchemaFromContext(RULE_ID$c, context);
-        const siblings = requireSiblingsOperations(RULE_ID$c, context);
+        const schema = requireGraphQLSchemaFromContext(RULE_ID$d, context);
+        const siblings = requireSiblingsOperations(RULE_ID$d, context);
         const { fieldName = DEFAULT_ID_FIELD_NAME } = context.options[0] || {};
         const idNames = asArray(fieldName);
         // Check selections only in OperationDefinition,
@@ -3883,7 +4008,7 @@ const rule$n = {
                 : ` or add to used fragment${checkedFragmentSpreads.size > 1 ? 's' : ''} ${englishJoinWords([...checkedFragmentSpreads].map(name => `\`${name}\``))}`;
             const problem = {
                 loc,
-                messageId: RULE_ID$c,
+                messageId: RULE_ID$d,
                 data: {
                     pluralSuffix,
                     fieldName,
@@ -3910,15 +4035,31 @@ const rule$n = {
     },
 };
 
-const RULE_ID$d = 'selection-set-depth';
-const rule$o = {
+const RULE_ID$e = 'selection-set-depth';
+const schema$c = {
+    type: 'array',
+    minItems: 1,
+    maxItems: 1,
+    items: {
+        type: 'object',
+        additionalProperties: false,
+        required: ['maxDepth'],
+        properties: {
+            maxDepth: {
+                type: 'number',
+            },
+            ignore: ARRAY_DEFAULT_OPTIONS,
+        },
+    },
+};
+const rule$p = {
     meta: {
         type: 'suggestion',
         hasSuggestions: true,
         docs: {
             category: 'Operations',
             description: 'Limit the complexity of the GraphQL operations solely by their depth. Based on [graphql-depth-limit](https://npmjs.com/package/graphql-depth-limit).',
-            url: `https://github.com/B2o5T/graphql-eslint/blob/master/docs/rules/${RULE_ID$d}.md`,
+            url: `https://github.com/B2o5T/graphql-eslint/blob/master/docs/rules/${RULE_ID$e}.md`,
             requiresSiblings: true,
             examples: [
                 {
@@ -3964,30 +4105,15 @@ const rule$o = {
             recommended: true,
             configOptions: [{ maxDepth: 7 }],
         },
-        schema: {
-            type: 'array',
-            minItems: 1,
-            maxItems: 1,
-            items: {
-                type: 'object',
-                additionalProperties: false,
-                required: ['maxDepth'],
-                properties: {
-                    maxDepth: {
-                        type: 'number',
-                    },
-                    ignore: ARRAY_DEFAULT_OPTIONS,
-                },
-            },
-        },
+        schema: schema$c,
     },
     create(context) {
         let siblings = null;
         try {
-            siblings = requireSiblingsOperations(RULE_ID$d, context);
+            siblings = requireSiblingsOperations(RULE_ID$e, context);
         }
         catch (_a) {
-            logger.warn(`Rule "${RULE_ID$d}" works best with siblings operations loaded. For more info: https://bit.ly/graphql-eslint-operations`);
+            logger.warn(`Rule "${RULE_ID$e}" works best with siblings operations loaded. For more info: https://bit.ly/graphql-eslint-operations`);
         }
         const { maxDepth, ignore = [] } = context.options[0];
         const checkFn = depthLimit(maxDepth, { ignore });
@@ -4031,22 +4157,54 @@ const rule$o = {
                     });
                 }
                 catch (e) {
-                    logger.warn(`Rule "${RULE_ID$d}" check failed due to a missing siblings operations. For more info: https://bit.ly/graphql-eslint-operations`, e);
+                    logger.warn(`Rule "${RULE_ID$e}" check failed due to a missing siblings operations. For more info: https://bit.ly/graphql-eslint-operations`, e);
                 }
             },
         };
     },
 };
 
-const RULE_ID$e = 'strict-id-in-types';
-const rule$p = {
+const RULE_ID$f = 'strict-id-in-types';
+const schema$d = {
+    type: 'array',
+    maxItems: 1,
+    items: {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+            acceptedIdNames: {
+                ...ARRAY_DEFAULT_OPTIONS,
+                default: ['id'],
+            },
+            acceptedIdTypes: {
+                ...ARRAY_DEFAULT_OPTIONS,
+                default: ['ID'],
+            },
+            exceptions: {
+                type: 'object',
+                additionalProperties: false,
+                properties: {
+                    types: {
+                        ...ARRAY_DEFAULT_OPTIONS,
+                        description: 'This is used to exclude types with names that match one of the specified values.',
+                    },
+                    suffixes: {
+                        ...ARRAY_DEFAULT_OPTIONS,
+                        description: 'This is used to exclude types with names with suffixes that match one of the specified values.',
+                    },
+                },
+            },
+        },
+    },
+};
+const rule$q = {
     meta: {
         type: 'suggestion',
         docs: {
             description: 'Requires output types to have one unique identifier unless they do not have a logical one. Exceptions can be used to ignore output types that do not have unique identifiers.',
             category: 'Schema',
             recommended: true,
-            url: `https://github.com/B2o5T/graphql-eslint/blob/master/docs/rules/${RULE_ID$e}.md`,
+            url: `https://github.com/B2o5T/graphql-eslint/blob/master/docs/rules/${RULE_ID$f}.md`,
             requiresSchema: true,
             examples: [
                 {
@@ -4110,37 +4268,7 @@ const rule$p = {
                 },
             ],
         },
-        schema: {
-            type: 'array',
-            maxItems: 1,
-            items: {
-                type: 'object',
-                additionalProperties: false,
-                properties: {
-                    acceptedIdNames: {
-                        ...ARRAY_DEFAULT_OPTIONS,
-                        default: ['id'],
-                    },
-                    acceptedIdTypes: {
-                        ...ARRAY_DEFAULT_OPTIONS,
-                        default: ['ID'],
-                    },
-                    exceptions: {
-                        type: 'object',
-                        properties: {
-                            types: {
-                                ...ARRAY_DEFAULT_OPTIONS,
-                                description: 'This is used to exclude types with names that match one of the specified values.',
-                            },
-                            suffixes: {
-                                ...ARRAY_DEFAULT_OPTIONS,
-                                description: 'This is used to exclude types with names with suffixes that match one of the specified values.',
-                            },
-                        },
-                    },
-                },
-            },
-        },
+        schema: schema$d,
     },
     create(context) {
         const options = {
@@ -4149,7 +4277,7 @@ const rule$p = {
             exceptions: {},
             ...context.options[0],
         };
-        const schema = requireGraphQLSchemaFromContext(RULE_ID$e, context);
+        const schema = requireGraphQLSchemaFromContext(RULE_ID$f, context);
         const rootTypeNames = [
             schema.getQueryType(),
             schema.getMutationType(),
@@ -4194,7 +4322,7 @@ const rule$p = {
     },
 };
 
-const RULE_ID$f = 'unique-fragment-name';
+const RULE_ID$g = 'unique-fragment-name';
 const checkNode = (context, node, ruleId) => {
     const documentName = node.name.value;
     const siblings = requireSiblingsOperations(ruleId, context);
@@ -4221,13 +4349,13 @@ const checkNode = (context, node, ruleId) => {
         });
     }
 };
-const rule$q = {
+const rule$r = {
     meta: {
         type: 'suggestion',
         docs: {
             category: 'Operations',
             description: 'Enforce unique fragment names across your project.',
-            url: `https://github.com/B2o5T/graphql-eslint/blob/master/docs/rules/${RULE_ID$f}.md`,
+            url: `https://github.com/B2o5T/graphql-eslint/blob/master/docs/rules/${RULE_ID$g}.md`,
             requiresSiblings: true,
             examples: [
                 {
@@ -4265,27 +4393,27 @@ const rule$q = {
             ],
         },
         messages: {
-            [RULE_ID$f]: 'Fragment named "{{ documentName }}" already defined in:\n{{ summary }}',
+            [RULE_ID$g]: 'Fragment named "{{ documentName }}" already defined in:\n{{ summary }}',
         },
         schema: [],
     },
     create(context) {
         return {
             FragmentDefinition(node) {
-                checkNode(context, node, RULE_ID$f);
+                checkNode(context, node, RULE_ID$g);
             },
         };
     },
 };
 
-const RULE_ID$g = 'unique-operation-name';
-const rule$r = {
+const RULE_ID$h = 'unique-operation-name';
+const rule$s = {
     meta: {
         type: 'suggestion',
         docs: {
             category: 'Operations',
             description: 'Enforce unique operation names across your project.',
-            url: `https://github.com/B2o5T/graphql-eslint/blob/master/docs/rules/${RULE_ID$g}.md`,
+            url: `https://github.com/B2o5T/graphql-eslint/blob/master/docs/rules/${RULE_ID$h}.md`,
             requiresSiblings: true,
             examples: [
                 {
@@ -4327,14 +4455,14 @@ const rule$r = {
             ],
         },
         messages: {
-            [RULE_ID$g]: 'Operation named "{{ documentName }}" already defined in:\n{{ summary }}',
+            [RULE_ID$h]: 'Operation named "{{ documentName }}" already defined in:\n{{ summary }}',
         },
         schema: [],
     },
     create(context) {
         return {
             'OperationDefinition[name!=undefined]'(node) {
-                checkNode(context, node, RULE_ID$g);
+                checkNode(context, node, RULE_ID$h);
             },
         };
     },
@@ -4348,31 +4476,32 @@ const rules = {
     alphabetize: rule,
     'description-style': rule$1,
     'input-name': rule$2,
-    'match-document-filename': rule$3,
-    'naming-convention': rule$4,
-    'no-anonymous-operations': rule$5,
-    'no-case-insensitive-enum-values-duplicates': rule$6,
-    'no-deprecated': rule$7,
-    'no-duplicate-fields': rule$8,
-    'no-hashtag-description': rule$9,
-    'no-root-type': rule$a,
-    'no-scalar-result-type-on-mutation': rule$b,
-    'no-typename-prefix': rule$c,
-    'no-unreachable-types': rule$d,
-    'no-unused-fields': rule$e,
-    'relay-arguments': rule$f,
-    'relay-connection-types': rule$g,
-    'relay-edge-types': rule$h,
-    'relay-page-info': rule$i,
-    'require-deprecation-date': rule$j,
-    'require-deprecation-reason': rule$k,
-    'require-description': rule$l,
-    'require-field-of-type-query-in-mutation-result': rule$m,
-    'require-id-when-available': rule$n,
-    'selection-set-depth': rule$o,
-    'strict-id-in-types': rule$p,
-    'unique-fragment-name': rule$q,
-    'unique-operation-name': rule$r,
+    'lone-executable-definition': rule$3,
+    'match-document-filename': rule$4,
+    'naming-convention': rule$5,
+    'no-anonymous-operations': rule$6,
+    'no-case-insensitive-enum-values-duplicates': rule$7,
+    'no-deprecated': rule$8,
+    'no-duplicate-fields': rule$9,
+    'no-hashtag-description': rule$a,
+    'no-root-type': rule$b,
+    'no-scalar-result-type-on-mutation': rule$c,
+    'no-typename-prefix': rule$d,
+    'no-unreachable-types': rule$e,
+    'no-unused-fields': rule$f,
+    'relay-arguments': rule$g,
+    'relay-connection-types': rule$h,
+    'relay-edge-types': rule$i,
+    'relay-page-info': rule$j,
+    'require-deprecation-date': rule$k,
+    'require-deprecation-reason': rule$l,
+    'require-description': rule$m,
+    'require-field-of-type-query-in-mutation-result': rule$n,
+    'require-id-when-available': rule$o,
+    'selection-set-depth': rule$p,
+    'strict-id-in-types': rule$q,
+    'unique-fragment-name': rule$r,
+    'unique-operation-name': rule$s,
 };
 
 // Based on the `eslint-plugin-import`'s cache