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

package/esm/rules/no-duplicate-fields.js

@@ -0,0 +1,116 @@
+import "../chunk-U3TKCM4X.js";
+import { Kind } from "graphql";
+const RULE_ID = "no-duplicate-fields", rule = {
+  meta: {
+    type: "suggestion",
+    hasSuggestions: !0,
+    docs: {
+      description: "Checks for duplicate fields in selection set, variables in operation definition, or in arguments set of a field.",
+      category: "Operations",
+      url: `https://the-guild.dev/graphql/eslint/rules/${RULE_ID}`,
+      recommended: !0,
+      examples: [
+        {
+          title: "Incorrect",
+          code: (
+            /* GraphQL */
+            `
+            query {
+              user {
+                name
+                email
+                name # duplicate field
+              }
+            }
+          `
+          )
+        },
+        {
+          title: "Incorrect",
+          code: (
+            /* GraphQL */
+            `
+            query {
+              users(
+                first: 100
+                skip: 50
+                after: "cji629tngfgou0b73kt7vi5jo"
+                first: 100 # duplicate argument
+              ) {
+                id
+              }
+            }
+          `
+          )
+        },
+        {
+          title: "Incorrect",
+          code: (
+            /* GraphQL */
+            `
+            query (
+              $first: Int!
+              $first: Int! # duplicate variable
+            ) {
+              users(first: $first, skip: 50) {
+                id
+              }
+            }
+          `
+          )
+        }
+      ]
+    },
+    messages: {
+      [RULE_ID]: "{{ type }} `{{ fieldName }}` defined multiple times."
+    },
+    schema: []
+  },
+  create(context) {
+    function checkNode(usedFields, node) {
+      const fieldName = node.value;
+      if (usedFields.has(fieldName)) {
+        const { parent } = node;
+        context.report({
+          node,
+          messageId: RULE_ID,
+          data: {
+            type: parent.type,
+            fieldName
+          },
+          suggest: [
+            {
+              desc: `Remove \`${fieldName}\` ${parent.type.toLowerCase()}`,
+              fix(fixer) {
+                return fixer.remove(
+                  parent.type === Kind.VARIABLE ? parent.parent : parent
+                );
+              }
+            }
+          ]
+        });
+      } else
+        usedFields.add(fieldName);
+    }
+    return {
+      OperationDefinition(node) {
+        const set = /* @__PURE__ */ new Set();
+        for (const varDef of node.variableDefinitions || [])
+          checkNode(set, varDef.variable.name);
+      },
+      Field(node) {
+        const set = /* @__PURE__ */ new Set();
+        for (const arg of node.arguments || [])
+          checkNode(set, arg.name);
+      },
+      SelectionSet(node) {
+        const set = /* @__PURE__ */ new Set();
+        for (const selection of node.selections)
+          selection.kind === Kind.FIELD && checkNode(set, selection.alias || selection.name);
+      }
+    };
+  }
+};
+export {
+  rule
+};

package/esm/rules/no-hashtag-description.d.mts

@@ -0,0 +1,14 @@
+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_ID = "HASHTAG_COMMENT";
+declare const rule: GraphQLESLintRule;
+
+export { RULE_ID, rule };

package/esm/rules/no-hashtag-description.js

@@ -0,0 +1,107 @@
+import "../chunk-U3TKCM4X.js";
+import { TokenKind } from "graphql";
+import { getNodeName } from "../utils.js";
+const RULE_ID = "HASHTAG_COMMENT", rule = {
+  meta: {
+    type: "suggestion",
+    hasSuggestions: !0,
+    schema: [],
+    messages: {
+      [RULE_ID]: 'Unexpected GraphQL descriptions as hashtag `#` for {{ nodeName }}.\nPrefer using `"""` for multiline, or `"` for a single line description.'
+    },
+    docs: {
+      description: 'Requires to use `"""` or `"` for adding a GraphQL description instead of `#`.\nAllows to use hashtag for comments, as long as it\'s not attached to an AST definition.',
+      category: "Schema",
+      url: "https://the-guild.dev/graphql/eslint/rules/no-hashtag-description",
+      examples: [
+        {
+          title: "Incorrect",
+          code: (
+            /* GraphQL */
+            `
+            # Represents a user
+            type User {
+              id: ID!
+              name: String
+            }
+          `
+          )
+        },
+        {
+          title: "Correct",
+          code: (
+            /* GraphQL */
+            `
+            " Represents a user "
+            type User {
+              id: ID!
+              name: String
+            }
+          `
+          )
+        },
+        {
+          title: "Correct",
+          code: (
+            /* GraphQL */
+            `
+            # This file defines the basic User type.
+            # This comment is valid because it's not attached specifically to an AST object.
+
+            " Represents a user "
+            type User {
+              id: ID! # This one is also valid, since it comes after the AST object
+              name: String
+            }
+          `
+          )
+        }
+      ],
+      recommended: !0
+    }
+  },
+  create(context) {
+    return {
+      ["Document[definitions.0.kind!=/^(OperationDefinition|FragmentDefinition)$/]"](node) {
+        let token = node.rawNode().loc.startToken;
+        for (; token; ) {
+          const { kind, prev, next, value, line, column } = token;
+          if (kind === TokenKind.COMMENT && prev && next) {
+            const isEslintComment = value.trimStart().startsWith("eslint"), linesAfter = next.line - line;
+            if (!isEslintComment && line !== prev.line && next.kind === TokenKind.NAME && linesAfter < 2) {
+              const sourceCode = context.getSourceCode(), { tokens } = sourceCode.ast, t = tokens.find(
+                (token2) => token2.loc.start.line === next.line && token2.loc.start.column === next.column - 1
+              ), nextNode = sourceCode.getNodeByRangeIndex(t.range[1] + 1);
+              context.report({
+                messageId: RULE_ID,
+                data: {
+                  nodeName: getNodeName(
+                    "name" in nextNode ? nextNode : nextNode.parent
+                  )
+                },
+                loc: {
+                  line,
+                  column: column - 1
+                },
+                suggest: ['"""', '"'].map((descriptionSyntax) => ({
+                  desc: `Replace with \`${descriptionSyntax}\` description syntax`,
+                  fix: (fixer) => fixer.replaceTextRange(
+                    [token.start, token.end],
+                    [descriptionSyntax, value.trim(), descriptionSyntax].join("")
+                  )
+                }))
+              });
+            }
+          }
+          if (!next)
+            break;
+          token = next;
+        }
+      }
+    };
+  }
+};
+export {
+  RULE_ID,
+  rule
+};

package/esm/rules/no-one-place-fragments.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-one-place-fragments.js

@@ -0,0 +1,83 @@
+import "../chunk-U3TKCM4X.js";
+import { relative } from "node:path";
+import { visit } from "graphql";
+import { CWD, requireSiblingsOperations } from "../utils.js";
+const RULE_ID = "no-one-place-fragments", rule = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      category: "Operations",
+      description: "Disallow fragments that are used only in one place.",
+      url: `https://the-guild.dev/graphql/eslint/rules/${RULE_ID}`,
+      examples: [
+        {
+          title: "Incorrect",
+          code: (
+            /* GraphQL */
+            `
+            fragment UserFields on User {
+              id
+            }
+
+            {
+              user {
+                ...UserFields
+              }
+            }
+          `
+          )
+        },
+        {
+          title: "Correct",
+          code: (
+            /* GraphQL */
+            `
+            fragment UserFields on User {
+              id
+            }
+
+            {
+              user {
+                ...UserFields
+                friends {
+                  ...UserFields
+                }
+              }
+            }
+          `
+          )
+        }
+      ],
+      requiresSiblings: !0
+    },
+    messages: {
+      [RULE_ID]: 'Fragment `{{fragmentName}}` used only once. Inline him in "{{filePath}}".'
+    },
+    schema: []
+  },
+  create(context) {
+    const operations = requireSiblingsOperations(RULE_ID, context), allDocuments = [...operations.getOperations(), ...operations.getFragments()], usedFragmentsMap = /* @__PURE__ */ Object.create(null);
+    for (const { document, filePath } of allDocuments) {
+      const relativeFilePath = relative(CWD, filePath);
+      visit(document, {
+        FragmentSpread({ name }) {
+          const spreadName = name.value;
+          usedFragmentsMap[spreadName] ||= [], usedFragmentsMap[spreadName].push(relativeFilePath);
+        }
+      });
+    }
+    return {
+      "FragmentDefinition > Name"(node) {
+        const fragmentName = node.value, fragmentUsage = usedFragmentsMap[fragmentName];
+        fragmentUsage.length === 1 && context.report({
+          node,
+          messageId: RULE_ID,
+          data: { fragmentName, filePath: fragmentUsage[0] }
+        });
+      }
+    };
+  }
+};
+export {
+  rule
+};

package/esm/rules/no-root-type.d.mts

@@ -0,0 +1,34 @@
+import { FromSchema } from 'json-schema-to-ts';
+import { GraphQLESLintRule } from '../types.mjs';
+import 'eslint';
+import 'estree';
+import 'graphql';
+import '../siblings.mjs';
+import '@graphql-tools/utils';
+import '../estree-converter/types.mjs';
+import 'graphql-config';
+
+declare const schema: {
+    readonly type: "array";
+    readonly minItems: 1;
+    readonly maxItems: 1;
+    readonly items: {
+        readonly type: "object";
+        readonly additionalProperties: false;
+        readonly required: readonly ["disallow"];
+        readonly properties: {
+            readonly disallow: {
+                readonly items: {
+                    readonly enum: readonly ["mutation", "subscription"];
+                };
+                readonly type: "array";
+                readonly uniqueItems: true;
+                readonly minItems: 1;
+            };
+        };
+    };
+};
+type RuleOptions = FromSchema<typeof schema>;
+declare const rule: GraphQLESLintRule<RuleOptions>;
+
+export { RuleOptions, rule };

package/esm/rules/no-root-type.js

@@ -0,0 +1,83 @@
+import "../chunk-U3TKCM4X.js";
+import { ARRAY_DEFAULT_OPTIONS, requireGraphQLSchemaFromContext, truthy } from "../utils.js";
+const schema = {
+  type: "array",
+  minItems: 1,
+  maxItems: 1,
+  items: {
+    type: "object",
+    additionalProperties: !1,
+    required: ["disallow"],
+    properties: {
+      disallow: {
+        ...ARRAY_DEFAULT_OPTIONS,
+        items: {
+          enum: ["mutation", "subscription"]
+        }
+      }
+    }
+  }
+}, rule = {
+  meta: {
+    type: "suggestion",
+    hasSuggestions: !0,
+    docs: {
+      category: "Schema",
+      description: "Disallow using root types `mutation` and/or `subscription`.",
+      url: "https://the-guild.dev/graphql/eslint/rules/no-root-type",
+      requiresSchema: !0,
+      examples: [
+        {
+          title: "Incorrect",
+          usage: [{ disallow: ["mutation", "subscription"] }],
+          code: (
+            /* GraphQL */
+            `
+            type Mutation {
+              createUser(input: CreateUserInput!): User!
+            }
+          `
+          )
+        },
+        {
+          title: "Correct",
+          usage: [{ disallow: ["mutation", "subscription"] }],
+          code: (
+            /* GraphQL */
+            `
+            type Query {
+              users: [User!]!
+            }
+          `
+          )
+        }
+      ],
+      configOptions: [{ disallow: ["mutation", "subscription"] }]
+    },
+    schema
+  },
+  create(context) {
+    const schema2 = requireGraphQLSchemaFromContext("no-root-type", context), disallow = new Set(context.options[0].disallow), rootTypeNames = [
+      disallow.has("mutation") && schema2.getMutationType(),
+      disallow.has("subscription") && schema2.getSubscriptionType()
+    ].filter(truthy).map((type) => type.name).join("|");
+    return rootTypeNames ? {
+      [`:matches(ObjectTypeDefinition, ObjectTypeExtension) > .name[value=/^(${rootTypeNames})$/]`](node) {
+        const typeName = node.value;
+        context.report({
+          node,
+          message: `Root type \`${typeName}\` is forbidden.`,
+          suggest: [
+            {
+              desc: `Remove \`${typeName}\` type`,
+              fix: (fixer) => fixer.remove(node.parent)
+            }
+          ]
+        });
+      }
+    } : {};
+  }
+};
+export {
+  rule
+};

package/esm/rules/no-scalar-result-type-on-mutation.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-scalar-result-type-on-mutation.js

@@ -0,0 +1,69 @@
+import "../chunk-U3TKCM4X.js";
+import { isScalarType, Kind } from "graphql";
+import { getNodeName, requireGraphQLSchemaFromContext } from "../utils.js";
+const RULE_ID = "no-scalar-result-type-on-mutation", rule = {
+  meta: {
+    type: "suggestion",
+    hasSuggestions: !0,
+    docs: {
+      category: "Schema",
+      description: "Avoid scalar result type on mutation type to make sure to return a valid state.",
+      url: `https://the-guild.dev/graphql/eslint/rules/${RULE_ID}`,
+      requiresSchema: !0,
+      examples: [
+        {
+          title: "Incorrect",
+          code: (
+            /* GraphQL */
+            `
+            type Mutation {
+              createUser: Boolean
+            }
+          `
+          )
+        },
+        {
+          title: "Correct",
+          code: (
+            /* GraphQL */
+            `
+            type Mutation {
+              createUser: User!
+            }
+          `
+          )
+        }
+      ]
+    },
+    schema: []
+  },
+  create(context) {
+    const schema = requireGraphQLSchemaFromContext(RULE_ID, context), mutationType = schema.getMutationType();
+    return mutationType ? {
+      [[
+        `:matches(ObjectTypeDefinition, ObjectTypeExtension)[name.value=${mutationType.name}]`,
+        "> FieldDefinition > .gqlType Name"
+      ].join(" ")](node) {
+        const typeName = node.value, graphQLType = schema.getType(typeName);
+        if (isScalarType(graphQLType)) {
+          let fieldDef = node.parent;
+          for (; fieldDef.kind !== Kind.FIELD_DEFINITION; )
+            fieldDef = fieldDef.parent;
+          context.report({
+            node,
+            message: `Unexpected scalar result type \`${typeName}\` for ${getNodeName(fieldDef)}`,
+            suggest: [
+              {
+                desc: `Remove \`${typeName}\``,
+                fix: (fixer) => fixer.remove(node)
+              }
+            ]
+          });
+        }
+      }
+    } : {};
+  }
+};
+export {
+  rule
+};

package/esm/rules/no-typename-prefix.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-typename-prefix.js

@@ -0,0 +1,71 @@
+import "../chunk-U3TKCM4X.js";
+const NO_TYPENAME_PREFIX = "NO_TYPENAME_PREFIX", rule = {
+  meta: {
+    type: "suggestion",
+    hasSuggestions: !0,
+    docs: {
+      category: "Schema",
+      description: "Enforces users to avoid using the type name in a field name while defining your schema.",
+      recommended: !0,
+      url: "https://the-guild.dev/graphql/eslint/rules/no-typename-prefix",
+      examples: [
+        {
+          title: "Incorrect",
+          code: (
+            /* GraphQL */
+            `
+            type User {
+              userId: ID!
+            }
+          `
+          )
+        },
+        {
+          title: "Correct",
+          code: (
+            /* GraphQL */
+            `
+            type User {
+              id: ID!
+            }
+          `
+          )
+        }
+      ]
+    },
+    messages: {
+      [NO_TYPENAME_PREFIX]: 'Field "{{ fieldName }}" starts with the name of the parent type "{{ typeName }}"'
+    },
+    schema: []
+  },
+  create(context) {
+    return {
+      "ObjectTypeDefinition, ObjectTypeExtension, InterfaceTypeDefinition, InterfaceTypeExtension"(node) {
+        const typeName = node.name.value, lowerTypeName = typeName.toLowerCase();
+        for (const field of node.fields || []) {
+          const fieldName = field.name.value;
+          fieldName.toLowerCase().startsWith(lowerTypeName) && context.report({
+            data: {
+              fieldName,
+              typeName
+            },
+            messageId: NO_TYPENAME_PREFIX,
+            node: field.name,
+            suggest: [
+              {
+                desc: `Remove \`${fieldName.slice(0, typeName.length)}\` prefix`,
+                fix: (fixer) => fixer.replaceText(
+                  field.name,
+                  fieldName.replace(new RegExp(`^${typeName}`, "i"), "")
+                )
+              }
+            ]
+          });
+        }
+      }
+    };
+  }
+};
+export {
+  rule
+};

package/esm/rules/no-unreachable-types.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 };