@graphql-eslint/eslint-plugin 4.0.0-alpha.1 → 4.0.0-alpha.11

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

@@ -0,0 +1,69 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});require('../../chunk-UIAXBAMD.js');
+var _graphql = require('graphql');
+var _utilsjs = require('../../utils.js');
+const RULE_ID = "no-scalar-result-type-on-mutation", rule = exports.rule = {
+  meta: {
+    type: "suggestion",
+    hasSuggestions: !0,
+    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,
+      examples: [
+        {
+          title: "Incorrect",
+          code: (
+            /* GraphQL */
+            `
+            type Mutation {
+              createUser: Boolean
+            }
+          `
+          )
+        },
+        {
+          title: "Correct",
+          code: (
+            /* GraphQL */
+            `
+            type Mutation {
+              createUser: User!
+            }
+          `
+          )
+        }
+      ]
+    },
+    schema: []
+  },
+  create(context) {
+    const schema = _utilsjs.requireGraphQLSchemaFromContext.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);
+        if (_graphql.isScalarType.call(void 0, graphQLType)) {
+          let fieldDef = node.parent;
+          for (; 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)}`,
+            suggest: [
+              {
+                desc: `Remove \`${typeName}\``,
+                fix: (fixer) => fixer.remove(node)
+              }
+            ]
+          });
+        }
+      }
+    } : {};
+  }
+};
+
+
+exports.rule = rule;

package/cjs/rules/no-typename-prefix/index.d.cts

@@ -0,0 +1,13 @@
+import { GraphQLESLintRule } from '../../types.cjs';
+import 'eslint';
+import 'estree';
+import 'graphql';
+import 'graphql-config';
+import 'json-schema-to-ts';
+import '../../estree-converter/types.cjs';
+import '../../siblings.cjs';
+import '@graphql-tools/utils';
+
+declare const rule: GraphQLESLintRule;
+
+export { rule };

package/cjs/rules/{no-typename-prefix.js → no-typename-prefix/index.js}

@@ -1,24 +1,5 @@
-"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 = {
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});require('../../chunk-UIAXBAMD.js');
+const NO_TYPENAME_PREFIX = "NO_TYPENAME_PREFIX", rule = exports.rule = {
   meta: {
     type: "suggestion",
     hasSuggestions: !0,
@@ -85,7 +66,6 @@ const NO_TYPENAME_PREFIX = "NO_TYPENAME_PREFIX", rule = {
     };
   }
 };
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  rule
-});
+
+
+exports.rule = rule;

package/cjs/rules/no-unreachable-types/index.d.cts

@@ -0,0 +1,13 @@
+import { GraphQLESLintRule } from '../../types.cjs';
+import 'eslint';
+import 'estree';
+import 'graphql';
+import 'graphql-config';
+import 'json-schema-to-ts';
+import '../../estree-converter/types.cjs';
+import '../../siblings.cjs';
+import '@graphql-tools/utils';
+
+declare const rule: GraphQLESLintRule;
+
+export { rule };

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

@@ -0,0 +1,155 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } 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; }require('../../chunk-UIAXBAMD.js');
+
+
+
+
+
+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 = [
+  _graphql.Kind.DIRECTIVE_DEFINITION,
+  _graphql.Kind.OBJECT_TYPE_DEFINITION,
+  _graphql.Kind.OBJECT_TYPE_EXTENSION,
+  _graphql.Kind.INTERFACE_TYPE_DEFINITION,
+  _graphql.Kind.INTERFACE_TYPE_EXTENSION,
+  _graphql.Kind.SCALAR_TYPE_DEFINITION,
+  _graphql.Kind.SCALAR_TYPE_EXTENSION,
+  _graphql.Kind.INPUT_OBJECT_TYPE_DEFINITION,
+  _graphql.Kind.INPUT_OBJECT_TYPE_EXTENSION,
+  _graphql.Kind.UNION_TYPE_DEFINITION,
+  _graphql.Kind.UNION_TYPE_EXTENSION,
+  _graphql.Kind.ENUM_TYPE_DEFINITION,
+  _graphql.Kind.ENUM_TYPE_EXTENSION
+], reachableTypesCache = new (0, _cachejs.ModuleCache)(), RequestDirectiveLocations = /* @__PURE__ */ new Set([
+  _graphql.DirectiveLocation.QUERY,
+  _graphql.DirectiveLocation.MUTATION,
+  _graphql.DirectiveLocation.SUBSCRIPTION,
+  _graphql.DirectiveLocation.FIELD,
+  _graphql.DirectiveLocation.FRAGMENT_DEFINITION,
+  _graphql.DirectiveLocation.FRAGMENT_SPREAD,
+  _graphql.DirectiveLocation.INLINE_FRAGMENT,
+  _graphql.DirectiveLocation.VARIABLE_DEFINITION
+]);
+function getReachableTypes(schema) {
+  const cachedValue = reachableTypesCache.get(schema);
+  if (process.env.NODE_ENV !== "test" && cachedValue)
+    return cachedValue;
+  const reachableTypes = /* @__PURE__ */ new Set(), collect = (node) => {
+    const typeName = _utilsjs.getTypeName.call(void 0, node);
+    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])
+        _graphql.visit.call(void 0, astNode, visitor);
+    } else _optionalChain([type, 'optionalAccess', _ => _.astNode]) && _graphql.visit.call(void 0, 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()
+  ])
+    _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) {
+        const argTypeName = "name" in arg.type && arg.type.name;
+        argTypeName && reachableTypes.add(argTypeName);
+      }
+    }
+  return reachableTypesCache.set(schema, reachableTypes), reachableTypes;
+}
+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 = _utilsjs.requireGraphQLSchemaFromContext.call(void 0, RULE_ID, context), reachableTypes = getReachableTypes(schema);
+    return {
+      [`:matches(${KINDS}) > .name`](node) {
+        const typeName = node.value;
+        if (!reachableTypes.has(typeName)) {
+          const type = _lodashlowercase2.default.call(void 0, 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)
+              }
+            ]
+          });
+        }
+      }
+    };
+  }
+};
+
+
+exports.rule = rule;

package/cjs/rules/no-unused-fields/index.d.cts

@@ -0,0 +1,34 @@
+import { FromSchema } from 'json-schema-to-ts';
+import { GraphQLESLintRule } from '../../types.cjs';
+import 'eslint';
+import 'estree';
+import 'graphql';
+import 'graphql-config';
+import '../../estree-converter/types.cjs';
+import '../../siblings.cjs';
+import '@graphql-tools/utils';
+
+declare const schema: {
+    readonly type: "array";
+    readonly maxItems: 1;
+    readonly items: {
+        readonly type: "object";
+        readonly additionalProperties: false;
+        readonly properties: {
+            readonly ignoredFieldSelectors: {
+                readonly type: "array";
+                readonly uniqueItems: true;
+                readonly minItems: 1;
+                readonly description: string;
+                readonly items: {
+                    readonly type: "string";
+                    readonly pattern: "^\\[(.+)]$";
+                };
+            };
+        };
+    };
+};
+type RuleOptions = FromSchema<typeof schema>;
+declare const rule: GraphQLESLintRule<RuleOptions>;
+
+export { type RuleOptions, rule };

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

@@ -0,0 +1,224 @@
+"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; }require('../../chunk-UIAXBAMD.js');
+var _graphql = require('graphql');
+var _cachejs = require('../../cache.js');
+var _utilsjs = require('../../utils.js');
+const RULE_ID = "no-unused-fields", RELAY_SCHEMA = (
+  /* GraphQL */
+  `
+  # Root Query Type
+  type Query {
+    user: User
+  }
+
+  # User Type
+  type User {
+    id: ID!
+    name: String!
+    friends(first: Int, after: String): FriendConnection!
+  }
+
+  # FriendConnection Type (Relay Connection)
+  type FriendConnection {
+    edges: [FriendEdge]
+    pageInfo: PageInfo!
+  }
+
+  # FriendEdge Type
+  type FriendEdge {
+    cursor: String!
+    node: Friend!
+  }
+
+  # Friend Type
+  type Friend {
+    id: ID!
+    name: String!
+  }
+
+  # PageInfo Type (Relay Pagination)
+  type PageInfo {
+    hasPreviousPage: Boolean!
+    hasNextPage: Boolean!
+    startCursor: String
+    endCursor: String
+  }
+`
+), RELAY_QUERY = (
+  /* GraphQL */
+  `
+  query {
+    user {
+      id
+      name
+      friends(first: 10) {
+        edges {
+          node {
+            id
+            name
+          }
+        }
+      }
+    }
+  }
+`
+), 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 = {
+  type: "array",
+  maxItems: 1,
+  items: {
+    type: "object",
+    additionalProperties: !1,
+    properties: {
+      ignoredFieldSelectors: {
+        type: "array",
+        uniqueItems: !0,
+        minItems: 1,
+        description: [
+          "Fields that will be ignored and are allowed to be unused.",
+          "",
+          "E.g. The following selector will ignore all the relay pagination fields for every connection exposed in the schema:",
+          "```json",
+          JSON.stringify(RELAY_DEFAULT_IGNORED_FIELD_SELECTORS, null, 2),
+          "```",
+          "",
+          "> These fields are defined by ESLint [`selectors`](https://eslint.org/docs/developer-guide/selectors).",
+          "> Paste or drop code into the editor in [ASTExplorer](https://astexplorer.net) and inspect the generated AST to compose your selector."
+        ].join(`
+`),
+        items: {
+          type: "string",
+          pattern: "^\\[(.+)]$"
+        }
+      }
+    }
+  }
+}, usedFieldsCache = new (0, _cachejs.ModuleCache)();
+function getUsedFields(schema2, operations) {
+  const cachedValue = usedFieldsCache.get(schema2);
+  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, {
+    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)
+    _graphql.visit.call(void 0, document, visitor);
+  return usedFieldsCache.set(schema2, usedFields), usedFields;
+}
+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
+              }
+            }
+          `
+          )
+        },
+        {
+          title: "Correct (ignoring fields)",
+          usage: [{ ignoredFieldSelectors: RELAY_DEFAULT_IGNORED_FIELD_SELECTORS }],
+          code: (
+            /* GraphQL */
+            `
+            ### 1\uFE0F\u20E3 YOUR SCHEMA
+            ${RELAY_SCHEMA}
+
+            ### 2\uFE0F\u20E3 YOUR QUERY
+            ${RELAY_QUERY}
+          `
+          )
+        }
+      ]
+    },
+    type: "suggestion",
+    schema,
+    hasSuggestions: !0
+  },
+  create(context) {
+    const schema2 = _utilsjs.requireGraphQLSchemaFromContext.call(void 0, RULE_ID, context), siblingsOperations = _utilsjs.requireSiblingsOperations.call(void 0, RULE_ID, context), usedFields = getUsedFields(schema2, siblingsOperations), { ignoredFieldSelectors } = context.options[0] || {};
+    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({
+          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);
+              }
+            }
+          ]
+        });
+      }
+    };
+  }
+};
+
+
+exports.rule = rule;

package/{esm/rules/relay-arguments.d.mts → cjs/rules/relay-arguments/index.d.cts}

@@ -1,11 +1,11 @@
 import { FromSchema } from 'json-schema-to-ts';
-import { GraphQLESLintRule } from '../types.mjs';
+import { GraphQLESLintRule } from '../../types.cjs';
 import 'eslint';
 import 'estree';
 import 'graphql';
 import 'graphql-config';
-import '../estree-converter/types.mjs';
-import '../siblings.mjs';
+import '../../estree-converter/types.cjs';
+import '../../siblings.cjs';
 import '@graphql-tools/utils';
 
 declare const schema: {

package/cjs/rules/{relay-arguments.js → relay-arguments/index.js}

@@ -1,24 +1,6 @@
-"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");
+"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; }require('../../chunk-UIAXBAMD.js');
+var _graphql = require('graphql');
+var _utilsjs = require('../../utils.js');
 const RULE_ID = "relay-arguments", MISSING_ARGUMENTS = "MISSING_ARGUMENTS", schema = {
   type: "array",
   maxItems: 1,
@@ -34,7 +16,7 @@ const RULE_ID = "relay-arguments", MISSING_ARGUMENTS = "MISSING_ARGUMENTS", sche
       }
     }
   }
-}, rule = {
+}, rule = exports.rule = {
   meta: {
     type: "problem",
     docs: {
@@ -88,14 +70,14 @@ const RULE_ID = "relay-arguments", MISSING_ARGUMENTS = "MISSING_ARGUMENTS", sche
     schema
   },
   create(context) {
-    const schema2 = (0, import_utils.requireGraphQLSchemaFromContext)(RULE_ID, context), { includeBoth = !0 } = context.options[0] || {};
+    const schema2 = _utilsjs.requireGraphQLSchemaFromContext.call(void 0, 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; )
+        for (; fieldNode.kind !== _graphql.Kind.FIELD_DEFINITION; )
           fieldNode = fieldNode.parent;
         const args = Object.fromEntries(
-          fieldNode.arguments?.map((argument) => [argument.name.value, argument]) || []
+          _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);
         if (!hasForwardPagination && !hasBackwardPagination) {
           context.report({
@@ -107,7 +89,7 @@ const RULE_ID = "relay-arguments", MISSING_ARGUMENTS = "MISSING_ARGUMENTS", sche
         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))))) {
+          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))))) {
             const returnType = typeName === "String" ? "String or Scalar" : typeName;
             context.report({
               node: (argument || fieldNode).name,
@@ -120,7 +102,6 @@ const RULE_ID = "relay-arguments", MISSING_ARGUMENTS = "MISSING_ARGUMENTS", sche
     };
   }
 };
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  rule
-});
+
+
+exports.rule = rule;

package/{esm/rules/relay-connection-types.d.mts → cjs/rules/relay-connection-types/index.d.cts}

@@ -1,11 +1,11 @@
 import { Kind } from 'graphql';
-import { GraphQLESLintRule } from '../types.mjs';
+import { GraphQLESLintRule } from '../../types.cjs';
 import 'eslint';
 import 'estree';
 import 'graphql-config';
 import 'json-schema-to-ts';
-import '../estree-converter/types.mjs';
-import '../siblings.mjs';
+import '../../estree-converter/types.cjs';
+import '../../siblings.cjs';
 import '@graphql-tools/utils';
 
 declare const NON_OBJECT_TYPES: Kind[];