@graphql-eslint/eslint-plugin 4.3.0 → 4.3.1-alpha-20241207204625-6a4230707a78900a6339b03afe904b9dd6c31561

package/cjs/rules/no-root-type/index.js

@@ -5,7 +5,7 @@ const schema = {
   maxItems: 1,
   items: {
     type: "object",
-    additionalProperties: !1,
+    additionalProperties: false,
     required: ["disallow"],
     properties: {
       disallow: {
@@ -16,15 +16,16 @@ const schema = {
       }
     }
   }
-}, rule = exports.rule = {
+};
+const rule = {
   meta: {
     type: "suggestion",
-    hasSuggestions: !0,
+    hasSuggestions: true,
     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,
+      requiresSchema: true,
       examples: [
         {
           title: "Incorrect",
@@ -56,12 +57,18 @@ const schema = {
     schema
   },
   create(context) {
-    const schema2 = _utilsjs.requireGraphQLSchema.call(void 0, "no-root-type", context), disallow = new Set(context.options[0].disallow), rootTypeNames = [
+    const schema2 = _utilsjs.requireGraphQLSchema.call(void 0, "no-root-type", context);
+    const disallow = new Set(context.options[0].disallow);
+    const rootTypeNames = [
       disallow.has("mutation") && schema2.getMutationType(),
       disallow.has("subscription") && schema2.getSubscriptionType()
     ].filter((v) => !!v).map((type) => type.name).join("|");
-    return rootTypeNames ? {
-      [`:matches(ObjectTypeDefinition, ObjectTypeExtension) > .name[value=/^(${rootTypeNames})$/]`](node) {
+    if (!rootTypeNames) {
+      return {};
+    }
+    const selector = `:matches(ObjectTypeDefinition, ObjectTypeExtension) > .name[value=/^(${rootTypeNames})$/]`;
+    return {
+      [selector](node) {
         const typeName = node.value;
         context.report({
           node,
@@ -74,7 +81,7 @@ const schema = {
           ]
         });
       }
-    } : {};
+    };
   }
 };
 

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

@@ -1,14 +1,15 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true});var _graphql = require('graphql');
 var _utilsjs = require('../../utils.js');
-const RULE_ID = "no-scalar-result-type-on-mutation", rule = exports.rule = {
+const RULE_ID = "no-scalar-result-type-on-mutation";
+const rule = {
   meta: {
     type: "suggestion",
-    hasSuggestions: !0,
+    hasSuggestions: true,
     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,
+      requiresSchema: true,
       examples: [
         {
           title: "Incorrect",
@@ -37,17 +38,24 @@ const RULE_ID = "no-scalar-result-type-on-mutation", rule = exports.rule = {
     schema: []
   },
   create(context) {
-    const schema = _utilsjs.requireGraphQLSchema.call(void 0, 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);
+    const schema = _utilsjs.requireGraphQLSchema.call(void 0, RULE_ID, context);
+    const mutationType = schema.getMutationType();
+    if (!mutationType) {
+      return {};
+    }
+    const selector = [
+      `:matches(ObjectTypeDefinition, ObjectTypeExtension)[name.value=${mutationType.name}]`,
+      "> FieldDefinition > .gqlType Name"
+    ].join(" ");
+    return {
+      [selector](node) {
+        const typeName = node.value;
+        const graphQLType = schema.getType(typeName);
         if (_graphql.isScalarType.call(void 0, graphQLType)) {
           let fieldDef = node.parent;
-          for (; fieldDef.kind !== _graphql.Kind.FIELD_DEFINITION; )
+          while (fieldDef.kind !== _graphql.Kind.FIELD_DEFINITION) {
             fieldDef = fieldDef.parent;
+          }
           context.report({
             node,
             message: `Unexpected scalar result type \`${typeName}\` for ${_utilsjs.getNodeName.call(void 0, fieldDef)}`,
@@ -60,7 +68,7 @@ const RULE_ID = "no-scalar-result-type-on-mutation", rule = exports.rule = {
           });
         }
       }
-    } : {};
+    };
   }
 };
 

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

@@ -1,11 +1,12 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});const NO_TYPENAME_PREFIX = "NO_TYPENAME_PREFIX", rule = exports.rule = {
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});const NO_TYPENAME_PREFIX = "NO_TYPENAME_PREFIX";
+const rule = {
   meta: {
     type: "suggestion",
-    hasSuggestions: !0,
+    hasSuggestions: true,
     docs: {
       category: "Schema",
       description: "Enforces users to avoid using the type name in a field name while defining your schema.",
-      recommended: !0,
+      recommended: true,
       url: "https://the-guild.dev/graphql/eslint/rules/no-typename-prefix",
       examples: [
         {
@@ -40,26 +41,29 @@
   create(context) {
     return {
       "ObjectTypeDefinition, ObjectTypeExtension, InterfaceTypeDefinition, InterfaceTypeExtension"(node) {
-        const typeName = node.name.value, lowerTypeName = typeName.toLowerCase();
+        const typeName = node.name.value;
+        const 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"), "")
-                )
-              }
-            ]
-          });
+          if (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"), "")
+                  )
+                }
+              ]
+            });
+          }
         }
       }
     };

package/cjs/rules/no-unreachable-types/index.js

@@ -8,7 +8,8 @@ var _graphql = require('graphql');
 var _lodashlowercase = require('lodash.lowercase'); var _lodashlowercase2 = _interopRequireDefault(_lodashlowercase);
 var _cachejs = require('../../cache.js');
 var _utilsjs = require('../../utils.js');
-const RULE_ID = "no-unreachable-types", KINDS = [
+const RULE_ID = "no-unreachable-types";
+const KINDS = [
   _graphql.Kind.DIRECTIVE_DEFINITION,
   _graphql.Kind.OBJECT_TYPE_DEFINITION,
   _graphql.Kind.OBJECT_TYPE_EXTENSION,
@@ -22,7 +23,9 @@ const RULE_ID = "no-unreachable-types", KINDS = [
   _graphql.Kind.UNION_TYPE_EXTENSION,
   _graphql.Kind.ENUM_TYPE_DEFINITION,
   _graphql.Kind.ENUM_TYPE_EXTENSION
-], reachableTypesCache = new (0, _cachejs.ModuleCache)(), RequestDirectiveLocations = /* @__PURE__ */ new Set([
+];
+const reachableTypesCache = new (0, _cachejs.ModuleCache)();
+const RequestDirectiveLocations = /* @__PURE__ */ new Set([
   _graphql.DirectiveLocation.QUERY,
   _graphql.DirectiveLocation.MUTATION,
   _graphql.DirectiveLocation.SUBSCRIPTION,
@@ -34,20 +37,27 @@ const RULE_ID = "no-unreachable-types", KINDS = [
 ]);
 function getReachableTypes(schema) {
   const cachedValue = reachableTypesCache.get(schema);
-  if (process.env.NODE_ENV !== "test" && cachedValue)
+  if (process.env.NODE_ENV !== "test" && cachedValue) {
     return cachedValue;
-  const reachableTypes = /* @__PURE__ */ new Set(), collect = (node) => {
+  }
+  const reachableTypes = /* @__PURE__ */ new Set();
+  const collect = (node) => {
     const typeName = _utilsjs.getTypeName.call(void 0, node);
-    if (reachableTypes.has(typeName))
+    if (reachableTypes.has(typeName)) {
       return;
+    }
     reachableTypes.add(typeName);
     const type = schema.getType(typeName) || schema.getDirective(typeName);
     if (_graphql.isInterfaceType.call(void 0, type)) {
       const { objects, interfaces } = schema.getImplementations(type);
-      for (const { astNode } of [...objects, ...interfaces])
+      for (const { astNode } of [...objects, ...interfaces]) {
         _graphql.visit.call(void 0, astNode, visitor);
-    } else _optionalChain([type, 'optionalAccess', _ => _.astNode]) && _graphql.visit.call(void 0, type.astNode, visitor);
-  }, visitor = {
+      }
+    } else if (_optionalChain([type, 'optionalAccess', _ => _.astNode])) {
+      _graphql.visit.call(void 0, type.astNode, visitor);
+    }
+  };
+  const visitor = {
     InterfaceTypeDefinition: collect,
     ObjectTypeDefinition: collect,
     InputValueDefinition: collect,
@@ -62,15 +72,21 @@ function getReachableTypes(schema) {
     schema.getQueryType(),
     schema.getMutationType(),
     schema.getSubscriptionType()
-  ])
-    _optionalChain([type, 'optionalAccess', _2 => _2.astNode]) && _graphql.visit.call(void 0, type.astNode, visitor);
-  for (const node of schema.getDirectives())
+  ]) {
+    if (_optionalChain([type, 'optionalAccess', _2 => _2.astNode])) {
+      _graphql.visit.call(void 0, 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)
+      for (const arg of node.args) {
         reachableTypes.add(_graphql.getNamedType.call(void 0, arg.type).name);
+      }
     }
-  return reachableTypesCache.set(schema, reachableTypes), reachableTypes;
+  }
+  reachableTypesCache.set(schema, reachableTypes);
+  return reachableTypes;
 }
 const rule = {
   meta: {
@@ -81,7 +97,7 @@ const rule = {
       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,
+      requiresSchema: true,
       examples: [
         {
           title: "Incorrect",
@@ -116,14 +132,15 @@ const rule = {
           )
         }
       ],
-      recommended: !0
+      recommended: true
     },
     type: "suggestion",
     schema: [],
-    hasSuggestions: !0
+    hasSuggestions: true
   },
   create(context) {
-    const schema = _utilsjs.requireGraphQLSchema.call(void 0, RULE_ID, context), reachableTypes = getReachableTypes(schema);
+    const schema = _utilsjs.requireGraphQLSchema.call(void 0, RULE_ID, context);
+    const reachableTypes = getReachableTypes(schema);
     return {
       [`:matches(${KINDS}) > .name`](node) {
         const typeName = node.value;

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

@@ -1,7 +1,8 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }var _graphql = require('graphql');
 var _cachejs = require('../../cache.js');
 var _utilsjs = require('../../utils.js');
-const RULE_ID = "no-unused-fields", RELAY_SCHEMA = (
+const RULE_ID = "no-unused-fields";
+const RELAY_SCHEMA = (
   /* GraphQL */
   `
   # Root Query Type
@@ -42,7 +43,8 @@ const RULE_ID = "no-unused-fields", RELAY_SCHEMA = (
     endCursor: String
   }
 `
-), RELAY_QUERY = (
+);
+const RELAY_QUERY = (
   /* GraphQL */
   `
   query {
@@ -60,20 +62,22 @@ const RULE_ID = "no-unused-fields", RELAY_SCHEMA = (
     }
   }
 `
-), RELAY_DEFAULT_IGNORED_FIELD_SELECTORS = [
+);
+const RELAY_DEFAULT_IGNORED_FIELD_SELECTORS = [
   "[parent.name.value=PageInfo][name.value=/(endCursor|startCursor|hasNextPage|hasPreviousPage)/]",
   "[parent.name.value=/Edge$/][name.value=cursor]",
   "[parent.name.value=/Connection$/][name.value=pageInfo]"
-], schema = {
+];
+const schema = {
   type: "array",
   maxItems: 1,
   items: {
     type: "object",
-    additionalProperties: !1,
+    additionalProperties: false,
     properties: {
       ignoredFieldSelectors: {
         type: "array",
-        uniqueItems: !0,
+        uniqueItems: true,
         minItems: 1,
         description: [
           "Fields that will be ignored and are allowed to be unused.",
@@ -83,8 +87,7 @@ const RULE_ID = "no-unused-fields", RELAY_SCHEMA = (
           JSON.stringify(RELAY_DEFAULT_IGNORED_FIELD_SELECTORS, null, 2),
           "```",
           _utilsjs.eslintSelectorsTip
-        ].join(`
-`),
+        ].join("\n"),
         items: {
           type: "string",
           pattern: "^\\[(.+)]$"
@@ -92,22 +95,33 @@ const RULE_ID = "no-unused-fields", RELAY_SCHEMA = (
       }
     }
   }
-}, usedFieldsCache = new (0, _cachejs.ModuleCache)();
+};
+const usedFieldsCache = new (0, _cachejs.ModuleCache)();
 function getUsedFields(schema2, operations) {
   const cachedValue = usedFieldsCache.get(schema2);
-  if (process.env.NODE_ENV !== "test" && cachedValue)
+  if (process.env.NODE_ENV !== "test" && cachedValue) {
     return cachedValue;
-  const usedFields = /* @__PURE__ */ Object.create(null), typeInfo = new (0, _graphql.TypeInfo)(schema2), visitor = _graphql.visitWithTypeInfo.call(void 0, typeInfo, {
+  }
+  const usedFields = /* @__PURE__ */ Object.create(null);
+  const typeInfo = new (0, _graphql.TypeInfo)(schema2);
+  const visitor = _graphql.visitWithTypeInfo.call(void 0, 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);
+      const fieldDef = typeInfo.getFieldDef();
+      if (!fieldDef) {
+        return false;
+      }
+      const parentTypeName = typeInfo.getParentType().name;
+      const fieldName = node.name.value;
+      usedFields[parentTypeName] ??= /* @__PURE__ */ new Set();
+      usedFields[parentTypeName].add(fieldName);
     }
-  }), allDocuments = [...operations.getOperations(), ...operations.getFragments()];
-  for (const { document } of allDocuments)
+  });
+  const allDocuments = [...operations.getOperations(), ...operations.getFragments()];
+  for (const { document } of allDocuments) {
     _graphql.visit.call(void 0, document, visitor);
-  return usedFieldsCache.set(schema2, usedFields), usedFields;
+  }
+  usedFieldsCache.set(schema2, usedFields);
+  return usedFields;
 }
 const rule = {
   meta: {
@@ -118,10 +132,10 @@ const rule = {
       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,
+      requiresSiblings: true,
+      requiresSchema: true,
       // Requires documents to be set
-      isDisabledForAllConfig: !0,
+      isDisabledForAllConfig: true,
       examples: [
         {
           title: "Incorrect",
@@ -188,17 +202,26 @@ const rule = {
     },
     type: "suggestion",
     schema,
-    hasSuggestions: !0
+    hasSuggestions: true
   },
   create(context) {
-    const schema2 = _utilsjs.requireGraphQLSchema.call(void 0, RULE_ID, context), siblingsOperations = _utilsjs.requireGraphQLOperations.call(void 0, RULE_ID, context), usedFields = getUsedFields(schema2, siblingsOperations), { ignoredFieldSelectors } = context.options[0] || {};
+    const schema2 = _utilsjs.requireGraphQLSchema.call(void 0, RULE_ID, context);
+    const siblingsOperations = _utilsjs.requireGraphQLOperations.call(void 0, RULE_ID, context);
+    const usedFields = getUsedFields(schema2, siblingsOperations);
+    const { ignoredFieldSelectors } = context.options[0] || {};
+    const selector = (ignoredFieldSelectors || []).reduce(
+      (acc, selector2) => `${acc}:not(${selector2})`,
+      "FieldDefinition"
+    );
     return {
-      [(ignoredFieldSelectors || []).reduce(
-        (acc, selector2) => `${acc}:not(${selector2})`,
-        "FieldDefinition"
-      )](node) {
-        const fieldName = node.name.value, parentTypeName = node.parent.name.value;
-        _optionalChain([usedFields, 'access', _ => _[parentTypeName], 'optionalAccess', _2 => _2.has, 'call', _3 => _3(fieldName)]) || context.report({
+      [selector](node) {
+        const fieldName = node.name.value;
+        const parentTypeName = node.parent.name.value;
+        const isUsed = _optionalChain([usedFields, 'access', _ => _[parentTypeName], 'optionalAccess', _2 => _2.has, 'call', _3 => _3(fieldName)]);
+        if (isUsed) {
+          return;
+        }
+        context.report({
           node: node.name,
           messageId: RULE_ID,
           data: { fieldName },
@@ -206,7 +229,10 @@ const rule = {
             {
               desc: `Remove \`${fieldName}\` field`,
               fix(fixer) {
-                const sourceCode = context.getSourceCode(), tokenBefore = sourceCode.getTokenBefore(node), tokenAfter = sourceCode.getTokenAfter(node), isEmptyType = tokenBefore.type === "{" && tokenAfter.type === "}";
+                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);
               }
             }

package/cjs/rules/relay-arguments/index.js

@@ -1,21 +1,24 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }var _graphql = require('graphql');
 var _utilsjs = require('../../utils.js');
-const RULE_ID = "relay-arguments", MISSING_ARGUMENTS = "MISSING_ARGUMENTS", schema = {
+const RULE_ID = "relay-arguments";
+const MISSING_ARGUMENTS = "MISSING_ARGUMENTS";
+const schema = {
   type: "array",
   maxItems: 1,
   items: {
     type: "object",
-    additionalProperties: !1,
+    additionalProperties: false,
     minProperties: 1,
     properties: {
       includeBoth: {
         type: "boolean",
-        default: !0,
+        default: true,
         description: "Enforce including both forward and backward pagination arguments"
       }
     }
   }
-}, rule = exports.rule = {
+};
+const rule = {
   meta: {
     type: "problem",
     docs: {
@@ -34,8 +37,7 @@ const RULE_ID = "relay-arguments", MISSING_ARGUMENTS = "MISSING_ARGUMENTS", sche
         "",
         "- `last` takes a non-negative integer",
         "- `before` takes the Cursor type"
-      ].join(`
-`),
+      ].join("\n"),
       url: `https://the-guild.dev/graphql/eslint/rules/${RULE_ID}`,
       examples: [
         {
@@ -61,7 +63,7 @@ const RULE_ID = "relay-arguments", MISSING_ARGUMENTS = "MISSING_ARGUMENTS", sche
           )
         }
       ],
-      isDisabledForAllConfig: !0
+      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."
@@ -69,15 +71,19 @@ const RULE_ID = "relay-arguments", MISSING_ARGUMENTS = "MISSING_ARGUMENTS", sche
     schema
   },
   create(context) {
-    const schema2 = _utilsjs.requireGraphQLSchema.call(void 0, RULE_ID, context), { includeBoth = !0 } = context.options[0] || {};
+    const schema2 = _utilsjs.requireGraphQLSchema.call(void 0, RULE_ID, context);
+    const { includeBoth = true } = context.options[0] || {};
     return {
       "FieldDefinition > .gqlType Name[value=/Connection$/]"(node) {
         let fieldNode = node.parent;
-        for (; fieldNode.kind !== _graphql.Kind.FIELD_DEFINITION; )
+        while (fieldNode.kind !== _graphql.Kind.FIELD_DEFINITION) {
           fieldNode = fieldNode.parent;
+        }
         const args = Object.fromEntries(
           _optionalChain([fieldNode, 'access', _ => _.arguments, 'optionalAccess', _2 => _2.map, 'call', _3 => _3((argument) => [argument.name.value, argument])]) || []
-        ), hasForwardPagination = !!(args.first && args.after), hasBackwardPagination = !!(args.last && args.before);
+        );
+        const hasForwardPagination = !!(args.first && args.after);
+        const hasBackwardPagination = !!(args.last && args.before);
         if (!hasForwardPagination && !hasBackwardPagination) {
           context.report({
             node: fieldNode.name,
@@ -86,9 +92,14 @@ const RULE_ID = "relay-arguments", MISSING_ARGUMENTS = "MISSING_ARGUMENTS", sche
           return;
         }
         function checkField(typeName, argumentName) {
-          const argument = args[argumentName], hasArgument = !!argument;
+          const argument = args[argumentName];
+          const hasArgument = !!argument;
           let type = argument;
-          if (hasArgument && type.gqlType.kind === _graphql.Kind.NON_NULL_TYPE && (type = type.gqlType), !(hasArgument && type.gqlType.kind === _graphql.Kind.NAMED_TYPE && (type.gqlType.name.value === typeName || typeName === "String" && _graphql.isScalarType.call(void 0, schema2.getType(type.gqlType.name.value))))) {
+          if (hasArgument && type.gqlType.kind === _graphql.Kind.NON_NULL_TYPE) {
+            type = type.gqlType;
+          }
+          const isAllowedNonNullType = hasArgument && type.gqlType.kind === _graphql.Kind.NAMED_TYPE && (type.gqlType.name.value === typeName || typeName === "String" && _graphql.isScalarType.call(void 0, schema2.getType(type.gqlType.name.value)));
+          if (!isAllowedNonNullType) {
             const returnType = typeName === "String" ? "String or Scalar" : typeName;
             context.report({
               node: (argument || fieldNode).name,
@@ -96,7 +107,14 @@ const RULE_ID = "relay-arguments", MISSING_ARGUMENTS = "MISSING_ARGUMENTS", sche
             });
           }
         }
-        (includeBoth || args.first || args.after) && (checkField("Int", "first"), checkField("String", "after")), (includeBoth || args.last || args.before) && (checkField("Int", "last"), checkField("String", "before"));
+        if (includeBoth || args.first || args.after) {
+          checkField("Int", "first");
+          checkField("String", "after");
+        }
+        if (includeBoth || args.last || args.before) {
+          checkField("Int", "last");
+          checkField("String", "before");
+        }
       }
     };
   }

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

@@ -1,5 +1,11 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }var _graphql = require('graphql');
-const MUST_BE_OBJECT_TYPE = "MUST_BE_OBJECT_TYPE", MUST_CONTAIN_FIELD_EDGES = "MUST_CONTAIN_FIELD_EDGES", MUST_CONTAIN_FIELD_PAGE_INFO = "MUST_CONTAIN_FIELD_PAGE_INFO", MUST_HAVE_CONNECTION_SUFFIX = "MUST_HAVE_CONNECTION_SUFFIX", EDGES_FIELD_MUST_RETURN_LIST_TYPE = "EDGES_FIELD_MUST_RETURN_LIST_TYPE", PAGE_INFO_FIELD_MUST_RETURN_NON_NULL_TYPE = "PAGE_INFO_FIELD_MUST_RETURN_NON_NULL_TYPE", NON_OBJECT_TYPES = exports.NON_OBJECT_TYPES = [
+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 = [
   _graphql.Kind.SCALAR_TYPE_DEFINITION,
   _graphql.Kind.UNION_TYPE_DEFINITION,
   _graphql.Kind.UNION_TYPE_EXTENSION,
@@ -9,7 +15,11 @@ const MUST_BE_OBJECT_TYPE = "MUST_BE_OBJECT_TYPE", MUST_CONTAIN_FIELD_EDGES = "M
   _graphql.Kind.ENUM_TYPE_EXTENSION,
   _graphql.Kind.INTERFACE_TYPE_DEFINITION,
   _graphql.Kind.INTERFACE_TYPE_EXTENSION
-], notConnectionTypesSelector = `:matches(${NON_OBJECT_TYPES})[name.value=/Connection$/] > .name`, hasEdgesField = (node) => _optionalChain([node, 'access', _ => _.fields, 'optionalAccess', _2 => _2.some, 'call', _3 => _3((field) => field.name.value === "edges")]), hasPageInfoField = (node) => _optionalChain([node, 'access', _4 => _4.fields, 'optionalAccess', _5 => _5.some, 'call', _6 => _6((field) => field.name.value === "pageInfo")]), rule = exports.rule = {
+];
+const notConnectionTypesSelector = `:matches(${NON_OBJECT_TYPES})[name.value=/Connection$/] > .name`;
+const hasEdgesField = (node) => _optionalChain([node, 'access', _ => _.fields, 'optionalAccess', _2 => _2.some, 'call', _3 => _3((field) => field.name.value === "edges")]);
+const hasPageInfoField = (node) => _optionalChain([node, 'access', _4 => _4.fields, 'optionalAccess', _5 => _5.some, 'call', _6 => _6((field) => field.name.value === "pageInfo")]);
+const rule = {
   meta: {
     type: "problem",
     docs: {
@@ -21,10 +31,9 @@ const MUST_BE_OBJECT_TYPE = "MUST_BE_OBJECT_TYPE", MUST_CONTAIN_FIELD_EDGES = "M
         "- 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(`
-`),
+      ].join("\n"),
       url: "https://the-guild.dev/graphql/eslint/rules/relay-connection-types",
-      isDisabledForAllConfig: !0,
+      isDisabledForAllConfig: true,
       examples: [
         {
           title: "Incorrect",
@@ -69,16 +78,29 @@ const MUST_BE_OBJECT_TYPE = "MUST_BE_OBJECT_TYPE", MUST_CONTAIN_FIELD_EDGES = "M
         context.report({ node, messageId: MUST_BE_OBJECT_TYPE });
       },
       ":matches(ObjectTypeDefinition, ObjectTypeExtension)[name.value!=/Connection$/]"(node) {
-        hasEdgesField(node) && hasPageInfoField(node) && context.report({ node: node.name, messageId: MUST_HAVE_CONNECTION_SUFFIX });
+        if (hasEdgesField(node) && hasPageInfoField(node)) {
+          context.report({ node: node.name, messageId: MUST_HAVE_CONNECTION_SUFFIX });
+        }
       },
       ":matches(ObjectTypeDefinition, ObjectTypeExtension)[name.value=/Connection$/]"(node) {
-        hasEdgesField(node) || context.report({ node: node.name, messageId: MUST_CONTAIN_FIELD_EDGES }), hasPageInfoField(node) || context.report({ node: node.name, messageId: MUST_CONTAIN_FIELD_PAGE_INFO });
+        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) {
-        node.kind === _graphql.Kind.LIST_TYPE || node.kind === _graphql.Kind.NON_NULL_TYPE && node.gqlType.kind === _graphql.Kind.LIST_TYPE || context.report({ node, messageId: EDGES_FIELD_MUST_RETURN_LIST_TYPE });
+        const isListType = node.kind === _graphql.Kind.LIST_TYPE || node.kind === _graphql.Kind.NON_NULL_TYPE && node.gqlType.kind === _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) {
-        node.kind === _graphql.Kind.NON_NULL_TYPE && node.gqlType.kind === _graphql.Kind.NAMED_TYPE && node.gqlType.name.value === "PageInfo" || context.report({ node, messageId: PAGE_INFO_FIELD_MUST_RETURN_NON_NULL_TYPE });
+        const isNonNullPageInfoType = node.kind === _graphql.Kind.NON_NULL_TYPE && node.gqlType.kind === _graphql.Kind.NAMED_TYPE && node.gqlType.name.value === "PageInfo";
+        if (!isNonNullPageInfoType) {
+          context.report({ node, messageId: PAGE_INFO_FIELD_MUST_RETURN_NON_NULL_TYPE });
+        }
       }
     };
   }