@graphql-eslint/eslint-plugin 2.5.0-alpha-14532ce.0 → 3.0.0-alpha-069461d.0

package/index.mjs

@@ -29,7 +29,34 @@ const recommendedConfig = {
         '@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/naming-convention': [
+            'error',
+            {
+                types: 'PascalCase',
+                fields: 'camelCase',
+                overrides: {
+                    EnumValueDefinition: 'UPPER_CASE',
+                    OperationDefinition: {
+                        style: 'PascalCase',
+                        forbiddenPrefixes: ['Query', 'Mutation', 'Subscription', 'Get'],
+                        forbiddenSuffixes: ['Query', 'Mutation', 'Subscription'],
+                    },
+                    FragmentDefinition: { style: 'PascalCase', forbiddenPrefixes: ['Fragment'], forbiddenSuffixes: ['Fragment'] },
+                    'FieldDefinition[parent.name.value=Query]': {
+                        forbiddenPrefixes: ['query', 'get'],
+                        forbiddenSuffixes: ['Query'],
+                    },
+                    'FieldDefinition[parent.name.value=Mutation]': {
+                        forbiddenPrefixes: ['mutation'],
+                        forbiddenSuffixes: ['Mutation'],
+                    },
+                    'FieldDefinition[parent.name.value=Subscription]': {
+                        forbiddenPrefixes: ['subscription'],
+                        forbiddenSuffixes: ['Subscription'],
+                    },
+                },
+            },
+        ],
         '@graphql-eslint/no-anonymous-operations': 'error',
         '@graphql-eslint/no-case-insensitive-enum-values-duplicates': 'error',
         '@graphql-eslint/no-fragment-cycles': 'error',
@@ -85,6 +112,7 @@ const allConfig = {
         '@graphql-eslint/match-document-filename': 'error',
         '@graphql-eslint/no-deprecated': 'error',
         '@graphql-eslint/no-hashtag-description': 'error',
+        '@graphql-eslint/no-root-type': ['error', { disallow: ['subscription'] }],
         '@graphql-eslint/no-unreachable-types': 'error',
         '@graphql-eslint/no-unused-fields': 'error',
         '@graphql-eslint/require-deprecation-date': 'error',
@@ -205,9 +233,14 @@ const loaderCache = new Proxy(Object.create(null), {
         return true;
     },
 });
-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';
+const TYPES_KINDS = [
+    Kind.OBJECT_TYPE_DEFINITION,
+    Kind.INTERFACE_TYPE_DEFINITION,
+    Kind.ENUM_TYPE_DEFINITION,
+    Kind.SCALAR_TYPE_DEFINITION,
+    Kind.INPUT_OBJECT_TYPE_DEFINITION,
+    Kind.UNION_TYPE_DEFINITION,
+];
 var CaseStyle;
 (function (CaseStyle) {
     CaseStyle["camelCase"] = "camelCase";
@@ -258,7 +291,7 @@ function getLocation(loc, fieldName = '', offset) {
 }
 
 function extractRuleName(stack) {
-    const match = (stack || '').match(/validation[/\\\\]rules[/\\\\](.*?)\.js:/) || [];
+    const match = (stack || '').match(/validation[/\\]rules[/\\](.*?)\.js:/) || [];
     return match[1] || null;
 }
 function validateDoc(sourceNode, context, schema, documentNode, rules, ruleName = null) {
@@ -507,11 +540,23 @@ const GRAPHQL_JS_VALIDATIONS = Object.assign({}, validationToRule('executable-de
 }));
 
 const ALPHABETIZE = 'ALPHABETIZE';
-const fieldsEnum = [Kind.OBJECT_TYPE_DEFINITION, Kind.INTERFACE_TYPE_DEFINITION, Kind.INPUT_OBJECT_TYPE_DEFINITION];
+const fieldsEnum = [
+    Kind.OBJECT_TYPE_DEFINITION,
+    Kind.INTERFACE_TYPE_DEFINITION,
+    Kind.INPUT_OBJECT_TYPE_DEFINITION,
+];
 const valuesEnum = [Kind.ENUM_TYPE_DEFINITION];
-const selectionsEnum = [Kind.OPERATION_DEFINITION, Kind.FRAGMENT_DEFINITION];
+const selectionsEnum = [
+    Kind.OPERATION_DEFINITION,
+    Kind.FRAGMENT_DEFINITION,
+];
 const variablesEnum = [Kind.OPERATION_DEFINITION];
-const argumentsEnum = [Kind.FIELD_DEFINITION, Kind.FIELD, Kind.DIRECTIVE_DEFINITION, Kind.DIRECTIVE];
+const argumentsEnum = [
+    Kind.FIELD_DEFINITION,
+    Kind.FIELD,
+    Kind.DIRECTIVE_DEFINITION,
+    Kind.DIRECTIVE,
+];
 const rule = {
     meta: {
         type: 'suggestion',
@@ -619,38 +664,48 @@ const rule = {
                 properties: {
                     fields: {
                         type: 'array',
-                        contains: {
+                        uniqueItems: true,
+                        minItems: 1,
+                        items: {
                             enum: fieldsEnum,
                         },
-                        description: 'Fields of `type`, `interface`, and `input`.',
+                        description: 'Fields of `type`, `interface`, and `input`',
                     },
                     values: {
                         type: 'array',
-                        contains: {
+                        uniqueItems: true,
+                        minItems: 1,
+                        items: {
                             enum: valuesEnum,
                         },
-                        description: 'Values of `enum`.',
+                        description: 'Values of `enum`',
                     },
                     selections: {
                         type: 'array',
-                        contains: {
+                        uniqueItems: true,
+                        minItems: 1,
+                        items: {
                             enum: selectionsEnum,
                         },
-                        description: 'Selections of operations (`query`, `mutation` and `subscription`) and `fragment`.',
+                        description: 'Selections of operations (`query`, `mutation` and `subscription`) and `fragment`',
                     },
                     variables: {
                         type: 'array',
-                        contains: {
+                        uniqueItems: true,
+                        minItems: 1,
+                        items: {
                             enum: variablesEnum,
                         },
-                        description: 'Variables of operations (`query`, `mutation` and `subscription`).',
+                        description: 'Variables of operations (`query`, `mutation` and `subscription`)',
                     },
                     arguments: {
                         type: 'array',
-                        contains: {
+                        uniqueItems: true,
+                        minItems: 1,
+                        items: {
                             enum: argumentsEnum,
                         },
-                        description: 'Arguments of fields and directives.',
+                        description: 'Arguments of fields and directives',
                     },
                 },
             },
@@ -681,7 +736,7 @@ const rule = {
         const opts = context.options[0];
         const fields = new Set((_a = opts.fields) !== null && _a !== void 0 ? _a : []);
         const listeners = {};
-        const fieldsSelector = [
+        const kinds = [
             fields.has(Kind.OBJECT_TYPE_DEFINITION) && [Kind.OBJECT_TYPE_DEFINITION, Kind.OBJECT_TYPE_EXTENSION],
             fields.has(Kind.INTERFACE_TYPE_DEFINITION) && [Kind.INTERFACE_TYPE_DEFINITION, Kind.INTERFACE_TYPE_EXTENSION],
             fields.has(Kind.INPUT_OBJECT_TYPE_DEFINITION) && [
@@ -689,8 +744,9 @@ const rule = {
                 Kind.INPUT_OBJECT_TYPE_EXTENSION,
             ],
         ]
-            .flat()
-            .join(',');
+            .filter(Boolean)
+            .flat();
+        const fieldsSelector = kinds.join(',');
         const hasEnumValues = ((_b = opts.values) === null || _b === void 0 ? void 0 : _b[0]) === Kind.ENUM_TYPE_DEFINITION;
         const selectionsSelector = (_c = opts.selections) === null || _c === void 0 ? void 0 : _c.join(',');
         const hasVariables = ((_d = opts.variables) === null || _d === void 0 ? void 0 : _d[0]) === Kind.OPERATION_DEFINITION;
@@ -1090,6 +1146,9 @@ const rule$5 = {
     },
 };
 
+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';
 const rule$6 = {
     meta: {
         type: 'suggestion',
@@ -1130,6 +1189,7 @@ const rule$6 = {
         schema: [
             {
                 type: 'object',
+                additionalProperties: false,
                 properties: {
                     checkInputType: {
                         type: 'boolean',
@@ -1152,24 +1212,22 @@ const rule$6 = {
                         description: 'Apply the rule to Mutations',
                     },
                 },
-                additionalProperties: false,
             },
         ],
     },
     create(context) {
-        var _a;
         const options = {
-            caseSensitiveInputType: true,
             checkInputType: false,
-            checkMutations: true,
+            caseSensitiveInputType: true,
             checkQueries: false,
-            ...(_a = context === null || context === void 0 ? void 0 : context.options) === null || _a === void 0 ? void 0 : _a[0],
+            checkMutations: true,
+            ...context.options[0],
         };
         const shouldCheckType = node => (options.checkMutations && isMutationType(node)) || (options.checkQueries && isQueryType(node));
         const listeners = {
-            'FieldDefinition > InputValueDefinition': node => {
-                const name = node.name.value;
-                if (name !== 'input' && shouldCheckType(node.parent.parent)) {
+            'FieldDefinition > InputValueDefinition[name.value!=input]'(node) {
+                if (shouldCheckType(node.parent.parent)) {
+                    const name = node.name.value;
                     context.report({
                         loc: getLocation(node.loc, name),
                         message: `Input "${name}" should be called "input"`,
@@ -1177,11 +1235,11 @@ const rule$6 = {
                 }
             },
         };
-        if (options === null || options === void 0 ? void 0 : options.checkInputType) {
-            listeners['FieldDefinition > InputValueDefinition NamedType'] = node => {
+        if (options.checkInputType) {
+            listeners['FieldDefinition > InputValueDefinition NamedType'] = (node) => {
                 const findInputType = item => {
                     let currentNode = item;
-                    while (currentNode.type !== 'InputValueDefinition') {
+                    while (currentNode.type !== Kind.INPUT_VALUE_DEFINITION) {
                         currentNode = currentNode.parent;
                     }
                     return currentNode;
@@ -1398,69 +1456,40 @@ const rule$7 = {
     },
 };
 
-const formats = {
-    camelCase: /^[a-z][^_]*$/g,
-    PascalCase: /^[A-Z][^_]*$/g,
-    snake_case: /^[a-z_][a-z0-9_]*$/g,
-    UPPER_CASE: /^[A-Z_][A-Z0-9_]*$/g,
-};
-const acceptedStyles = [
-    'camelCase',
-    'PascalCase',
-    'snake_case',
-    'UPPER_CASE',
+const FIELDS_KINDS = [
+    Kind.FIELD_DEFINITION,
+    Kind.INPUT_VALUE_DEFINITION,
+    Kind.VARIABLE_DEFINITION,
+    Kind.ARGUMENT,
+    Kind.DIRECTIVE_DEFINITION,
 ];
-function checkNameFormat(params) {
-    const { value, style, leadingUnderscore, trailingUnderscore, suffix, prefix, forbiddenPrefixes, forbiddenSuffixes, } = params;
-    let name = value;
-    if (leadingUnderscore === 'allow') {
-        [, name] = name.match(/^_*(.*)$/);
-    }
-    if (trailingUnderscore === 'allow') {
-        name = name.replace(/_*$/, '');
-    }
-    if (prefix && !name.startsWith(prefix)) {
-        return {
-            ok: false,
-            errorMessage: '{{nodeType}} name "{{nodeName}}" should have "{{prefix}}" prefix',
-        };
-    }
-    if (suffix && !name.endsWith(suffix)) {
-        return {
-            ok: false,
-            errorMessage: '{{nodeType}} name "{{nodeName}}" should have "{{suffix}}" suffix',
-        };
-    }
-    if (style && !acceptedStyles.includes(style)) {
-        return {
-            ok: false,
-            errorMessage: `{{nodeType}} name "{{nodeName}}" should be in one of the following options: ${acceptedStyles.join(',')}`,
-        };
-    }
-    if (forbiddenPrefixes.some(forbiddenPrefix => name.startsWith(forbiddenPrefix))) {
-        return {
-            ok: false,
-            errorMessage: '{{nodeType}} "{{nodeName}}" should not have one of the following prefix(es): {{forbiddenPrefixes}}',
-        };
-    }
-    if (forbiddenSuffixes.some(forbiddenSuffix => name.endsWith(forbiddenSuffix))) {
-        return {
-            ok: false,
-            errorMessage: '{{nodeType}} "{{nodeName}}" should not have one of the following suffix(es): {{forbiddenSuffixes}}',
-        };
-    }
-    if (!formats[style]) {
-        return { ok: true };
-    }
-    const ok = new RegExp(formats[style]).test(name);
-    if (ok) {
-        return { ok: true };
-    }
-    return {
-        ok: false,
-        errorMessage: '{{nodeType}} name "{{nodeName}}" should be in {{format}} format',
-    };
-}
+const KindToDisplayName = {
+    // types
+    [Kind.OBJECT_TYPE_DEFINITION]: 'Type',
+    [Kind.INTERFACE_TYPE_DEFINITION]: 'Interface',
+    [Kind.ENUM_TYPE_DEFINITION]: 'Enumerator',
+    [Kind.SCALAR_TYPE_DEFINITION]: 'Scalar',
+    [Kind.INPUT_OBJECT_TYPE_DEFINITION]: 'Input type',
+    [Kind.UNION_TYPE_DEFINITION]: 'Union',
+    // fields
+    [Kind.FIELD_DEFINITION]: 'Field',
+    [Kind.INPUT_VALUE_DEFINITION]: 'Input property',
+    [Kind.VARIABLE_DEFINITION]: 'Variable',
+    [Kind.ARGUMENT]: 'Argument',
+    [Kind.DIRECTIVE_DEFINITION]: 'Directive',
+    // rest
+    [Kind.ENUM_VALUE_DEFINITION]: 'Enumeration value',
+    [Kind.OPERATION_DEFINITION]: 'Operation',
+    [Kind.FRAGMENT_DEFINITION]: 'Fragment',
+};
+const StyleToRegex = {
+    camelCase: /^[a-z][\dA-Za-z]*$/,
+    PascalCase: /^[A-Z][\dA-Za-z]*$/,
+    snake_case: /^[a-z][\d_a-z]*[\da-z]$/,
+    UPPER_CASE: /^[A-Z][\dA-Z_]*[\dA-Z]$/,
+};
+const ALLOWED_KINDS = Object.keys(KindToDisplayName).sort();
+const ALLOWED_STYLES = Object.keys(StyleToRegex);
 const schemaOption$1 = {
     oneOf: [{ $ref: '#/definitions/asString' }, { $ref: '#/definitions/asObject' }],
 };
@@ -1475,89 +1504,120 @@ const rule$8 = {
             examples: [
                 {
                     title: 'Incorrect',
-                    usage: [{ ObjectTypeDefinition: 'PascalCase' }],
+                    usage: [{ types: 'PascalCase', fields: 'camelCase' }],
                     code: /* GraphQL */ `
-            type someTypeName {
-              f: String!
+            type user {
+              first_name: String!
             }
           `,
                 },
                 {
                     title: 'Correct',
-                    usage: [{ FieldDefinition: 'camelCase', ObjectTypeDefinition: 'PascalCase' }],
+                    usage: [{ types: 'PascalCase', fields: 'camelCase' }],
                     code: /* GraphQL */ `
-            type SomeTypeName {
-              someFieldName: String
+            type User {
+              firstName: String
             }
           `,
                 },
             ],
+            optionsForConfig: [
+                {
+                    types: 'PascalCase',
+                    fields: 'camelCase',
+                    overrides: {
+                        EnumValueDefinition: 'UPPER_CASE',
+                        OperationDefinition: {
+                            style: 'PascalCase',
+                            forbiddenPrefixes: ['Query', 'Mutation', 'Subscription', 'Get'],
+                            forbiddenSuffixes: ['Query', 'Mutation', 'Subscription'],
+                        },
+                        FragmentDefinition: {
+                            style: 'PascalCase',
+                            forbiddenPrefixes: ['Fragment'],
+                            forbiddenSuffixes: ['Fragment'],
+                        },
+                        'FieldDefinition[parent.name.value=Query]': {
+                            forbiddenPrefixes: ['query', 'get'],
+                            forbiddenSuffixes: ['Query'],
+                        },
+                        'FieldDefinition[parent.name.value=Mutation]': {
+                            forbiddenPrefixes: ['mutation'],
+                            forbiddenSuffixes: ['Mutation'],
+                        },
+                        'FieldDefinition[parent.name.value=Subscription]': {
+                            forbiddenPrefixes: ['subscription'],
+                            forbiddenSuffixes: ['Subscription'],
+                        },
+                    },
+                },
+            ],
         },
         schema: {
             definitions: {
                 asString: {
-                    type: 'string',
-                    description: `One of: ${acceptedStyles.map(t => `\`${t}\``).join(', ')}`,
-                    enum: acceptedStyles,
+                    enum: ALLOWED_STYLES,
+                    description: `One of: ${ALLOWED_STYLES.map(t => `\`${t}\``).join(', ')}`,
                 },
                 asObject: {
                     type: 'object',
+                    additionalProperties: false,
                     properties: {
-                        style: {
-                            type: 'string',
-                            enum: acceptedStyles,
-                        },
-                        prefix: {
-                            type: 'string',
-                        },
-                        suffix: {
-                            type: 'string',
-                        },
+                        style: { enum: ALLOWED_STYLES },
+                        prefix: { type: 'string' },
+                        suffix: { type: 'string' },
                         forbiddenPrefixes: {
-                            additionalItems: false,
                             type: 'array',
+                            uniqueItems: true,
                             minItems: 1,
-                            items: {
-                                type: 'string',
-                            },
+                            items: { type: 'string' },
                         },
                         forbiddenSuffixes: {
-                            additionalItems: false,
                             type: 'array',
+                            uniqueItems: true,
                             minItems: 1,
-                            items: {
-                                type: 'string',
-                            },
+                            items: { type: 'string' },
                         },
                     },
                 },
             },
-            $schema: 'http://json-schema.org/draft-04/schema#',
             type: 'array',
+            maxItems: 1,
             items: {
                 type: 'object',
+                additionalProperties: false,
                 properties: {
-                    [Kind.FIELD_DEFINITION]: schemaOption$1,
-                    [Kind.INPUT_OBJECT_TYPE_DEFINITION]: schemaOption$1,
-                    [Kind.ENUM_VALUE_DEFINITION]: schemaOption$1,
-                    [Kind.INPUT_VALUE_DEFINITION]: schemaOption$1,
-                    [Kind.OBJECT_TYPE_DEFINITION]: schemaOption$1,
-                    [Kind.INTERFACE_TYPE_DEFINITION]: schemaOption$1,
-                    [Kind.ENUM_TYPE_DEFINITION]: schemaOption$1,
-                    [Kind.UNION_TYPE_DEFINITION]: schemaOption$1,
-                    [Kind.SCALAR_TYPE_DEFINITION]: schemaOption$1,
-                    [Kind.OPERATION_DEFINITION]: schemaOption$1,
-                    [Kind.FRAGMENT_DEFINITION]: schemaOption$1,
-                    QueryDefinition: schemaOption$1,
-                    leadingUnderscore: {
-                        type: 'string',
-                        enum: ['allow', 'forbid'],
-                        default: 'forbid',
+                    types: {
+                        ...schemaOption$1,
+                        description: `Includes:\n\n${TYPES_KINDS.map(kind => `- \`${kind}\``).join('\n')}`,
                     },
-                    trailingUnderscore: {
-                        type: 'string',
-                        enum: ['allow', 'forbid'],
-                        default: 'forbid',
+                    fields: {
+                        ...schemaOption$1,
+                        description: `Includes:\n\n${FIELDS_KINDS.map(kind => `- \`${kind}\``).join('\n')}`,
+                    },
+                    allowLeadingUnderscore: {
+                        type: 'boolean',
+                        default: false,
+                    },
+                    allowTrailingUnderscore: {
+                        type: 'boolean',
+                        default: false,
+                    },
+                    overrides: {
+                        type: 'object',
+                        additionalProperties: false,
+                        description: [
+                            'May contain the following `ASTNode` names:',
+                            '',
+                            ...ALLOWED_KINDS.map(kind => `- \`${kind}\``),
+                            '',
+                            "> It's also possible to use a [`selector`](https://eslint.org/docs/developer-guide/selectors) that starts with `ASTNode` name",
+                            '>',
+                            '> Example: pattern property `FieldDefinition[parent.name.value=Query]` will match only fields for type `Query`',
+                        ].join('\n'),
+                        patternProperties: {
+                            [`^(${ALLOWED_KINDS.join('|')})(.+)?$`]: schemaOption$1,
+                        },
                     },
                 },
             },
@@ -1565,136 +1625,83 @@ const rule$8 = {
     },
     create(context) {
         const options = {
-            leadingUnderscore: 'forbid',
-            trailingUnderscore: 'forbid',
-            ...(context.options[0] || {}),
+            overrides: {},
+            ...context.options[0],
         };
-        const checkNode = (node, property, nodeType) => {
-            const { style, suffix = '', prefix = '', forbiddenPrefixes = [], forbiddenSuffixes = [] } = property;
-            const result = checkNameFormat({
-                value: node.value,
-                style,
-                leadingUnderscore: options.leadingUnderscore,
-                trailingUnderscore: options.trailingUnderscore,
-                prefix,
-                suffix,
-                forbiddenPrefixes,
-                forbiddenSuffixes,
-            });
-            if (result.ok === false) {
+        function normalisePropertyOption(kind) {
+            let style = options.overrides[kind];
+            if (!style) {
+                style = TYPES_KINDS.includes(kind) ? options.types : options.fields;
+            }
+            return typeof style === 'object' ? style : { style };
+        }
+        const checkNode = (selector) => (node) => {
+            const { name } = node.kind === Kind.VARIABLE_DEFINITION ? node.variable : node;
+            if (!name) {
+                return;
+            }
+            const { prefix, suffix, forbiddenPrefixes, forbiddenSuffixes, style } = normalisePropertyOption(selector);
+            const nodeType = KindToDisplayName[node.kind] || node.kind;
+            const nodeName = name.value;
+            const errorMessage = getErrorMessage();
+            if (errorMessage) {
                 context.report({
-                    loc: getLocation(node.loc, node.value),
-                    message: result.errorMessage,
-                    data: {
-                        prefix,
-                        suffix,
-                        format: style,
-                        forbiddenPrefixes: forbiddenPrefixes.join(', '),
-                        forbiddenSuffixes: forbiddenSuffixes.join(', '),
-                        nodeType,
-                        nodeName: node.value,
-                    },
+                    loc: getLocation(name.loc, name.value),
+                    message: `${nodeType} "${nodeName}" should ${errorMessage}`,
                 });
             }
-        };
-        const normalisePropertyOption = (value) => {
-            if (typeof value === 'object') {
-                return value;
-            }
-            return {
-                style: value,
-                prefix: '',
-                suffix: '',
-            };
-        };
-        return {
-            Name: node => {
-                if (node.value.startsWith('_') && options.leadingUnderscore === 'forbid') {
-                    context.report({
-                        loc: getLocation(node.loc, node.value),
-                        message: 'Leading underscores are not allowed',
-                    });
-                }
-                if (node.value.endsWith('_') && options.trailingUnderscore === 'forbid') {
-                    context.report({
-                        loc: getLocation(node.loc, node.value),
-                        message: 'Trailing underscores are not allowed',
-                    });
-                }
-            },
-            ObjectTypeDefinition: node => {
-                if (options.ObjectTypeDefinition) {
-                    const property = normalisePropertyOption(options.ObjectTypeDefinition);
-                    checkNode(node.name, property, 'Type');
-                }
-            },
-            InterfaceTypeDefinition: node => {
-                if (options.InterfaceTypeDefinition) {
-                    const property = normalisePropertyOption(options.InterfaceTypeDefinition);
-                    checkNode(node.name, property, 'Interface');
-                }
-            },
-            EnumTypeDefinition: node => {
-                if (options.EnumTypeDefinition) {
-                    const property = normalisePropertyOption(options.EnumTypeDefinition);
-                    checkNode(node.name, property, 'Enumerator');
+            function getErrorMessage() {
+                let name = nodeName;
+                if (options.allowLeadingUnderscore) {
+                    name = name.replace(/^_*/, '');
                 }
-            },
-            InputObjectTypeDefinition: node => {
-                if (options.InputObjectTypeDefinition) {
-                    const property = normalisePropertyOption(options.InputObjectTypeDefinition);
-                    checkNode(node.name, property, 'Input type');
+                if (options.allowTrailingUnderscore) {
+                    name = name.replace(/_*$/, '');
                 }
-            },
-            FieldDefinition: (node) => {
-                if (options.QueryDefinition && isQueryType(node.parent)) {
-                    const property = normalisePropertyOption(options.QueryDefinition);
-                    checkNode(node.name, property, 'Query');
+                if (prefix && !name.startsWith(prefix)) {
+                    return `have "${prefix}" prefix`;
                 }
-                if (options.FieldDefinition && !isQueryType(node.parent)) {
-                    const property = normalisePropertyOption(options.FieldDefinition);
-                    checkNode(node.name, property, 'Field');
+                if (suffix && !name.endsWith(suffix)) {
+                    return `have "${suffix}" suffix`;
                 }
-            },
-            EnumValueDefinition: node => {
-                if (options.EnumValueDefinition) {
-                    const property = normalisePropertyOption(options.EnumValueDefinition);
-                    checkNode(node.name, property, 'Enumeration value');
+                const forbiddenPrefix = forbiddenPrefixes === null || forbiddenPrefixes === void 0 ? void 0 : forbiddenPrefixes.find(prefix => name.startsWith(prefix));
+                if (forbiddenPrefix) {
+                    return `not have "${forbiddenPrefix}" prefix`;
                 }
-            },
-            InputValueDefinition: node => {
-                if (options.InputValueDefinition) {
-                    const property = normalisePropertyOption(options.InputValueDefinition);
-                    checkNode(node.name, property, 'Input property');
+                const forbiddenSuffix = forbiddenSuffixes === null || forbiddenSuffixes === void 0 ? void 0 : forbiddenSuffixes.find(suffix => name.endsWith(suffix));
+                if (forbiddenSuffix) {
+                    return `not have "${forbiddenSuffix}" suffix`;
                 }
-            },
-            OperationDefinition: node => {
-                if (options.OperationDefinition) {
-                    const property = normalisePropertyOption(options.OperationDefinition);
-                    if (node.name) {
-                        checkNode(node.name, property, 'Operation');
-                    }
+                if (style && !ALLOWED_STYLES.includes(style)) {
+                    return `be in one of the following options: ${ALLOWED_STYLES.join(', ')}`;
                 }
-            },
-            FragmentDefinition: node => {
-                if (options.FragmentDefinition) {
-                    const property = normalisePropertyOption(options.FragmentDefinition);
-                    checkNode(node.name, property, 'Fragment');
+                const caseRegex = StyleToRegex[style];
+                if (caseRegex && !caseRegex.test(name)) {
+                    return `be in ${style} format`;
                 }
-            },
-            ScalarTypeDefinition: node => {
-                if (options.ScalarTypeDefinition) {
-                    const property = normalisePropertyOption(options.ScalarTypeDefinition);
-                    checkNode(node.name, property, 'Scalar');
-                }
-            },
-            UnionTypeDefinition: node => {
-                if (options.UnionTypeDefinition) {
-                    const property = normalisePropertyOption(options.UnionTypeDefinition);
-                    checkNode(node.name, property, 'Union');
-                }
-            },
+            }
         };
+        const checkUnderscore = (node) => {
+            const name = node.value;
+            context.report({
+                loc: getLocation(node.loc, name),
+                message: `${name.startsWith('_') ? 'Leading' : 'Trailing'} underscores are not allowed`,
+            });
+        };
+        const listeners = {};
+        if (!options.allowLeadingUnderscore) {
+            listeners['Name[value=/^_/]:matches([parent.kind!=Field], [parent.kind=Field][parent.alias])'] = checkUnderscore;
+        }
+        if (!options.allowTrailingUnderscore) {
+            listeners['Name[value=/_$/]:matches([parent.kind!=Field], [parent.kind=Field][parent.alias])'] = checkUnderscore;
+        }
+        const selectors = new Set([options.types && TYPES_KINDS, options.fields && FIELDS_KINDS, Object.keys(options.overrides)]
+            .flat()
+            .filter(Boolean));
+        for (const selector of selectors) {
+            listeners[selector] = checkNode(selector);
+        }
+        return listeners;
     },
 };
 
@@ -2059,9 +2066,100 @@ const rule$d = {
     },
 };
 
+const ROOT_TYPES = ['query', 'mutation', 'subscription'];
+const rule$e = {
+    meta: {
+        type: 'suggestion',
+        docs: {
+            category: 'Validation',
+            description: 'Disallow using root types for `read-only` or `write-only` schemas.',
+            url: 'https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/no-root-type.md',
+            requiresSchema: true,
+            examples: [
+                {
+                    title: 'Incorrect (`read-only` schema)',
+                    usage: [{ disallow: ['mutation', 'subscription'] }],
+                    code: /* GraphQL */ `
+            type Mutation {
+              createUser(input: CreateUserInput!): User!
+            }
+          `,
+                },
+                {
+                    title: 'Incorrect (`write-only` schema)',
+                    usage: [{ disallow: ['query'] }],
+                    code: /* GraphQL */ `
+            type Query {
+              users: [User!]!
+            }
+          `,
+                },
+                {
+                    title: 'Correct (`read-only` schema)',
+                    usage: [{ disallow: ['mutation', 'subscription'] }],
+                    code: /* GraphQL */ `
+            type Query {
+              users: [User!]!
+            }
+          `,
+                },
+            ],
+            optionsForConfig: [{ disallow: ['subscription'] }],
+        },
+        schema: {
+            type: 'array',
+            minItems: 1,
+            maxItems: 1,
+            items: {
+                type: 'object',
+                additionalProperties: false,
+                required: ['disallow'],
+                properties: {
+                    disallow: {
+                        type: 'array',
+                        uniqueItems: true,
+                        minItems: 1,
+                        items: {
+                            enum: ROOT_TYPES,
+                        },
+                    },
+                },
+            },
+        },
+    },
+    create(context) {
+        const schema = requireGraphQLSchemaFromContext('no-root-type', context);
+        const disallow = new Set(context.options[0].disallow);
+        const rootTypeNames = [
+            disallow.has('query') && schema.getQueryType(),
+            disallow.has('mutation') && schema.getMutationType(),
+            disallow.has('subscription') && schema.getSubscriptionType(),
+        ]
+            .filter(Boolean)
+            .map(type => type.name);
+        if (rootTypeNames.length === 0) {
+            return {};
+        }
+        const selector = [
+            `:matches(${Kind.OBJECT_TYPE_DEFINITION}, ${Kind.OBJECT_TYPE_EXTENSION})`,
+            '>',
+            `${Kind.NAME}[value=/^(${rootTypeNames.join('|')})$/]`,
+        ].join(' ');
+        return {
+            [selector](node) {
+                const typeName = node.value;
+                context.report({
+                    loc: getLocation(node.loc, typeName),
+                    message: `Root type "${typeName}" is forbidden`,
+                });
+            },
+        };
+    },
+};
+
 const UNREACHABLE_TYPE = 'UNREACHABLE_TYPE';
 const RULE_NAME = 'no-unreachable-types';
-const rule$e = {
+const rule$f = {
     meta: {
         messages: {
             [UNREACHABLE_TYPE]: `Type "{{ typeName }}" is unreachable`,
@@ -2137,7 +2235,7 @@ const rule$e = {
 
 const UNUSED_FIELD = 'UNUSED_FIELD';
 const RULE_NAME$1 = 'no-unused-fields';
-const rule$f = {
+const rule$g = {
     meta: {
         messages: {
             [UNUSED_FIELD]: `Field "{{fieldName}}" is unused`,
@@ -2320,12 +2418,13 @@ function convertDescription(node) {
     return [];
 }
 
+// eslint-disable-next-line unicorn/better-regex
 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$g = {
+const rule$h = {
     meta: {
         type: 'suggestion',
         docs: {
@@ -2428,7 +2527,7 @@ const rule$g = {
     },
 };
 
-const rule$h = {
+const rule$i = {
     meta: {
         docs: {
             description: `Require all deprecation directives to specify a reason.`,
@@ -2508,7 +2607,7 @@ function verifyRule(context, node) {
         }
     }
 }
-const rule$i = {
+const rule$j = {
     meta: {
         docs: {
             category: 'Best Practices',
@@ -2573,7 +2672,7 @@ const rule$i = {
 };
 
 const RULE_NAME$2 = 'require-field-of-type-query-in-mutation-result';
-const rule$j = {
+const rule$k = {
     meta: {
         type: 'suggestion',
         docs: {
@@ -2741,7 +2840,7 @@ const convertNode = (typeInfo) => (node, key, parent) => {
 
 const REQUIRE_ID_WHEN_AVAILABLE = 'REQUIRE_ID_WHEN_AVAILABLE';
 const DEFAULT_ID_FIELD_NAME = 'id';
-const rule$k = {
+const rule$l = {
     meta: {
         type: 'suggestion',
         docs: {
@@ -2877,7 +2976,7 @@ const rule$k = {
     },
 };
 
-const rule$l = {
+const rule$m = {
     meta: {
         docs: {
             category: 'Best Practices',
@@ -2999,7 +3098,7 @@ const shouldIgnoreNode = ({ node, exceptions }) => {
     }
     return false;
 };
-const rule$m = {
+const rule$n = {
     meta: {
         type: 'suggestion',
         docs: {
@@ -3113,7 +3212,7 @@ const rule$m = {
             acceptedIdNames: ['id'],
             acceptedIdTypes: ['ID'],
             exceptions: {},
-            ...(context.options[0] || {}),
+            ...context.options[0],
         };
         return {
             ObjectTypeDefinition(node) {
@@ -3176,7 +3275,7 @@ const checkNode = (context, node, ruleName, messageId) => {
         });
     }
 };
-const rule$n = {
+const rule$o = {
     meta: {
         type: 'suggestion',
         docs: {
@@ -3235,7 +3334,7 @@ const rule$n = {
 
 const RULE_NAME$4 = 'unique-operation-name';
 const UNIQUE_OPERATION_NAME = 'UNIQUE_OPERATION_NAME';
-const rule$o = {
+const rule$p = {
     meta: {
         type: 'suggestion',
         docs: {
@@ -3315,17 +3414,18 @@ const rules = {
     'no-deprecated': rule$b,
     'no-hashtag-description': rule$c,
     'no-operation-name-suffix': rule$d,
-    'no-unreachable-types': rule$e,
-    'no-unused-fields': rule$f,
-    'require-deprecation-date': rule$g,
-    'require-deprecation-reason': rule$h,
-    'require-description': rule$i,
-    'require-field-of-type-query-in-mutation-result': rule$j,
-    'require-id-when-available': rule$k,
-    'selection-set-depth': rule$l,
-    'strict-id-in-types': rule$m,
-    'unique-fragment-name': rule$n,
-    'unique-operation-name': rule$o,
+    'no-root-type': rule$e,
+    'no-unreachable-types': rule$f,
+    'no-unused-fields': rule$g,
+    'require-deprecation-date': rule$h,
+    'require-deprecation-reason': rule$i,
+    'require-description': rule$j,
+    'require-field-of-type-query-in-mutation-result': rule$k,
+    'require-id-when-available': rule$l,
+    'selection-set-depth': rule$m,
+    'strict-id-in-types': rule$n,
+    'unique-fragment-name': rule$o,
+    'unique-operation-name': rule$p,
 };
 
 const RELEVANT_KEYWORDS = ['gql', 'graphql', '/* GraphQL */'];