Catch unhandled exception in abstract resolution (#4392)

Co-authored-by: Benjie <benjie@jemjie.com>

Author: 2 people

.c8rc.json

@@ -7,7 +7,8 @@
     "src/jsutils/Maybe.ts",
     "src/jsutils/ObjMap.ts",
     "src/jsutils/PromiseOrValue.ts",
-    "src/utilities/typedQueryDocumentNode.ts"
+    "src/utilities/typedQueryDocumentNode.ts",
+    "src/**/__tests__/**/*.ts"
   ],
   "clean": true,
   "report-dir": "reports/coverage",

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

@@ -143,7 +143,7 @@ const PetType = new GraphQLUnionType({
     if (value instanceof Cat) {
       return CatType.name;
     }
-    /* c8 ignore next 3 */
+
     // Not reachable, all possible types have been considered.
     expect.fail('Not reachable');
   },
@@ -191,6 +191,70 @@ const john = new Person(
   [garfield, fern],
 );
 
+const SearchableInterface = new GraphQLInterfaceType({
+  name: 'Searchable',
+  fields: {
+    id: { type: GraphQLString },
+  },
+});
+
+const TypeA = new GraphQLObjectType({
+  name: 'TypeA',
+  interfaces: [SearchableInterface],
+  fields: () => ({
+    id: { type: GraphQLString },
+    nameA: { type: GraphQLString },
+  }),
+  isTypeOf: (_value, _context, _info) =>
+    new Promise((_resolve, reject) =>
+      setTimeout(() => reject(new Error('TypeA_isTypeOf_rejected')), 10),
+    ),
+});
+
+const TypeB = new GraphQLObjectType({
+  name: 'TypeB',
+  interfaces: [SearchableInterface],
+  fields: () => ({
+    id: { type: GraphQLString },
+    nameB: { type: GraphQLString },
+  }),
+  isTypeOf: (value: any, _context, _info) => value.id === 'b',
+});
+
+const queryTypeWithSearchable = new GraphQLObjectType({
+  name: 'Query',
+  fields: {
+    person: {
+      type: PersonType,
+      resolve: () => john,
+    },
+    search: {
+      type: SearchableInterface,
+      args: { id: { type: GraphQLString } },
+      resolve: (_source, { id }) => {
+        if (id === 'a') {
+          return { id: 'a', nameA: 'Object A' };
+        } else if (id === 'b') {
+          return { id: 'b', nameB: 'Object B' };
+        }
+      },
+    },
+  },
+});
+
+const schemaWithSearchable = new GraphQLSchema({
+  query: queryTypeWithSearchable,
+  types: [
+    PetType,
+    TypeA,
+    TypeB,
+    SearchableInterface,
+    PersonType,
+    DogType,
+    CatType,
+  ],
+});
+
 describe('Execute: Union and intersection types', () => {
   it('can introspect on union and intersection types', () => {
     const document = parse(`
@@ -633,4 +697,51 @@ describe('Execute: Union and intersection types', () => {
       },
     });
   });
+
+  it('handles promises from isTypeOf correctly when a later type matches synchronously', async () => {
+    const document = parse(`
+      query TestSearch {
+        search(id: "b") {
+          __typename
+          id
+          ... on TypeA {
+            nameA
+          }
+          ... on TypeB {
+            nameB
+          }
+        }
+      }
+    `);
+
+    let unhandledRejection: any = null;
+    const unhandledRejectionListener = (reason: any) => {
+      unhandledRejection = reason;
+    };
+    // eslint-disable-next-line
+    process.on('unhandledRejection', unhandledRejectionListener);
+
+    const result = await execute({
+      schema: schemaWithSearchable,
+      document,
+    });
+
+    expect(result.errors).to.equal(undefined);
+    expect(result.data).to.deep.equal({
+      search: {
+        __typename: 'TypeB',
+        id: 'b',
+        nameB: 'Object B',
+      },
+    });
+
+    // Give the TypeA promise a chance to reject and the listener to fire
+
+    await new Promise((resolve) => setTimeout(resolve, 20));
+
+    // eslint-disable-next-line
+    process.removeListener('unhandledRejection', unhandledRejectionListener);
+
+    expect(unhandledRejection).to.equal(null);
+  });
 });

src/execution/execute.ts

@@ -2048,12 +2048,14 @@ 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 */
-            });
+          if (promisedIsTypeOfResults.length) {
+            // Explicitly ignore any promise rejections
+            Promise.allSettled(promisedIsTypeOfResults)
+              /* c8 ignore next 3 */
+              .catch(() => {
+                // Do nothing
+              });
           }
-
           return type.name;
         }
       }