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

package/cjs/rules/require-deprecation-reason.js

@@ -0,0 +1,85 @@
+"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 require_deprecation_reason_exports = {};
+__export(require_deprecation_reason_exports, {
+  rule: () => rule
+});
+module.exports = __toCommonJS(require_deprecation_reason_exports);
+var import_estree_converter = require("../estree-converter/index.js"), import_utils = require("../utils.js");
+const rule = {
+  meta: {
+    docs: {
+      description: "Require all deprecation directives to specify a reason.",
+      category: "Schema",
+      url: "https://the-guild.dev/graphql/eslint/rules/require-deprecation-reason",
+      recommended: !0,
+      examples: [
+        {
+          title: "Incorrect",
+          code: (
+            /* GraphQL */
+            `
+            type MyType {
+              name: String @deprecated
+            }
+          `
+          )
+        },
+        {
+          title: "Incorrect",
+          code: (
+            /* GraphQL */
+            `
+            type MyType {
+              name: String @deprecated(reason: "")
+            }
+          `
+          )
+        },
+        {
+          title: "Correct",
+          code: (
+            /* GraphQL */
+            `
+            type MyType {
+              name: String @deprecated(reason: "no longer relevant, please use fullName field")
+            }
+          `
+          )
+        }
+      ]
+    },
+    type: "suggestion",
+    schema: []
+  },
+  create(context) {
+    return {
+      "Directive[name.value=deprecated]"(node) {
+        const reasonArgument = node.arguments?.find(
+          (arg) => arg.name.value === "reason"
+        );
+        reasonArgument && String((0, import_estree_converter.valueFromNode)(reasonArgument.value)).trim() || context.report({
+          node: node.name,
+          message: `Deprecation reason is required for ${(0, import_utils.getNodeName)(node.parent)}.`
+        });
+      }
+    };
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  rule
+});

package/cjs/rules/require-description.d.ts

@@ -0,0 +1,24 @@
+import { Kind } from 'graphql';
+import { GraphQLESLintRule } from '../types.js';
+import 'eslint';
+import 'estree';
+import 'json-schema-to-ts';
+import '../siblings.js';
+import '@graphql-tools/utils';
+import '../estree-converter/types.js';
+import 'graphql-config';
+
+declare const RULE_ID = "require-description";
+declare const ALLOWED_KINDS: readonly [Kind.OBJECT_TYPE_DEFINITION, Kind.INTERFACE_TYPE_DEFINITION, Kind.ENUM_TYPE_DEFINITION, Kind.SCALAR_TYPE_DEFINITION, Kind.INPUT_OBJECT_TYPE_DEFINITION, Kind.UNION_TYPE_DEFINITION, Kind.DIRECTIVE_DEFINITION, Kind.FIELD_DEFINITION, Kind.INPUT_VALUE_DEFINITION, Kind.ENUM_VALUE_DEFINITION, Kind.OPERATION_DEFINITION];
+type AllowedKind = (typeof ALLOWED_KINDS)[number];
+type RuleOptions = [
+    {
+        [key in AllowedKind]?: boolean;
+    } & {
+        types?: boolean;
+        rootField?: boolean;
+    }
+];
+declare const rule: GraphQLESLintRule<RuleOptions>;
+
+export { RULE_ID, RuleOptions, rule };

package/cjs/rules/require-description.js

@@ -0,0 +1,179 @@
+"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 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"), import_graphql = require("graphql"), import_utils2 = require("../utils.js");
+const RULE_ID = "require-description", 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
+], schema = {
+  type: "array",
+  minItems: 1,
+  maxItems: 1,
+  items: {
+    type: "object",
+    additionalProperties: !1,
+    minProperties: 1,
+    properties: {
+      types: {
+        type: "boolean",
+        description: `Includes:
+${import_utils2.TYPES_KINDS.map((kind) => `- \`${kind}\``).join(`
+`)}`
+      },
+      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}).`;
+          return kind === import_graphql.Kind.OPERATION_DEFINITION && (description += '\n> You must use only comment syntax `#` and not description syntax `"""` or `"`.'), [kind, { type: "boolean", description }];
+        })
+      )
+    }
+  }
+}, 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: !0, FieldDefinition: !0 }],
+          code: (
+            /* GraphQL */
+            `
+            type someTypeName {
+              name: String
+            }
+          `
+          )
+        },
+        {
+          title: "Correct",
+          usage: [{ types: !0, FieldDefinition: !0 }],
+          code: (
+            /* GraphQL */
+            `
+            """
+            Some type description
+            """
+            type someTypeName {
+              """
+              Name description
+              """
+              name: String
+            }
+          `
+          )
+        },
+        {
+          title: "Correct",
+          usage: [{ OperationDefinition: !0 }],
+          code: (
+            /* GraphQL */
+            `
+            # Create a new user
+            mutation createUser {
+              # ...
+            }
+          `
+          )
+        },
+        {
+          title: "Correct",
+          usage: [{ rootField: !0 }],
+          code: (
+            /* GraphQL */
+            `
+            type Mutation {
+              "Create a new user"
+              createUser: User
+            }
+
+            type User {
+              name: String
+            }
+          `
+          )
+        }
+      ],
+      configOptions: [
+        {
+          types: !0,
+          [import_graphql.Kind.DIRECTIVE_DEFINITION]: !0,
+          rootField: !0
+        }
+      ],
+      recommended: !0
+    },
+    type: "suggestion",
+    messages: {
+      [RULE_ID]: "Description is required for {{ nodeName }}"
+    },
+    schema
+  },
+  create(context) {
+    const { types, rootField, ...restOptions } = context.options[0] || {}, kinds = new Set(types ? import_utils2.TYPES_KINDS : []);
+    for (const [kind, isEnabled] of Object.entries(restOptions))
+      isEnabled ? kinds.add(kind) : kinds.delete(kind);
+    if (rootField) {
+      const schema2 = (0, import_utils2.requireGraphQLSchemaFromContext)(RULE_ID, context), rootTypeNames = (0, import_utils.getRootTypeNames)(schema2);
+      kinds.add(
+        `:matches(ObjectTypeDefinition, ObjectTypeExtension)[name.value=/^(${[
+          ...rootTypeNames
+        ].join(",")})$/] > FieldDefinition`
+      );
+    }
+    return {
+      [[...kinds].join(",")](node) {
+        let description = "";
+        const isOperation = node.kind === import_graphql.Kind.OPERATION_DEFINITION;
+        if (isOperation) {
+          const rawNode = node.rawNode(), { prev, line } = rawNode.loc.startToken;
+          if (prev?.kind === import_graphql.TokenKind.COMMENT) {
+            const value = prev.value.trim(), linesBefore = line - prev.line;
+            !value.startsWith("eslint") && linesBefore === 1 && (description = value);
+          }
+        } else
+          description = node.description?.value.trim() || "";
+        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,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/require-field-of-type-query-in-mutation-result.js

@@ -0,0 +1,87 @@
+"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 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"), import_utils = require("../utils.js");
+const RULE_ID = "require-field-of-type-query-in-mutation-result", 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: !0,
+      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), mutationType = schema.getMutationType(), queryType = schema.getQueryType();
+    return !mutationType || !queryType ? {} : {
+      [`:matches(ObjectTypeDefinition, ObjectTypeExtension)[name.value=${mutationType.name}] > FieldDefinition > .gqlType Name`](node) {
+        const typeName = node.value, graphQLType = schema.getType(typeName);
+        if ((0, import_graphql.isObjectType)(graphQLType)) {
+          const { fields } = graphQLType.astNode;
+          fields?.some((field) => (0, import_utils.getTypeName)(field) === queryType.name) || 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-import-fragment.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/require-import-fragment.js

@@ -0,0 +1,148 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf, __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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: !0 }) : target,
+  mod
+)), __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+var require_import_fragment_exports = {};
+__export(require_import_fragment_exports, {
+  rule: () => rule
+});
+module.exports = __toCommonJS(require_import_fragment_exports);
+var import_node_path = __toESM(require("node:path")), import_utils = require("../utils.js");
+const RULE_ID = "require-import-fragment", SUGGESTION_ID = "add-import-expression", rule = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      category: "Operations",
+      description: "Require fragments to be imported via an import expression.",
+      url: `https://the-guild.dev/graphql/eslint/rules/${RULE_ID}`,
+      examples: [
+        {
+          title: "Incorrect",
+          code: (
+            /* GraphQL */
+            `
+            query {
+              user {
+                ...UserFields
+              }
+            }
+          `
+          )
+        },
+        {
+          title: "Incorrect",
+          code: (
+            /* GraphQL */
+            `
+            # import 'post-fields.fragment.graphql'
+            query {
+              user {
+                ...UserFields
+              }
+            }
+          `
+          )
+        },
+        {
+          title: "Incorrect",
+          code: (
+            /* GraphQL */
+            `
+            # import UserFields from 'post-fields.fragment.graphql'
+            query {
+              user {
+                ...UserFields
+              }
+            }
+          `
+          )
+        },
+        {
+          title: "Correct",
+          code: (
+            /* GraphQL */
+            `
+            # import UserFields from 'user-fields.fragment.graphql'
+            query {
+              user {
+                ...UserFields
+              }
+            }
+          `
+          )
+        }
+      ],
+      requiresSiblings: !0
+    },
+    hasSuggestions: !0,
+    messages: {
+      [RULE_ID]: 'Expected "{{fragmentName}}" fragment to be imported.',
+      [SUGGESTION_ID]: 'Add import expression for "{{fragmentName}}".'
+    },
+    schema: []
+  },
+  create(context) {
+    const comments = context.getSourceCode().getAllComments(), siblings = (0, import_utils.requireSiblingsOperations)(RULE_ID, context), filePath = context.filename;
+    return {
+      "FragmentSpread > .name"(node) {
+        const fragmentName = node.value, fragmentsFromSiblings = siblings.getFragment(fragmentName);
+        for (const comment of comments) {
+          if (comment.type !== "Line" || !new RegExp(
+            `^\\s*import\\s+(${fragmentName}\\s+from\\s+)?['"]`
+          ).test(comment.value))
+            continue;
+          const extractedImportPath = comment.value.match(/(["'])((?:\1|.)*?)\1/)?.[2];
+          if (!extractedImportPath)
+            continue;
+          const importPath = import_node_path.default.join(import_node_path.default.dirname(filePath), extractedImportPath);
+          if (fragmentsFromSiblings.some(
+            (source) => source.filePath === importPath
+          ))
+            return;
+        }
+        if (fragmentsFromSiblings.some(
+          (source) => source.filePath === filePath
+        ))
+          return;
+        const suggestedFilePaths = fragmentsFromSiblings.length ? fragmentsFromSiblings.map((o) => import_node_path.default.relative(import_node_path.default.dirname(filePath), o.filePath)) : ["CHANGE_ME.graphql"];
+        context.report({
+          node,
+          messageId: RULE_ID,
+          data: { fragmentName },
+          suggest: suggestedFilePaths.map((suggestedPath) => ({
+            messageId: SUGGESTION_ID,
+            data: { fragmentName },
+            fix: (fixer) => fixer.insertTextBeforeRange(
+              [0, 0],
+              `# import ${fragmentName} from '${suggestedPath}'
+`
+            )
+          }))
+        });
+      }
+    };
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  rule
+});

package/cjs/rules/require-nullable-fields-with-oneof.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/require-nullable-fields-with-oneof.js

@@ -0,0 +1,81 @@
+"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 require_nullable_fields_with_oneof_exports = {};
+__export(require_nullable_fields_with_oneof_exports, {
+  rule: () => rule
+});
+module.exports = __toCommonJS(require_nullable_fields_with_oneof_exports);
+var import_graphql = require("graphql"), import_utils = require("../utils.js");
+const RULE_ID = "require-nullable-fields-with-oneof", rule = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      category: "Schema",
+      description: "Require `input` or `type` fields to be non-nullable with `@oneOf` directive.",
+      url: `https://the-guild.dev/graphql/eslint/rules/${RULE_ID}`,
+      examples: [
+        {
+          title: "Incorrect",
+          code: (
+            /* GraphQL */
+            `
+            input Input @oneOf {
+              foo: String!
+              b: Int
+            }
+          `
+          )
+        },
+        {
+          title: "Correct",
+          code: (
+            /* GraphQL */
+            `
+            input Input @oneOf {
+              foo: String
+              bar: Int
+            }
+          `
+          )
+        }
+      ]
+    },
+    messages: {
+      [RULE_ID]: '{{ nodeName }} must be nullable when "@oneOf" is in use'
+    },
+    schema: []
+  },
+  create(context) {
+    return {
+      "Directive[name.value=oneOf]"({ parent }) {
+        if ([
+          import_graphql.Kind.OBJECT_TYPE_DEFINITION,
+          import_graphql.Kind.INPUT_OBJECT_TYPE_DEFINITION
+        ].includes(parent.kind))
+          for (const field of parent.fields || [])
+            field.gqlType.kind === import_graphql.Kind.NON_NULL_TYPE && context.report({
+              node: field.name,
+              messageId: RULE_ID,
+              data: { nodeName: (0, import_utils.getNodeName)(field) }
+            });
+      }
+    };
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  rule
+});

package/cjs/rules/require-nullable-result-in-root.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 };