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

package/cjs/cache.js

@@ -3,20 +3,24 @@ const log = _debug2.default.call(void 0, "graphql-eslint:ModuleCache");
 class ModuleCache {constructor() { ModuleCache.prototype.__init.call(this); }
   __init() {this.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;
+    }
   }
 }
 

package/cjs/configs/operations-all.js

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

package/cjs/configs/schema-all.js

@@ -4,9 +4,9 @@
     "@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/cjs/configs/schema-recommended.js

@@ -54,7 +54,7 @@
     "@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/cjs/documents.js

@@ -2,17 +2,20 @@
 var _debug = require('debug'); var _debug2 = _interopRequireDefault(_debug);
 var _fastglob = require('fast-glob'); var _fastglob2 = _interopRequireDefault(_fastglob);
 var _cachejs = require('./cache.js');
-const debug = _debug2.default.call(void 0, "graphql-eslint:operations"), operationsCache = new (0, _cachejs.ModuleCache)(), handleVirtualPath = (documents) => {
+const debug = _debug2.default.call(void 0, "graphql-eslint:operations");
+const operationsCache = new (0, _cachejs.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: _nodepath2.default.resolve(location)
       };
+    }
     filepathMap[location] ??= -1;
     const index = filepathMap[location] += 1;
     return {
@@ -20,23 +23,26 @@ const debug = _debug2.default.call(void 0, "graphql-eslint:operations"), operati
       location: _nodepath2.default.resolve(location, `${index}_document.graphql`)
     };
   });
-}, getDocuments = exports.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 = _fastglob2.default.sync(project.documents, { absolute: !0 });
+      const operationsPaths = _fastglob2.default.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/cjs/estree-converter/converter.js

@@ -6,14 +6,16 @@
 var _graphql = require('graphql');
 var _utilsjs = require('./utils.js');
 function convertToESTree(node, schema) {
-  const typeInfo = schema && new (0, _graphql.TypeInfo)(schema), visitor = {
+  const typeInfo = schema && new (0, _graphql.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 === _graphql.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 === _graphql.Kind.DOCUMENT ? {
+          ...node2,
+          definitions: node2.definitions.map(
+            (definition) => definition.rawNode()
+          )
+        } : node2;
+      };
+      const commonFields = {
         ...node2,
         type: node2.kind,
         loc: _utilsjs.convertLocation.call(void 0, node2.loc),

package/cjs/estree-converter/utils.js

@@ -6,9 +6,14 @@
 
 var _graphql = require('graphql');
 var _valueFromASTUntypedjs = require('graphql/utilities/valueFromASTUntyped.js');
-const valueFromNode = (...args) => _valueFromASTUntypedjs.valueFromASTUntyped.call(void 0, ...args);
+const valueFromNode = (...args) => {
+  return _valueFromASTUntypedjs.valueFromASTUntyped.call(void 0, ...args);
+};
 function getBaseType(type) {
-  return _graphql.isNonNullType.call(void 0, type) || _graphql.isListType.call(void 0, type) ? getBaseType(type.ofType) : type;
+  if (_graphql.isNonNullType.call(void 0, type) || _graphql.isListType.call(void 0, 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 (0, _graphql.Source)(code, filePath), lexer = new (0, _graphql.Lexer)(source), tokens = [];
+  const source = new (0, _graphql.Source)(code, filePath);
+  const lexer = new (0, _graphql.Lexer)(source);
+  const tokens = [];
   let token = lexer.advance();
-  for (; token && token.kind !== _graphql.TokenKind.EOF; ) {
+  while (token && token.kind !== _graphql.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 === _graphql.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;
 }
 
 

package/cjs/graphql-config.js

@@ -6,15 +6,16 @@ var _codefileloader = require('@graphql-tools/code-file-loader');
 const debug = _debug2.default.call(void 0, "graphql-eslint:graphql-config");
 let graphQLConfig;
 function getFirstExistingPath(filePath) {
-  for (; !_nodefs2.default.existsSync(filePath); )
+  while (!_nodefs2.default.existsSync(filePath)) {
     filePath = _nodepath2.default.dirname(filePath);
+  }
   return filePath;
 }
 function loadOnDiskGraphQLConfig(filePath) {
   return _graphqlconfig.loadConfigSync.call(void 0, {
     // load config relative to the file being linted
     rootDir: getFirstExistingPath(_nodepath2.default.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: _nullishCoalesce(_optionalChain([config, 'optionalAccess', _ => _.schema]), () => ( "")),
     ...config
   };
-  return graphQLConfig = onDiskConfig || new (0, _graphqlconfig.GraphQLConfig)({ config: configOptions, filepath: "" }, [codeFileLoaderExtension]), graphQLConfig;
+  graphQLConfig = onDiskConfig || new (0, _graphqlconfig.GraphQLConfig)({ config: configOptions, filepath: "" }, [codeFileLoaderExtension]);
+  return graphQLConfig;
 }
 const codeFileLoaderExtension = (api) => {
   const { schema, documents } = api.loaders;
-  return schema.register(new (0, _codefileloader.CodeFileLoader)()), documents.register(new (0, _codefileloader.CodeFileLoader)()), { name: "code-file-loaders" };
+  schema.register(new (0, _codefileloader.CodeFileLoader)());
+  documents.register(new (0, _codefileloader.CodeFileLoader)());
+  return { name: "code-file-loaders" };
 };
 
 

package/cjs/index.d.cts

@@ -1,4 +1,3 @@
-import { RuleOptions } from './rules/require-description/index.cjs';
 import { CaseStyle } from './utils.cjs';
 export { requireGraphQLOperations, requireGraphQLSchema } from './utils.cjs';
 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/cjs/meta.js

@@ -1,4 +1,4 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});const version = "4.3.0";
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});const version = "4.3.1-alpha-20241207204625-6a4230707a78900a6339b03afe904b9dd6c31561";
 
 
 exports.version = version;

package/cjs/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 } = _utils.parseGraphQLSDL.call(void 0, filePath, code, { noLocation: !1 });
-    let project, schema, documents;
-    project = _graphqlconfigjs.loadGraphQLConfig.call(void 0, options).getProjectForFile(_graphqlconfigjs.getFirstExistingPath.call(void 0, filePath)), documents = _documentsjs.getDocuments.call(void 0, project);
+    const { filePath } = options;
+    const { document } = _utils.parseGraphQLSDL.call(void 0, filePath, code, { noLocation: false });
+    let project;
+    let schema, documents;
+    if (true) {
+      const gqlConfig = _graphqlconfigjs.loadGraphQLConfig.call(void 0, options);
+      project = gqlConfig.getProjectForFile(_graphqlconfigjs.getFirstExistingPath.call(void 0, filePath));
+      documents = _documentsjs.getDocuments.call(void 0, project);
+    } else {
+      documents = [
+        _utils.parseGraphQLSDL.call(void 0, 
+          "operation.graphql",
+          options.graphQLConfig.documents,
+          { noLocation: true }
+        )
+      ];
+    }
     try {
-      schema = _schemajs.getSchema.call(void 0, project);
+      if (true) {
+        schema = _schemajs.getSchema.call(void 0, 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 = _indexjs.convertToESTree.call(void 0, 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 _graphql.GraphQLError) {
+    if (error instanceof Error) {
+      error.message = `[graphql-eslint] ${error.message}`;
+    }
+    if (error instanceof _graphql.GraphQLError) {
       const location = _optionalChain([error, 'access', _ => _.locations, 'optionalAccess', _2 => _2[0]]);
-      throw {
+      const eslintError = {
         index: _optionalChain([error, 'access', _3 => _3.positions, 'optionalAccess', _4 => _4[0]]),
         ...location && {
           lineNumber: location.line,
@@ -64,6 +90,7 @@ function parseForESLint(code, options) {
         },
         message: error.message
       };
+      throw eslintError;
     }
     throw error;
   }

package/cjs/processor.js

@@ -7,19 +7,25 @@ var _graphqlconfigjs = require('./graphql-config.js');
 var _metajs = require('./meta.js');
 var _utilsjs = require('./utils.js');
 const blocksMap = /* @__PURE__ */ new Map();
-let onDiskConfig, onDiskConfigLoaded = !1;
-const RELEVANT_KEYWORDS = ["gql", "graphql", "GraphQL"], processor = exports.processor = {
+let onDiskConfig;
+let onDiskConfigLoaded = false;
+const RELEVANT_KEYWORDS = ["gql", "graphql", "GraphQL"];
+const processor = {
   meta: {
     name: "@graphql-eslint/processor",
     version: _metajs.version
   },
-  supportsAutofix: !0,
+  supportsAutofix: true,
   preprocess(code, filePath) {
-    if (process.env.ESLINT_USE_FLAT_CONFIG !== "false" && filePath.endsWith(".vue"))
+    if (process.env.ESLINT_USE_FLAT_CONFIG !== "false" && filePath.endsWith(".vue")) {
       throw new Error(
         "Processing of `.vue` files is no longer supported, follow the new official vue example for ESLint's flat config https://github.com/dimaMachina/graphql-eslint/tree/master/examples/vue-code-file"
       );
-    onDiskConfigLoaded || (onDiskConfig = _graphqlconfigjs.loadOnDiskGraphQLConfig.call(void 0, filePath), onDiskConfigLoaded = !0);
+    }
+    if (!onDiskConfigLoaded) {
+      onDiskConfig = _graphqlconfigjs.loadOnDiskGraphQLConfig.call(void 0, filePath);
+      onDiskConfigLoaded = true;
+    }
     let keywords = RELEVANT_KEYWORDS;
     const pluckConfig = _optionalChain([onDiskConfig, 'optionalAccess', _ => _.getProjectForFile, 'call', _2 => _2(filePath), 'access', _3 => _3.extensions, 'access', _4 => _4.pluckConfig]);
     if (pluckConfig) {
@@ -27,34 +33,43 @@ const RELEVANT_KEYWORDS = ["gql", "graphql", "GraphQL"], processor = exports.pro
         modules = [],
         globalGqlIdentifierName = ["gql", "graphql"],
         gqlMagicComment = "GraphQL"
-      } = pluckConfig, result = [...modules.map(({ identifier }) => identifier).filter((v) => !!v), ..._utils.asArray.call(void 0, globalGqlIdentifierName), gqlMagicComment];
+      } = pluckConfig;
+      const mods = modules.map(({ identifier }) => identifier).filter((v) => !!v);
+      const result = [...mods, ..._utils.asArray.call(void 0, globalGqlIdentifierName), gqlMagicComment];
       keywords = [...new Set(result)];
     }
-    if (keywords.every((keyword) => !code.includes(keyword)))
+    if (keywords.every((keyword) => !code.includes(keyword))) {
       return [code];
+    }
     try {
-      const blocks = _graphqltagpluck.gqlPluckFromCodeStringSync.call(void 0, filePath, code, {
-        skipIndent: !0,
+      const sources = _graphqltagpluck.gqlPluckFromCodeStringSync.call(void 0, filePath, code, {
+        skipIndent: true,
         ...pluckConfig
-      }).map((item) => ({
+      });
+      const blocks = sources.map((item) => ({
         filename: "document.graphql",
         text: item.body,
         lineOffset: item.locationOffset.line - 1,
         // @ts-expect-error -- `index` field exist but show ts error
         offset: item.locationOffset.index + 1
       }));
-      return blocksMap.set(filePath, blocks), [
+      blocksMap.set(filePath, blocks);
+      return [
         ...blocks,
         code
         /* source code must be provided and be last */
       ];
     } catch (error) {
-      return error instanceof Error && (error.message = `[graphql-eslint] Error while preprocessing "${_nodepath.relative.call(void 0, 
-        _utilsjs.CWD,
-        filePath
-      )}" file
+      if (error instanceof Error) {
+        error.message = `[graphql-eslint] Error while preprocessing "${_nodepath.relative.call(void 0, 
+          _utilsjs.CWD,
+          filePath
+        )}" file
 
-${error.message}`), console.error(error), [code];
+${error.message}`;
+      }
+      console.error(error);
+      return [code];
     }
   },
   postprocess(messages, filePath) {
@@ -62,18 +77,31 @@ ${error.message}`), console.error(error), [code];
     for (let i = 0; i < blocks.length; i += 1) {
       const { lineOffset, offset } = blocks[i];
       for (const message of messages[i] || []) {
-        if (/\.(vue|svelte)$/.test(filePath)) {
-          delete message.endLine, delete message.endColumn, delete message.fix, delete message.suggestions, Object.assign(message, _utilsjs.REPORT_ON_FIRST_CHARACTER);
+        const isVueOrSvelte = /\.(vue|svelte)$/.test(filePath);
+        if (isVueOrSvelte) {
+          delete message.endLine;
+          delete message.endColumn;
+          delete message.fix;
+          delete message.suggestions;
+          Object.assign(message, _utilsjs.REPORT_ON_FIRST_CHARACTER);
           continue;
         }
-        message.line += lineOffset, typeof message.endLine == "number" && (message.endLine += lineOffset), message.fix && (message.fix.range[0] += offset, message.fix.range[1] += offset);
+        message.line += lineOffset;
+        if (typeof message.endLine === "number") {
+          message.endLine += lineOffset;
+        }
+        if (message.fix) {
+          message.fix.range[0] += offset;
+          message.fix.range[1] += offset;
+        }
         for (const suggestion of message.suggestions || []) {
           const [start, end] = suggestion.fix.range;
           suggestion.fix.range = [start + offset, end + offset];
         }
       }
     }
-    return messages.flat().sort((a, b) => a.line - b.line || a.column - b.column);
+    const result = messages.flat();
+    return result.sort((a, b) => a.line - b.line || a.column - b.column);
   }
 };