@graphql-eslint/eslint-plugin 4.0.0-alpha-20230801163310-8bc4340 → 4.0.0-alpha-20230810155929-e89edf7

package/esm/rules/unique-operation-name.js

@@ -1,14 +1,14 @@
-import "../chunk-BMTV3EA2.js";
+import "../chunk-U3TKCM4X.js";
 import { checkNode } from "./unique-fragment-name.js";
-const RULE_ID = "unique-operation-name";
-const rule = {
+const RULE_ID = "unique-operation-name", rule = {
   meta: {
     type: "suggestion",
     docs: {
       category: "Operations",
       description: "Enforce unique operation names across your project.",
       url: `https://the-guild.dev/graphql/eslint/rules/${RULE_ID}`,
-      requiresSiblings: true,
+      requiresSiblings: !0,
+      recommended: !0,
       examples: [
         {
           title: "Incorrect",
@@ -55,7 +55,8 @@ const rule = {
       ]
     },
     messages: {
-      [RULE_ID]: 'Operation named "{{ documentName }}" already defined in:\n{{ summary }}'
+      [RULE_ID]: `Operation named "{{ documentName }}" already defined in:
+{{ summary }}`
     },
     schema: []
   },

package/esm/schema.d.mts

@@ -1,12 +1,13 @@
 import { GraphQLProjectConfig } from 'graphql-config';
-import { P as ParserOptions, S as Schema } from './types-ace77d86.js';
-import '@graphql-tools/utils';
+import { Schema } from './types.mjs';
 import 'eslint';
 import 'estree';
 import 'graphql';
 import 'json-schema-to-ts';
+import './siblings.mjs';
+import '@graphql-tools/utils';
 import './estree-converter/types.mjs';
 
-declare function getSchema(project: GraphQLProjectConfig, schemaOptions?: ParserOptions['schemaOptions']): Schema;
+declare function getSchema(project: GraphQLProjectConfig): Schema;
 
 export { getSchema };

package/esm/schema.js

@@ -1,31 +1,26 @@
-import "./chunk-BMTV3EA2.js";
+import "./chunk-U3TKCM4X.js";
 import debugFactory from "debug";
 import fg from "fast-glob";
 import { GraphQLSchema } from "graphql";
 import { ModuleCache } from "./cache.js";
-const schemaCache = new ModuleCache();
-const debug = debugFactory("graphql-eslint:schema");
-function getSchema(project, schemaOptions) {
+const schemaCache = new ModuleCache(), debug = debugFactory("graphql-eslint:schema");
+function getSchema(project) {
   const schemaKey = project.schema;
-  if (!schemaKey) {
+  if (!schemaKey)
     return null;
-  }
   const cache = schemaCache.get(schemaKey);
-  if (cache) {
+  if (cache)
     return cache;
-  }
   debug("Loading schema from %o", project.schema);
   const schema = project.loadSchemaSync(project.schema, "GraphQLSchema", {
-    ...schemaOptions,
     pluckConfig: project.extensions.pluckConfig
   });
   if (debug.enabled) {
     debug("Schema loaded: %o", schema instanceof GraphQLSchema);
-    const schemaPaths = fg.sync(project.schema, { absolute: true });
+    const schemaPaths = fg.sync(project.schema, { absolute: !0 });
     debug("Schema pointers %O", schemaPaths);
   }
-  schemaCache.set(schemaKey, schema);
-  return schema;
+  return schemaCache.set(schemaKey, schema), schema;
 }
 export {
   getSchema

package/esm/siblings.d.mts

@@ -1,8 +1,24 @@
-import 'graphql';
-import 'graphql-config';
-export { F as FragmentSource, h as OperationSource, g as SiblingOperations, i as getSiblings } from './types-ace77d86.js';
-import '@graphql-tools/utils';
-import 'eslint';
-import 'estree';
-import 'json-schema-to-ts';
-import './estree-converter/types.mjs';
+import { Source } from '@graphql-tools/utils';
+import { FragmentDefinitionNode, OperationDefinitionNode, SelectionSetNode, OperationTypeNode } from 'graphql';
+
+type FragmentSource = {
+    filePath: string;
+    document: FragmentDefinitionNode;
+};
+type OperationSource = {
+    filePath: string;
+    document: OperationDefinitionNode;
+};
+type SiblingOperations = {
+    available: boolean;
+    getFragment(fragmentName: string): FragmentSource[];
+    getFragments(): FragmentSource[];
+    getFragmentByType(typeName: string): FragmentSource[];
+    getFragmentsInUse(baseOperation: FragmentDefinitionNode | OperationDefinitionNode | SelectionSetNode, recursive?: boolean): FragmentDefinitionNode[];
+    getOperation(operationName: string): OperationSource[];
+    getOperations(): OperationSource[];
+    getOperationByType(operationType: OperationTypeNode): OperationSource[];
+};
+declare function getSiblings(documents: Source[]): SiblingOperations;
+
+export { FragmentSource, OperationSource, SiblingOperations, getSiblings };

package/esm/siblings.js

@@ -1,27 +1,18 @@
-import "./chunk-BMTV3EA2.js";
-import { parseGraphQLSDL } from "@graphql-tools/utils";
+import "./chunk-U3TKCM4X.js";
 import {
   Kind,
   visit
 } from "graphql";
-import { getDocuments } from "./documents.js";
 import { logger } from "./utils.js";
 const siblingOperationsCache = /* @__PURE__ */ new Map();
-function getSiblings(project, documents) {
-  const siblings = project ? getDocuments(project) : typeof documents === "string" ? [parseGraphQLSDL("operation.graphql", documents, { noLocation: true })] : [];
-  if (siblings.length === 0) {
-    let printed = false;
-    const noopWarn = () => {
-      if (!printed) {
-        logger.warn(
-          'getSiblingOperations was called without any operations. Make sure to set "parserOptions.operations" to make this feature available!'
-        );
-        printed = true;
-      }
-      return [];
-    };
+function getSiblings(documents) {
+  if (documents.length === 0) {
+    let printed = !1;
+    const noopWarn = () => (printed || (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), []);
     return {
-      available: false,
+      available: !1,
       getFragment: noopWarn,
       getFragments: noopWarn,
       getFragmentByType: noopWarn,
@@ -31,85 +22,58 @@ function getSiblings(project, documents) {
       getOperationByType: noopWarn
     };
   }
-  const value = siblingOperationsCache.get(siblings);
-  if (value) {
+  const value = siblingOperationsCache.get(documents);
+  if (value)
     return value;
-  }
   let fragmentsCache = null;
   const getFragments = () => {
-    var _a;
     if (fragmentsCache === null) {
       const result = [];
-      for (const source of siblings) {
-        for (const definition of ((_a = source.document) == null ? void 0 : _a.definitions) || []) {
-          if (definition.kind === Kind.FRAGMENT_DEFINITION) {
-            result.push({
-              filePath: source.location,
-              document: definition
-            });
-          }
-        }
-      }
+      for (const source of documents)
+        for (const definition of source.document?.definitions || [])
+          definition.kind === Kind.FRAGMENT_DEFINITION && result.push({
+            filePath: source.location,
+            document: definition
+          });
       fragmentsCache = result;
     }
     return fragmentsCache;
   };
   let cachedOperations = null;
   const getOperations = () => {
-    var _a;
     if (cachedOperations === null) {
       const result = [];
-      for (const source of siblings) {
-        for (const definition of ((_a = source.document) == null ? void 0 : _a.definitions) || []) {
-          if (definition.kind === Kind.OPERATION_DEFINITION) {
-            result.push({
-              filePath: source.location,
-              document: definition
-            });
-          }
-        }
-      }
+      for (const source of documents)
+        for (const definition of source.document?.definitions || [])
+          definition.kind === Kind.OPERATION_DEFINITION && result.push({
+            filePath: source.location,
+            document: definition
+          });
       cachedOperations = result;
     }
     return cachedOperations;
-  };
-  const getFragment = (name) => getFragments().filter((f) => f.document.name.value === name);
-  const collectFragments = (selectable, recursive, collected = /* @__PURE__ */ new Map()) => {
-    visit(selectable, {
-      FragmentSpread(spread) {
-        const fragmentName = spread.name.value;
-        const [fragment] = getFragment(fragmentName);
-        if (!fragment) {
-          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);
-          }
-        }
+  }, getFragment = (name) => getFragments().filter((f) => f.document.name.value === name), collectFragments = (selectable, recursive, collected = /* @__PURE__ */ new Map()) => (visit(selectable, {
+    FragmentSpread(spread) {
+      const fragmentName = spread.name.value, [fragment] = getFragment(fragmentName);
+      if (!fragment) {
+        logger.warn(
+          `Unable to locate fragment named "${fragmentName}", please make sure it's loaded using "parserOptions.operations"`
+        );
+        return;
       }
-    });
-    return collected;
-  };
-  const siblingOperations = {
-    available: true,
+      collected.has(fragmentName) || (collected.set(fragmentName, fragment.document), recursive && collectFragments(fragment.document, recursive, collected));
+    }
+  }), collected), siblingOperations = {
+    available: !0,
     getFragment,
     getFragments,
     getFragmentByType: (typeName) => getFragments().filter((f) => f.document.typeCondition.name.value === typeName),
-    getFragmentsInUse: (selectable, recursive = true) => Array.from(collectFragments(selectable, recursive).values()),
-    getOperation: (name) => getOperations().filter((o) => {
-      var _a;
-      return ((_a = o.document.name) == null ? void 0 : _a.value) === name;
-    }),
+    getFragmentsInUse: (selectable, recursive = !0) => Array.from(collectFragments(selectable, recursive).values()),
+    getOperation: (name) => getOperations().filter((o) => o.document.name?.value === name),
     getOperations,
     getOperationByType: (type) => getOperations().filter((o) => o.document.operation === type)
   };
-  siblingOperationsCache.set(siblings, siblingOperations);
-  return siblingOperations;
+  return siblingOperationsCache.set(documents, siblingOperations), siblingOperations;
 }
 export {
   getSiblings

package/esm/types.d.mts

@@ -1,8 +1,75 @@
+import { Linter, Rule, AST } from 'eslint';
+import * as ESTree from 'estree';
+import { GraphQLSchema, ASTKindToNode } from 'graphql';
+import { JSONSchema } from 'json-schema-to-ts';
+import { SiblingOperations } from './siblings.mjs';
+import { GraphQLESTreeNode } from './estree-converter/types.mjs';
+import { IGraphQLConfig } from 'graphql-config';
 import '@graphql-tools/utils';
-import 'eslint';
-import 'estree';
-import 'graphql';
-import 'graphql-config';
-import 'json-schema-to-ts';
-export { C as CategoryType, G as GraphQLESLintParseResult, f as GraphQLESLintRule, c as GraphQLESLintRuleContext, e as GraphQLESLintRuleListener, O as OmitRecursively, P as ParserOptions, b as ParserServices, a as Pointer, R as ReportDescriptor, d as RuleDocsInfo, S as Schema, V as ValueOf } from './types-ace77d86.js';
-import './estree-converter/types.mjs';
+
+type Schema = GraphQLSchema | null;
+type Pointer = string | string[];
+interface ParserOptions {
+    graphQLConfig?: IGraphQLConfig;
+    filePath: string;
+}
+type ParserServices = {
+    schema: Schema;
+    siblingOperations: SiblingOperations;
+};
+type GraphQLESLintParseResult = Linter.ESLintParseResult & {
+    services: ParserServices;
+};
+type Location = AST.SourceLocation | ESTree.Position;
+type ReportDescriptorLocation = {
+    loc: Location;
+} | {
+    node: {
+        loc: Location;
+    };
+};
+type ReportDescriptor = ReportDescriptorLocation & Rule.ReportDescriptorMessage & Rule.ReportDescriptorOptions;
+type GraphQLESLintRuleContext<Options = any[]> = Omit<Rule.RuleContext, 'options' | 'parserServices' | 'report'> & {
+    options: Options;
+    parserServices: ParserServices;
+    report(descriptor: ReportDescriptor): void;
+};
+type CategoryType = 'Operations' | 'Schema';
+type RuleMetaDataDocs = Required<Rule.RuleMetaData>['docs'];
+type RuleDocsInfo<T> = Omit<RuleMetaDataDocs, 'category' | 'suggestion'> & {
+    category: CategoryType | CategoryType[];
+    requiresSchema?: true;
+    requiresSiblings?: true;
+    examples?: {
+        title: string;
+        code: string;
+        usage?: T;
+    }[];
+    configOptions?: T | {
+        schema?: T;
+        operations?: T;
+    };
+    graphQLJSRuleName?: string;
+    isDisabledForAllConfig?: true;
+};
+type GraphQLESLintRuleListener<WithTypeInfo extends boolean = false> = Record<string, any> & {
+    [K in keyof ASTKindToNode]?: (node: GraphQLESTreeNode<ASTKindToNode[K], WithTypeInfo>) => void;
+};
+type GraphQLESLintRule<Options = [], WithTypeInfo extends boolean = false> = {
+    meta: Omit<Rule.RuleMetaData, 'docs' | 'schema'> & {
+        docs?: RuleDocsInfo<Options>;
+        schema: Readonly<JSONSchema> | [];
+    };
+    create(context: GraphQLESLintRuleContext<Options>): GraphQLESLintRuleListener<WithTypeInfo>;
+};
+type ValueOf<T> = T[keyof T];
+type Id<T> = {
+    [P in keyof T]: T[P];
+} & {};
+type OmitDistributive<T, K extends PropertyKey> = T extends object ? Id<OmitRecursively<T, K>> : T;
+type OmitRecursively<T extends object, K extends PropertyKey> = Omit<{
+    [P in keyof T]: OmitDistributive<T[P], K>;
+}, K>;
+type ConfigName = 'operations-all' | 'operations-recommended' | 'schema-all' | 'schema-recommended' | 'schema-relay';
+
+export { CategoryType, ConfigName, GraphQLESLintParseResult, GraphQLESLintRule, GraphQLESLintRuleContext, GraphQLESLintRuleListener, OmitRecursively, ParserOptions, ParserServices, Pointer, ReportDescriptor, RuleDocsInfo, Schema, ValueOf };

package/esm/utils.d.mts

@@ -1,11 +1,12 @@
 import { AST } from 'eslint';
 import { Position } from 'estree';
 import { GraphQLSchema, ASTNode, Kind } from 'graphql';
-import { c as GraphQLESLintRuleContext, g as SiblingOperations } from './types-ace77d86.js';
+import { SiblingOperations } from './siblings.mjs';
+import { GraphQLESLintRuleContext } from './types.mjs';
 import { GraphQLESTreeNode } from './estree-converter/types.mjs';
 import '@graphql-tools/utils';
-import 'graphql-config';
 import 'json-schema-to-ts';
+import 'graphql-config';
 
 declare function requireSiblingsOperations(ruleId: string, context: GraphQLESLintRuleContext): SiblingOperations | never;
 declare function requireGraphQLSchemaFromContext(ruleId: string, context: GraphQLESLintRuleContext): GraphQLSchema | never;

package/esm/utils.js

@@ -1,53 +1,45 @@
-import "./chunk-BMTV3EA2.js";
-import chalk from "chalk";
+import "./chunk-U3TKCM4X.js";
 import { Kind } from "graphql";
 import lowerCase from "lodash.lowercase";
 function requireSiblingsOperations(ruleId, context) {
-  const { siblingOperations } = context.parserServices;
-  if (!siblingOperations.available) {
+  const { siblingOperations } = context.sourceCode.parserServices;
+  if (!siblingOperations.available)
     throw new Error(
-      `Rule \`${ruleId}\` requires \`parserOptions.operations\` to be set and loaded. See https://bit.ly/graphql-eslint-operations for more info`
+      `Rule \`${ruleId}\` requires graphql-config \`documents\` field to be set and loaded. See https://the-guild.dev/graphql/config/docs/user/documents for more info`
     );
-  }
   return siblingOperations;
 }
 function requireGraphQLSchemaFromContext(ruleId, context) {
-  const { schema } = context.parserServices;
-  if (!schema) {
+  const { schema } = context.sourceCode.parserServices;
+  if (!schema)
     throw new Error(
-      `Rule \`${ruleId}\` requires \`parserOptions.schema\` to be set and loaded. See https://bit.ly/graphql-eslint-schema for more info`
+      `Rule \`${ruleId}\` requires graphql-config \`schema\` field to be set and loaded. See https://the-guild.dev/graphql/config/docs/user/schema for more info`
     );
-  }
   return schema;
 }
-const logger = {
+const chalk = {
+  red: (str) => `\x1B[31m${str}\x1B[39m`,
+  yellow: (str) => `\x1B[33m${str}\x1B[39m`
+}, logger = {
   error: (...args) => (
     // eslint-disable-next-line no-console
-    console.error(chalk.red("error"), "[graphql-eslint]", chalk(...args))
+    console.error(chalk.red("error"), "[graphql-eslint]", ...args)
   ),
   warn: (...args) => (
     // eslint-disable-next-line no-console
-    console.warn(chalk.yellow("warning"), "[graphql-eslint]", chalk(...args))
+    console.warn(chalk.yellow("warning"), "[graphql-eslint]", ...args)
   )
-};
-const normalizePath = (path) => (path || "").replace(/\\/g, "/");
-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 = [
+}, normalizePath = (path) => (path || "").replace(/\\/g, "/"), VIRTUAL_DOCUMENT_REGEX = /\/\d+_document.graphql$/, CWD = process.cwd(), getTypeName = (node) => "type" in node ? getTypeName(node.type) : "name" in node && node.name ? node.name.value : "", TYPES_KINDS = [
   Kind.OBJECT_TYPE_DEFINITION,
   Kind.INTERFACE_TYPE_DEFINITION,
   Kind.ENUM_TYPE_DEFINITION,
   Kind.SCALAR_TYPE_DEFINITION,
   Kind.INPUT_OBJECT_TYPE_DEFINITION,
   Kind.UNION_TYPE_DEFINITION
-];
-const pascalCase = (str) => lowerCase(str).split(" ").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join("");
-const camelCase = (str) => {
+], pascalCase = (str) => lowerCase(str).split(" ").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(""), camelCase = (str) => {
   const result = pascalCase(str);
   return result.charAt(0).toLowerCase() + result.slice(1);
-};
-const convertCase = (style, str) => {
+}, convertCase = (style, str) => {
   switch (style) {
     case "camelCase":
       return camelCase(str);
@@ -74,16 +66,14 @@ function getLocation(start, fieldName = "") {
     }
   };
 }
-const REPORT_ON_FIRST_CHARACTER = { column: 0, line: 1 };
-const ARRAY_DEFAULT_OPTIONS = {
+const REPORT_ON_FIRST_CHARACTER = { column: 0, line: 1 }, ARRAY_DEFAULT_OPTIONS = {
   type: "array",
-  uniqueItems: true,
+  uniqueItems: !0,
   minItems: 1,
   items: {
     type: "string"
   }
-};
-const englishJoinWords = (words) => new Intl.ListFormat("en-US", { type: "disjunction" }).format(words);
+}, englishJoinWords = (words) => new Intl.ListFormat("en-US", { type: "disjunction" }).format(words);
 function truthy(value) {
   return !!value;
 }
@@ -110,8 +100,7 @@ const DisplayNodeNameMap = {
   [Kind.FIELD]: "field"
 };
 function displayNodeName(node) {
-  var _a, _b;
-  return `${node.kind === Kind.OPERATION_DEFINITION ? node.operation : DisplayNodeNameMap[node.kind]} "${"alias" in node && ((_a = node.alias) == null ? void 0 : _a.value) || "name" in node && ((_b = node.name) == null ? void 0 : _b.value)}"`;
+  return `${node.kind === Kind.OPERATION_DEFINITION ? node.operation : DisplayNodeNameMap[node.kind]} "${"alias" in node && node.alias?.value || "name" in node && node.name?.value}"`;
 }
 function getNodeName(node) {
   switch (node.kind) {