Detect Reference Loops in defined-types-are-used

meiamsome · meiamsome · commit e0d436683d56 · 2020-12-12T01:28:29.000Z
In defined-types-are-used - Add support for detecting reference loops (fixes #264). - Add support for custom schema roots.
diff --git a/src/rules/defined_types_are_used.js b/src/rules/defined_types_are_used.js
@@ -1,58 +1,139 @@
+import { Kind } from 'graphql';
 import { ValidationError } from '../validation_error';
 
+// Removes any NonNull or List wrapping
+function unwrapType(typeAst) {
+  let type = typeAst;
+  while (type.type) {
+    type = type.type;
+  }
+  return type;
+}
+
 export function DefinedTypesAreUsed(context) {
-  var ignoredTypes = ['Query', 'Mutation', 'Subscription'];
-  var definedTypes = [];
-  var referencedTypes = new Set();
-
-  var recordDefinedType = (node) => {
-    if (ignoredTypes.indexOf(node.name.value) == -1) {
-      definedTypes.push(node);
-    }
+  const typeMap = new Map();
+  const topLevelTypes = new Set();
+
+  let seenSchemaDefinition = false;
+  let currentType = null;
+
+  const visitType = {
+    enter(node) {
+      currentType = node.name.value;
+
+      if (!typeMap.has(currentType)) {
+        typeMap.set(currentType, {
+          node,
+          interfaces: new Set(),
+          referencedTypes: new Set(),
+        });
+      }
+
+      if (node.interfaces) {
+        for (const interfaceType of node.interfaces) {
+          typeMap.get(currentType).interfaces.add(interfaceType.name.value);
+        }
+      }
+
+      if (
+        node.kind === Kind.UNION_TYPE_DEFINITION ||
+        node.kind === Kind.UNION_TYPE_EXTENSION
+      ) {
+        for (const type of node.types) {
+          typeMap.get(node.name.value).referencedTypes.add(type.name.value);
+        }
+      }
+    },
+    leave() {
+      currentType = null;
+    },
   };
 
   return {
-    ScalarTypeDefinition: recordDefinedType,
-    ObjectTypeDefinition: recordDefinedType,
-    InterfaceTypeDefinition: recordDefinedType,
-    UnionTypeDefinition: recordDefinedType,
-    EnumTypeDefinition: recordDefinedType,
-    InputObjectTypeDefinition: recordDefinedType,
-
-    NamedType: (node, key, parent, path, ancestors) => {
-      referencedTypes.add(node.name.value);
+    SchemaDefinition() {
+      seenSchemaDefinition = true;
+    },
+    ScalarTypeDefinition: visitType,
+    ObjectTypeDefinition: visitType,
+    ObjectTypeExtension: visitType,
+    InterfaceTypeDefinition: visitType,
+    InterfaceTypeExtension: visitType,
+    EnumTypeDefinition: visitType,
+    EnumTypeExtension: visitType,
+    InputObjectTypeDefinition: visitType,
+    InputObjectExtension: visitType,
+    UnionTypeDefinition: visitType,
+    UnionTypeExtension: visitType,
+
+    OperationTypeDefinition(node) {
+      // Used as a root type in the schema definition
+      topLevelTypes.add(node.type.name.value);
+    },
+
+    InputValueDefinition(node) {
+      if (currentType) {
+        // Used as an input
+        typeMap
+          .get(currentType)
+          .referencedTypes.add(unwrapType(node.type).name.value);
+      } else {
+        // Used in a directive's arguments - this doesn't check whether the directive itself is used
+        topLevelTypes.add(unwrapType(node.type).name.value);
+      }
+    },
+
+    FieldDefinition(node) {
+      // Used as the result of a field
+      typeMap
+        .get(currentType)
+        .referencedTypes.add(unwrapType(node.type).name.value);
     },
 
     Document: {
-      leave: (node) => {
-        definedTypes.forEach((node) => {
-          if (node.kind == 'ObjectTypeDefinition') {
-            let implementedInterfaces = node.interfaces.map((node) => {
-              return node.name.value;
-            });
-
-            let anyReferencedInterfaces = implementedInterfaces.some(
-              (interfaceName) => {
-                return referencedTypes.has(interfaceName);
-              }
-            );
+      leave() {
+        if (!seenSchemaDefinition) {
+          // If we haven't seen a schema definition these types are used if they exist.
+          topLevelTypes.add('Query');
+          topLevelTypes.add('Mutation');
+          topLevelTypes.add('Subscription');
+        }
+
+        // Interfaces are inverted dependencies, so we have to un-invert them here.
+        for (const [typeName, { interfaces }] of typeMap.entries()) {
+          for (const interfaceName of interfaces.values()) {
+            typeMap.get(interfaceName).referencedTypes.add(typeName);
+          }
+        }
 
-            if (anyReferencedInterfaces) {
-              return;
+        // BFS of types to find the used ones
+        const referencedTypes = new Set(topLevelTypes);
+        let typeQueue = [...topLevelTypes];
+        for (const typeName of typeQueue) {
+          if (typeMap.has(typeName)) {
+            for (const childType of typeMap
+              .get(typeName)
+              .referencedTypes.values()) {
+              if (!referencedTypes.has(childType)) {
+                referencedTypes.add(childType);
+                typeQueue.push(childType);
+              }
             }
           }
+        }
 
-          if (!referencedTypes.has(node.name.value)) {
+        // For every type in the document, check if it is used.
+        for (const [name, { node }] of typeMap.entries()) {
+          if (!referencedTypes.has(name)) {
             context.reportError(
               new ValidationError(
                 'defined-types-are-used',
-                `The type \`${node.name.value}\` is defined in the ` +
+                `The type \`${name}\` is defined in the ` +
                   `schema but not used anywhere.`,
                 [node]
               )
             );
           }
-        });
+        }
       },
     },
   };
diff --git a/test/rules/defined_types_are_used.js b/test/rules/defined_types_are_used.js
@@ -110,6 +110,123 @@ describe('DefinedTypesAreUsed rule', () => {
     );
   });
 
+  it('catches Query type if a custom query type is used', () => {
+    expectFailsRule(
+      DefinedTypesAreUsed,
+      `
+        extend type Query {
+          b: String
+        }
+
+        type CustomQuery {
+          a: String
+        }
+
+        schema {
+          query: CustomQuery,
+        }
+      `,
+      [
+        {
+          message:
+            'The type `Query` is defined in the schema but not used anywhere.',
+          locations: [{ line: 2, column: 9 }],
+        },
+      ]
+    );
+  });
+
+  it('catches Mutation type if a custom mutation type is used', () => {
+    expectFailsRule(
+      DefinedTypesAreUsed,
+      `
+        type Mutation {
+          a: String
+        }
+
+        schema {
+          query: Query
+          mutation: Query
+        }
+      `,
+      [
+        {
+          message:
+            'The type `Mutation` is defined in the schema but not used anywhere.',
+          locations: [{ line: 2, column: 9 }],
+        },
+      ]
+    );
+  });
+
+  it('catches Subscription type if a custom subscription type is used', () => {
+    expectFailsRule(
+      DefinedTypesAreUsed,
+      `
+        type Subscription {
+          a: String
+        }
+
+        schema {
+          query: Query
+          subscription: Query
+        }
+      `,
+      [
+        {
+          message:
+            'The type `Subscription` is defined in the schema but not used anywhere.',
+          locations: [{ line: 2, column: 9 }],
+        },
+      ]
+    );
+  });
+
+  it('catches a self-referential type that is unused', () => {
+    expectFailsRule(
+      DefinedTypesAreUsed,
+      `
+        type A {
+          a: A
+        }
+      `,
+      [
+        {
+          message:
+            'The type `A` is defined in the schema but not used anywhere.',
+          locations: [{ line: 2, column: 9 }],
+        },
+      ]
+    );
+  });
+
+  it('catches co-referential types that are unused', () => {
+    expectFailsRule(
+      DefinedTypesAreUsed,
+      `
+        type A {
+          b: B
+        }
+
+        type B {
+          a: A
+        }
+      `,
+      [
+        {
+          message:
+            'The type `A` is defined in the schema but not used anywhere.',
+          locations: [{ line: 2, column: 9 }],
+        },
+        {
+          message:
+            'The type `B` is defined in the schema but not used anywhere.',
+          locations: [{ line: 6, column: 9 }],
+        },
+      ]
+    );
+  });
+
   it('ignores types that are a member of a union', () => {
     expectPassesRule(
       DefinedTypesAreUsed,
@@ -127,6 +244,24 @@ describe('DefinedTypesAreUsed rule', () => {
     );
   });
 
+  it('ignores types that are a member of an extended union', () => {
+    expectPassesRule(
+      DefinedTypesAreUsed,
+      `
+        extend type Query {
+          b: B
+        }
+
+        type A {
+          a: String
+        }
+
+        union B = Query
+        extend union B = A
+      `
+    );
+  });
+
   it('ignores types that implement an interface that is used', () => {
     expectPassesRule(
       DefinedTypesAreUsed,
@@ -146,6 +281,29 @@ describe('DefinedTypesAreUsed rule', () => {
     );
   });
 
+  it('ignores types that implement an interface that is used in an extension', () => {
+    expectPassesRule(
+      DefinedTypesAreUsed,
+      `
+        extend type Query {
+          c: Node
+        }
+
+        interface Node {
+          id: ID!
+        }
+
+        type A {
+          a: String
+        }
+
+        extend type A implements Node{
+          id: ID!
+        }
+      `
+    );
+  });
+
   it('ignores types that are used in field definitions', () => {
     expectPassesRule(
       DefinedTypesAreUsed,
@@ -167,7 +325,7 @@ describe('DefinedTypesAreUsed rule', () => {
       `
       extend type Query {
         b(date: Date): String
-        c(c: C): String
+        c(c: [C!]!): String
       }
 
       scalar Date
@@ -179,6 +337,21 @@ describe('DefinedTypesAreUsed rule', () => {
     );
   });
 
+  it('ignores types that are used in directives', () => {
+    expectPassesRule(
+      DefinedTypesAreUsed,
+      `
+        directive @exampleDirective(argument1: [C!], argument2: Date) on FIELD_DEFINITION
+
+        scalar Date
+
+        input C {
+          c: String
+        }
+      `
+    );
+  });
+
   it('ignores unreferenced Mutation object type', () => {
     expectPassesRule(
       DefinedTypesAreUsed,
