@graphql-eslint/eslint-plugin 4.0.0-alpha-20220821140530-e968cfc → 4.0.0-alpha-20230801163310-8bc4340

package/esm/rules/naming-convention.js

@@ -0,0 +1,417 @@
+import "../chunk-BMTV3EA2.js";
+import { Kind } from "graphql";
+import {
+  ARRAY_DEFAULT_OPTIONS,
+  convertCase,
+  englishJoinWords,
+  truthy,
+  TYPES_KINDS
+} from "../utils.js";
+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.ARGUMENT]: "Argument",
+  [Kind.DIRECTIVE_DEFINITION]: "Directive",
+  // rest
+  [Kind.ENUM_VALUE_DEFINITION]: "Enumeration value",
+  [Kind.OPERATION_DEFINITION]: "Operation",
+  [Kind.FRAGMENT_DEFINITION]: "Fragment",
+  [Kind.VARIABLE_DEFINITION]: "Variable"
+};
+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 = {
+  oneOf: [{ $ref: "#/definitions/asString" }, { $ref: "#/definitions/asObject" }]
+};
+const schema = {
+  definitions: {
+    asString: {
+      enum: ALLOWED_STYLES,
+      description: `One of: ${ALLOWED_STYLES.map((t) => `\`${t}\``).join(", ")}`
+    },
+    asObject: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        style: { enum: ALLOWED_STYLES },
+        prefix: { type: "string" },
+        suffix: { type: "string" },
+        forbiddenPrefixes: ARRAY_DEFAULT_OPTIONS,
+        forbiddenSuffixes: ARRAY_DEFAULT_OPTIONS,
+        requiredPrefixes: ARRAY_DEFAULT_OPTIONS,
+        requiredSuffixes: ARRAY_DEFAULT_OPTIONS,
+        ignorePattern: {
+          type: "string",
+          description: "Option to skip validation of some words, e.g. acronyms"
+        }
+      }
+    }
+  },
+  type: "array",
+  maxItems: 1,
+  items: {
+    type: "object",
+    additionalProperties: false,
+    properties: {
+      types: {
+        ...schemaOption,
+        description: `Includes:
+${TYPES_KINDS.map((kind) => `- \`${kind}\``).join("\n")}`
+      },
+      ...Object.fromEntries(
+        ALLOWED_KINDS.map((kind) => [
+          kind,
+          {
+            ...schemaOption,
+            description: `Read more about this kind on [spec.graphql.org](https://spec.graphql.org/October2021/#${kind}).`
+          }
+        ])
+      ),
+      allowLeadingUnderscore: {
+        type: "boolean",
+        default: false
+      },
+      allowTrailingUnderscore: {
+        type: "boolean",
+        default: false
+      }
+    },
+    patternProperties: {
+      [`^(${ALLOWED_KINDS.join("|")})(.+)?$`]: schemaOption
+    },
+    description: [
+      "> It's possible to use a [`selector`](https://eslint.org/docs/developer-guide/selectors) that starts with allowed `ASTNode` names which are described below.",
+      ">",
+      "> Paste or drop code into the editor in [ASTExplorer](https://astexplorer.net) and inspect the generated AST to compose your selector.",
+      ">",
+      "> Example: pattern property `FieldDefinition[parent.name.value=Query]` will match only fields for type `Query`."
+    ].join("\n")
+  }
+};
+const rule = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Require names to follow specified conventions.",
+      category: ["Schema", "Operations"],
+      recommended: true,
+      url: "https://the-guild.dev/graphql/eslint/rules/naming-convention",
+      examples: [
+        {
+          title: "Incorrect",
+          usage: [{ types: "PascalCase", FieldDefinition: "camelCase" }],
+          code: (
+            /* GraphQL */
+            `
+            type user {
+              first_name: String!
+            }
+          `
+          )
+        },
+        {
+          title: "Incorrect",
+          usage: [{ FragmentDefinition: { style: "PascalCase", forbiddenSuffixes: ["Fragment"] } }],
+          code: (
+            /* GraphQL */
+            `
+            fragment UserFragment on User {
+              # ...
+            }
+          `
+          )
+        },
+        {
+          title: "Incorrect",
+          usage: [{ "FieldDefinition[parent.name.value=Query]": { forbiddenPrefixes: ["get"] } }],
+          code: (
+            /* GraphQL */
+            `
+            type Query {
+              getUsers: [User!]!
+            }
+          `
+          )
+        },
+        {
+          title: "Correct",
+          usage: [{ types: "PascalCase", FieldDefinition: "camelCase" }],
+          code: (
+            /* GraphQL */
+            `
+            type User {
+              firstName: String
+            }
+          `
+          )
+        },
+        {
+          title: "Correct",
+          usage: [{ FragmentDefinition: { style: "PascalCase", forbiddenSuffixes: ["Fragment"] } }],
+          code: (
+            /* GraphQL */
+            `
+            fragment UserFields on User {
+              # ...
+            }
+          `
+          )
+        },
+        {
+          title: "Correct",
+          usage: [{ "FieldDefinition[parent.name.value=Query]": { forbiddenPrefixes: ["get"] } }],
+          code: (
+            /* GraphQL */
+            `
+            type Query {
+              users: [User!]!
+            }
+          `
+          )
+        },
+        {
+          title: "Correct",
+          usage: [{ FieldDefinition: { style: "camelCase", ignorePattern: "^(EAN13|UPC|UK)" } }],
+          code: (
+            /* GraphQL */
+            `
+            type Product {
+              EAN13: String
+              UPC: String
+              UKFlag: String
+            }
+          `
+          )
+        },
+        {
+          title: "Correct",
+          usage: [
+            {
+              "FieldDefinition[gqlType.name.value=Boolean]": {
+                style: "camelCase",
+                requiredPrefixes: ["is", "has"]
+              },
+              "FieldDefinition[gqlType.gqlType.name.value=Boolean]": {
+                style: "camelCase",
+                requiredPrefixes: ["is", "has"]
+              }
+            }
+          ],
+          code: (
+            /* GraphQL */
+            `
+            type Product {
+              isBackordered: Boolean
+              isNew: Boolean!
+              hasDiscount: Boolean!
+            }
+          `
+          )
+        },
+        {
+          title: "Correct",
+          usage: [
+            {
+              "FieldDefinition[gqlType.gqlType.name.value=SensitiveSecret]": {
+                style: "camelCase",
+                requiredSuffixes: ["SensitiveSecret"]
+              }
+            }
+          ],
+          code: (
+            /* GraphQL */
+            `
+            scalar SensitiveSecret
+
+            type Account {
+              accountSensitiveSecret: SensitiveSecret!
+            }
+          `
+          )
+        }
+      ],
+      configOptions: {
+        schema: [
+          {
+            types: "PascalCase",
+            FieldDefinition: "camelCase",
+            InputValueDefinition: "camelCase",
+            Argument: "camelCase",
+            DirectiveDefinition: "camelCase",
+            EnumValueDefinition: "UPPER_CASE",
+            "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"]
+            }
+          }
+        ],
+        operations: [
+          {
+            VariableDefinition: "camelCase",
+            OperationDefinition: {
+              style: "PascalCase",
+              forbiddenPrefixes: ["Query", "Mutation", "Subscription", "Get"],
+              forbiddenSuffixes: ["Query", "Mutation", "Subscription"]
+            },
+            FragmentDefinition: {
+              style: "PascalCase",
+              forbiddenPrefixes: ["Fragment"],
+              forbiddenSuffixes: ["Fragment"]
+            }
+          }
+        ]
+      }
+    },
+    hasSuggestions: true,
+    schema
+  },
+  create(context) {
+    const options = context.options[0] || {};
+    const { allowLeadingUnderscore, allowTrailingUnderscore, types, ...restOptions } = options;
+    function normalisePropertyOption(kind) {
+      const style = restOptions[kind] || types;
+      return typeof style === "object" ? style : { style };
+    }
+    function report(node, message, suggestedNames) {
+      context.report({
+        node,
+        message,
+        suggest: suggestedNames.map((suggestedName) => ({
+          desc: `Rename to \`${suggestedName}\``,
+          fix: (fixer) => fixer.replaceText(node, suggestedName)
+        }))
+      });
+    }
+    const checkNode = (selector) => (n) => {
+      const { name: node } = n.kind === Kind.VARIABLE_DEFINITION ? n.variable : n;
+      if (!node) {
+        return;
+      }
+      const {
+        prefix,
+        suffix,
+        forbiddenPrefixes,
+        forbiddenSuffixes,
+        style,
+        ignorePattern,
+        requiredPrefixes,
+        requiredSuffixes
+      } = normalisePropertyOption(selector);
+      const nodeType = KindToDisplayName[n.kind] || n.kind;
+      const nodeName = node.value;
+      const error = getError();
+      if (error) {
+        const { errorMessage, renameToNames } = error;
+        const [leadingUnderscores] = nodeName.match(/^_*/);
+        const [trailingUnderscores] = nodeName.match(/_*$/);
+        const suggestedNames = renameToNames.map(
+          (renameToName) => leadingUnderscores + renameToName + trailingUnderscores
+        );
+        report(node, `${nodeType} "${nodeName}" should ${errorMessage}`, suggestedNames);
+      }
+      function getError() {
+        const name = nodeName.replace(/(^_+)|(_+$)/g, "");
+        if (ignorePattern && new RegExp(ignorePattern, "u").test(name)) {
+          return;
+        }
+        if (prefix && !name.startsWith(prefix)) {
+          return {
+            errorMessage: `have "${prefix}" prefix`,
+            renameToNames: [prefix + name]
+          };
+        }
+        if (suffix && !name.endsWith(suffix)) {
+          return {
+            errorMessage: `have "${suffix}" suffix`,
+            renameToNames: [name + suffix]
+          };
+        }
+        const forbiddenPrefix = forbiddenPrefixes == null ? void 0 : forbiddenPrefixes.find((prefix2) => name.startsWith(prefix2));
+        if (forbiddenPrefix) {
+          return {
+            errorMessage: `not have "${forbiddenPrefix}" prefix`,
+            renameToNames: [name.replace(new RegExp(`^${forbiddenPrefix}`), "")]
+          };
+        }
+        const forbiddenSuffix = forbiddenSuffixes == null ? void 0 : forbiddenSuffixes.find((suffix2) => name.endsWith(suffix2));
+        if (forbiddenSuffix) {
+          return {
+            errorMessage: `not have "${forbiddenSuffix}" suffix`,
+            renameToNames: [name.replace(new RegExp(`${forbiddenSuffix}$`), "")]
+          };
+        }
+        if (requiredPrefixes && !requiredPrefixes.some((requiredPrefix) => name.startsWith(requiredPrefix))) {
+          return {
+            errorMessage: `have one of the following prefixes: ${englishJoinWords(
+              requiredPrefixes
+            )}`,
+            renameToNames: style ? requiredPrefixes.map((prefix2) => convertCase(style, `${prefix2} ${name}`)) : requiredPrefixes.map((prefix2) => `${prefix2}${name}`)
+          };
+        }
+        if (requiredSuffixes && !requiredSuffixes.some((requiredSuffix) => name.endsWith(requiredSuffix))) {
+          return {
+            errorMessage: `have one of the following suffixes: ${englishJoinWords(
+              requiredSuffixes
+            )}`,
+            renameToNames: style ? requiredSuffixes.map((suffix2) => convertCase(style, `${name} ${suffix2}`)) : requiredSuffixes.map((suffix2) => `${name}${suffix2}`)
+          };
+        }
+        if (!style) {
+          return;
+        }
+        const caseRegex = StyleToRegex[style];
+        if (!caseRegex.test(name)) {
+          return {
+            errorMessage: `be in ${style} format`,
+            renameToNames: [convertCase(style, name)]
+          };
+        }
+      }
+    };
+    const checkUnderscore = (isLeading) => (node) => {
+      const suggestedName = node.value.replace(isLeading ? /^_+/ : /_+$/, "");
+      report(node, `${isLeading ? "Leading" : "Trailing"} underscores are not allowed`, [
+        suggestedName
+      ]);
+    };
+    const listeners = {};
+    if (!allowLeadingUnderscore) {
+      listeners["Name[value=/^_/]:matches([parent.kind!=Field], [parent.kind=Field][parent.alias])"] = checkUnderscore(true);
+    }
+    if (!allowTrailingUnderscore) {
+      listeners["Name[value=/_$/]:matches([parent.kind!=Field], [parent.kind=Field][parent.alias])"] = checkUnderscore(false);
+    }
+    const selectors = new Set(
+      [types && TYPES_KINDS, Object.keys(restOptions)].flat().filter(truthy)
+    );
+    for (const selector of selectors) {
+      listeners[selector] = checkNode(selector);
+    }
+    return listeners;
+  }
+};
+export {
+  rule
+};

package/esm/rules/no-anonymous-operations.d.mts

@@ -0,0 +1,12 @@
+import { f as GraphQLESLintRule } from '../types-ace77d86.js';
+import '@graphql-tools/utils';
+import 'eslint';
+import 'estree';
+import 'graphql';
+import 'graphql-config';
+import 'json-schema-to-ts';
+import '../estree-converter/types.mjs';
+
+declare const rule: GraphQLESLintRule;
+
+export { rule };

package/esm/rules/no-anonymous-operations.js

@@ -0,0 +1,75 @@
+import "../chunk-BMTV3EA2.js";
+import { Kind } from "graphql";
+import { getLocation } from "../utils.js";
+const RULE_ID = "no-anonymous-operations";
+const rule = {
+  meta: {
+    type: "suggestion",
+    hasSuggestions: true,
+    docs: {
+      category: "Operations",
+      description: "Require name for your GraphQL operations. This is useful since most GraphQL client libraries are using the operation name for caching purposes.",
+      recommended: true,
+      url: `https://the-guild.dev/graphql/eslint/rules/${RULE_ID}`,
+      examples: [
+        {
+          title: "Incorrect",
+          code: (
+            /* GraphQL */
+            `
+            query {
+              # ...
+            }
+          `
+          )
+        },
+        {
+          title: "Correct",
+          code: (
+            /* GraphQL */
+            `
+            query user {
+              # ...
+            }
+          `
+          )
+        }
+      ]
+    },
+    messages: {
+      [RULE_ID]: "Anonymous GraphQL operations are forbidden. Make sure to name your {{ operation }}!"
+    },
+    schema: []
+  },
+  create(context) {
+    return {
+      "OperationDefinition[name=undefined]"(node) {
+        const [firstSelection] = node.selectionSet.selections;
+        const suggestedName = firstSelection.kind === Kind.FIELD ? (firstSelection.alias || firstSelection.name).value : node.operation;
+        context.report({
+          loc: getLocation(node.loc.start, node.operation),
+          messageId: RULE_ID,
+          data: {
+            operation: node.operation
+          },
+          suggest: [
+            {
+              desc: `Rename to \`${suggestedName}\``,
+              fix(fixer) {
+                const sourceCode = context.getSourceCode();
+                const hasQueryKeyword = sourceCode.getText({ range: [node.range[0], node.range[0] + 1] }) !== "{";
+                return fixer.insertTextAfterRange(
+                  [node.range[0], node.range[0] + (hasQueryKeyword ? node.operation.length : 0)],
+                  `${hasQueryKeyword ? "" : "query"} ${suggestedName}${hasQueryKeyword ? "" : " "}`
+                );
+              }
+            }
+          ]
+        });
+      }
+    };
+  }
+};
+export {
+  rule
+};

package/esm/rules/no-case-insensitive-enum-values-duplicates.d.mts

@@ -0,0 +1,12 @@
+import { f as GraphQLESLintRule } from '../types-ace77d86.js';
+import '@graphql-tools/utils';
+import 'eslint';
+import 'estree';
+import 'graphql';
+import 'graphql-config';
+import 'json-schema-to-ts';
+import '../estree-converter/types.mjs';
+
+declare const rule: GraphQLESLintRule;
+
+export { rule };

package/esm/rules/no-case-insensitive-enum-values-duplicates.js

@@ -0,0 +1,73 @@
+import "../chunk-BMTV3EA2.js";
+import { Kind } from "graphql";
+import { getNodeName } from "../utils.js";
+const rule = {
+  meta: {
+    type: "suggestion",
+    hasSuggestions: true,
+    docs: {
+      url: "https://the-guild.dev/graphql/eslint/rules/no-case-insensitive-enum-values-duplicates",
+      category: "Schema",
+      recommended: true,
+      description: "Disallow case-insensitive enum values duplicates.",
+      examples: [
+        {
+          title: "Incorrect",
+          code: (
+            /* GraphQL */
+            `
+            enum MyEnum {
+              Value
+              VALUE
+              ValuE
+            }
+          `
+          )
+        },
+        {
+          title: "Correct",
+          code: (
+            /* GraphQL */
+            `
+            enum MyEnum {
+              Value1
+              Value2
+              Value3
+            }
+          `
+          )
+        }
+      ]
+    },
+    schema: []
+  },
+  create(context) {
+    const selector = [Kind.ENUM_TYPE_DEFINITION, Kind.ENUM_TYPE_EXTENSION].join(",");
+    return {
+      [selector](node) {
+        var _a;
+        const duplicates = (_a = node.values) == null ? void 0 : _a.filter(
+          (item, index, array) => array.findIndex((v) => v.name.value.toLowerCase() === item.name.value.toLowerCase()) !== index
+        );
+        for (const duplicate of duplicates || []) {
+          const enumName = duplicate.name.value;
+          context.report({
+            node: duplicate.name,
+            message: `Unexpected case-insensitive enum values duplicates for ${getNodeName(
+              duplicate
+            )}`,
+            suggest: [
+              {
+                desc: `Remove \`${enumName}\` enum value`,
+                fix: (fixer) => fixer.remove(duplicate)
+              }
+            ]
+          });
+        }
+      }
+    };
+  }
+};
+export {
+  rule
+};

package/esm/rules/no-deprecated.d.mts

@@ -0,0 +1,12 @@
+import { f as GraphQLESLintRule } from '../types-ace77d86.js';
+import '@graphql-tools/utils';
+import 'eslint';
+import 'estree';
+import 'graphql';
+import 'graphql-config';
+import 'json-schema-to-ts';
+import '../estree-converter/types.mjs';
+
+declare const rule: GraphQLESLintRule<[], true>;
+
+export { rule };