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

package/cjs/rules/no-typename-prefix.js

@@ -0,0 +1,91 @@
+"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_typename_prefix_exports = {};
+__export(no_typename_prefix_exports, {
+  rule: () => rule
+});
+module.exports = __toCommonJS(no_typename_prefix_exports);
+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"), "")
+                )
+              }
+            ]
+          });
+        }
+      }
+    };
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  rule
+});

package/cjs/rules/no-unreachable-types.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-unreachable-types.js

@@ -0,0 +1,177 @@
+"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 no_unreachable_types_exports = {};
+__export(no_unreachable_types_exports, {
+  rule: () => rule
+});
+module.exports = __toCommonJS(no_unreachable_types_exports);
+var import_graphql = require("graphql"), import_lodash = __toESM(require("lodash.lowercase")), import_utils = require("../utils.js");
+const RULE_ID = "no-unreachable-types", KINDS = [
+  import_graphql.Kind.DIRECTIVE_DEFINITION,
+  import_graphql.Kind.OBJECT_TYPE_DEFINITION,
+  import_graphql.Kind.OBJECT_TYPE_EXTENSION,
+  import_graphql.Kind.INTERFACE_TYPE_DEFINITION,
+  import_graphql.Kind.INTERFACE_TYPE_EXTENSION,
+  import_graphql.Kind.SCALAR_TYPE_DEFINITION,
+  import_graphql.Kind.SCALAR_TYPE_EXTENSION,
+  import_graphql.Kind.INPUT_OBJECT_TYPE_DEFINITION,
+  import_graphql.Kind.INPUT_OBJECT_TYPE_EXTENSION,
+  import_graphql.Kind.UNION_TYPE_DEFINITION,
+  import_graphql.Kind.UNION_TYPE_EXTENSION,
+  import_graphql.Kind.ENUM_TYPE_DEFINITION,
+  import_graphql.Kind.ENUM_TYPE_EXTENSION
+];
+let reachableTypesCache;
+const RequestDirectiveLocations = /* @__PURE__ */ new Set([
+  import_graphql.DirectiveLocation.QUERY,
+  import_graphql.DirectiveLocation.MUTATION,
+  import_graphql.DirectiveLocation.SUBSCRIPTION,
+  import_graphql.DirectiveLocation.FIELD,
+  import_graphql.DirectiveLocation.FRAGMENT_DEFINITION,
+  import_graphql.DirectiveLocation.FRAGMENT_SPREAD,
+  import_graphql.DirectiveLocation.INLINE_FRAGMENT,
+  import_graphql.DirectiveLocation.VARIABLE_DEFINITION
+]);
+function getReachableTypes(schema) {
+  if (reachableTypesCache)
+    return reachableTypesCache;
+  const reachableTypes = /* @__PURE__ */ new Set(), collect = (node) => {
+    const typeName = (0, import_utils.getTypeName)(node);
+    if (reachableTypes.has(typeName))
+      return;
+    reachableTypes.add(typeName);
+    const type = schema.getType(typeName) || schema.getDirective(typeName);
+    if ((0, import_graphql.isInterfaceType)(type)) {
+      const { objects, interfaces } = schema.getImplementations(type);
+      for (const { astNode } of [...objects, ...interfaces])
+        (0, import_graphql.visit)(astNode, visitor);
+    } else
+      type?.astNode && (0, import_graphql.visit)(type.astNode, visitor);
+  }, visitor = {
+    InterfaceTypeDefinition: collect,
+    ObjectTypeDefinition: collect,
+    InputValueDefinition: collect,
+    UnionTypeDefinition: collect,
+    FieldDefinition: collect,
+    Directive: collect,
+    NamedType: collect
+  };
+  for (const type of [
+    schema,
+    // visiting SchemaDefinition node
+    schema.getQueryType(),
+    schema.getMutationType(),
+    schema.getSubscriptionType()
+  ])
+    type?.astNode && (0, import_graphql.visit)(type.astNode, visitor);
+  for (const node of schema.getDirectives())
+    if (node.locations.some((location) => RequestDirectiveLocations.has(location))) {
+      reachableTypes.add(node.name);
+      for (const arg of node.args) {
+        const argTypeName = "name" in arg.type && arg.type.name;
+        argTypeName && reachableTypes.add(argTypeName);
+      }
+    }
+  return reachableTypesCache = reachableTypes, reachableTypesCache;
+}
+const rule = {
+  meta: {
+    messages: {
+      [RULE_ID]: "{{ type }} `{{ typeName }}` is unreachable."
+    },
+    docs: {
+      description: "Requires all types to be reachable at some level by root level fields.",
+      category: "Schema",
+      url: `https://the-guild.dev/graphql/eslint/rules/${RULE_ID}`,
+      requiresSchema: !0,
+      examples: [
+        {
+          title: "Incorrect",
+          code: (
+            /* GraphQL */
+            `
+            type User {
+              id: ID!
+              name: String
+            }
+
+            type Query {
+              me: String
+            }
+          `
+          )
+        },
+        {
+          title: "Correct",
+          code: (
+            /* GraphQL */
+            `
+            type User {
+              id: ID!
+              name: String
+            }
+
+            type Query {
+              me: User
+            }
+          `
+          )
+        }
+      ],
+      recommended: !0
+    },
+    type: "suggestion",
+    schema: [],
+    hasSuggestions: !0
+  },
+  create(context) {
+    const schema = (0, import_utils.requireGraphQLSchemaFromContext)(RULE_ID, context), reachableTypes = getReachableTypes(schema);
+    return {
+      [`:matches(${KINDS}) > .name`](node) {
+        const typeName = node.value;
+        if (!reachableTypes.has(typeName)) {
+          const type = (0, import_lodash.default)(node.parent.kind.replace(/(Extension|Definition)$/, ""));
+          context.report({
+            node,
+            messageId: RULE_ID,
+            data: {
+              type: type[0].toUpperCase() + type.slice(1),
+              typeName
+            },
+            suggest: [
+              {
+                desc: `Remove \`${typeName}\``,
+                fix: (fixer) => fixer.remove(node.parent)
+              }
+            ]
+          });
+        }
+      }
+    };
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  rule
+});

package/cjs/rules/no-unused-fields.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-unused-fields.js

@@ -0,0 +1,132 @@
+"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_unused_fields_exports = {};
+__export(no_unused_fields_exports, {
+  rule: () => rule
+});
+module.exports = __toCommonJS(no_unused_fields_exports);
+var import_graphql = require("graphql"), import_utils = require("../utils.js");
+const RULE_ID = "no-unused-fields";
+let usedFieldsCache;
+function getUsedFields(schema, operations) {
+  if (usedFieldsCache)
+    return usedFieldsCache;
+  const usedFields = /* @__PURE__ */ Object.create(null), typeInfo = new import_graphql.TypeInfo(schema), visitor = (0, import_graphql.visitWithTypeInfo)(typeInfo, {
+    Field(node) {
+      if (!typeInfo.getFieldDef())
+        return !1;
+      const parentTypeName = typeInfo.getParentType().name, fieldName = node.name.value;
+      usedFields[parentTypeName] ??= /* @__PURE__ */ new Set(), usedFields[parentTypeName].add(fieldName);
+    }
+  }), allDocuments = [...operations.getOperations(), ...operations.getFragments()];
+  for (const { document } of allDocuments)
+    (0, import_graphql.visit)(document, visitor);
+  return usedFieldsCache = usedFields, usedFieldsCache;
+}
+const rule = {
+  meta: {
+    messages: {
+      [RULE_ID]: 'Field "{{fieldName}}" is unused'
+    },
+    docs: {
+      description: "Requires all fields to be used at some level by siblings operations.",
+      category: "Schema",
+      url: `https://the-guild.dev/graphql/eslint/rules/${RULE_ID}`,
+      requiresSiblings: !0,
+      requiresSchema: !0,
+      // Requires documents to be set
+      isDisabledForAllConfig: !0,
+      examples: [
+        {
+          title: "Incorrect",
+          code: (
+            /* GraphQL */
+            `
+            type User {
+              id: ID!
+              name: String
+              someUnusedField: String
+            }
+
+            type Query {
+              me: User
+            }
+
+            query {
+              me {
+                id
+                name
+              }
+            }
+          `
+          )
+        },
+        {
+          title: "Correct",
+          code: (
+            /* GraphQL */
+            `
+            type User {
+              id: ID!
+              name: String
+            }
+
+            type Query {
+              me: User
+            }
+
+            query {
+              me {
+                id
+                name
+              }
+            }
+          `
+          )
+        }
+      ]
+    },
+    type: "suggestion",
+    schema: [],
+    hasSuggestions: !0
+  },
+  create(context) {
+    const schema = (0, import_utils.requireGraphQLSchemaFromContext)(RULE_ID, context), siblingsOperations = (0, import_utils.requireSiblingsOperations)(RULE_ID, context), usedFields = getUsedFields(schema, siblingsOperations);
+    return {
+      FieldDefinition(node) {
+        const fieldName = node.name.value, parentTypeName = node.parent.name.value;
+        usedFields[parentTypeName]?.has(fieldName) || context.report({
+          node: node.name,
+          messageId: RULE_ID,
+          data: { fieldName },
+          suggest: [
+            {
+              desc: `Remove \`${fieldName}\` field`,
+              fix(fixer) {
+                const sourceCode = context.getSourceCode(), tokenBefore = sourceCode.getTokenBefore(node), tokenAfter = sourceCode.getTokenAfter(node), isEmptyType = tokenBefore.type === "{" && tokenAfter.type === "}";
+                return fixer.remove(isEmptyType ? node.parent : node);
+              }
+            }
+          ]
+        });
+      }
+    };
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  rule
+});

package/cjs/rules/relay-arguments.d.ts

@@ -0,0 +1,30 @@
+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 maxItems: 1;
+    readonly items: {
+        readonly type: "object";
+        readonly additionalProperties: false;
+        readonly minProperties: 1;
+        readonly properties: {
+            readonly includeBoth: {
+                readonly type: "boolean";
+                readonly default: true;
+                readonly description: "Enforce including both forward and backward pagination arguments";
+            };
+        };
+    };
+};
+type RuleOptions = FromSchema<typeof schema>;
+declare const rule: GraphQLESLintRule<RuleOptions, true>;
+
+export { RuleOptions, rule };

package/cjs/rules/relay-arguments.js

@@ -0,0 +1,126 @@
+"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 relay_arguments_exports = {};
+__export(relay_arguments_exports, {
+  rule: () => rule
+});
+module.exports = __toCommonJS(relay_arguments_exports);
+var import_graphql = require("graphql"), import_utils = require("../utils.js");
+const RULE_ID = "relay-arguments", MISSING_ARGUMENTS = "MISSING_ARGUMENTS", schema = {
+  type: "array",
+  maxItems: 1,
+  items: {
+    type: "object",
+    additionalProperties: !1,
+    minProperties: 1,
+    properties: {
+      includeBoth: {
+        type: "boolean",
+        default: !0,
+        description: "Enforce including both forward and backward pagination arguments"
+      }
+    }
+  }
+}, rule = {
+  meta: {
+    type: "problem",
+    docs: {
+      category: "Schema",
+      description: [
+        "Set of rules to follow Relay specification for Arguments.",
+        "",
+        "- A field that returns a Connection type must include forward pagination arguments (`first` and `after`), backward pagination arguments (`last` and `before`), or both",
+        "",
+        "Forward pagination arguments",
+        "",
+        "- `first` takes a non-negative integer",
+        "- `after` takes the Cursor type",
+        "",
+        "Backward pagination arguments",
+        "",
+        "- `last` takes a non-negative integer",
+        "- `before` takes the Cursor type"
+      ].join(`
+`),
+      url: `https://the-guild.dev/graphql/eslint/rules/${RULE_ID}`,
+      examples: [
+        {
+          title: "Incorrect",
+          code: (
+            /* GraphQL */
+            `
+            type User {
+              posts: PostConnection
+            }
+          `
+          )
+        },
+        {
+          title: "Correct",
+          code: (
+            /* GraphQL */
+            `
+            type User {
+              posts(after: String, first: Int, before: String, last: Int): PostConnection
+            }
+          `
+          )
+        }
+      ],
+      isDisabledForAllConfig: !0
+    },
+    messages: {
+      [MISSING_ARGUMENTS]: "A field that returns a Connection type must include forward pagination arguments (`first` and `after`), backward pagination arguments (`last` and `before`), or both."
+    },
+    schema
+  },
+  create(context) {
+    const schema2 = (0, import_utils.requireGraphQLSchemaFromContext)(RULE_ID, context), { includeBoth = !0 } = context.options[0] || {};
+    return {
+      "FieldDefinition > .gqlType Name[value=/Connection$/]"(node) {
+        let fieldNode = node.parent;
+        for (; fieldNode.kind !== import_graphql.Kind.FIELD_DEFINITION; )
+          fieldNode = fieldNode.parent;
+        const args = Object.fromEntries(
+          fieldNode.arguments?.map((argument) => [argument.name.value, argument]) || []
+        ), hasForwardPagination = !!(args.first && args.after), hasBackwardPagination = !!(args.last && args.before);
+        if (!hasForwardPagination && !hasBackwardPagination) {
+          context.report({
+            node: fieldNode.name,
+            messageId: MISSING_ARGUMENTS
+          });
+          return;
+        }
+        function checkField(typeName, argumentName) {
+          const argument = args[argumentName], hasArgument = !!argument;
+          let type = argument;
+          if (hasArgument && type.gqlType.kind === import_graphql.Kind.NON_NULL_TYPE && (type = type.gqlType), !(hasArgument && type.gqlType.kind === import_graphql.Kind.NAMED_TYPE && (type.gqlType.name.value === typeName || typeName === "String" && (0, import_graphql.isScalarType)(schema2.getType(type.gqlType.name.value))))) {
+            const returnType = typeName === "String" ? "String or Scalar" : typeName;
+            context.report({
+              node: (argument || fieldNode).name,
+              message: hasArgument ? `Argument \`${argumentName}\` must return ${returnType}.` : `Field \`${fieldNode.name.value}\` must contain an argument \`${argumentName}\`, that return ${returnType}.`
+            });
+          }
+        }
+        (includeBoth || args.first || args.after) && (checkField("Int", "first"), checkField("String", "after")), (includeBoth || args.last || args.before) && (checkField("Int", "last"), checkField("String", "before"));
+      }
+    };
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  rule
+});

package/cjs/rules/relay-connection-types.d.ts

@@ -0,0 +1,14 @@
+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 NON_OBJECT_TYPES: Kind[];
+declare const rule: GraphQLESLintRule;
+
+export { NON_OBJECT_TYPES, rule };