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

package/esm/meta.d.ts

@@ -0,0 +1,4 @@
+declare const name: string;
+declare const version: string;
+
+export { name, version };

package/esm/meta.js

@@ -0,0 +1,7 @@
+import "./chunk-UIAXBAMD.js";
+import packageJson from "../package.json" assert { type: "json" };
+const { name, version } = packageJson;
+export {
+  name,
+  version
+};

package/{cjs → esm}/parser.d.ts

@@ -9,5 +9,12 @@ import './siblings.js';
 import '@graphql-tools/utils';
 
 declare function parseForESLint(code: string, options: ParserOptions): GraphQLESLintParseResult;
+declare const parser: {
+    parseForESLint: typeof parseForESLint;
+    meta: {
+        name: string;
+        version: string;
+    };
+};
 
-export { parseForESLint };
+export { parseForESLint, parser };

package/esm/parser.js

@@ -5,6 +5,7 @@ import { parseGraphQLSDL } from "@graphql-tools/utils";
 import { getDocuments } from "./documents.js";
 import { convertToESTree, extractComments, extractTokens } from "./estree-converter/index.js";
 import { loadGraphQLConfig } from "./graphql-config.js";
+import { version } from "./meta.js";
 import { getSchema } from "./schema.js";
 import { getSiblings } from "./siblings.js";
 import { CWD, VIRTUAL_DOCUMENT_REGEX } from "./utils.js";
@@ -71,6 +72,14 @@ function parseForESLint(code, options) {
     throw error;
   }
 }
+const parser = {
+  parseForESLint,
+  meta: {
+    name: "@graphql-eslint/parser",
+    version
+  }
+};
 export {
-  parseForESLint
+  parseForESLint,
+  parser
 };

package/{cjs → esm}/processor.d.ts

@@ -5,6 +5,10 @@ type Block = Linter.ProcessorFile & {
     offset: number;
 };
 declare const processor: {
+    meta: {
+        name: string;
+        version: string;
+    };
     supportsAutofix: true;
     preprocess(code: string, filePath: string): (string | Block)[];
     postprocess(messages: Linter.LintMessage[][], filePath: string): Linter.LintMessage[];

package/esm/processor.js

@@ -5,10 +5,15 @@ import {
 } from "@graphql-tools/graphql-tag-pluck";
 import { asArray } from "@graphql-tools/utils";
 import { loadOnDiskGraphQLConfig } from "./graphql-config.js";
+import { version } from "./meta.js";
 import { CWD, REPORT_ON_FIRST_CHARACTER, truthy } from "./utils.js";
 const blocksMap = /* @__PURE__ */ new Map();
 let onDiskConfig, onDiskConfigLoaded = !1;
 const RELEVANT_KEYWORDS = ["gql", "graphql", "GraphQL"], processor = {
+  meta: {
+    name: "@graphql-eslint/processor",
+    version
+  },
   supportsAutofix: !0,
   preprocess(code, filePath) {
     onDiskConfigLoaded || (onDiskConfig = loadOnDiskGraphQLConfig(filePath), onDiskConfigLoaded = !0);

package/{cjs → esm}/rules/alphabetize.d.ts

@@ -45,7 +45,7 @@ declare const schema: {
             };
             readonly arguments: {
                 readonly items: {
-                    readonly enum: ("FieldDefinition" | "Field" | "DirectiveDefinition" | "Directive")[];
+                    readonly enum: ("Field" | "Directive" | "FieldDefinition" | "DirectiveDefinition")[];
                 };
                 readonly description: "Arguments of fields and directives.";
                 readonly type: "array";

package/{cjs → esm}/rules/index.d.ts

@@ -14,7 +14,7 @@ declare const rules: {
     alphabetize: GraphQLESLintRule<{
         definitions?: boolean | undefined;
         selections?: ("OperationDefinition" | "FragmentDefinition")[] | undefined;
-        arguments?: ("FieldDefinition" | "Field" | "DirectiveDefinition" | "Directive")[] | undefined;
+        arguments?: ("Field" | "Directive" | "FieldDefinition" | "DirectiveDefinition")[] | undefined;
         values?: boolean | undefined;
         fields?: ("ObjectTypeDefinition" | "InterfaceTypeDefinition" | "InputObjectTypeDefinition")[] | undefined;
         variables?: boolean | undefined;
@@ -33,32 +33,32 @@ declare const rules: {
         ignore?: (graphql.OperationTypeNode | "fragment")[] | undefined;
     }[]>;
     'match-document-filename': GraphQLESLintRule<{
-        query?: (CaseStyle | "matchDocumentStyle") | {
+        fragment?: (CaseStyle | "matchDocumentStyle") | {
             style?: (CaseStyle | "matchDocumentStyle") | undefined;
             suffix?: string | undefined;
             prefix?: string | undefined;
         } | undefined;
-        mutation?: (CaseStyle | "matchDocumentStyle") | {
+        fileExtension?: ".gql" | ".graphql" | undefined;
+        query?: (CaseStyle | "matchDocumentStyle") | {
             style?: (CaseStyle | "matchDocumentStyle") | undefined;
             suffix?: string | undefined;
             prefix?: string | undefined;
         } | undefined;
-        subscription?: (CaseStyle | "matchDocumentStyle") | {
+        mutation?: (CaseStyle | "matchDocumentStyle") | {
             style?: (CaseStyle | "matchDocumentStyle") | undefined;
             suffix?: string | undefined;
             prefix?: string | undefined;
         } | undefined;
-        fragment?: (CaseStyle | "matchDocumentStyle") | {
+        subscription?: (CaseStyle | "matchDocumentStyle") | {
             style?: (CaseStyle | "matchDocumentStyle") | undefined;
             suffix?: string | undefined;
             prefix?: string | undefined;
         } | undefined;
-        fileExtension?: ".gql" | ".graphql" | undefined;
     }[]>;
     'naming-convention': GraphQLESLintRule<{
         [x: string]: unknown;
-        types?: ("PascalCase" | "camelCase" | "UPPER_CASE" | "snake_case") | {
-            style?: ("PascalCase" | "camelCase" | "UPPER_CASE" | "snake_case") | undefined;
+        types?: ("camelCase" | "PascalCase" | "snake_case" | "UPPER_CASE") | {
+            style?: ("camelCase" | "PascalCase" | "snake_case" | "UPPER_CASE") | undefined;
             suffix?: string | undefined;
             prefix?: string | undefined;
             forbiddenPrefixes?: string[] | undefined;

package/esm/rules/match-document-filename.js

@@ -187,8 +187,8 @@ const MATCH_EXTENSION = "MATCH_EXTENSION", MATCH_STYLE = "MATCH_STYLE", CASE_STY
   create(context) {
     const options = context.options[0] || {
       fileExtension: null
-    }, filePath = context.filename;
-    if (VIRTUAL_DOCUMENT_REGEX.test(filePath))
+    }, filePath = context.filename, isVirtualFile = VIRTUAL_DOCUMENT_REGEX.test(filePath);
+    if (process.env.NODE_ENV !== "test" && isVirtualFile)
       return {};
     const fileExtension = extname(filePath), filename = basename(filePath, fileExtension);
     return {

package/esm/rules/no-unreachable-types.js

@@ -6,6 +6,7 @@ import {
   visit
 } from "graphql";
 import lowerCase from "lodash.lowercase";
+import { ModuleCache } from "../cache.js";
 import { getTypeName, requireGraphQLSchemaFromContext } from "../utils.js";
 const RULE_ID = "no-unreachable-types", KINDS = [
   Kind.DIRECTIVE_DEFINITION,
@@ -21,9 +22,7 @@ const RULE_ID = "no-unreachable-types", KINDS = [
   Kind.UNION_TYPE_EXTENSION,
   Kind.ENUM_TYPE_DEFINITION,
   Kind.ENUM_TYPE_EXTENSION
-];
-let reachableTypesCache;
-const RequestDirectiveLocations = /* @__PURE__ */ new Set([
+], reachableTypesCache = new ModuleCache(), RequestDirectiveLocations = /* @__PURE__ */ new Set([
   DirectiveLocation.QUERY,
   DirectiveLocation.MUTATION,
   DirectiveLocation.SUBSCRIPTION,
@@ -34,8 +33,9 @@ const RequestDirectiveLocations = /* @__PURE__ */ new Set([
   DirectiveLocation.VARIABLE_DEFINITION
 ]);
 function getReachableTypes(schema) {
-  if (reachableTypesCache)
-    return reachableTypesCache;
+  const cachedValue = reachableTypesCache.get(schema);
+  if (process.env.NODE_ENV !== "test" && cachedValue)
+    return cachedValue;
   const reachableTypes = /* @__PURE__ */ new Set(), collect = (node) => {
     const typeName = getTypeName(node);
     if (reachableTypes.has(typeName))
@@ -72,7 +72,7 @@ function getReachableTypes(schema) {
         argTypeName && reachableTypes.add(argTypeName);
       }
     }
-  return reachableTypesCache = reachableTypes, reachableTypesCache;
+  return reachableTypesCache.set(schema, reachableTypes), reachableTypes;
 }
 const rule = {
   meta: {

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

@@ -1,11 +1,12 @@
 import "../chunk-UIAXBAMD.js";
 import { TypeInfo, visit, visitWithTypeInfo } from "graphql";
+import { ModuleCache } from "../cache.js";
 import { requireGraphQLSchemaFromContext, requireSiblingsOperations } from "../utils.js";
-const RULE_ID = "no-unused-fields";
-let usedFieldsCache;
+const RULE_ID = "no-unused-fields", usedFieldsCache = new ModuleCache();
 function getUsedFields(schema, operations) {
-  if (usedFieldsCache)
-    return usedFieldsCache;
+  const cachedValue = usedFieldsCache.get(schema);
+  if (process.env.NODE_ENV !== "test" && cachedValue)
+    return cachedValue;
   const usedFields = /* @__PURE__ */ Object.create(null), typeInfo = new TypeInfo(schema), visitor = visitWithTypeInfo(typeInfo, {
     Field(node) {
       if (!typeInfo.getFieldDef())
@@ -16,7 +17,7 @@ function getUsedFields(schema, operations) {
   }), allDocuments = [...operations.getOperations(), ...operations.getFragments()];
   for (const { document } of allDocuments)
     visit(document, visitor);
-  return usedFieldsCache = usedFields, usedFieldsCache;
+  return usedFieldsCache.set(schema, usedFields), usedFields;
 }
 const rule = {
   meta: {

package/esm/rules/relay-edge-types.js

@@ -10,7 +10,7 @@ import { getTypeName, requireGraphQLSchemaFromContext } from "../utils.js";
 const RULE_ID = "relay-edge-types", MESSAGE_MUST_BE_OBJECT_TYPE = "MESSAGE_MUST_BE_OBJECT_TYPE", MESSAGE_MISSING_EDGE_SUFFIX = "MESSAGE_MISSING_EDGE_SUFFIX", MESSAGE_LIST_TYPE_ONLY_EDGE_TYPE = "MESSAGE_LIST_TYPE_ONLY_EDGE_TYPE", MESSAGE_SHOULD_IMPLEMENTS_NODE = "MESSAGE_SHOULD_IMPLEMENTS_NODE";
 let edgeTypesCache;
 function getEdgeTypes(schema2) {
-  if (edgeTypesCache)
+  if (process.env.NODE_ENV !== "test" && edgeTypesCache)
     return edgeTypesCache;
   const edgeTypes = /* @__PURE__ */ new Set(), visitor = {
     ObjectTypeDefinition(node) {

package/esm/rules/relay-page-info.js

@@ -45,7 +45,7 @@ const rule = {
   },
   create(context) {
     const schema = requireGraphQLSchemaFromContext(RULE_ID, context);
-    return hasPageInfoChecked || (schema.getType("PageInfo") || context.report({
+    return (process.env.NODE_ENV === "test" || !hasPageInfoChecked) && (schema.getType("PageInfo") || context.report({
       loc: REPORT_ON_FIRST_CHARACTER,
       messageId: MESSAGE_MUST_EXIST
     }), hasPageInfoChecked = !0), {

package/esm/rules/require-selections.js

@@ -38,6 +38,7 @@ const RULE_ID = "require-selections", DEFAULT_ID_FIELD_NAME = "id", schema = {
 }, rule = {
   meta: {
     type: "suggestion",
+    // eslint-disable-next-line eslint-plugin/require-meta-has-suggestions -- false positive since we assign `problem.suggest` conditionally
     hasSuggestions: !0,
     docs: {
       category: "Operations",

package/esm/rules/selection-set-depth.js

@@ -92,7 +92,7 @@ const RULE_ID = "selection-set-depth", schema = {
           checkFn({
             getDocument: () => document,
             reportError(error) {
-              const { line, column } = error.locations[0], token = context.getAncestors()[0].tokens.find(
+              const { line, column } = error.locations[0], token = context.sourceCode.getAncestors(node)[0].tokens.find(
                 (token2) => token2.loc.start.line === line && token2.loc.start.column === column - 1
               );
               context.report({