@graphql-eslint/eslint-plugin 2.5.0-alpha-e34c5d6.0 → 3.0.0-alpha-3168a9b.0

package/index.js

@@ -35,7 +35,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',
@@ -212,9 +239,14 @@ const loaderCache = new Proxy(Object.create(null), {
         return true;
     },
 });
-const isObjectType = (node) => [graphql.Kind.OBJECT_TYPE_DEFINITION, graphql.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 = [
+    graphql.Kind.OBJECT_TYPE_DEFINITION,
+    graphql.Kind.INTERFACE_TYPE_DEFINITION,
+    graphql.Kind.ENUM_TYPE_DEFINITION,
+    graphql.Kind.SCALAR_TYPE_DEFINITION,
+    graphql.Kind.INPUT_OBJECT_TYPE_DEFINITION,
+    graphql.Kind.UNION_TYPE_DEFINITION,
+];
 var CaseStyle;
 (function (CaseStyle) {
     CaseStyle["camelCase"] = "camelCase";
@@ -265,7 +297,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) {
@@ -626,38 +658,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',
                     },
                 },
             },
@@ -688,7 +730,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(graphql.Kind.OBJECT_TYPE_DEFINITION) && [graphql.Kind.OBJECT_TYPE_DEFINITION, graphql.Kind.OBJECT_TYPE_EXTENSION],
             fields.has(graphql.Kind.INTERFACE_TYPE_DEFINITION) && [graphql.Kind.INTERFACE_TYPE_DEFINITION, graphql.Kind.INTERFACE_TYPE_EXTENSION],
             fields.has(graphql.Kind.INPUT_OBJECT_TYPE_DEFINITION) && [
@@ -696,8 +738,9 @@ const rule = {
                 graphql.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]) === graphql.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]) === graphql.Kind.OPERATION_DEFINITION;
@@ -1097,6 +1140,9 @@ const rule$5 = {
     },
 };
 
+const isObjectType = (node) => [graphql.Kind.OBJECT_TYPE_DEFINITION, graphql.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',
@@ -1137,6 +1183,7 @@ const rule$6 = {
         schema: [
             {
                 type: 'object',
+                additionalProperties: false,
                 properties: {
                     checkInputType: {
                         type: 'boolean',
@@ -1159,24 +1206,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"`,
@@ -1184,11 +1229,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 !== graphql.Kind.INPUT_VALUE_DEFINITION) {
                         currentNode = currentNode.parent;
                     }
                     return currentNode;
@@ -1405,69 +1450,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 = [
+    graphql.Kind.FIELD_DEFINITION,
+    graphql.Kind.INPUT_VALUE_DEFINITION,
+    graphql.Kind.VARIABLE_DEFINITION,
+    graphql.Kind.ARGUMENT,
+    graphql.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
+    [graphql.Kind.OBJECT_TYPE_DEFINITION]: 'Type',
+    [graphql.Kind.INTERFACE_TYPE_DEFINITION]: 'Interface',
+    [graphql.Kind.ENUM_TYPE_DEFINITION]: 'Enumerator',
+    [graphql.Kind.SCALAR_TYPE_DEFINITION]: 'Scalar',
+    [graphql.Kind.INPUT_OBJECT_TYPE_DEFINITION]: 'Input type',
+    [graphql.Kind.UNION_TYPE_DEFINITION]: 'Union',
+    // fields
+    [graphql.Kind.FIELD_DEFINITION]: 'Field',
+    [graphql.Kind.INPUT_VALUE_DEFINITION]: 'Input property',
+    [graphql.Kind.VARIABLE_DEFINITION]: 'Variable',
+    [graphql.Kind.ARGUMENT]: 'Argument',
+    [graphql.Kind.DIRECTIVE_DEFINITION]: 'Directive',
+    // rest
+    [graphql.Kind.ENUM_VALUE_DEFINITION]: 'Enumeration value',
+    [graphql.Kind.OPERATION_DEFINITION]: 'Operation',
+    [graphql.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' }],
 };
@@ -1482,89 +1498,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: {
-                    [graphql.Kind.FIELD_DEFINITION]: schemaOption$1,
-                    [graphql.Kind.INPUT_OBJECT_TYPE_DEFINITION]: schemaOption$1,
-                    [graphql.Kind.ENUM_VALUE_DEFINITION]: schemaOption$1,
-                    [graphql.Kind.INPUT_VALUE_DEFINITION]: schemaOption$1,
-                    [graphql.Kind.OBJECT_TYPE_DEFINITION]: schemaOption$1,
-                    [graphql.Kind.INTERFACE_TYPE_DEFINITION]: schemaOption$1,
-                    [graphql.Kind.ENUM_TYPE_DEFINITION]: schemaOption$1,
-                    [graphql.Kind.UNION_TYPE_DEFINITION]: schemaOption$1,
-                    [graphql.Kind.SCALAR_TYPE_DEFINITION]: schemaOption$1,
-                    [graphql.Kind.OPERATION_DEFINITION]: schemaOption$1,
-                    [graphql.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,
+                        },
                     },
                 },
             },
@@ -1572,136 +1619,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 === graphql.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');
-                }
-            },
-            InputObjectTypeDefinition: node => {
-                if (options.InputObjectTypeDefinition) {
-                    const property = normalisePropertyOption(options.InputObjectTypeDefinition);
-                    checkNode(node.name, property, 'Input type');
-                }
-            },
-            FieldDefinition: (node) => {
-                if (options.QueryDefinition && isQueryType(node.parent)) {
-                    const property = normalisePropertyOption(options.QueryDefinition);
-                    checkNode(node.name, property, 'Query');
+            function getErrorMessage() {
+                let name = nodeName;
+                if (options.allowLeadingUnderscore) {
+                    name = name.replace(/^_*/, '');
                 }
-                if (options.FieldDefinition && !isQueryType(node.parent)) {
-                    const property = normalisePropertyOption(options.FieldDefinition);
-                    checkNode(node.name, property, 'Field');
+                if (options.allowTrailingUnderscore) {
+                    name = name.replace(/_*$/, '');
                 }
-            },
-            EnumValueDefinition: node => {
-                if (options.EnumValueDefinition) {
-                    const property = normalisePropertyOption(options.EnumValueDefinition);
-                    checkNode(node.name, property, 'Enumeration value');
+                if (prefix && !name.startsWith(prefix)) {
+                    return `have "${prefix}" prefix`;
                 }
-            },
-            InputValueDefinition: node => {
-                if (options.InputValueDefinition) {
-                    const property = normalisePropertyOption(options.InputValueDefinition);
-                    checkNode(node.name, property, 'Input property');
+                if (suffix && !name.endsWith(suffix)) {
+                    return `have "${suffix}" suffix`;
                 }
-            },
-            OperationDefinition: node => {
-                if (options.OperationDefinition) {
-                    const property = normalisePropertyOption(options.OperationDefinition);
-                    if (node.name) {
-                        checkNode(node.name, property, 'Operation');
-                    }
+                const forbiddenPrefix = forbiddenPrefixes === null || forbiddenPrefixes === void 0 ? void 0 : forbiddenPrefixes.find(prefix => name.startsWith(prefix));
+                if (forbiddenPrefix) {
+                    return `not have "${forbiddenPrefix}" prefix`;
                 }
-            },
-            FragmentDefinition: node => {
-                if (options.FragmentDefinition) {
-                    const property = normalisePropertyOption(options.FragmentDefinition);
-                    checkNode(node.name, property, 'Fragment');
+                const forbiddenSuffix = forbiddenSuffixes === null || forbiddenSuffixes === void 0 ? void 0 : forbiddenSuffixes.find(suffix => name.endsWith(suffix));
+                if (forbiddenSuffix) {
+                    return `not have "${forbiddenSuffix}" suffix`;
                 }
-            },
-            ScalarTypeDefinition: node => {
-                if (options.ScalarTypeDefinition) {
-                    const property = normalisePropertyOption(options.ScalarTypeDefinition);
-                    checkNode(node.name, property, 'Scalar');
+                if (style && !ALLOWED_STYLES.includes(style)) {
+                    return `be in one of the following options: ${ALLOWED_STYLES.join(', ')}`;
                 }
-            },
-            UnionTypeDefinition: node => {
-                if (options.UnionTypeDefinition) {
-                    const property = normalisePropertyOption(options.UnionTypeDefinition);
-                    checkNode(node.name, property, 'Union');
+                const caseRegex = StyleToRegex[style];
+                if (caseRegex && !caseRegex.test(name)) {
+                    return `be in ${style} format`;
                 }
-            },
+            }
         };
+        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;
     },
 };
 
@@ -2418,6 +2412,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';
@@ -3211,7 +3206,7 @@ const rule$n = {
             acceptedIdNames: ['id'],
             acceptedIdTypes: ['ID'],
             exceptions: {},
-            ...(context.options[0] || {}),
+            ...context.options[0],
         };
         return {
             ObjectTypeDefinition(node) {