1️⃣ Add multi-project support in .eslintrc file, use graphql-config even there is no graphql-config cosmiconfig file (#545)

Author: Dimitri POSTOLOV

.changeset/gold-mice-sell.md

@@ -0,0 +1,5 @@
+---
+'@graphql-eslint/eslint-plugin': patch
+---
+
+use `graphql-config` even there is no `graphql-config` consmiconfig file

package.json

@@ -18,7 +18,7 @@
     "transpile-ts": "tsc --project tsconfig.json",
     "build": "yarn transpile-ts && bob build",
     "postbuild": "cp -r README.md docs ./packages/plugin/dist/",
-    "test": "jest --no-watchman --forceExit",
+    "test": "jest --no-watchman --forceExit --noStackTrace",
     "prerelease": "yarn build",
     "release": "changeset publish",
     "release:canary": "(node scripts/canary-release.js && yarn build && yarn changeset publish --tag alpha) || echo Skipping Canary...",

packages/plugin/package.json

@@ -16,23 +16,18 @@
     "prepack": "bob prepack"
   },
   "dependencies": {
-    "@graphql-tools/code-file-loader": "~6.3.0",
-    "@graphql-tools/graphql-file-loader": "~6.2.0",
-    "@graphql-tools/graphql-tag-pluck": "~6.5.0",
+    "@graphql-tools/code-file-loader": "^7.0.1",
+    "@graphql-tools/graphql-tag-pluck": "^7.0.1",
     "@graphql-tools/import": "^6.3.1",
-    "@graphql-tools/json-file-loader": "~6.2.6",
-    "@graphql-tools/load": "~6.2.0",
-    "@graphql-tools/url-loader": "~6.10.0",
-    "@graphql-tools/utils": "~7.10.0",
-    "graphql-config": "^3.2.0",
+    "@graphql-tools/utils": "^8.0.1",
+    "graphql-config": "^3.4.0",
     "graphql-depth-limit": "1.1.0"
   },
   "devDependencies": {
     "@types/eslint": "7.28.0",
     "@types/graphql-depth-limit": "1.1.2",
     "bob-the-bundler": "1.2.1",
-    "graphql": "15.5.1",
-    "graphql-config": "3.4.0",
+    "graphql": "15.5.0",
     "typescript": "4.3.5"
   },
   "peerDependencies": {

packages/plugin/src/graphql-config.ts

@@ -1,25 +1,46 @@
 import { GraphQLConfig, GraphQLExtensionDeclaration, loadConfigSync } from 'graphql-config';
-import { schemaLoaders } from './schema';
-import { operationsLoaders } from './sibling-operations';
+import { CodeFileLoader } from '@graphql-tools/code-file-loader';
 import { ParserOptions } from './types';
 
-export function loadGraphqlConfig(options: ParserOptions): GraphQLConfig | null {
-  if (options?.skipGraphQLConfig) return null;
-  if (!graphqlConfig) {
-    graphqlConfig = loadConfigSync({
-      throwOnEmpty: false,
-      throwOnMissing: false,
-      extensions: [addCodeFileLoaderExtension],
-    });
+let graphqlConfig: GraphQLConfig;
+
+export function loadGraphqlConfig(options: ParserOptions): GraphQLConfig {
+  // We don't want cache config on test environment
+  // Otherwise schema and documents will be same for all tests
+  if (process.env.NODE_ENV !== 'test' && graphqlConfig) {
+    return graphqlConfig;
   }
 
+  const onDiskConfig = options.skipGraphQLConfig
+    ? null
+    : loadConfigSync({
+        throwOnEmpty: false,
+        throwOnMissing: false,
+        extensions: [addCodeFileLoaderExtension],
+      });
+
+  graphqlConfig =
+    onDiskConfig ||
+    new GraphQLConfig(
+      {
+        config: {
+          schema: options.schema || '', // if undefined will throw error `Project 'default' not found`
+          documents: options.documents || options.operations,
+          extensions: options.extensions,
+          include: options.include,
+          exclude: options.exclude,
+          projects: options.projects,
+        },
+        filepath: 'virtual-config',
+      },
+      [addCodeFileLoaderExtension]
+    );
+
   return graphqlConfig;
 }
 
-let graphqlConfig: GraphQLConfig | null;
-
 const addCodeFileLoaderExtension: GraphQLExtensionDeclaration = api => {
-  schemaLoaders.forEach(loader => api.loaders.schema.register(loader));
-  operationsLoaders.forEach(loader => api.loaders.documents.register(loader));
+  api.loaders.schema.register(new CodeFileLoader());
+  api.loaders.documents.register(new CodeFileLoader());
   return { name: 'graphql-eslint-loaders' };
 };

packages/plugin/src/rules/no-unused-fields.ts

@@ -2,7 +2,7 @@ import { GraphQLESLintRule } from '../types';
 import { requireUsedFieldsFromContext } from '../utils';
 
 const UNUSED_FIELD = 'UNUSED_FIELD';
-const ruleName = 'no-unused-fields';
+const RULE_NAME = 'no-unused-fields';
 
 const rule: GraphQLESLintRule = {
   meta: {
@@ -12,7 +12,7 @@ const rule: GraphQLESLintRule = {
     docs: {
       description: `Requires all fields to be used at some level by siblings operations.`,
       category: 'Best Practices',
-      url: `https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/${ruleName}.md`,
+      url: `https://github.com/dotansimha/graphql-eslint/blob/master/docs/rules/${RULE_NAME}.md`,
       requiresSiblings: true,
       requiresSchema: true,
       examples: [
@@ -28,7 +28,7 @@ const rule: GraphQLESLintRule = {
             type Query {
               me: User
             }
-            
+
             query {
               me {
                 id
@@ -48,7 +48,7 @@ const rule: GraphQLESLintRule = {
             type Query {
               me: User
             }
-            
+
             query {
               me {
                 id
@@ -63,14 +63,12 @@ const rule: GraphQLESLintRule = {
     type: 'suggestion',
   },
   create(context) {
-    const sourceCode = context.getSourceCode();
-    const usedFields = requireUsedFieldsFromContext(ruleName, context);
+    const usedFields = requireUsedFieldsFromContext(RULE_NAME, context);
 
     return {
       FieldDefinition(node) {
         const fieldName = node.name.value;
         const parentTypeName = (node as any).parent.name.value;
-
         const isUsed = usedFields[parentTypeName]?.has(fieldName);
 
         if (isUsed) {
@@ -82,6 +80,7 @@ const rule: GraphQLESLintRule = {
           messageId: UNUSED_FIELD,
           data: { fieldName },
           fix(fixer) {
+            const sourceCode = context.getSourceCode();
             const tokenBefore = (sourceCode as any).getTokenBefore(node);
             const tokenAfter = (sourceCode as any).getTokenAfter(node);
             const isEmptyType = tokenBefore.type === '{' && tokenAfter.type === '}';

packages/plugin/src/schema.ts

@@ -1,74 +1,28 @@
-import { CodeFileLoader } from '@graphql-tools/code-file-loader';
-import { GraphQLFileLoader } from '@graphql-tools/graphql-file-loader';
-import { JsonFileLoader } from '@graphql-tools/json-file-loader';
-import { loadSchemaSync } from '@graphql-tools/load';
-import { UrlLoader } from '@graphql-tools/url-loader';
-import { Loader, SingleFileOptions } from '@graphql-tools/utils';
-import { buildSchema, GraphQLSchema } from 'graphql';
+import { GraphQLSchema } from 'graphql';
 import { GraphQLConfig } from 'graphql-config';
-import { dirname } from 'path';
+import { asArray } from '@graphql-tools/utils';
 import { ParserOptions } from './types';
 import { getOnDiskFilepath } from './utils';
 
 const schemaCache: Map<string, GraphQLSchema> = new Map();
 
-export const schemaLoaders: Loader<string, SingleFileOptions>[] = [
-  {
-    loaderId: () => 'direct-string',
-    canLoad: async () => false,
-    load: async () => null,
-    canLoadSync: pointer => typeof pointer === 'string' && pointer.includes('type '),
-    loadSync: pointer => ({
-      schema: buildSchema(pointer),
-    }),
-  },
-  new GraphQLFileLoader(),
-  new JsonFileLoader(),
-  new UrlLoader(),
-  new CodeFileLoader(),
-];
-
 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,
-  // We are using the directory of the file as the key for the schema caching, to avoid reloading of the schema.
-  if (gqlConfig && options.filePath) {
-    const realFilepath = getOnDiskFilepath(options.filePath);
-    const projectForFile = gqlConfig.getProjectForFile(realFilepath);
-    const schemaKey = projectForFile.schema.toString();
-
-    if (schemaCache.has(schemaKey)) {
-      schema = schemaCache.get(schemaKey);
-    } else {
-      schema = projectForFile.getSchemaSync();
-      schemaCache.set(schemaKey, schema);
-    }
+  const realFilepath = options.filePath ? getOnDiskFilepath(options.filePath) : null;
+  const projectForFile = realFilepath ? gqlConfig.getProjectForFile(realFilepath) : gqlConfig.getDefault();
+  const schemaKey = asArray(projectForFile.schema)
+    .sort()
+    .join(',');
+
+  if (!schemaKey) {
+    return null;
   }
 
-  // If schema was not loaded yet, and user configured it in the parserConfig, we can try to load it,
-  // In this case, the cache key is the path for the schema. This is needed in order to allow separate
-  // configurations for different file paths (a very edgey case).
-  if (!schema && options.schema) {
-    const schemaKey = options.schema.toString();
-
-    if (schemaCache.has(schemaKey)) {
-      schema = schemaCache.get(schemaKey);
-    } else {
-      try {
-        schema = loadSchemaSync(options.schema, {
-          ...(options.schemaOptions || {}),
-          assumeValidSDL: true,
-          loaders: schemaLoaders,
-        });
-        schemaCache.set(schemaKey, schema);
-      } catch (e) {
-        e.message += `\nRunning from directory: ${process.cwd()}`;
-
-        throw e;
-      }
-    }
+  if (schemaCache.has(schemaKey)) {
+    return schemaCache.get(schemaKey);
   }
 
+  const schema = projectForFile.getSchemaSync();
+  schemaCache.set(schemaKey, schema);
+
   return schema;
 }

packages/plugin/src/sibling-operations.ts

@@ -1,37 +1,19 @@
-import { GraphQLFileLoader } from '@graphql-tools/graphql-file-loader';
-import { CodeFileLoader } from '@graphql-tools/code-file-loader';
-import { loadDocumentsSync } from '@graphql-tools/load';
-import { Loader, SingleFileOptions, Source } from '@graphql-tools/utils';
 import {
   FragmentDefinitionNode,
   FragmentSpreadNode,
   Kind,
   OperationDefinitionNode,
-  parse,
   SelectionSetNode,
   visit,
 } from 'graphql';
-import { ParserOptions } from './types';
+import { Source, asArray } from '@graphql-tools/utils';
 import { GraphQLConfig } from 'graphql-config';
-import { dirname } from 'path';
+import { ParserOptions } from './types';
+import { getOnDiskFilepath } from './utils';
 
 export type FragmentSource = { filePath: string; document: FragmentDefinitionNode };
 export type OperationSource = { filePath: string; document: OperationDefinitionNode };
 
-export const operationsLoaders: Loader<string, SingleFileOptions>[] = [
-  new GraphQLFileLoader(),
-  new CodeFileLoader(),
-  {
-    loaderId: () => 'direct-string',
-    canLoad: async () => false,
-    load: async () => null,
-    canLoadSync: pointer => typeof pointer === 'string' && pointer.includes('type '),
-    loadSync: pointer => ({
-      document: parse(pointer),
-    }),
-  },
-];
-
 export type SiblingOperations = {
   available: boolean;
   getOperations(): OperationSource[];
@@ -46,65 +28,46 @@ export type SiblingOperations = {
   getOperationByType(operationType: 'query' | 'mutation' | 'subscription'): OperationSource[];
 };
 
-function loadSiblings(baseDir: string, loadPaths: string[]): Source[] {
-  return loadDocumentsSync(loadPaths, {
-    cwd: baseDir,
-    loaders: operationsLoaders,
-    skipGraphQLImport: true,
-  });
-}
-
 const operationsCache: Map<string, Source[]> = new Map();
 const siblingOperationsCache: Map<Source[], SiblingOperations> = new Map();
 
-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 (gqlConfig && options?.filePath) {
-    const fileDir = dirname(options.filePath);
-
-    if (operationsCache.has(fileDir)) {
-      siblings = operationsCache.get(fileDir);
-    } else {
-      const projectForFile = gqlConfig.getProjectForFile(options.filePath);
-
-      if (projectForFile?.documents) {
-        siblings = projectForFile.loadDocumentsSync(projectForFile.documents, {
-          skipGraphQLImport: true,
-        });
-        operationsCache.set(fileDir, siblings);
-      }
-    }
-  }
+const getSiblings = (filePath: string, gqlConfig: GraphQLConfig): Source[] | null => {
+  const realFilepath = filePath ? getOnDiskFilepath(filePath) : null;
+  const projectForFile = realFilepath ? gqlConfig.getProjectForFile(realFilepath) : gqlConfig.getDefault();
+  const documentsKey = asArray(projectForFile.documents)
+    .sort()
+    .join(',');
 
-  if (!siblings && options?.operations) {
-    const loadPaths = Array.isArray(options.operations) ? options.operations : [options.operations];
-    const loadKey = loadPaths.join(',');
+  if (!documentsKey) {
+    return [];
+  }
 
-    if (operationsCache.has(loadKey)) {
-      siblings = operationsCache.get(loadKey);
-    } else {
-      siblings = loadSiblings(process.cwd(), loadPaths);
-      operationsCache.set(loadKey, siblings);
-    }
+  if (operationsCache.has(documentsKey)) {
+    return operationsCache.get(documentsKey);
   }
 
-  if (!siblings || siblings.length === 0) {
+  const siblings = projectForFile.loadDocumentsSync(projectForFile.documents, {
+    skipGraphQLImport: true,
+  });
+  operationsCache.set(documentsKey, siblings);
+
+  return siblings;
+};
+
+export function getSiblingOperations(options: ParserOptions, gqlConfig: GraphQLConfig): SiblingOperations {
+  const siblings = getSiblings(options.filePath, gqlConfig);
+
+  if (siblings.length === 0) {
     let printed = false;
 
     const noopWarn = () => {
-      if (printed) {
-        return [];
+      if (!printed) {
+        // eslint-disable-next-line no-console
+        console.warn(
+          `getSiblingOperations was called without any operations. Make sure to set "parserOptions.operations" to make this feature available!`
+        );
+        printed = true;
       }
-
-      printed = true;
-      // eslint-disable-next-line no-console
-      console.warn(
-        `getSiblingOperations was called without any operations. Make sure to set "parserOptions.operations" to make this feature available!`
-      );
-
       return [];
     };
 

packages/plugin/src/testkit.ts

@@ -21,7 +21,7 @@ export type GraphQLInvalidTestCase<T> = GraphQLValidTestCase<T> & {
 };
 
 export class GraphQLRuleTester extends require('eslint').RuleTester {
-  constructor(parserOptions?: ParserOptions) {
+  constructor(parserOptions: ParserOptions = {}) {
     super({
       parser: require.resolve('@graphql-eslint/eslint-plugin'),
       parserOptions: {