fix: improve handling of promises in defaultTypeResolver

Author: hayes

src/execution/__tests__/union-interface-test.ts

@@ -1,6 +1,8 @@
 import { expect } from 'chai';
 import { describe, it } from 'mocha';
 
+import { expectJSON } from '../../__testUtils__/expectJSON.js';
+
 import { parse } from '../../language/parser.js';
 
 import {
@@ -12,7 +14,7 @@ import {
 import { GraphQLBoolean, GraphQLString } from '../../type/scalars.js';
 import { GraphQLSchema } from '../../type/schema.js';
 
-import { executeSync } from '../execute.js';
+import { execute, executeSync } from '../execute.js';
 
 class Dog {
   name: string;
@@ -42,19 +44,30 @@ class Cat {
   }
 }
 
+class Plant {
+  name: string;
+
+  constructor(name: string) {
+    this.name = name;
+  }
+}
+
 class Person {
   name: string;
   pets: ReadonlyArray<Dog | Cat> | undefined;
   friends: ReadonlyArray<Dog | Cat | Person> | undefined;
+  responsibilities: ReadonlyArray<Dog | Cat | Plant> | undefined;
 
   constructor(
     name: string,
     pets?: ReadonlyArray<Dog | Cat>,
     friends?: ReadonlyArray<Dog | Cat | Person>,
+    responsibilities?: ReadonlyArray<Dog | Cat | Plant>,
   ) {
     this.name = name;
     this.pets = pets;
     this.friends = friends;
+    this.responsibilities = responsibilities;
   }
 }
 
@@ -108,6 +121,18 @@ const CatType: GraphQLObjectType = new GraphQLObjectType({
   isTypeOf: (value) => value instanceof Cat,
 });
 
+const PlantType: GraphQLObjectType = new GraphQLObjectType({
+  name: 'Plant',
+  interfaces: [NamedType],
+  fields: () => ({
+    name: { type: GraphQLString },
+  }),
+  // eslint-disable-next-line @typescript-eslint/require-await
+  isTypeOf: async () => {
+    throw new Error('Not sure if this is a plant');
+  },
+});
+
 const PetType = new GraphQLUnionType({
   name: 'Pet',
   types: [DogType, CatType],
@@ -124,13 +149,19 @@ const PetType = new GraphQLUnionType({
   },
 });
 
+const PetOrPlantType = new GraphQLUnionType({
+  name: 'PetOrPlantType',
+  types: [PlantType, DogType, CatType],
+});
+
 const PersonType: GraphQLObjectType = new GraphQLObjectType({
   name: 'Person',
   interfaces: [NamedType, MammalType, LifeType],
   fields: () => ({
     name: { type: GraphQLString },
     pets: { type: new GraphQLList(PetType) },
     friends: { type: new GraphQLList(NamedType) },
+    responsibilities: { type: new GraphQLList(PetOrPlantType) },
     progeny: { type: new GraphQLList(PersonType) },
     mother: { type: PersonType },
     father: { type: PersonType },
@@ -151,8 +182,14 @@ const odie = new Dog('Odie', true);
 odie.mother = new Dog("Odie's Mom", true);
 odie.mother.progeny = [odie];
 
+const fern = new Plant('Fern');
 const liz = new Person('Liz');
-const john = new Person('John', [garfield, odie], [liz, odie]);
+const john = new Person(
+  'John',
+  [garfield, odie],
+  [liz, odie],
+  [garfield, fern],
+);
 
 describe('Execute: Union and intersection types', () => {
   it('can introspect on union and intersection types', () => {
@@ -195,7 +232,12 @@ describe('Execute: Union and intersection types', () => {
           name: 'Named',
           fields: [{ name: 'name' }],
           interfaces: [],
-          possibleTypes: [{ name: 'Dog' }, { name: 'Cat' }, { name: 'Person' }],
+          possibleTypes: [
+            { name: 'Dog' },
+            { name: 'Cat' },
+            { name: 'Person' },
+            { name: 'Plant' },
+          ],
           enumValues: null,
           inputFields: null,
         },
@@ -545,4 +587,56 @@ describe('Execute: Union and intersection types', () => {
     expect(encounteredRootValue).to.equal(rootValue);
     expect(encounteredContext).to.equal(contextValue);
   });
+
+  it('it rejects if isTypeOf check rejects in defaultResolveType', async () => {
+    const document = parse(`
+      {
+        responsibilities {
+          __typename
+          ... on Dog {
+            name
+            barks
+          }
+          ... on Cat {
+            name
+            meows
+          }
+        }
+      }
+    `);
+
+    const rootValue = new Person('John', [], [liz], [garfield]);
+    const contextValue = { authToken: '123abc' };
+
+    /* c8 ignore next 4 */
+    // eslint-disable-next-line no-undef
+    process.on('unhandledRejection', () => {
+      expect.fail('Unhandled rejection');
+    });
+
+    const result = await execute({
+      schema,
+      document,
+      rootValue,
+      contextValue,
+    });
+
+    expectJSON(result).toDeepEqual({
+      data: {
+        responsibilities: [null],
+      },
+      errors: [
+        {
+          message: 'Not sure if this is a plant',
+          locations: [
+            {
+              column: 9,
+              line: 3,
+            },
+          ],
+          path: ['responsibilities', 0],
+        },
+      ],
+    });
+  });
 });

src/execution/execute.ts

@@ -1618,6 +1618,12 @@ export const defaultTypeResolver: GraphQLTypeResolver<unknown, unknown> =
         if (isPromise(isTypeOfResult)) {
           promisedIsTypeOfResults[i] = isTypeOfResult;
         } else if (isTypeOfResult) {
+          if (promisedIsTypeOfResults.length > 0) {
+            Promise.all(promisedIsTypeOfResults).then(undefined, () => {
+              /* ignore errors */
+            });
+          }
+
           return type.name;
         }
       }

src/utilities/__tests__/printSchema-test.ts

@@ -509,23 +509,6 @@ describe('Type System Printer', () => {
     `);
   });
 
-  it('Print Input Type with @oneOf directive', () => {
-    const InputType = new GraphQLInputObjectType({
-      name: 'InputType',
-      isOneOf: true,
-      fields: {
-        int: { type: GraphQLInt },
-      },
-    });
-
-    const schema = new GraphQLSchema({ types: [InputType] });
-    expectPrintedSchema(schema).to.equal(dedent`
-      input InputType @oneOf {
-        int: Int
-      }
-    `);
-  });
-
   it('Custom Scalar', () => {
     const OddType = new GraphQLScalarType({ name: 'Odd' });
 
@@ -680,7 +663,7 @@ describe('Type System Printer', () => {
       schema {
         query: Query
       }
-
+      
       """"""
       directive @someDirective(
         """"""

src/utilities/printSchema.ts

@@ -204,12 +204,7 @@ function printInputObject(type: GraphQLInputObjectType): string {
   const fields = Object.values(type.getFields()).map(
     (f, i) => printDescription(f, '  ', !i) + '  ' + printInputValue(f),
   );
-  return (
-    printDescription(type) +
-    `input ${type.name}` +
-    printOneOf(type.isOneOf) +
-    printBlock(fields)
-  );
+  return printDescription(type) + `input ${type.name}` + printBlock(fields);
 }
 
 function printFields(type: GraphQLObjectType | GraphQLInterfaceType): string {
@@ -292,14 +287,6 @@ function printDeprecated(reason: Maybe<string>): string {
   return ' @deprecated';
 }
 
-function printOneOf(isOneOf: boolean): string {
-  if (!isOneOf) {
-    return '';
-  }
-
-  return ' @oneOf';
-}
-
 function printSpecifiedByURL(scalar: GraphQLScalarType): string {
   if (scalar.specifiedByURL == null) {
     return '';