refactor: no-unused-fields and no-unreachable-types, move visitor functions inside rule files (#973)

* move visitor functions inside rule files

* improve error message in `no-unreachable-types`

Author: dimaMachina

packages/plugin/src/graphql-ast.ts

@@ -6,7 +6,6 @@ import { GraphQLESLintParseResult, ParserOptions, ParserServices } from './types
 import { getSchema } from './schema';
 import { getSiblingOperations } from './sibling-operations';
 import { loadGraphQLConfig } from './graphql-config';
-import { getReachableTypes, getUsedFields } from './graphql-ast';
 
 export function parse(code: string, options?: ParserOptions): Linter.ESLintParseResult['ast'] {
   return parseForESLint(code, options).ast;
@@ -19,8 +18,6 @@ export function parseForESLint(code: string, options: ParserOptions = {}): Graph
     hasTypeInfo: schema !== null,
     schema,
     siblingOperations: getSiblingOperations(options, gqlConfig),
-    reachableTypes: getReachableTypes,
-    usedFields: getUsedFields,
   };
 
   try {
@@ -31,7 +28,10 @@ export function parseForESLint(code: string, options: ParserOptions = {}): Graph
       noLocation: false,
     });
 
-    const { rootTree, comments } = convertToESTree(graphqlAst.document as ASTNode, schema ? new TypeInfo(schema) : null);
+    const { rootTree, comments } = convertToESTree(
+      graphqlAst.document as ASTNode,
+      schema ? new TypeInfo(schema) : null
+    );
     const tokens = extractTokens(new Source(code, filePath));
 
     return {

packages/plugin/src/parser.ts

@@ -1,9 +1,9 @@
-import { ASTKindToNode, Kind } from 'graphql';
+import { ASTKindToNode, ASTNode, ASTVisitor, GraphQLSchema, isInterfaceType, Kind, visit } from 'graphql';
+import lowerCase from 'lodash.lowercase';
 import { GraphQLESLintRule, ValueOf } from '../types';
-import { requireReachableTypesFromContext } from '../utils';
+import { getTypeName, requireGraphQLSchemaFromContext } from '../utils';
 import { GraphQLESTreeNode } from '../estree-parser';
 
-const UNREACHABLE_TYPE = 'UNREACHABLE_TYPE';
 const RULE_ID = 'no-unreachable-types';
 
 const KINDS = [
@@ -25,10 +25,66 @@ const KINDS = [
 type AllowedKind = typeof KINDS[number];
 type AllowedKindToNode = Pick<ASTKindToNode, AllowedKind>;
 
+type ReachableTypes = Set<string>;
+
+let reachableTypesCache: ReachableTypes;
+
+function getReachableTypes(schema: GraphQLSchema): ReachableTypes {
+  // We don't want cache reachableTypes on test environment
+  // Otherwise reachableTypes will be same for all tests
+  if (process.env.NODE_ENV !== 'test' && reachableTypesCache) {
+    return reachableTypesCache;
+  }
+  const reachableTypes: ReachableTypes = new Set();
+
+  const collect = (node: ASTNode): false | void => {
+    const typeName = getTypeName(node);
+    if (reachableTypes.has(typeName)) {
+      return;
+    }
+    reachableTypes.add(typeName);
+    const type = schema.getType(typeName) || schema.getDirective(typeName);
+
+    if (isInterfaceType(type)) {
+      const { objects, interfaces } = schema.getImplementations(type);
+      for (const { astNode } of [...objects, ...interfaces]) {
+        visit(astNode, visitor);
+      }
+    } else if (type.astNode) {
+      // astNode can be undefined for ID, String, Boolean
+      visit(type.astNode, visitor);
+    }
+  };
+
+  const visitor: ASTVisitor = {
+    InterfaceTypeDefinition: collect,
+    ObjectTypeDefinition: collect,
+    InputValueDefinition: collect,
+    UnionTypeDefinition: collect,
+    FieldDefinition: collect,
+    Directive: collect,
+    NamedType: collect,
+  };
+
+  for (const type of [
+    schema, // visiting SchemaDefinition node
+    schema.getQueryType(),
+    schema.getMutationType(),
+    schema.getSubscriptionType(),
+  ]) {
+    // if schema don't have Query type, schema.astNode will be undefined
+    if (type?.astNode) {
+      visit(type.astNode, visitor);
+    }
+  }
+  reachableTypesCache = reachableTypes;
+  return reachableTypesCache;
+}
+
 const rule: GraphQLESLintRule = {
   meta: {
     messages: {
-      [UNREACHABLE_TYPE]: 'Type "{{ typeName }}" is unreachable',
+      [RULE_ID]: '{{ type }} `{{ typeName }}` is unreachable.',
     },
     docs: {
       description: `Requires all types to be reachable at some level by root level fields.`,
@@ -70,18 +126,23 @@ const rule: GraphQLESLintRule = {
     hasSuggestions: true,
   },
   create(context) {
-    const reachableTypes = requireReachableTypesFromContext(RULE_ID, context);
+    const schema = requireGraphQLSchemaFromContext(RULE_ID, context);
+    const reachableTypes = getReachableTypes(schema);
     const selector = KINDS.join(',');
 
     return {
       [selector](node: GraphQLESTreeNode<ValueOf<AllowedKindToNode>>) {
         const typeName = node.name.value;
 
         if (!reachableTypes.has(typeName)) {
+          const type = lowerCase(node.kind.replace(/(Extension|Definition)$/, ''))
           context.report({
             node: node.name,
-            messageId: UNREACHABLE_TYPE,
-            data: { typeName },
+            messageId: RULE_ID,
+            data: {
+              type: type[0].toUpperCase() + type.slice(1),
+              typeName
+            },
             suggest: [
               {
                 desc: `Remove \`${typeName}\``,

packages/plugin/src/rules/no-unreachable-types.ts

@@ -1,13 +1,50 @@
+import { GraphQLSchema, TypeInfo, visit, visitWithTypeInfo } from 'graphql';
 import { GraphQLESLintRule } from '../types';
-import { requireUsedFieldsFromContext } from '../utils';
+import { requireGraphQLSchemaFromContext, requireSiblingsOperations } from '../utils';
+import { SiblingOperations } from '../sibling-operations';
 
-const UNUSED_FIELD = 'UNUSED_FIELD';
 const RULE_ID = 'no-unused-fields';
 
+type UsedFields = Record<string, Set<string>>;
+
+let usedFieldsCache: UsedFields;
+
+function getUsedFields(schema: GraphQLSchema, operations: SiblingOperations): UsedFields {
+  // We don't want cache usedFields on test environment
+  // Otherwise usedFields will be same for all tests
+  if (process.env.NODE_ENV !== 'test' && usedFieldsCache) {
+    return usedFieldsCache;
+  }
+  const usedFields: UsedFields = Object.create(null);
+  const typeInfo = new TypeInfo(schema);
+
+  const visitor = visitWithTypeInfo(typeInfo, {
+    Field(node): false | void {
+      const fieldDef = typeInfo.getFieldDef();
+      if (!fieldDef) {
+        // skip visiting this node if field is not defined in schema
+        return false;
+      }
+      const parentTypeName = typeInfo.getParentType().name;
+      const fieldName = node.name.value;
+
+      usedFields[parentTypeName] ??= new Set();
+      usedFields[parentTypeName].add(fieldName);
+    },
+  });
+
+  const allDocuments = [...operations.getOperations(), ...operations.getFragments()];
+  for (const { document } of allDocuments) {
+    visit(document, visitor);
+  }
+  usedFieldsCache = usedFields;
+  return usedFieldsCache;
+}
+
 const rule: GraphQLESLintRule = {
   meta: {
     messages: {
-      [UNUSED_FIELD]: `Field "{{fieldName}}" is unused`,
+      [RULE_ID]: `Field "{{fieldName}}" is unused`,
     },
     docs: {
       description: `Requires all fields to be used at some level by siblings operations.`,
@@ -65,7 +102,9 @@ const rule: GraphQLESLintRule = {
     hasSuggestions: true,
   },
   create(context) {
-    const usedFields = requireUsedFieldsFromContext(RULE_ID, context);
+    const schema = requireGraphQLSchemaFromContext(RULE_ID, context);
+    const siblingsOperations = requireSiblingsOperations(RULE_ID, context);
+    const usedFields = getUsedFields(schema, siblingsOperations);
 
     return {
       FieldDefinition(node) {
@@ -79,7 +118,7 @@ const rule: GraphQLESLintRule = {
 
         context.report({
           node: node.name,
-          messageId: UNUSED_FIELD,
+          messageId: RULE_ID,
           data: { fieldName },
           suggest: [
             {

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

@@ -128,7 +128,6 @@ const rule: GraphQLESLintRule<[SelectionSetDepthRuleConfig]> = {
                   {
                     desc: 'Remove selections',
                     fix(fixer) {
-                      const { line, column } = error.locations[0];
                       const ancestors = context.getAncestors();
                       const token = (ancestors[0] as AST.Program).tokens.find(
                         token => token.loc.start.line === line && token.loc.start.column === column - 1

packages/plugin/src/rules/selection-set-depth.ts

@@ -5,7 +5,6 @@ import { IExtensions, IGraphQLProject, DocumentPointer, SchemaPointer } from 'gr
 import { GraphQLESLintRuleListener } from './testkit';
 import { GraphQLESTreeNode } from './estree-parser';
 import { SiblingOperations } from './sibling-operations';
-import { getReachableTypes, getUsedFields } from './graphql-ast';
 
 export interface ParserOptions {
   schema?: SchemaPointer | Record<string, { headers: Record<string, string> }>;
@@ -27,8 +26,6 @@ export type ParserServices = {
   hasTypeInfo: boolean;
   schema: GraphQLSchema | null;
   siblingOperations: SiblingOperations;
-  reachableTypes: typeof getReachableTypes;
-  usedFields: typeof getUsedFields;
 };
 
 export type GraphQLESLintParseResult = Linter.ESLintParseResult & {

packages/plugin/src/types.ts

@@ -7,7 +7,6 @@ import lowerCase from 'lodash.lowercase';
 import chalk from 'chalk';
 import { GraphQLESLintRuleContext } from './types';
 import { SiblingOperations } from './sibling-operations';
-import { ReachableTypes, UsedFields } from './graphql-ast';
 import type * as ESTree from 'estree';
 
 export function requireSiblingsOperations(
@@ -55,20 +54,6 @@ export const logger = {
   warn: (...args) => console.warn(chalk.yellow('warning'), '[graphql-eslint]', chalk(...args)),
 };
 
-export function requireReachableTypesFromContext(
-  ruleName: string,
-  context: GraphQLESLintRuleContext
-): ReachableTypes | never {
-  const schema = requireGraphQLSchemaFromContext(ruleName, context);
-  return context.parserServices.reachableTypes(schema);
-}
-
-export function requireUsedFieldsFromContext(ruleName: string, context: GraphQLESLintRuleContext): UsedFields | never {
-  const schema = requireGraphQLSchemaFromContext(ruleName, context);
-  const siblings = requireSiblingsOperations(ruleName, context);
-  return context.parserServices.usedFields(schema, siblings);
-}
-
 export const normalizePath = (path: string): string => (path || '').replace(/\\/g, '/');
 
 /**