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

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

@@ -0,0 +1,136 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+var no_duplicate_fields_exports = {};
+__export(no_duplicate_fields_exports, {
+  rule: () => rule
+});
+module.exports = __toCommonJS(no_duplicate_fields_exports);
+var import_graphql = require("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 === import_graphql.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 === import_graphql.Kind.FIELD && checkNode(set, selection.alias || selection.name);
+      }
+    };
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  rule
+});

package/cjs/rules/no-hashtag-description.d.ts

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

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

@@ -0,0 +1,127 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+var no_hashtag_description_exports = {};
+__export(no_hashtag_description_exports, {
+  RULE_ID: () => RULE_ID,
+  rule: () => rule
+});
+module.exports = __toCommonJS(no_hashtag_description_exports);
+var import_graphql = require("graphql"), import_utils = require("../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 === import_graphql.TokenKind.COMMENT && prev && next) {
+            const isEslintComment = value.trimStart().startsWith("eslint"), linesAfter = next.line - line;
+            if (!isEslintComment && line !== prev.line && next.kind === import_graphql.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: (0, import_utils.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;
+        }
+      }
+    };
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RULE_ID,
+  rule
+});

package/cjs/rules/no-one-place-fragments.d.ts

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

package/cjs/rules/no-one-place-fragments.js

@@ -0,0 +1,101 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+var no_one_place_fragments_exports = {};
+__export(no_one_place_fragments_exports, {
+  rule: () => rule
+});
+module.exports = __toCommonJS(no_one_place_fragments_exports);
+var import_node_path = require("node:path"), import_graphql = require("graphql"), import_utils = require("../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 = (0, import_utils.requireSiblingsOperations)(RULE_ID, context), allDocuments = [...operations.getOperations(), ...operations.getFragments()], usedFragmentsMap = /* @__PURE__ */ Object.create(null);
+    for (const { document, filePath } of allDocuments) {
+      const relativeFilePath = (0, import_node_path.relative)(import_utils.CWD, filePath);
+      (0, import_graphql.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] }
+        });
+      }
+    };
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  rule
+});

package/cjs/rules/no-root-type.d.ts

@@ -0,0 +1,34 @@
+import { FromSchema } from 'json-schema-to-ts';
+import { GraphQLESLintRule } from '../types.js';
+import 'eslint';
+import 'estree';
+import 'graphql';
+import '../siblings.js';
+import '@graphql-tools/utils';
+import '../estree-converter/types.js';
+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/cjs/rules/no-root-type.js

@@ -0,0 +1,103 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+var no_root_type_exports = {};
+__export(no_root_type_exports, {
+  rule: () => rule
+});
+module.exports = __toCommonJS(no_root_type_exports);
+var import_utils = require("../utils.js");
+const schema = {
+  type: "array",
+  minItems: 1,
+  maxItems: 1,
+  items: {
+    type: "object",
+    additionalProperties: !1,
+    required: ["disallow"],
+    properties: {
+      disallow: {
+        ...import_utils.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 = (0, import_utils.requireGraphQLSchemaFromContext)("no-root-type", context), disallow = new Set(context.options[0].disallow), rootTypeNames = [
+      disallow.has("mutation") && schema2.getMutationType(),
+      disallow.has("subscription") && schema2.getSubscriptionType()
+    ].filter(import_utils.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)
+            }
+          ]
+        });
+      }
+    } : {};
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  rule
+});

package/cjs/rules/no-scalar-result-type-on-mutation.d.ts

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

package/cjs/rules/no-scalar-result-type-on-mutation.js

@@ -0,0 +1,88 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+var no_scalar_result_type_on_mutation_exports = {};
+__export(no_scalar_result_type_on_mutation_exports, {
+  rule: () => rule
+});
+module.exports = __toCommonJS(no_scalar_result_type_on_mutation_exports);
+var import_graphql = require("graphql"), import_utils = require("../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 = (0, import_utils.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 ((0, import_graphql.isScalarType)(graphQLType)) {
+          let fieldDef = node.parent;
+          for (; fieldDef.kind !== import_graphql.Kind.FIELD_DEFINITION; )
+            fieldDef = fieldDef.parent;
+          context.report({
+            node,
+            message: `Unexpected scalar result type \`${typeName}\` for ${(0, import_utils.getNodeName)(fieldDef)}`,
+            suggest: [
+              {
+                desc: `Remove \`${typeName}\``,
+                fix: (fixer) => fixer.remove(node)
+              }
+            ]
+          });
+        }
+      }
+    } : {};
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  rule
+});

package/cjs/rules/no-typename-prefix.d.ts

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