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

package/cjs/rules/require-description.js

@@ -0,0 +1,205 @@
+"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: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__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: true }), mod);
+var require_description_exports = {};
+__export(require_description_exports, {
+  RULE_ID: () => RULE_ID,
+  rule: () => rule
+});
+module.exports = __toCommonJS(require_description_exports);
+var import_utils = require("@graphql-tools/utils");
+var import_graphql = require("graphql");
+var import_utils2 = require("../utils.js");
+const RULE_ID = "require-description";
+const ALLOWED_KINDS = [
+  ...import_utils2.TYPES_KINDS,
+  import_graphql.Kind.DIRECTIVE_DEFINITION,
+  import_graphql.Kind.FIELD_DEFINITION,
+  import_graphql.Kind.INPUT_VALUE_DEFINITION,
+  import_graphql.Kind.ENUM_VALUE_DEFINITION,
+  import_graphql.Kind.OPERATION_DEFINITION
+];
+const schema = {
+  type: "array",
+  minItems: 1,
+  maxItems: 1,
+  items: {
+    type: "object",
+    additionalProperties: false,
+    minProperties: 1,
+    properties: {
+      types: {
+        type: "boolean",
+        description: `Includes:
+${import_utils2.TYPES_KINDS.map((kind) => `- \`${kind}\``).join("\n")}`
+      },
+      rootField: {
+        type: "boolean",
+        description: "Definitions within `Query`, `Mutation`, and `Subscription` root types."
+      },
+      ...Object.fromEntries(
+        [...ALLOWED_KINDS].sort().map((kind) => {
+          let description = `Read more about this kind on [spec.graphql.org](https://spec.graphql.org/October2021/#${kind}).`;
+          if (kind === import_graphql.Kind.OPERATION_DEFINITION) {
+            description += '\n> You must use only comment syntax `#` and not description syntax `"""` or `"`.';
+          }
+          return [kind, { type: "boolean", description }];
+        })
+      )
+    }
+  }
+};
+const rule = {
+  meta: {
+    docs: {
+      category: "Schema",
+      description: "Enforce descriptions in type definitions and operations.",
+      url: `https://the-guild.dev/graphql/eslint/rules/${RULE_ID}`,
+      examples: [
+        {
+          title: "Incorrect",
+          usage: [{ types: true, FieldDefinition: true }],
+          code: (
+            /* GraphQL */
+            `
+            type someTypeName {
+              name: String
+            }
+          `
+          )
+        },
+        {
+          title: "Correct",
+          usage: [{ types: true, FieldDefinition: true }],
+          code: (
+            /* GraphQL */
+            `
+            """
+            Some type description
+            """
+            type someTypeName {
+              """
+              Name description
+              """
+              name: String
+            }
+          `
+          )
+        },
+        {
+          title: "Correct",
+          usage: [{ OperationDefinition: true }],
+          code: (
+            /* GraphQL */
+            `
+            # Create a new user
+            mutation createUser {
+              # ...
+            }
+          `
+          )
+        },
+        {
+          title: "Correct",
+          usage: [{ rootField: true }],
+          code: (
+            /* GraphQL */
+            `
+            type Mutation {
+              "Create a new user"
+              createUser: User
+            }
+
+            type User {
+              name: String
+            }
+          `
+          )
+        }
+      ],
+      configOptions: [
+        {
+          types: true,
+          [import_graphql.Kind.DIRECTIVE_DEFINITION]: true
+          // rootField: true TODO enable in graphql-eslint v4
+        }
+      ],
+      recommended: true
+    },
+    type: "suggestion",
+    messages: {
+      [RULE_ID]: "Description is required for {{ nodeName }}"
+    },
+    schema
+  },
+  create(context) {
+    const { types, rootField, ...restOptions } = context.options[0] || {};
+    const kinds = new Set(types ? import_utils2.TYPES_KINDS : []);
+    for (const [kind, isEnabled] of Object.entries(restOptions)) {
+      if (isEnabled) {
+        kinds.add(kind);
+      } else {
+        kinds.delete(kind);
+      }
+    }
+    if (rootField) {
+      const schema2 = (0, import_utils2.requireGraphQLSchemaFromContext)(RULE_ID, context);
+      const rootTypeNames = (0, import_utils.getRootTypeNames)(schema2);
+      kinds.add(
+        `:matches(ObjectTypeDefinition, ObjectTypeExtension)[name.value=/^(${[
+          ...rootTypeNames
+        ].join(",")})$/] > FieldDefinition`
+      );
+    }
+    const selector = [...kinds].join(",");
+    return {
+      [selector](node) {
+        var _a;
+        let description = "";
+        const isOperation = node.kind === import_graphql.Kind.OPERATION_DEFINITION;
+        if (isOperation) {
+          const rawNode = node.rawNode();
+          const { prev, line } = rawNode.loc.startToken;
+          if ((prev == null ? void 0 : prev.kind) === import_graphql.TokenKind.COMMENT) {
+            const value = prev.value.trim();
+            const linesBefore = line - prev.line;
+            if (!value.startsWith("eslint") && linesBefore === 1) {
+              description = value;
+            }
+          }
+        } else {
+          description = ((_a = node.description) == null ? void 0 : _a.value.trim()) || "";
+        }
+        if (description.length === 0) {
+          context.report({
+            loc: isOperation ? (0, import_utils2.getLocation)(node.loc.start, node.operation) : node.name.loc,
+            messageId: RULE_ID,
+            data: {
+              nodeName: (0, import_utils2.getNodeName)(node)
+            }
+          });
+        }
+      }
+    };
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RULE_ID,
+  rule
+});

package/cjs/rules/require-field-of-type-query-in-mutation-result.d.ts

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

package/cjs/rules/require-field-of-type-query-in-mutation-result.js

@@ -0,0 +1,102 @@
+"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: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__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: true }), mod);
+var require_field_of_type_query_in_mutation_result_exports = {};
+__export(require_field_of_type_query_in_mutation_result_exports, {
+  rule: () => rule
+});
+module.exports = __toCommonJS(require_field_of_type_query_in_mutation_result_exports);
+var import_graphql = require("graphql");
+var import_utils = require("../utils.js");
+const RULE_ID = "require-field-of-type-query-in-mutation-result";
+const rule = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      category: "Schema",
+      description: "Allow the client in one round-trip not only to call mutation but also to get a wagon of data to update their application.\n> Currently, no errors are reported for result type `union`, `interface` and `scalar`.",
+      url: `https://the-guild.dev/graphql/eslint/rules/${RULE_ID}`,
+      requiresSchema: true,
+      examples: [
+        {
+          title: "Incorrect",
+          code: (
+            /* GraphQL */
+            `
+            type User { ... }
+
+            type Mutation {
+              createUser: User!
+            }
+          `
+          )
+        },
+        {
+          title: "Correct",
+          code: (
+            /* GraphQL */
+            `
+            type User { ... }
+
+            type Query { ... }
+
+            type CreateUserPayload {
+              user: User!
+              query: Query!
+            }
+
+            type Mutation {
+              createUser: CreateUserPayload!
+            }
+          `
+          )
+        }
+      ]
+    },
+    schema: []
+  },
+  create(context) {
+    const schema = (0, import_utils.requireGraphQLSchemaFromContext)(RULE_ID, context);
+    const mutationType = schema.getMutationType();
+    const queryType = schema.getQueryType();
+    if (!mutationType || !queryType) {
+      return {};
+    }
+    const selector = `:matches(ObjectTypeDefinition, ObjectTypeExtension)[name.value=${mutationType.name}] > FieldDefinition > .gqlType Name`;
+    return {
+      [selector](node) {
+        const typeName = node.value;
+        const graphQLType = schema.getType(typeName);
+        if ((0, import_graphql.isObjectType)(graphQLType)) {
+          const { fields } = graphQLType.astNode;
+          const hasQueryType = fields == null ? void 0 : fields.some((field) => (0, import_utils.getTypeName)(field) === queryType.name);
+          if (!hasQueryType) {
+            context.report({
+              node,
+              message: `Mutation result type "${graphQLType.name}" must contain field of type "${queryType.name}"`
+            });
+          }
+        }
+      }
+    };
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  rule
+});

package/cjs/rules/require-id-when-available.d.ts

@@ -0,0 +1,44 @@
+import { FromSchema } from 'json-schema-to-ts';
+import { f as GraphQLESLintRule } from '../types-8d5f4ae0.js';
+import '@graphql-tools/utils';
+import 'eslint';
+import 'estree';
+import 'graphql';
+import 'graphql-config';
+import '../estree-converter/types.js';
+
+declare const schema: {
+    readonly definitions: {
+        readonly asString: {
+            readonly type: "string";
+        };
+        readonly asArray: {
+            readonly type: "array";
+            readonly uniqueItems: true;
+            readonly minItems: 1;
+            readonly items: {
+                readonly type: "string";
+            };
+        };
+    };
+    readonly type: "array";
+    readonly maxItems: 1;
+    readonly items: {
+        readonly type: "object";
+        readonly additionalProperties: false;
+        readonly properties: {
+            readonly fieldName: {
+                readonly oneOf: readonly [{
+                    readonly $ref: "#/definitions/asString";
+                }, {
+                    readonly $ref: "#/definitions/asArray";
+                }];
+                readonly default: "id";
+            };
+        };
+    };
+};
+type RuleOptions = FromSchema<typeof schema>;
+declare const rule: GraphQLESLintRule<RuleOptions, true>;
+
+export { RuleOptions, rule };

package/cjs/rules/require-id-when-available.js

@@ -0,0 +1,241 @@
+"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: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__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: true }), mod);
+var require_id_when_available_exports = {};
+__export(require_id_when_available_exports, {
+  rule: () => rule
+});
+module.exports = __toCommonJS(require_id_when_available_exports);
+var import_utils = require("@graphql-tools/utils");
+var import_graphql = require("graphql");
+var import_estree_converter = require("../estree-converter/index.js");
+var import_utils2 = require("../utils.js");
+const RULE_ID = "require-id-when-available";
+const DEFAULT_ID_FIELD_NAME = "id";
+const schema = {
+  definitions: {
+    asString: {
+      type: "string"
+    },
+    asArray: import_utils2.ARRAY_DEFAULT_OPTIONS
+  },
+  type: "array",
+  maxItems: 1,
+  items: {
+    type: "object",
+    additionalProperties: false,
+    properties: {
+      fieldName: {
+        oneOf: [{ $ref: "#/definitions/asString" }, { $ref: "#/definitions/asArray" }],
+        default: DEFAULT_ID_FIELD_NAME
+      }
+    }
+  }
+};
+const rule = {
+  meta: {
+    type: "suggestion",
+    hasSuggestions: true,
+    docs: {
+      category: "Operations",
+      description: "Enforce selecting specific fields when they are available on the GraphQL type.",
+      url: `https://the-guild.dev/graphql/eslint/rules/${RULE_ID}`,
+      requiresSchema: true,
+      requiresSiblings: true,
+      examples: [
+        {
+          title: "Incorrect",
+          code: (
+            /* GraphQL */
+            `
+            # In your schema
+            type User {
+              id: ID!
+              name: String!
+            }
+
+            # Query
+            query {
+              user {
+                name
+              }
+            }
+          `
+          )
+        },
+        {
+          title: "Correct",
+          code: (
+            /* GraphQL */
+            `
+            # In your schema
+            type User {
+              id: ID!
+              name: String!
+            }
+
+            # Query
+            query {
+              user {
+                id
+                name
+              }
+            }
+
+            # Selecting \`id\` with an alias is also valid
+            query {
+              user {
+                id: name
+              }
+            }
+          `
+          )
+        }
+      ],
+      recommended: true
+    },
+    messages: {
+      [RULE_ID]: "Field{{ pluralSuffix }} {{ fieldName }} must be selected when it's available on a type.\nInclude it in your selection set{{ addition }}."
+    },
+    schema
+  },
+  create(context) {
+    const schema2 = (0, import_utils2.requireGraphQLSchemaFromContext)(RULE_ID, context);
+    const siblings = (0, import_utils2.requireSiblingsOperations)(RULE_ID, context);
+    const { fieldName = DEFAULT_ID_FIELD_NAME } = context.options[0] || {};
+    const idNames = (0, import_utils.asArray)(fieldName);
+    const selector = "OperationDefinition SelectionSet[parent.kind!=/(^OperationDefinition|InlineFragment)$/]";
+    const typeInfo = new import_graphql.TypeInfo(schema2);
+    function checkFragments(node) {
+      for (const selection of node.selections) {
+        if (selection.kind !== import_graphql.Kind.FRAGMENT_SPREAD) {
+          continue;
+        }
+        const [foundSpread] = siblings.getFragment(selection.name.value);
+        if (!foundSpread) {
+          continue;
+        }
+        const checkedFragmentSpreads = /* @__PURE__ */ new Set();
+        const visitor = (0, import_graphql.visitWithTypeInfo)(typeInfo, {
+          SelectionSet(node2, key, _parent) {
+            const parent = _parent;
+            if (parent.kind === import_graphql.Kind.FRAGMENT_DEFINITION) {
+              checkedFragmentSpreads.add(parent.name.value);
+            } else if (parent.kind !== import_graphql.Kind.INLINE_FRAGMENT) {
+              checkSelections(
+                node2,
+                typeInfo.getType(),
+                selection.loc.start,
+                parent,
+                checkedFragmentSpreads
+              );
+            }
+          }
+        });
+        (0, import_graphql.visit)(foundSpread.document, visitor);
+      }
+    }
+    function checkSelections(node, type, loc, parent, checkedFragmentSpreads = /* @__PURE__ */ new Set()) {
+      const rawType = (0, import_estree_converter.getBaseType)(type);
+      if (rawType instanceof import_graphql.GraphQLObjectType || rawType instanceof import_graphql.GraphQLInterfaceType) {
+        checkFields(rawType);
+      } else if (rawType instanceof import_graphql.GraphQLUnionType) {
+        for (const selection of node.selections) {
+          if (selection.kind === import_graphql.Kind.INLINE_FRAGMENT) {
+            const types = rawType.getTypes();
+            const t = types.find((t2) => t2.name === selection.typeCondition.name.value);
+            if (t) {
+              checkFields(t);
+            }
+          }
+        }
+      }
+      function checkFields(rawType2) {
+        const fields = rawType2.getFields();
+        const hasIdFieldInType = idNames.some((name) => fields[name]);
+        if (!hasIdFieldInType) {
+          return;
+        }
+        function hasIdField({ selections }) {
+          return selections.some((selection) => {
+            if (selection.kind === import_graphql.Kind.FIELD) {
+              if (selection.alias && idNames.includes(selection.alias.value)) {
+                return true;
+              }
+              return idNames.includes(selection.name.value);
+            }
+            if (selection.kind === import_graphql.Kind.INLINE_FRAGMENT) {
+              return hasIdField(selection.selectionSet);
+            }
+            if (selection.kind === import_graphql.Kind.FRAGMENT_SPREAD) {
+              const [foundSpread] = siblings.getFragment(selection.name.value);
+              if (foundSpread) {
+                const fragmentSpread = foundSpread.document;
+                checkedFragmentSpreads.add(fragmentSpread.name.value);
+                return hasIdField(fragmentSpread.selectionSet);
+              }
+            }
+            return false;
+          });
+        }
+        const hasId = hasIdField(node);
+        checkFragments(node);
+        if (hasId) {
+          return;
+        }
+        const pluralSuffix = idNames.length > 1 ? "s" : "";
+        const fieldName2 = (0, import_utils2.englishJoinWords)(
+          idNames.map((name) => `\`${(parent.alias || parent.name).value}.${name}\``)
+        );
+        const addition = checkedFragmentSpreads.size === 0 ? "" : ` or add to used fragment${checkedFragmentSpreads.size > 1 ? "s" : ""} ${(0, import_utils2.englishJoinWords)([...checkedFragmentSpreads].map((name) => `\`${name}\``))}`;
+        const problem = {
+          loc,
+          messageId: RULE_ID,
+          data: {
+            pluralSuffix,
+            fieldName: fieldName2,
+            addition
+          }
+        };
+        if ("type" in node) {
+          problem.suggest = idNames.map((idName) => ({
+            desc: `Add \`${idName}\` selection`,
+            fix: (fixer) => {
+              let insertNode = node.selections[0];
+              insertNode = insertNode.kind === import_graphql.Kind.INLINE_FRAGMENT ? insertNode.selectionSet.selections[0] : insertNode;
+              return fixer.insertTextBefore(insertNode, `${idName} `);
+            }
+          }));
+        }
+        context.report(problem);
+      }
+    }
+    return {
+      [selector](node) {
+        const typeInfo2 = node.typeInfo();
+        if (typeInfo2.gqlType) {
+          checkSelections(node, typeInfo2.gqlType, node.loc.start, node.parent);
+        }
+      }
+    };
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  rule
+});

package/cjs/rules/require-import-fragment.d.ts

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