fix(healing): empty types should be pruned even if fields of those ty…

…pes still exist

Fixes #37.

src/test/testUtils.ts

@@ -0,0 +1,35 @@
+/* tslint:disable:no-unused-expression */
+
+import { expect } from 'chai';
+
+import { healSchema } from '../utils';
+import { makeExecutableSchema } from '../makeExecutableSchema';
+import { GraphQLObjectType, GraphQLObjectTypeConfig } from 'graphql';
+
+describe('heal', () => {
+  it('should prune empty types', () => {
+    const schema = makeExecutableSchema({
+      typeDefs: `
+      type WillBeEmptyObject {
+        willBeRemoved: String
+      }
+
+      type Query {
+        someQuery: WillBeEmptyObject
+      }
+      `
+    });
+    const originalTypeMap = schema.getTypeMap();
+
+    const config = originalTypeMap['WillBeEmptyObject'].toConfig() as GraphQLObjectTypeConfig<any, any>;
+    originalTypeMap['WillBeEmptyObject'] = new GraphQLObjectType({
+      ...config,
+      fields: {},
+    });
+
+    healSchema(schema);
+
+    const healedTypeMap = schema.getTypeMap();
+    expect(healedTypeMap).not.to.haveOwnProperty('WillBeEmptyObject');
+  });
+});

src/test/tests.ts

@@ -16,3 +16,5 @@ import './testTransforms';
 import './testExtensionExtraction';
 import './testIntegration';
 import './testUpload';
+import './testUtils';
+

src/utils/heal.ts

@@ -208,22 +208,25 @@ function pruneTypes(typeMap: NamedTypeMap, directives: ReadonlyArray<GraphQLDire
   });
 
   let prunedTypeMap = false;
-  updateEachKey(typeMap, (type, typeName) => {
-    let shouldPrune: boolean = false;
-    if (type instanceof GraphQLObjectType) {
+  each(typeMap, (type, typeName) => {
+    if (type instanceof GraphQLObjectType || type instanceof GraphQLInputObjectType) {
       // prune types with no fields
-      shouldPrune = !Object.keys(type.getFields()).length;
+      if (!Object.keys(type.getFields()).length) {
+        typeMap[typeName] = null;
+        prunedTypeMap = true;
+      }
     } else if (type instanceof GraphQLUnionType) {
       // prune unions without underlying types
-      shouldPrune = !type.getTypes().length;
+      if (!type.getTypes().length) {
+        typeMap[typeName] = null;
+        prunedTypeMap = true;
+      }
     } else if (type instanceof GraphQLInterfaceType) {
       // prune interfaces without fields or without implementations
-      shouldPrune = !Object.keys(type.getFields()).length || !implementedInterfaces[type.name];
-    }
-
-    if (shouldPrune) {
-      prunedTypeMap = true;
-      return null;
+      if (!Object.keys(type.getFields()).length || !implementedInterfaces[type.name]) {
+        typeMap[typeName] = null;
+        prunedTypeMap = true;
+      }
     }
   });