Fixes for sibling operations and graphql-config (#190)

Author: dotansimha

.changeset/six-fans-leave.md

@@ -0,0 +1,5 @@
+---
+'@graphql-eslint/eslint-plugin': patch
+---
+
+Better integration of siblings operations and graphql-config

packages/plugin/src/parser.ts

@@ -6,18 +6,22 @@ import { GraphQLESLintParseResult, ParserOptions } from './types';
 import { extractTokens } from './utils';
 import { getSchema } from './schema';
 import { getSiblingOperations } from './sibling-operations';
+import { loadConfigSync, GraphQLConfig } from 'graphql-config';
 
 export function parse(code: string, options?: ParserOptions): Linter.ESLintParseResult['ast'] {
   return parseForESLint(code, options).ast;
 }
 
 export function parseForESLint(code: string, options?: ParserOptions): GraphQLESLintParseResult {
-  const schema = getSchema(options);
-  const operationsPaths = options.operations || [];
-  const siblingOperations = getSiblingOperations(
-    process.cwd(),
-    Array.isArray(operationsPaths) ? operationsPaths : [operationsPaths]
-  );
+  const gqlConfig: GraphQLConfig | null = options?.skipGraphQLConfig
+    ? null
+    : loadConfigSync({
+        throwOnEmpty: false,
+        throwOnMissing: false,
+      });
+
+  const schema = getSchema(options, gqlConfig);
+  const siblingOperations = getSiblingOperations(options, gqlConfig);
   const parserServices = {
     hasTypeInfo: schema !== null,
     schema,

packages/plugin/src/schema.ts

@@ -3,13 +3,13 @@ import { JsonFileLoader } from '@graphql-tools/json-file-loader';
 import { loadSchemaSync } from '@graphql-tools/load';
 import { UrlLoader } from '@graphql-tools/url-loader';
 import { buildSchema, GraphQLSchema } from 'graphql';
-import { loadConfigSync } from 'graphql-config';
+import { GraphQLConfig, loadConfigSync } from 'graphql-config';
 import { dirname } from 'path';
 import { ParserOptions } from './types';
 
 const schemaCache: Map<string, GraphQLSchema> = new Map();
 
-export function getSchema(options: ParserOptions): GraphQLSchema | null {
+export function getSchema(options: ParserOptions, gqlConfig: GraphQLConfig): GraphQLSchema | null {
   let schema: GraphQLSchema | null = null;
 
   // We first try to use graphql-config for loading the schema, based on the type of the file,
@@ -20,11 +20,6 @@ export function getSchema(options: ParserOptions): GraphQLSchema | null {
     if (schemaCache.has(fileDir)) {
       schema = schemaCache.get(fileDir);
     } else {
-      const gqlConfig = loadConfigSync({
-        throwOnEmpty: false,
-        throwOnMissing: false,
-      });
-
       if (gqlConfig) {
         const projectForFile = gqlConfig.getProject(options.filePath);
 

packages/plugin/src/sibling-operations.ts

@@ -11,6 +11,9 @@ import {
   SelectionSetNode,
   visit,
 } from 'graphql';
+import { ParserOptions } from './types';
+import { GraphQLConfig } from 'graphql-config';
+import { dirname } from 'path';
 
 export type SiblingOperations = {
   available: boolean;
@@ -47,8 +50,41 @@ function loadSiblings(baseDir: string, loadPaths: string[]): Source[] {
 
 const operationsCache: Map<string, Source[]> = new Map();
 
-export function getSiblingOperations(baseDir: string, loadPaths: string[]): SiblingOperations {
-  if (loadPaths.length === 0) {
+export function getSiblingOperations(options: ParserOptions, gqlConfig: GraphQLConfig): SiblingOperations {
+  let siblings: Source[] | null = null;
+
+  // We first try to use graphql-config for loading the operations paths, based on the type of the file,
+  // We are using the directory of the file as the key for the schema caching, to avoid reloading of the schema.
+  if (options && options.filePath && !options.skipGraphQLConfig) {
+    const fileDir = dirname(options.filePath);
+
+    if (operationsCache.has(fileDir)) {
+      siblings = operationsCache.get(fileDir);
+    } else {
+      if (gqlConfig) {
+        const projectForFile = gqlConfig.getProject(options.filePath);
+
+        if (projectForFile) {
+          siblings = projectForFile.getDocumentsSync();
+          operationsCache.set(fileDir, siblings);
+        }
+      }
+    }
+  }
+
+  if (options && options.operations && !siblings) {
+    const loadPaths = Array.isArray(options.operations) ? options.operations : [options.operations] || [];
+    const loadKey = loadPaths.join(',');
+
+    if (!operationsCache.has(loadKey)) {
+      siblings = loadSiblings(process.cwd(), loadPaths);
+      operationsCache.set(loadKey, siblings);
+    } else {
+      siblings = operationsCache.get(loadKey);
+    }
+  }
+
+  if (!siblings || siblings.length === 0) {
     let printed = false;
 
     const noopWarn = () => {
@@ -76,14 +112,6 @@ export function getSiblingOperations(baseDir: string, loadPaths: string[]): Sibl
       getUsedFragments: noopWarn,
     };
   }
-  const loadKey = loadPaths.join(',');
-
-  if (!operationsCache.has(loadKey)) {
-    const loadedSiblings = loadSiblings(baseDir, loadPaths);
-    operationsCache.set(loadKey, loadedSiblings);
-  }
-
-  const siblings = operationsCache.get(loadKey);
 
   let fragmentsCache: FragmentDefinitionNode[] | null = null;