@graphql-eslint/eslint-plugin 2.4.0-alpha-0a1c477.0 → 3.0.0-alpha-5388f29.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',
@@ -205,9 +232,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 +290,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) {
@@ -619,38 +651,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 +723,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 +731,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 +1133,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 +1176,7 @@ const rule$6 = {
         schema: [
             {
                 type: 'object',
+                additionalProperties: false,
                 properties: {
                     checkInputType: {
                         type: 'boolean',
@@ -1152,24 +1199,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 +1222,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 +1443,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 +1491,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 +1612,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',
-                    });
+            function getErrorMessage() {
+                let name = nodeName;
+                if (options.allowLeadingUnderscore) {
+                    name = name.replace(/^_*/, '');
                 }
-                if (node.value.endsWith('_') && options.trailingUnderscore === 'forbid') {
-                    context.report({
-                        loc: getLocation(node.loc, node.value),
-                        message: 'Trailing underscores are not allowed',
-                    });
+                if (options.allowTrailingUnderscore) {
+                    name = name.replace(/_*$/, '');
                 }
-            },
-            ObjectTypeDefinition: node => {
-                if (options.ObjectTypeDefinition) {
-                    const property = normalisePropertyOption(options.ObjectTypeDefinition);
-                    checkNode(node.name, property, 'Type');
+                if (prefix && !name.startsWith(prefix)) {
+                    return `have "${prefix}" prefix`;
                 }
-            },
-            InterfaceTypeDefinition: node => {
-                if (options.InterfaceTypeDefinition) {
-                    const property = normalisePropertyOption(options.InterfaceTypeDefinition);
-                    checkNode(node.name, property, 'Interface');
+                if (suffix && !name.endsWith(suffix)) {
+                    return `have "${suffix}" suffix`;
                 }
-            },
-            EnumTypeDefinition: node => {
-                if (options.EnumTypeDefinition) {
-                    const property = normalisePropertyOption(options.EnumTypeDefinition);
-                    checkNode(node.name, property, 'Enumerator');
+                const forbiddenPrefix = forbiddenPrefixes === null || forbiddenPrefixes === void 0 ? void 0 : forbiddenPrefixes.find(prefix => name.startsWith(prefix));
+                if (forbiddenPrefix) {
+                    return `not have "${forbiddenPrefix}" prefix`;
                 }
-            },
-            InputObjectTypeDefinition: node => {
-                if (options.InputObjectTypeDefinition) {
-                    const property = normalisePropertyOption(options.InputObjectTypeDefinition);
-                    checkNode(node.name, property, 'Input type');
+                const forbiddenSuffix = forbiddenSuffixes === null || forbiddenSuffixes === void 0 ? void 0 : forbiddenSuffixes.find(suffix => name.endsWith(suffix));
+                if (forbiddenSuffix) {
+                    return `not have "${forbiddenSuffix}" suffix`;
                 }
-            },
-            FieldDefinition: (node) => {
-                if (options.QueryDefinition && isQueryType(node.parent)) {
-                    const property = normalisePropertyOption(options.QueryDefinition);
-                    checkNode(node.name, property, 'Query');
+                if (style && !ALLOWED_STYLES.includes(style)) {
+                    return `be in one of the following options: ${ALLOWED_STYLES.join(', ')}`;
                 }
-                if (options.FieldDefinition && !isQueryType(node.parent)) {
-                    const property = normalisePropertyOption(options.FieldDefinition);
-                    checkNode(node.name, property, 'Field');
-                }
-            },
-            EnumValueDefinition: node => {
-                if (options.EnumValueDefinition) {
-                    const property = normalisePropertyOption(options.EnumValueDefinition);
-                    checkNode(node.name, property, 'Enumeration value');
+                const caseRegex = StyleToRegex[style];
+                if (caseRegex && !caseRegex.test(name)) {
+                    return `be in ${style} format`;
                 }
-            },
-            InputValueDefinition: node => {
-                if (options.InputValueDefinition) {
-                    const property = normalisePropertyOption(options.InputValueDefinition);
-                    checkNode(node.name, property, 'Input property');
-                }
-            },
-            OperationDefinition: node => {
-                if (options.OperationDefinition) {
-                    const property = normalisePropertyOption(options.OperationDefinition);
-                    if (node.name) {
-                        checkNode(node.name, property, 'Operation');
-                    }
-                }
-            },
-            FragmentDefinition: node => {
-                if (options.FragmentDefinition) {
-                    const property = normalisePropertyOption(options.FragmentDefinition);
-                    checkNode(node.name, property, 'Fragment');
-                }
-            },
-            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;
     },
 };
 
@@ -1885,7 +1879,7 @@ const rule$b = {
                 requireGraphQLSchemaFromContext('no-deprecated', context);
                 const typeInfo = node.typeInfo();
                 if (typeInfo && typeInfo.enumValue) {
-                    if (typeInfo.enumValue.deprecationReason) {
+                    if (typeInfo.enumValue.isDeprecated) {
                         const enumValueName = node.value;
                         context.report({
                             loc: getLocation(node.loc, enumValueName),
@@ -1902,7 +1896,7 @@ const rule$b = {
                 requireGraphQLSchemaFromContext('no-deprecated', context);
                 const typeInfo = node.typeInfo();
                 if (typeInfo && typeInfo.fieldDef) {
-                    if (typeInfo.fieldDef.deprecationReason) {
+                    if (typeInfo.fieldDef.isDeprecated) {
                         const fieldName = node.name.value;
                         context.report({
                             loc: getLocation(node.loc, fieldName),
@@ -2320,6 +2314,7 @@ 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';
@@ -2517,7 +2512,7 @@ const rule$i = {
             examples: [
                 {
                     title: 'Incorrect',
-                    usage: [{ on: [Kind.OBJECT_TYPE_DEFINITION, Kind.FIELD_DEFINITION] }],
+                    usage: [{ on: ['ObjectTypeDefinition', 'FieldDefinition'] }],
                     code: /* GraphQL */ `
             type someTypeName {
               name: String
@@ -2526,7 +2521,7 @@ const rule$i = {
                 },
                 {
                     title: 'Correct',
-                    usage: [{ on: [Kind.OBJECT_TYPE_DEFINITION, Kind.FIELD_DEFINITION] }],
+                    usage: [{ on: ['ObjectTypeDefinition', 'FieldDefinition'] }],
                     code: /* GraphQL */ `
             """
             Some type description
@@ -3113,7 +3108,7 @@ const rule$m = {
             acceptedIdNames: ['id'],
             acceptedIdTypes: ['ID'],
             exceptions: {},
-            ...(context.options[0] || {}),
+            ...context.options[0],
         };
         return {
             ObjectTypeDefinition(node) {