🎉 New rule no-unused-fields (#451)

Co-authored-by: dimitri <[email protected]>

Author: Dimitri POSTOLOV

.changeset/mean-lies-invite.md

@@ -0,0 +1,5 @@
+---
+'@graphql-eslint/eslint-plugin': patch
+---
+
+add `no-unused-fields` rule

docs/README.md

@@ -3,6 +3,7 @@
 
 - [`avoid-typename-prefix`](./rules/avoid-typename-prefix.md)
 - [`no-unreachable-types`](./rules/no-unreachable-types.md)
+- [`no-unused-fields`](./rules/no-unused-fields.md)
 - [`no-deprecated`](./rules/no-deprecated.md)
 - [`unique-fragment-name`](./rules/unique-fragment-name.md)
 - [`unique-operation-name`](./rules/unique-operation-name.md)

docs/rules/no-unused-fields.md

@@ -0,0 +1,55 @@
+# `no-unused-fields`
+
+- Category: `Best Practices`
+- Rule name: `@graphql-eslint/no-unused-fields`
+- Requires GraphQL Schema: `true` [ℹ️](../../README.md#extended-linting-rules-with-graphql-schema)
+- Requires GraphQL Operations: `true` [ℹ️](../../README.md#extended-linting-rules-with-siblings-operations)
+
+Requires all fields to be used at some level by siblings operations
+
+## Usage Examples
+
+### Incorrect
+
+```graphql
+# eslint @graphql-eslint/no-unused-fields: ["error"]
+
+type User {
+  id: ID!
+  name: String
+  someUnusedField: String
+}
+
+type Query {
+  me: User
+}
+
+query {
+  me {
+    id
+    name
+  }
+}
+```
+
+### Correct
+
+```graphql
+# eslint @graphql-eslint/no-unused-fields: ["error"]
+
+type User {
+  id: ID!
+  name: String
+}
+
+type Query {
+  me: User
+}
+
+query {
+  me {
+    id
+    name
+  }
+}
+```

packages/plugin/src/graphql-ast.ts

@@ -16,7 +16,11 @@ import {
   isListType,
   isNonNullType,
   GraphQLDirective,
+  TypeInfo,
+  visit,
+  visitWithTypeInfo,
 } from 'graphql';
+import { SiblingOperations } from './sibling-operations';
 
 export function createReachableTypesService(schema: GraphQLSchema): () => Set<string>;
 export function createReachableTypesService(schema?: GraphQLSchema): () => Set<string> | null {
@@ -128,3 +132,62 @@ export function collectReachableTypes(schema: GraphQLSchema): Set<string> {
     return false;
   }
 }
+
+export type FieldsCache = Record<string, Set<string>>;
+
+export function createUsedFieldsService(schema: GraphQLSchema, operations: SiblingOperations): () => FieldsCache | null {
+  if (!schema || !operations) {
+    return () => null;
+  }
+
+  let cache: FieldsCache = null;
+
+  return () => {
+    if (!cache) {
+      cache = collectUsedFields(schema, operations);
+    }
+
+    return cache;
+  };
+}
+
+export function collectUsedFields(schema: GraphQLSchema, operations: SiblingOperations): FieldsCache {
+  const cache: FieldsCache = {};
+
+  const addField = (typeName, fieldName) => {
+    const fieldType = cache[typeName] ?? (cache[typeName] = new Set());
+    fieldType.add(fieldName);
+  };
+
+  const typeInfo = new TypeInfo(schema);
+
+  const visitor = visitWithTypeInfo(typeInfo, {
+    Field: {
+      enter(node) {
+        const fieldDef = typeInfo.getFieldDef();
+
+        if (!fieldDef) {
+          // skip visiting this node if field is not defined in schema
+          return false;
+        }
+
+        const parent = typeInfo.getParentType();
+        const fieldName = node.name.value;
+        addField(parent.name, fieldName);
+
+        return undefined;
+      },
+    },
+  });
+
+  const allDocuments = [
+    ...operations.getOperations(),
+    ...operations.getFragments(),
+  ];
+
+  for (const { document } of allDocuments) {
+    visit(document, visitor);
+  }
+
+  return cache;
+}

packages/plugin/src/parser.ts

@@ -7,7 +7,7 @@ import { extractTokens } from './utils';
 import { getSchema } from './schema';
 import { getSiblingOperations } from './sibling-operations';
 import { loadGraphqlConfig } from './graphql-config';
-import { createReachableTypesService } from './graphql-ast';
+import { createReachableTypesService, createUsedFieldsService } from './graphql-ast';
 
 export function parse(code: string, options?: ParserOptions): Linter.ESLintParseResult['ast'] {
   return parseForESLint(code, options).ast;
@@ -22,6 +22,7 @@ export function parseForESLint(code: string, options?: ParserOptions): GraphQLES
     schema,
     siblingOperations,
     getReachableTypes: createReachableTypesService(schema),
+    getUsedFields: createUsedFieldsService(schema, siblingOperations),
   };
 
   try {

packages/plugin/src/rules/index.ts

@@ -1,4 +1,5 @@
 import noUnreachableTypes from './no-unreachable-types';
+import noUnusedFields from './no-unused-fields';
 import noAnonymousOperations from './no-anonymous-operations';
 import noOperationNameSuffix from './no-operation-name-suffix';
 import requireDeprecationReason from './require-deprecation-reason';
@@ -22,6 +23,7 @@ import { GRAPHQL_JS_VALIDATIONS } from './graphql-js-validation';
 export const rules = {
   'avoid-typename-prefix': avoidTypenamePrefix,
   'no-unreachable-types': noUnreachableTypes,
+  'no-unused-fields': noUnusedFields,
   'no-deprecated': noDeprecated,
   'unique-fragment-name': uniqueFragmentName,
   'unique-operation-name': uniqueOperationName,

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

@@ -0,0 +1,107 @@
+import { GraphQLESLintRule } from '../types';
+import { requireUsedFieldsFromContext } from '../utils';
+
+const UNUSED_FIELD = 'UNUSED_FIELD';
+const ruleName = 'no-unused-fields';
+
+const rule: GraphQLESLintRule = {
+  meta: {
+    messages: {
+      [UNUSED_FIELD]: `Field "{{fieldName}}" is unused`,
+    },
+    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`,
+      requiresSiblings: true,
+      requiresSchema: true,
+      examples: [
+        {
+          title: 'Incorrect',
+          code: /* GraphQL */ `
+            type User {
+              id: ID!
+              name: String
+              someUnusedField: String
+            }
+
+            type Query {
+              me: User
+            }
+            
+            query {
+              me {
+                id
+                name
+              }
+            }
+          `,
+        },
+        {
+          title: 'Correct',
+          code: /* GraphQL */ `
+            type User {
+              id: ID!
+              name: String
+            }
+
+            type Query {
+              me: User
+            }
+            
+            query {
+              me {
+                id
+                name
+              }
+            }
+          `,
+        },
+      ],
+    },
+    fixable: 'code',
+    type: 'suggestion',
+  },
+  create(context) {
+    const sourceCode = context.getSourceCode();
+    const usedFields = requireUsedFieldsFromContext(ruleName, 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) {
+          return;
+        }
+
+        context.report({
+          node,
+          messageId: UNUSED_FIELD,
+          data: { fieldName },
+          fix(fixer) {
+            const tokenBefore = (sourceCode as any).getTokenBefore(node);
+            const tokenAfter = (sourceCode as any).getTokenAfter(node);
+            const isEmptyType = tokenBefore.type === '{' && tokenAfter.type === '}';
+
+            if (isEmptyType) {
+              // Remove type
+              const { parent } = node as any;
+              const parentBeforeToken = sourceCode.getTokenBefore(parent);
+              return parentBeforeToken
+                ? fixer.removeRange([parentBeforeToken.range[1], parent.range[1]])
+                : fixer.remove(parent);
+            }
+
+            // Remove whitespace before token
+            return fixer.removeRange([tokenBefore.range[1], node.range[1]]);
+          },
+        });
+      },
+    };
+  },
+};
+
+export default rule;

packages/plugin/src/types.ts

@@ -4,6 +4,7 @@ import { ASTNode, GraphQLSchema } from 'graphql';
 import { GraphQLParseOptions } from '@graphql-tools/utils';
 import { GraphQLESlintRuleListener } from './testkit';
 import { SiblingOperations } from './sibling-operations';
+import { FieldsCache } from './graphql-ast';
 
 export interface ParserOptions {
   schema?: string | string[];
@@ -19,6 +20,7 @@ export type ParserServices = {
   hasTypeInfo: boolean;
   schema: GraphQLSchema | null;
   getReachableTypes: () => Set<string> | null;
+  getUsedFields: () => FieldsCache | null;
 };
 
 export type GraphQLESLintParseResult = Linter.ESLintParseResult & {

packages/plugin/src/utils.ts

@@ -2,6 +2,7 @@ import { Source, Lexer, GraphQLSchema, Token, DocumentNode } from 'graphql';
 import { GraphQLESlintRuleContext } from './types';
 import { AST } from 'eslint';
 import { SiblingOperations } from './sibling-operations';
+import { FieldsCache } from './graphql-ast';
 
 export function requireSiblingsOperations(ruleName: string, context: GraphQLESlintRuleContext<any>): SiblingOperations {
   if (!context || !context.parserServices) {
@@ -57,6 +58,25 @@ export function requireReachableTypesFromContext(
   return context.parserServices.getReachableTypes();
 }
 
+export function requireUsedFieldsFromContext(
+  ruleName: string,
+  context: GraphQLESlintRuleContext<any>
+): FieldsCache {
+  if (!context || !context.parserServices) {
+    throw new Error(
+      `Rule '${ruleName}' requires 'parserOptions.schema' to be set. See http://bit.ly/graphql-eslint-schema for more info`
+    );
+  }
+
+  if (!context.parserServices.schema) {
+    throw new Error(
+      `Rule '${ruleName}' requires 'parserOptions.schema' to be set and schema to be loaded. See http://bit.ly/graphql-eslint-schema for more info`
+    );
+  }
+
+  return context.parserServices.getUsedFields();
+}
+
 function getLexer(source: Source): Lexer {
   // GraphQL v14
   const gqlLanguage = require('graphql/language');