@graphql-eslint/eslint-plugin 4.3.0 → 4.4.0-alpha-20241207210859-41eb4549764dc0314b5bd4f257ea6667b178540e

package/cjs/siblings.js

@@ -6,12 +6,18 @@ var _utilsjs = require('./utils.js');
 const siblingOperationsCache = /* @__PURE__ */ new Map();
 function getSiblings(documents) {
   if (documents.length === 0) {
-    let printed = !1;
-    const noopWarn = () => (printed || (_utilsjs.logger.warn(
-      "getSiblingOperations was called without any operations. Make sure to set graphql-config `documents` field to make this feature available! See https://the-guild.dev/graphql/config/docs/user/documents for more info"
-    ), printed = !0), []);
+    let printed = false;
+    const noopWarn = () => {
+      if (!printed) {
+        _utilsjs.logger.warn(
+          "getSiblingOperations was called without any operations. Make sure to set graphql-config `documents` field to make this feature available! See https://the-guild.dev/graphql/config/docs/user/documents for more info"
+        );
+        printed = true;
+      }
+      return [];
+    };
     return {
-      available: !1,
+      available: false,
       getFragment: noopWarn,
       getFragments: noopWarn,
       getFragmentByType: noopWarn,
@@ -22,18 +28,23 @@ function getSiblings(documents) {
     };
   }
   const value = siblingOperationsCache.get(documents);
-  if (value)
+  if (value) {
     return value;
+  }
   let fragmentsCache = null;
   const getFragments = () => {
     if (fragmentsCache === null) {
       const result = [];
-      for (const source of documents)
-        for (const definition of _optionalChain([source, 'access', _ => _.document, 'optionalAccess', _2 => _2.definitions]) || [])
-          definition.kind === _graphql.Kind.FRAGMENT_DEFINITION && result.push({
-            filePath: source.location,
-            document: definition
-          });
+      for (const source of documents) {
+        for (const definition of _optionalChain([source, 'access', _ => _.document, 'optionalAccess', _2 => _2.definitions]) || []) {
+          if (definition.kind === _graphql.Kind.FRAGMENT_DEFINITION) {
+            result.push({
+              filePath: source.location,
+              document: definition
+            });
+          }
+        }
+      }
       fragmentsCache = result;
     }
     return fragmentsCache;
@@ -42,37 +53,54 @@ function getSiblings(documents) {
   const getOperations = () => {
     if (cachedOperations === null) {
       const result = [];
-      for (const source of documents)
-        for (const definition of _optionalChain([source, 'access', _3 => _3.document, 'optionalAccess', _4 => _4.definitions]) || [])
-          definition.kind === _graphql.Kind.OPERATION_DEFINITION && result.push({
-            filePath: source.location,
-            document: definition
-          });
+      for (const source of documents) {
+        for (const definition of _optionalChain([source, 'access', _3 => _3.document, 'optionalAccess', _4 => _4.definitions]) || []) {
+          if (definition.kind === _graphql.Kind.OPERATION_DEFINITION) {
+            result.push({
+              filePath: source.location,
+              document: definition
+            });
+          }
+        }
+      }
       cachedOperations = result;
     }
     return cachedOperations;
-  }, getFragment = (name) => getFragments().filter((f) => f.document.name.value === name), collectFragments = (selectable, recursive, collected = /* @__PURE__ */ new Map()) => (_graphql.visit.call(void 0, selectable, {
-    FragmentSpread(spread) {
-      const fragmentName = spread.name.value, [fragment] = getFragment(fragmentName);
-      if (!fragment) {
-        _utilsjs.logger.warn(
-          `Unable to locate fragment named "${fragmentName}", please make sure it's loaded using "parserOptions.operations"`
-        );
-        return;
+  };
+  const getFragment = (name) => getFragments().filter((f) => f.document.name.value === name);
+  const collectFragments = (selectable, recursive, collected = /* @__PURE__ */ new Map()) => {
+    _graphql.visit.call(void 0, selectable, {
+      FragmentSpread(spread) {
+        const fragmentName = spread.name.value;
+        const [fragment] = getFragment(fragmentName);
+        if (!fragment) {
+          _utilsjs.logger.warn(
+            `Unable to locate fragment named "${fragmentName}", please make sure it's loaded using "parserOptions.operations"`
+          );
+          return;
+        }
+        if (!collected.has(fragmentName)) {
+          collected.set(fragmentName, fragment.document);
+          if (recursive) {
+            collectFragments(fragment.document, recursive, collected);
+          }
+        }
       }
-      collected.has(fragmentName) || (collected.set(fragmentName, fragment.document), recursive && collectFragments(fragment.document, recursive, collected));
-    }
-  }), collected), siblingOperations = {
-    available: !0,
+    });
+    return collected;
+  };
+  const siblingOperations = {
+    available: true,
     getFragment,
     getFragments,
     getFragmentByType: (typeName) => getFragments().filter((f) => f.document.typeCondition.name.value === typeName),
-    getFragmentsInUse: (selectable, recursive = !0) => Array.from(collectFragments(selectable, recursive).values()),
+    getFragmentsInUse: (selectable, recursive = true) => Array.from(collectFragments(selectable, recursive).values()),
     getOperation: (name) => getOperations().filter((o) => _optionalChain([o, 'access', _5 => _5.document, 'access', _6 => _6.name, 'optionalAccess', _7 => _7.value]) === name),
     getOperations,
     getOperationByType: (type) => getOperations().filter((o) => o.document.operation === type)
   };
-  return siblingOperationsCache.set(documents, siblingOperations), siblingOperations;
+  siblingOperationsCache.set(documents, siblingOperations);
+  return siblingOperations;
 }
 
 

package/cjs/utils.js

@@ -2,24 +2,27 @@
 var _lodashlowercase = require('lodash.lowercase'); var _lodashlowercase2 = _interopRequireDefault(_lodashlowercase);
 function requireGraphQLOperations(ruleId, context) {
   const { siblingOperations } = context.sourceCode.parserServices;
-  if (!siblingOperations.available)
+  if (!siblingOperations.available) {
     throw new Error(
       `Rule \`${ruleId}\` requires graphql-config \`documents\` field to be set and loaded. See https://the-guild.dev/graphql/eslint/docs/usage#providing-operations for more info`
     );
+  }
   return siblingOperations;
 }
 function requireGraphQLSchema(ruleId, context) {
   const { schema } = context.sourceCode.parserServices;
-  if (!schema)
+  if (!schema) {
     throw new Error(
       `Rule \`${ruleId}\` requires graphql-config \`schema\` field to be set and loaded. See https://the-guild.dev/graphql/eslint/docs/usage#providing-schema for more info`
     );
+  }
   return schema;
 }
 const chalk = {
   red: (str) => `\x1B[31m${str}\x1B[39m`,
   yellow: (str) => `\x1B[33m${str}\x1B[39m`
-}, logger = exports.logger = {
+};
+const logger = {
   error: (...args) => (
     // eslint-disable-next-line no-console
     console.error(chalk.red("error"), "[graphql-eslint]", ...args)
@@ -28,17 +31,25 @@ const chalk = {
     // eslint-disable-next-line no-console
     console.warn(chalk.yellow("warning"), "[graphql-eslint]", ...args)
   )
-}, slash = exports.slash = (path) => path.replaceAll("\\", "/"), VIRTUAL_DOCUMENT_REGEX = exports.VIRTUAL_DOCUMENT_REGEX = /[/\\]\d+_document.graphql$/, CWD = exports.CWD = process.cwd(), getTypeName = exports.getTypeName = (node) => "type" in node ? getTypeName(node.type) : "name" in node && node.name ? node.name.value : "", TYPES_KINDS = exports.TYPES_KINDS = [
+};
+const slash = (path) => path.replaceAll("\\", "/");
+const VIRTUAL_DOCUMENT_REGEX = /[/\\]\d+_document.graphql$/;
+const CWD = process.cwd();
+const getTypeName = (node) => "type" in node ? getTypeName(node.type) : "name" in node && node.name ? node.name.value : "";
+const TYPES_KINDS = [
   _graphql.Kind.OBJECT_TYPE_DEFINITION,
   _graphql.Kind.INTERFACE_TYPE_DEFINITION,
   _graphql.Kind.ENUM_TYPE_DEFINITION,
   _graphql.Kind.SCALAR_TYPE_DEFINITION,
   _graphql.Kind.INPUT_OBJECT_TYPE_DEFINITION,
   _graphql.Kind.UNION_TYPE_DEFINITION
-], pascalCase = exports.pascalCase = (str) => _lodashlowercase2.default.call(void 0, str).split(" ").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(""), camelCase = exports.camelCase = (str) => {
+];
+const pascalCase = (str) => _lodashlowercase2.default.call(void 0, str).split(" ").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join("");
+const camelCase = (str) => {
   const result = pascalCase(str);
   return result.charAt(0).toLowerCase() + result.slice(1);
-}, convertCase = exports.convertCase = (style, str) => {
+};
+const convertCase = (style, str) => {
   switch (style) {
     case "camelCase":
       return camelCase(str);
@@ -65,14 +76,17 @@ function getLocation(start, fieldName = "") {
     }
   };
 }
-const REPORT_ON_FIRST_CHARACTER = { column: 0, line: 1 }, ARRAY_DEFAULT_OPTIONS = exports.ARRAY_DEFAULT_OPTIONS = {
+const REPORT_ON_FIRST_CHARACTER = { column: 0, line: 1 };
+const ARRAY_DEFAULT_OPTIONS = {
   type: "array",
-  uniqueItems: !0,
+  uniqueItems: true,
   minItems: 1,
   items: {
     type: "string"
   }
-}, englishJoinWords = exports.englishJoinWords = (words) => new Intl.ListFormat("en-US", { type: "disjunction" }).format(words), DisplayNodeNameMap = {
+};
+const englishJoinWords = (words) => new Intl.ListFormat("en-US", { type: "disjunction" }).format(words);
+const DisplayNodeNameMap = {
   [_graphql.Kind.ARGUMENT]: "argument",
   [_graphql.Kind.BOOLEAN]: "boolean",
   [_graphql.Kind.DIRECTIVE_DEFINITION]: "directive",

package/esm/cache.js

@@ -3,20 +3,24 @@ const log = debugFactory("graphql-eslint:ModuleCache");
 class ModuleCache {
   map = /* @__PURE__ */ new Map();
   set(cacheKey, result) {
-    this.map.set(cacheKey, { lastSeen: process.hrtime(), result }), log("setting entry for", cacheKey);
+    if (false) return;
+    this.map.set(cacheKey, { lastSeen: process.hrtime(), result });
+    log("setting entry for", cacheKey);
   }
   get(cacheKey, settings = {
     lifetime: 10
     /* seconds */
   }) {
+    if (false) return;
     const value = this.map.get(cacheKey);
     if (!value) {
       log("cache miss for", cacheKey);
       return;
     }
     const { lastSeen, result } = value;
-    if (process.env.NODE || process.hrtime(lastSeen)[0] < settings.lifetime)
+    if (process.env.NODE || process.hrtime(lastSeen)[0] < settings.lifetime) {
       return result;
+    }
   }
 }
 export {

package/esm/configs/operations-all.js

@@ -4,9 +4,9 @@ var operations_all_default = {
     "@graphql-eslint/alphabetize": [
       "error",
       {
-        definitions: !0,
+        definitions: true,
         selections: ["OperationDefinition", "FragmentDefinition"],
-        variables: !0,
+        variables: true,
         arguments: ["Field", "Directive"],
         groups: ["...", "id", "*", "{"]
       }

package/esm/configs/schema-all.js

@@ -4,9 +4,9 @@ var schema_all_default = {
     "@graphql-eslint/alphabetize": [
       "error",
       {
-        definitions: !0,
+        definitions: true,
         fields: ["ObjectTypeDefinition", "InterfaceTypeDefinition", "InputObjectTypeDefinition"],
-        values: !0,
+        values: true,
         arguments: ["FieldDefinition", "Field", "DirectiveDefinition", "Directive"],
         groups: ["id", "*", "createdAt", "updatedAt"]
       }

package/esm/configs/schema-recommended.js

@@ -54,7 +54,7 @@ var schema_recommended_default = {
     "@graphql-eslint/require-deprecation-reason": "error",
     "@graphql-eslint/require-description": [
       "error",
-      { types: !0, DirectiveDefinition: !0, rootField: !0 }
+      { types: true, DirectiveDefinition: true, rootField: true }
     ],
     "@graphql-eslint/strict-id-in-types": "error",
     "@graphql-eslint/unique-directive-names": "error",

package/esm/documents.js

@@ -2,17 +2,20 @@ import path from "node:path";
 import debugFactory from "debug";
 import fg from "fast-glob";
 import { ModuleCache } from "./cache.js";
-const debug = debugFactory("graphql-eslint:operations"), operationsCache = new ModuleCache(), handleVirtualPath = (documents) => {
+const debug = debugFactory("graphql-eslint:operations");
+const operationsCache = new ModuleCache();
+const handleVirtualPath = (documents) => {
   const filepathMap = /* @__PURE__ */ Object.create(null);
   return documents.map((source) => {
     const location = source.location;
-    if ([".gql", ".graphql"].some((extension) => location.endsWith(extension)))
+    if ([".gql", ".graphql"].some((extension) => location.endsWith(extension))) {
       return {
         ...source,
         // When using glob pattern e.g. `**/*.gql` location contains always forward slashes even on
         // Windows
         location: path.resolve(location)
       };
+    }
     filepathMap[location] ??= -1;
     const index = filepathMap[location] += 1;
     return {
@@ -20,23 +23,26 @@ const debug = debugFactory("graphql-eslint:operations"), operationsCache = new M
       location: path.resolve(location, `${index}_document.graphql`)
     };
   });
-}, getDocuments = (project) => {
+};
+const getDocuments = (project) => {
   const documentsKey = project.documents;
-  if (!documentsKey)
+  if (!documentsKey) {
     return [];
+  }
   let siblings = operationsCache.get(documentsKey);
   if (!siblings) {
     debug("Loading operations from %o", project.documents);
     const documents = project.loadDocumentsSync(project.documents, {
-      skipGraphQLImport: !0,
+      skipGraphQLImport: true,
       pluckConfig: project.extensions.pluckConfig
     });
     if (debug.enabled) {
       debug("Loaded %d operations", documents.length);
-      const operationsPaths = fg.sync(project.documents, { absolute: !0 });
+      const operationsPaths = fg.sync(project.documents, { absolute: true });
       debug("Operations pointers %O", operationsPaths);
     }
-    siblings = handleVirtualPath(documents), operationsCache.set(documentsKey, siblings);
+    siblings = handleVirtualPath(documents);
+    operationsCache.set(documentsKey, siblings);
   }
   return siblings;
 };

package/esm/estree-converter/converter.js

@@ -6,14 +6,16 @@ import {
 } from "graphql";
 import { convertLocation } from "./utils.js";
 function convertToESTree(node, schema) {
-  const typeInfo = schema && new TypeInfo(schema), visitor = {
+  const typeInfo = schema && new TypeInfo(schema);
+  const visitor = {
     leave(node2, key, parent) {
       const leadingComments = "description" in node2 && node2.description ? [
         {
           type: node2.description.block ? "Block" : "Line",
           value: node2.description.value
         }
-      ] : [], calculatedTypeInfo = typeInfo ? {
+      ] : [];
+      const calculatedTypeInfo = typeInfo ? {
         argument: typeInfo.getArgument(),
         defaultValue: typeInfo.getDefaultValue(),
         directive: typeInfo.getDirective(),
@@ -23,12 +25,19 @@ function convertToESTree(node, schema) {
         parentInputType: typeInfo.getParentInputType(),
         parentType: typeInfo.getParentType(),
         gqlType: typeInfo.getType()
-      } : {}, rawNode = () => parent && key !== void 0 ? parent[key] : node2.kind === Kind.DOCUMENT ? {
-        ...node2,
-        definitions: node2.definitions.map(
-          (definition) => definition.rawNode()
-        )
-      } : node2, commonFields = {
+      } : {};
+      const rawNode = () => {
+        if (parent && key !== void 0) {
+          return parent[key];
+        }
+        return node2.kind === Kind.DOCUMENT ? {
+          ...node2,
+          definitions: node2.definitions.map(
+            (definition) => definition.rawNode()
+          )
+        } : node2;
+      };
+      const commonFields = {
         ...node2,
         type: node2.kind,
         loc: convertLocation(node2.loc),

package/esm/estree-converter/utils.js

@@ -6,9 +6,14 @@ import {
   TokenKind
 } from "graphql";
 import { valueFromASTUntyped } from "graphql/utilities/valueFromASTUntyped.js";
-const valueFromNode = (...args) => valueFromASTUntyped(...args);
+const valueFromNode = (...args) => {
+  return valueFromASTUntyped(...args);
+};
 function getBaseType(type) {
-  return isNonNullType(type) || isListType(type) ? getBaseType(type.ofType) : type;
+  if (isNonNullType(type) || isListType(type)) {
+    return getBaseType(type.ofType);
+  }
+  return type;
 }
 function convertToken(token, type) {
   const { line, column, end, start, value } = token;
@@ -33,20 +38,24 @@ function convertToken(token, type) {
   };
 }
 function extractTokens(filePath, code) {
-  const source = new Source(code, filePath), lexer = new Lexer(source), tokens = [];
+  const source = new Source(code, filePath);
+  const lexer = new Lexer(source);
+  const tokens = [];
   let token = lexer.advance();
-  for (; token && token.kind !== TokenKind.EOF; ) {
+  while (token && token.kind !== TokenKind.EOF) {
     const result = convertToken(token, token.kind);
-    tokens.push(result), token = lexer.advance();
+    tokens.push(result);
+    token = lexer.advance();
   }
   return tokens;
 }
 function extractComments(loc) {
-  if (!loc)
+  if (!loc) {
     return [];
+  }
   const comments = [];
   let token = loc.startToken;
-  for (; token; ) {
+  while (token) {
     if (token.kind === TokenKind.COMMENT) {
       const comment = convertToken(
         token,
@@ -60,7 +69,8 @@ function extractComments(loc) {
   return comments;
 }
 function convertLocation(location) {
-  const { startToken, endToken, source, start, end } = location, loc = {
+  const { startToken, endToken, source, start, end } = location;
+  const loc = {
     start: {
       /*
        * Kind.Document has startToken: { line: 0, column: 0 }, we set line as 1 and column as 0
@@ -74,7 +84,10 @@ function convertLocation(location) {
     },
     source: source.body
   };
-  return loc.start.column === loc.end.column && (loc.end.column += end - start), loc;
+  if (loc.start.column === loc.end.column) {
+    loc.end.column += end - start;
+  }
+  return loc;
 }
 export {
   convertLocation,

package/esm/graphql-config.js

@@ -6,15 +6,16 @@ import { CodeFileLoader } from "@graphql-tools/code-file-loader";
 const debug = debugFactory("graphql-eslint:graphql-config");
 let graphQLConfig;
 function getFirstExistingPath(filePath) {
-  for (; !fs.existsSync(filePath); )
+  while (!fs.existsSync(filePath)) {
     filePath = path.dirname(filePath);
+  }
   return filePath;
 }
 function loadOnDiskGraphQLConfig(filePath) {
   return loadConfigSync({
     // load config relative to the file being linted
     rootDir: getFirstExistingPath(path.dirname(filePath)),
-    throwOnMissing: !1,
+    throwOnMissing: false,
     extensions: [codeFileLoaderExtension]
   });
 }
@@ -22,21 +23,27 @@ function loadGraphQLConfig({
   graphQLConfig: config,
   filePath
 }) {
-  if (process.env.NODE_ENV !== "test" && graphQLConfig)
+  if (process.env.NODE_ENV !== "test" && graphQLConfig) {
     return graphQLConfig;
+  }
   debug("parserOptions.graphQLConfig: %o", config);
   const onDiskConfig = !config && loadOnDiskGraphQLConfig(filePath);
-  onDiskConfig && debug("GraphQL-Config path %o", onDiskConfig.filepath);
+  if (onDiskConfig) {
+    debug("GraphQL-Config path %o", onDiskConfig.filepath);
+  }
   const configOptions = config && ("projects" in config || "schemaPath" in config) ? config : {
     // if `schema` is `undefined` will throw error `Project 'default' not found`
     schema: config?.schema ?? "",
     ...config
   };
-  return graphQLConfig = onDiskConfig || new GraphQLConfig({ config: configOptions, filepath: "" }, [codeFileLoaderExtension]), graphQLConfig;
+  graphQLConfig = onDiskConfig || new GraphQLConfig({ config: configOptions, filepath: "" }, [codeFileLoaderExtension]);
+  return graphQLConfig;
 }
 const codeFileLoaderExtension = (api) => {
   const { schema, documents } = api.loaders;
-  return schema.register(new CodeFileLoader()), documents.register(new CodeFileLoader()), { name: "code-file-loaders" };
+  schema.register(new CodeFileLoader());
+  documents.register(new CodeFileLoader());
+  return { name: "code-file-loaders" };
 };
 export {
   getFirstExistingPath,

package/esm/index.d.ts

@@ -1,4 +1,3 @@
-import { RuleOptions } from './rules/require-description/index.js';
 import { CaseStyle } from './utils.js';
 export { requireGraphQLOperations, requireGraphQLSchema } from './utils.js';
 import * as graphql from 'graphql';
@@ -101,9 +100,9 @@ declare const _default: {
                 forbiddenPatterns?: {
                     [x: string]: unknown;
                 }[] | undefined;
-                requiredPatterns?: {
+                requiredPattern?: {
                     [x: string]: unknown;
-                }[] | undefined;
+                } | undefined;
                 forbiddenPrefixes?: string[] | undefined;
                 forbiddenSuffixes?: string[] | undefined;
                 requiredPrefixes?: string[] | undefined;
@@ -141,7 +140,22 @@ declare const _default: {
             argumentName?: string | undefined;
         }[]>;
         'require-deprecation-reason': GraphQLESLintRule;
-        'require-description': GraphQLESLintRule<RuleOptions>;
+        'require-description': GraphQLESLintRule<{
+            types?: true | undefined;
+            OperationDefinition?: boolean | undefined;
+            ScalarTypeDefinition?: boolean | undefined;
+            ObjectTypeDefinition?: boolean | undefined;
+            FieldDefinition?: boolean | undefined;
+            InputValueDefinition?: boolean | undefined;
+            InterfaceTypeDefinition?: boolean | undefined;
+            UnionTypeDefinition?: boolean | undefined;
+            EnumTypeDefinition?: boolean | undefined;
+            EnumValueDefinition?: boolean | undefined;
+            InputObjectTypeDefinition?: boolean | undefined;
+            DirectiveDefinition?: boolean | undefined;
+            rootField?: true | undefined;
+            ignoredSelectors?: string[] | undefined;
+        }[]>;
         'require-field-of-type-query-in-mutation-result': GraphQLESLintRule;
         'require-import-fragment': GraphQLESLintRule;
         'require-nullable-fields-with-oneof': GraphQLESLintRule;

package/esm/meta.js

@@ -1,4 +1,4 @@
-const version = "4.3.0";
+const version = "4.4.0-alpha-20241207210859-41eb4549764dc0314b5bd4f257ea6667b178540e";
 export {
   version
 };

package/esm/parser.js

@@ -23,19 +23,42 @@ const LEGACY_PARSER_OPTIONS_KEYS = [
   "operations"
 ];
 function parseForESLint(code, options) {
-  for (const key of LEGACY_PARSER_OPTIONS_KEYS)
-    if (key in options)
+  for (const key of LEGACY_PARSER_OPTIONS_KEYS) {
+    if (key in options) {
       throw new Error(
         `\`parserOptions.${key}\` was removed in graphql-eslint@4. Use physical graphql-config for setting schema and documents or \`parserOptions.graphQLConfig\` for programmatic usage.`
       );
+    }
+  }
   try {
-    const { filePath } = options, { document } = parseGraphQLSDL(filePath, code, { noLocation: !1 });
-    let project, schema, documents;
-    project = loadGraphQLConfig(options).getProjectForFile(getFirstExistingPath(filePath)), documents = getDocuments(project);
+    const { filePath } = options;
+    const { document } = parseGraphQLSDL(filePath, code, { noLocation: false });
+    let project;
+    let schema, documents;
+    if (true) {
+      const gqlConfig = loadGraphQLConfig(options);
+      project = gqlConfig.getProjectForFile(getFirstExistingPath(filePath));
+      documents = getDocuments(project);
+    } else {
+      documents = [
+        parseGraphQLSDL(
+          "operation.graphql",
+          options.graphQLConfig.documents,
+          { noLocation: true }
+        )
+      ];
+    }
     try {
-      schema = getSchema(project);
+      if (true) {
+        schema = getSchema(project);
+      } else {
+        schema = buildSchema(options.graphQLConfig.schema);
+      }
     } catch (error) {
-      throw error instanceof Error && (error.message = `Error while loading schema: ${error.message}`), error;
+      if (error instanceof Error) {
+        error.message = `Error while loading schema: ${error.message}`;
+      }
+      throw error;
     }
     const rootTree = convertToESTree(document, schema);
     return {
@@ -54,9 +77,12 @@ function parseForESLint(code, options) {
       }
     };
   } catch (error) {
-    if (error instanceof Error && (error.message = `[graphql-eslint] ${error.message}`), error instanceof GraphQLError) {
+    if (error instanceof Error) {
+      error.message = `[graphql-eslint] ${error.message}`;
+    }
+    if (error instanceof GraphQLError) {
       const location = error.locations?.[0];
-      throw {
+      const eslintError = {
         index: error.positions?.[0],
         ...location && {
           lineNumber: location.line,
@@ -64,6 +90,7 @@ function parseForESLint(code, options) {
         },
         message: error.message
       };
+      throw eslintError;
     }
     throw error;
   }