@graphql-eslint/eslint-plugin 4.0.0-alpha-20220821140530-e968cfc → 4.0.0-alpha-20230810155929-e89edf7

package/esm/rules/naming-convention.js

@@ -0,0 +1,403 @@
+import "../chunk-U3TKCM4X.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"
+}, 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]*$/
+}, ALLOWED_KINDS = Object.keys(KindToDisplayName).sort(), ALLOWED_STYLES = Object.keys(StyleToRegex), schemaOption = {
+  oneOf: [{ $ref: "#/definitions/asString" }, { $ref: "#/definitions/asObject" }]
+}, schema = {
+  definitions: {
+    asString: {
+      enum: ALLOWED_STYLES,
+      description: `One of: ${ALLOWED_STYLES.map((t) => `\`${t}\``).join(", ")}`
+    },
+    asObject: {
+      type: "object",
+      additionalProperties: !1,
+      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: !1,
+    properties: {
+      types: {
+        ...schemaOption,
+        description: `Includes:
+${TYPES_KINDS.map((kind) => `- \`${kind}\``).join(`
+`)}`
+      },
+      ...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: !1
+      },
+      allowTrailingUnderscore: {
+        type: "boolean",
+        default: !1
+      }
+    },
+    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(`
+`)
+  }
+}, rule = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Require names to follow specified conventions.",
+      category: ["Schema", "Operations"],
+      recommended: !0,
+      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"]
+            },
+            "EnumTypeDefinition,EnumTypeExtension": {
+              forbiddenPrefixes: ["Enum"],
+              forbiddenSuffixes: ["Enum"]
+            },
+            "InterfaceTypeDefinition,InterfaceTypeExtension": {
+              forbiddenPrefixes: ["Interface"],
+              forbiddenSuffixes: ["Interface"]
+            },
+            "UnionTypeDefinition,UnionTypeExtension": {
+              forbiddenPrefixes: ["Union"],
+              forbiddenSuffixes: ["Union"]
+            },
+            "ObjectTypeDefinition,ObjectTypeExtension": {
+              forbiddenPrefixes: ["Type"],
+              forbiddenSuffixes: ["Type"]
+            }
+          }
+        ],
+        operations: [
+          {
+            VariableDefinition: "camelCase",
+            OperationDefinition: {
+              style: "PascalCase",
+              forbiddenPrefixes: ["Query", "Mutation", "Subscription", "Get"],
+              forbiddenSuffixes: ["Query", "Mutation", "Subscription"]
+            },
+            FragmentDefinition: {
+              style: "PascalCase",
+              forbiddenPrefixes: ["Fragment"],
+              forbiddenSuffixes: ["Fragment"]
+            }
+          }
+        ]
+      }
+    },
+    hasSuggestions: !0,
+    schema
+  },
+  create(context) {
+    const options = context.options[0] || {}, { 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), nodeType = KindToDisplayName[n.kind] || n.kind, nodeName = node.value, error = getError();
+      if (error) {
+        const { errorMessage, renameToNames } = error, [leadingUnderscores] = nodeName.match(/^_*/), [trailingUnderscores] = nodeName.match(/_*$/), 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?.find((prefix2) => name.startsWith(prefix2));
+        if (forbiddenPrefix)
+          return {
+            errorMessage: `not have "${forbiddenPrefix}" prefix`,
+            renameToNames: [name.replace(new RegExp(`^${forbiddenPrefix}`), "")]
+          };
+        const forbiddenSuffix = 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;
+        if (!StyleToRegex[style].test(name))
+          return {
+            errorMessage: `be in ${style} format`,
+            renameToNames: [convertCase(style, name)]
+          };
+      }
+    }, checkUnderscore = (isLeading) => (node) => {
+      const suggestedName = node.value.replace(isLeading ? /^_+/ : /_+$/, "");
+      report(node, `${isLeading ? "Leading" : "Trailing"} underscores are not allowed`, [
+        suggestedName
+      ]);
+    }, listeners = {};
+    allowLeadingUnderscore || (listeners["Name[value=/^_/]:matches([parent.kind!=Field], [parent.kind=Field][parent.alias])"] = checkUnderscore(!0)), allowTrailingUnderscore || (listeners["Name[value=/_$/]:matches([parent.kind!=Field], [parent.kind=Field][parent.alias])"] = checkUnderscore(!1));
+    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,13 @@
+import { GraphQLESLintRule } from '../types.mjs';
+import 'eslint';
+import 'estree';
+import 'graphql';
+import 'json-schema-to-ts';
+import '../siblings.mjs';
+import '@graphql-tools/utils';
+import '../estree-converter/types.mjs';
+import 'graphql-config';
+
+declare const rule: GraphQLESLintRule;
+
+export { rule };

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

@@ -0,0 +1,72 @@
+import "../chunk-U3TKCM4X.js";
+import { Kind } from "graphql";
+import { getLocation } from "../utils.js";
+const RULE_ID = "no-anonymous-operations", rule = {
+  meta: {
+    type: "suggestion",
+    hasSuggestions: !0,
+    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: !0,
+      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, 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 hasQueryKeyword = context.getSourceCode().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-deprecated.d.mts

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

package/esm/rules/no-deprecated.js

@@ -0,0 +1,124 @@
+import "../chunk-U3TKCM4X.js";
+import { Kind } from "graphql";
+import { requireGraphQLSchemaFromContext } from "../utils.js";
+const RULE_ID = "no-deprecated", rule = {
+  meta: {
+    type: "suggestion",
+    hasSuggestions: !0,
+    docs: {
+      category: "Operations",
+      description: "Enforce that deprecated fields or enum values are not in use by operations.",
+      url: `https://the-guild.dev/graphql/eslint/rules/${RULE_ID}`,
+      requiresSchema: !0,
+      examples: [
+        {
+          title: "Incorrect (field)",
+          code: (
+            /* GraphQL */
+            `
+            # In your schema
+            type User {
+              id: ID!
+              name: String! @deprecated(reason: "old field, please use fullName instead")
+              fullName: String!
+            }
+
+            # Query
+            query user {
+              user {
+                name # This is deprecated, so you'll get an error
+              }
+            }
+          `
+          )
+        },
+        {
+          title: "Incorrect (enum value)",
+          code: (
+            /* GraphQL */
+            `
+            # In your schema
+            type Mutation {
+              changeSomething(type: SomeType): Boolean!
+            }
+
+            enum SomeType {
+              NEW
+              OLD @deprecated(reason: "old field, please use NEW instead")
+            }
+
+            # Mutation
+            mutation {
+              changeSomething(
+                type: OLD # This is deprecated, so you'll get an error
+              ) {
+                ...
+              }
+            }
+          `
+          )
+        },
+        {
+          title: "Correct",
+          code: (
+            /* GraphQL */
+            `
+            # In your schema
+            type User {
+              id: ID!
+              name: String! @deprecated(reason: "old field, please use fullName instead")
+              fullName: String!
+            }
+
+            # Query
+            query user {
+              user {
+                id
+                fullName
+              }
+            }
+          `
+          )
+        }
+      ],
+      recommended: !0
+    },
+    messages: {
+      [RULE_ID]: "This {{ type }} is marked as deprecated in your GraphQL schema (reason: {{ reason }})"
+    },
+    schema: []
+  },
+  create(context) {
+    requireGraphQLSchemaFromContext(RULE_ID, context);
+    function report(node, reason) {
+      const nodeName = node.kind === Kind.ENUM ? node.value : node.name.value, nodeType = node.kind === Kind.ENUM ? "enum value" : "field";
+      context.report({
+        node,
+        messageId: RULE_ID,
+        data: {
+          type: nodeType,
+          reason
+        },
+        suggest: [
+          {
+            desc: `Remove \`${nodeName}\` ${nodeType}`,
+            fix: (fixer) => fixer.remove(node)
+          }
+        ]
+      });
+    }
+    return {
+      EnumValue(node) {
+        const reason = node.typeInfo().enumValue?.deprecationReason;
+        reason && report(node, reason);
+      },
+      Field(node) {
+        const reason = node.typeInfo().fieldDef?.deprecationReason;
+        reason && report(node, reason);
+      }
+    };
+  }
+};
+export {
+  rule
+};

package/esm/rules/no-duplicate-fields.d.mts

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