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

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

@@ -0,0 +1,157 @@
+"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 no_unused_fields_exports = {};
+__export(no_unused_fields_exports, {
+  rule: () => rule
+});
+module.exports = __toCommonJS(no_unused_fields_exports);
+var import_graphql = require("graphql");
+var 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);
+  const typeInfo = new import_graphql.TypeInfo(schema);
+  const visitor = (0, import_graphql.visitWithTypeInfo)(typeInfo, {
+    Field(node) {
+      var _a;
+      const fieldDef = typeInfo.getFieldDef();
+      if (!fieldDef) {
+        return false;
+      }
+      const parentTypeName = typeInfo.getParentType().name;
+      const fieldName = node.name.value;
+      (_a = usedFields[parentTypeName]) != null ? _a : usedFields[parentTypeName] = /* @__PURE__ */ new Set();
+      usedFields[parentTypeName].add(fieldName);
+    }
+  });
+  const allDocuments = [...operations.getOperations(), ...operations.getFragments()];
+  for (const { document } of allDocuments) {
+    (0, import_graphql.visit)(document, visitor);
+  }
+  usedFieldsCache = usedFields;
+  return 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: true,
+      requiresSchema: true,
+      isDisabledForAllConfig: true,
+      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: true
+  },
+  create(context) {
+    const schema = (0, import_utils.requireGraphQLSchemaFromContext)(RULE_ID, context);
+    const siblingsOperations = (0, import_utils.requireSiblingsOperations)(RULE_ID, context);
+    const usedFields = getUsedFields(schema, siblingsOperations);
+    return {
+      FieldDefinition(node) {
+        var _a;
+        const fieldName = node.name.value;
+        const parentTypeName = node.parent.name.value;
+        const isUsed = (_a = usedFields[parentTypeName]) == null ? void 0 : _a.has(fieldName);
+        if (isUsed) {
+          return;
+        }
+        context.report({
+          node: node.name,
+          messageId: RULE_ID,
+          data: { fieldName },
+          suggest: [
+            {
+              desc: `Remove \`${fieldName}\` field`,
+              fix(fixer) {
+                const sourceCode = context.getSourceCode();
+                const tokenBefore = sourceCode.getTokenBefore(node);
+                const tokenAfter = sourceCode.getTokenAfter(node);
+                const 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,29 @@
+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 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,149 @@
+"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 relay_arguments_exports = {};
+__export(relay_arguments_exports, {
+  rule: () => rule
+});
+module.exports = __toCommonJS(relay_arguments_exports);
+var import_graphql = require("graphql");
+var import_utils = require("../utils.js");
+const RULE_ID = "relay-arguments";
+const MISSING_ARGUMENTS = "MISSING_ARGUMENTS";
+const schema = {
+  type: "array",
+  maxItems: 1,
+  items: {
+    type: "object",
+    additionalProperties: false,
+    minProperties: 1,
+    properties: {
+      includeBoth: {
+        type: "boolean",
+        default: true,
+        description: "Enforce including both forward and backward pagination arguments"
+      }
+    }
+  }
+};
+const 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("\n"),
+      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: true
+    },
+    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);
+    const { includeBoth = true } = context.options[0] || {};
+    return {
+      "FieldDefinition > .gqlType Name[value=/Connection$/]"(node) {
+        var _a;
+        let fieldNode = node.parent;
+        while (fieldNode.kind !== import_graphql.Kind.FIELD_DEFINITION) {
+          fieldNode = fieldNode.parent;
+        }
+        const args = Object.fromEntries(
+          ((_a = fieldNode.arguments) == null ? void 0 : _a.map((argument) => [argument.name.value, argument])) || []
+        );
+        const hasForwardPagination = !!(args.first && args.after);
+        const 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];
+          const hasArgument = !!argument;
+          let type = argument;
+          if (hasArgument && type.gqlType.kind === import_graphql.Kind.NON_NULL_TYPE) {
+            type = type.gqlType;
+          }
+          const isAllowedNonNullType = 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)));
+          if (!isAllowedNonNullType) {
+            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}.`
+            });
+          }
+        }
+        if (includeBoth || args.first || args.after) {
+          checkField("Int", "first");
+          checkField("String", "after");
+        }
+        if (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,13 @@
+import { Kind } from 'graphql';
+import { f as GraphQLESLintRule } from '../types-8d5f4ae0.js';
+import '@graphql-tools/utils';
+import 'eslint';
+import 'estree';
+import 'graphql-config';
+import 'json-schema-to-ts';
+import '../estree-converter/types.js';
+
+declare const NON_OBJECT_TYPES: Kind[];
+declare const rule: GraphQLESLintRule;
+
+export { NON_OBJECT_TYPES, rule };

package/cjs/rules/relay-connection-types.js

@@ -0,0 +1,142 @@
+"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 relay_connection_types_exports = {};
+__export(relay_connection_types_exports, {
+  NON_OBJECT_TYPES: () => NON_OBJECT_TYPES,
+  rule: () => rule
+});
+module.exports = __toCommonJS(relay_connection_types_exports);
+var import_graphql = require("graphql");
+const MUST_BE_OBJECT_TYPE = "MUST_BE_OBJECT_TYPE";
+const MUST_CONTAIN_FIELD_EDGES = "MUST_CONTAIN_FIELD_EDGES";
+const MUST_CONTAIN_FIELD_PAGE_INFO = "MUST_CONTAIN_FIELD_PAGE_INFO";
+const MUST_HAVE_CONNECTION_SUFFIX = "MUST_HAVE_CONNECTION_SUFFIX";
+const EDGES_FIELD_MUST_RETURN_LIST_TYPE = "EDGES_FIELD_MUST_RETURN_LIST_TYPE";
+const PAGE_INFO_FIELD_MUST_RETURN_NON_NULL_TYPE = "PAGE_INFO_FIELD_MUST_RETURN_NON_NULL_TYPE";
+const NON_OBJECT_TYPES = [
+  import_graphql.Kind.SCALAR_TYPE_DEFINITION,
+  import_graphql.Kind.UNION_TYPE_DEFINITION,
+  import_graphql.Kind.UNION_TYPE_EXTENSION,
+  import_graphql.Kind.INPUT_OBJECT_TYPE_DEFINITION,
+  import_graphql.Kind.INPUT_OBJECT_TYPE_EXTENSION,
+  import_graphql.Kind.ENUM_TYPE_DEFINITION,
+  import_graphql.Kind.ENUM_TYPE_EXTENSION,
+  import_graphql.Kind.INTERFACE_TYPE_DEFINITION,
+  import_graphql.Kind.INTERFACE_TYPE_EXTENSION
+];
+const notConnectionTypesSelector = `:matches(${NON_OBJECT_TYPES})[name.value=/Connection$/] > .name`;
+const hasEdgesField = (node) => {
+  var _a;
+  return (_a = node.fields) == null ? void 0 : _a.some((field) => field.name.value === "edges");
+};
+const hasPageInfoField = (node) => {
+  var _a;
+  return (_a = node.fields) == null ? void 0 : _a.some((field) => field.name.value === "pageInfo");
+};
+const rule = {
+  meta: {
+    type: "problem",
+    docs: {
+      category: "Schema",
+      description: [
+        "Set of rules to follow Relay specification for Connection types.",
+        "",
+        '- Any type whose name ends in "Connection" is considered by spec to be a `Connection type`',
+        "- Connection type must be an Object type",
+        "- Connection type must contain a field `edges` that return a list type that wraps an edge type",
+        "- Connection type must contain a field `pageInfo` that return a non-null `PageInfo` Object type"
+      ].join("\n"),
+      url: "https://the-guild.dev/graphql/eslint/rules/relay-connection-types",
+      isDisabledForAllConfig: true,
+      examples: [
+        {
+          title: "Incorrect",
+          code: (
+            /* GraphQL */
+            `
+            type UserPayload { # should be an Object type with \`Connection\` suffix
+              edges: UserEdge! # should return a list type
+              pageInfo: PageInfo # should return a non-null \`PageInfo\` Object type
+            }
+          `
+          )
+        },
+        {
+          title: "Correct",
+          code: (
+            /* GraphQL */
+            `
+            type UserConnection {
+              edges: [UserEdge]
+              pageInfo: PageInfo!
+            }
+          `
+          )
+        }
+      ]
+    },
+    messages: {
+      // Connection types
+      [MUST_BE_OBJECT_TYPE]: "Connection type must be an Object type.",
+      [MUST_HAVE_CONNECTION_SUFFIX]: "Connection type must have `Connection` suffix.",
+      [MUST_CONTAIN_FIELD_EDGES]: "Connection type must contain a field `edges` that return a list type.",
+      [MUST_CONTAIN_FIELD_PAGE_INFO]: "Connection type must contain a field `pageInfo` that return a non-null `PageInfo` Object type.",
+      [EDGES_FIELD_MUST_RETURN_LIST_TYPE]: "`edges` field must return a list type.",
+      [PAGE_INFO_FIELD_MUST_RETURN_NON_NULL_TYPE]: "`pageInfo` field must return a non-null `PageInfo` Object type."
+    },
+    schema: []
+  },
+  create(context) {
+    return {
+      [notConnectionTypesSelector](node) {
+        context.report({ node, messageId: MUST_BE_OBJECT_TYPE });
+      },
+      ":matches(ObjectTypeDefinition, ObjectTypeExtension)[name.value!=/Connection$/]"(node) {
+        if (hasEdgesField(node) && hasPageInfoField(node)) {
+          context.report({ node: node.name, messageId: MUST_HAVE_CONNECTION_SUFFIX });
+        }
+      },
+      ":matches(ObjectTypeDefinition, ObjectTypeExtension)[name.value=/Connection$/]"(node) {
+        if (!hasEdgesField(node)) {
+          context.report({ node: node.name, messageId: MUST_CONTAIN_FIELD_EDGES });
+        }
+        if (!hasPageInfoField(node)) {
+          context.report({ node: node.name, messageId: MUST_CONTAIN_FIELD_PAGE_INFO });
+        }
+      },
+      ":matches(ObjectTypeDefinition, ObjectTypeExtension)[name.value=/Connection$/] > FieldDefinition[name.value=edges] > .gqlType"(node) {
+        const isListType = node.kind === import_graphql.Kind.LIST_TYPE || node.kind === import_graphql.Kind.NON_NULL_TYPE && node.gqlType.kind === import_graphql.Kind.LIST_TYPE;
+        if (!isListType) {
+          context.report({ node, messageId: EDGES_FIELD_MUST_RETURN_LIST_TYPE });
+        }
+      },
+      ":matches(ObjectTypeDefinition, ObjectTypeExtension)[name.value=/Connection$/] > FieldDefinition[name.value=pageInfo] > .gqlType"(node) {
+        const isNonNullPageInfoType = node.kind === import_graphql.Kind.NON_NULL_TYPE && node.gqlType.kind === import_graphql.Kind.NAMED_TYPE && node.gqlType.name.value === "PageInfo";
+        if (!isNonNullPageInfoType) {
+          context.report({ node, messageId: PAGE_INFO_FIELD_MUST_RETURN_NON_NULL_TYPE });
+        }
+      }
+    };
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  NON_OBJECT_TYPES,
+  rule
+});

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

@@ -0,0 +1,39 @@
+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 type: "array";
+    readonly maxItems: 1;
+    readonly items: {
+        readonly type: "object";
+        readonly additionalProperties: false;
+        readonly minProperties: 1;
+        readonly properties: {
+            readonly withEdgeSuffix: {
+                readonly type: "boolean";
+                readonly default: true;
+                readonly description: "Edge type name must end in \"Edge\".";
+            };
+            readonly shouldImplementNode: {
+                readonly type: "boolean";
+                readonly default: true;
+                readonly description: "Edge type's field `node` must implement `Node` interface.";
+            };
+            readonly listTypeCanWrapOnlyEdgeType: {
+                readonly type: "boolean";
+                readonly default: true;
+                readonly description: "A list type should only wrap an edge type.";
+            };
+        };
+    };
+};
+type RuleOptions = FromSchema<typeof schema>;
+declare const rule: GraphQLESLintRule<RuleOptions, true>;
+
+export { RuleOptions, rule };