[naming-convention] Add QueryDefinition option, forbiddenSuffixes and forbiddenPrefixes properties. (#256)

eddeee888 · web-flow · commit 46d759e5cc73 · 2021-02-02T08:35:48.000+02:00
diff --git a/.changeset/funny-swans-speak.md b/.changeset/funny-swans-speak.md
@@ -0,0 +1,5 @@
+---
+'@graphql-eslint/eslint-plugin': minor
+---
+
+[naming-convention] Add forbiddenPrefixes and forbiddenSuffixes options. Add QueryDefinition which targets queries ( may break existing config if FieldDefinition is used )
diff --git a/docs/rules/naming-convention.md b/docs/rules/naming-convention.md
@@ -114,6 +114,13 @@ The object must be one of the following types:
 * `asString`
 * `asObject`
 
+#### `QueryDefinition`
+
+The object must be one of the following types:
+
+* `asString`
+* `asObject`
+
 #### `leadingUnderscore` (string, enum)
 
 This element must be one of the following enum values:
@@ -157,4 +164,20 @@ This element must be one of the following enum values:
 
 ### `prefix` (string)
 
-### `suffix` (string)
+### `suffix` (string)
+
+### `forbiddenPrefixes` (array)
+
+The object is an array with all elements of the type `string`.
+
+Additional restrictions:
+
+* Minimum items: `1`
+
+### `forbiddenSuffixes` (array)
+
+The object is an array with all elements of the type `string`.
+
+Additional restrictions:
+
+* Minimum items: `1`
diff --git a/packages/plugin/src/rules/naming-convention.ts b/packages/plugin/src/rules/naming-convention.ts
@@ -22,9 +22,20 @@ interface CheckNameFormatParams {
   trailingUnderscore: 'allow' | 'forbid';
   prefix: string;
   suffix: string;
+  forbiddenPrefixes: string[];
+  forbiddenSuffixes: string[];
 }
 function checkNameFormat(params: CheckNameFormatParams): { ok: false; errorMessage: string } | { ok: true } {
-  const { value, style, leadingUnderscore, trailingUnderscore, suffix, prefix } = params;
+  const {
+    value,
+    style,
+    leadingUnderscore,
+    trailingUnderscore,
+    suffix,
+    prefix,
+    forbiddenPrefixes,
+    forbiddenSuffixes,
+  } = params;
   let name = value;
   if (leadingUnderscore === 'allow') {
     [, name] = name.match(/^_*(.*)$/);
@@ -46,6 +57,22 @@ function checkNameFormat(params: CheckNameFormatParams): { ok: false; errorMessa
       )}`,
     };
   }
+  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 };
   }
@@ -64,12 +91,15 @@ interface PropertySchema {
   style?: ValidNaming;
   suffix?: string;
   prefix?: string;
+  forbiddenPrefixes?: string[];
+  forbiddenSuffixes?: string[];
 }
 
 type NamingConventionRuleConfig = [
   {
     leadingUnderscore?: 'allow' | 'forbid';
     trailingUnderscore?: 'allow' | 'forbid';
+    QueryDefinition?: ValidNaming | PropertySchema;
     [Kind.FIELD_DEFINITION]?: ValidNaming | PropertySchema;
     [Kind.ENUM_VALUE_DEFINITION]?: ValidNaming | PropertySchema;
     [Kind.INPUT_VALUE_DEFINITION]?: ValidNaming | PropertySchema;
@@ -135,6 +165,22 @@ const rule: GraphQLESLintRule<NamingConventionRuleConfig> = {
             suffix: {
               type: 'string',
             },
+            forbiddenPrefixes: {
+              additionalItems: false,
+              type: 'array',
+              minItems: 1,
+              items: {
+                type: 'string',
+              },
+            },
+            forbiddenSuffixes: {
+              additionalItems: false,
+              type: 'array',
+              minItems: 1,
+              items: {
+                type: 'string',
+              },
+            },
           },
         },
       },
@@ -154,6 +200,7 @@ const rule: GraphQLESLintRule<NamingConventionRuleConfig> = {
           [Kind.SCALAR_TYPE_DEFINITION as string]: schemaOption,
           [Kind.OPERATION_DEFINITION as string]: schemaOption,
           [Kind.FRAGMENT_DEFINITION as string]: schemaOption,
+          QueryDefinition: schemaOption,
           leadingUnderscore: {
             type: 'string',
             enum: ['allow', 'forbid'],
@@ -175,14 +222,17 @@ const rule: GraphQLESLintRule<NamingConventionRuleConfig> = {
       ...(context.options[0] || {}),
     };
 
-    const checkNode = (node, style, nodeType, suffix = '', prefix = '') => {
+    const checkNode = (node, property: PropertySchema, nodeType: string) => {
+      const { style, suffix = '', prefix = '', forbiddenPrefixes = [], forbiddenSuffixes = [] } = property;
       const result = checkNameFormat({
         value: node.value,
         style,
         leadingUnderscore: options.leadingUnderscore,
         trailingUnderscore: options.trailingUnderscore,
         prefix: prefix,
         suffix: suffix,
+        forbiddenPrefixes: forbiddenPrefixes,
+        forbiddenSuffixes: forbiddenSuffixes,
       });
       if (result.ok === false) {
         context.report({
@@ -192,6 +242,8 @@ const rule: GraphQLESLintRule<NamingConventionRuleConfig> = {
             prefix: prefix,
             suffix: suffix,
             format: style,
+            forbiddenPrefixes: forbiddenPrefixes.join(', '),
+            forbiddenSuffixes: forbiddenSuffixes.join(', '),
             nodeType,
             nodeName: node.value,
           },
@@ -210,6 +262,12 @@ const rule: GraphQLESLintRule<NamingConventionRuleConfig> = {
       };
     };
 
+    const isQueryType = (node): boolean => {
+      return (
+        (node.type === 'ObjectTypeDefinition' || node.type === 'ObjectTypeExtension') && node.name.value === 'Query'
+      );
+    };
+
     return {
       Name: node => {
         if (node.value.startsWith('_') && options.leadingUnderscore === 'forbid') {
@@ -225,61 +283,66 @@ const rule: GraphQLESLintRule<NamingConventionRuleConfig> = {
       ObjectTypeDefinition: node => {
         if (options.ObjectTypeDefinition) {
           const property = normalisePropertyOption(options.ObjectTypeDefinition);
-          checkNode(node.name, property.style, 'Type', property.suffix, property.prefix);
+          checkNode(node.name, property, 'Type');
         }
       },
       InterfaceTypeDefinition: node => {
         if (options.InterfaceTypeDefinition) {
           const property = normalisePropertyOption(options.InterfaceTypeDefinition);
-          checkNode(node.name, property.style, 'Interface', property.suffix, property.prefix);
+          checkNode(node.name, property, 'Interface');
         }
       },
       EnumTypeDefinition: node => {
         if (options.EnumTypeDefinition) {
           const property = normalisePropertyOption(options.EnumTypeDefinition);
-          checkNode(node.name, property.style, 'Enumerator', property.suffix, property.prefix);
+          checkNode(node.name, property, 'Enumerator');
         }
       },
       InputObjectTypeDefinition: node => {
         if (options.InputObjectTypeDefinition) {
           const property = normalisePropertyOption(options.InputObjectTypeDefinition);
-          checkNode(node.name, property.style, 'Input type', property.suffix, property.prefix);
+          checkNode(node.name, property, 'Input type');
         }
       },
-      FieldDefinition: node => {
-        if (options.FieldDefinition) {
+      FieldDefinition: (node: any) => {
+        if (options.QueryDefinition && isQueryType(node.parent)) {
+          const property = normalisePropertyOption(options.QueryDefinition);
+          checkNode(node.name, property, 'Query');
+        }
+
+        if (options.FieldDefinition && !isQueryType(node.parent)) {
           const property = normalisePropertyOption(options.FieldDefinition);
-          checkNode(node.name, property.style, 'Field', property.suffix, property.prefix);
+          checkNode(node.name, property, 'Field');
         }
       },
       EnumValueDefinition: node => {
         if (options.EnumValueDefinition) {
           const property = normalisePropertyOption(options.EnumValueDefinition);
-          checkNode(node.name, property.style, 'Enumeration value', property.suffix, property.prefix);
+          checkNode(node.name, property, 'Enumeration value');
         }
       },
       InputValueDefinition: node => {
         if (options.InputValueDefinition) {
           const property = normalisePropertyOption(options.InputValueDefinition);
-          checkNode(node.name, property.style, 'Input property', property.suffix, property.prefix);
+          checkNode(node.name, property, 'Input property');
         }
       },
       FragmentDefinition: node => {
         if (options.FragmentDefinition) {
           const property = normalisePropertyOption(options.FragmentDefinition);
-          checkNode(node.name, property.style, 'Fragment', property.suffix, property.prefix);
+          checkNode(node.name, property, 'Fragment');
         }
       },
       ScalarTypeDefinition: node => {
         if (options.ScalarTypeDefinition) {
           const property = normalisePropertyOption(options.ScalarTypeDefinition);
-          checkNode(node.name, property.style, 'Scalar', property.suffix, property.prefix);
+          checkNode(node.name, property, 'Scalar');
         }
       },
       UnionTypeDefinition: node => {
         if (options.UnionTypeDefinition) {
           const property = normalisePropertyOption(options.UnionTypeDefinition);
-          checkNode(node.name, property.style, 'Scalar', property.suffix, property.prefix);
+          checkNode(node.name, property, 'Union');
         }
       },
     };
diff --git a/packages/plugin/tests/naming-convention.spec.ts b/packages/plugin/tests/naming-convention.spec.ts
@@ -103,6 +103,15 @@ ruleTester.runGraphQLTests('naming-convention', rule, {
         },
       ],
     },
+    {
+      code: 'type One { fieldA: String } type Query { QUERY_A(id: ID!): String }',
+      options: [
+        {
+          FieldDefinition: { style: 'camelCase', prefix: 'field' },
+          QueryDefinition: { style: 'UPPER_CASE', prefix: 'QUERY' },
+        },
+      ],
+    },
   ],
   invalid: [
     {
@@ -199,5 +208,23 @@ ruleTester.runGraphQLTests('naming-convention', rule, {
         { message: 'Enumeration value name "VALUE_TWO" should have "ENUM" prefix' },
       ],
     },
+    {
+      code:
+        'type One { getFoo: String, queryBar: String } type Query { getA(id: ID!): String, queryB: String } extend type Query { getC: String }',
+      options: [
+        {
+          ObjectTypeDefinition: { style: 'PascalCase', forbiddenPrefixes: ['On'] },
+          FieldDefinition: { style: 'camelCase', forbiddenPrefixes: ['foo', 'bar'], forbiddenSuffixes: ['Foo'] },
+          QueryDefinition: { style: 'camelCase', forbiddenPrefixes: ['get', 'query'] },
+        },
+      ],
+      errors: [
+        { message: 'Type "One" should not have one of the following prefix(es): On' },
+        { message: 'Field "getFoo" should not have one of the following suffix(es): Foo' },
+        { message: 'Query "getA" should not have one of the following prefix(es): get, query' },
+        { message: 'Query "queryB" should not have one of the following prefix(es): get, query' },
+        { message: 'Query "getC" should not have one of the following prefix(es): get, query' },
+      ],
+    },
   ],
 });

-Original file line number
+Diff line change
@@ @@ -0,0 +1,5 @@ @@
 +---
 +'@graphql-eslint/eslint-plugin': minor
 +---
++
 +[naming-convention] Add forbiddenPrefixes and forbiddenSuffixes options. Add QueryDefinition which targets queries ( may break existing config if FieldDefinition is used )