cancel execution despite pending resolvers

Author: yaacovCR

src/execution/__tests__/abort-signal-test.ts

@@ -52,6 +52,7 @@ const schema = buildSchema(`
 
   type Query {
     todo: Todo
+    nonNullableTodo: Todo!
   }
 
   type Mutation {
@@ -300,6 +301,97 @@ describe('Execute: Cancellation', () => {
     });
   });
 
+  it('should stop the execution when aborted despite a hanging resolver', async () => {
+    const abortController = new AbortController();
+    const document = parse(`
+      query {
+        todo {
+          id
+          author {
+            id
+          }
+        }
+      }
+    `);
+
+    const resultPromise = execute({
+      document,
+      schema,
+      abortSignal: abortController.signal,
+      rootValue: {
+        todo: () =>
+          new Promise(() => {
+            /* will never resolve */
+          }),
+      },
+    });
+
+    abortController.abort();
+
+    const result = await resultPromise;
+
+    expect(result.errors?.[0].originalError?.name).to.equal('AbortError');
+
+    expectJSON(result).toDeepEqual({
+      data: {
+        todo: null,
+      },
+      errors: [
+        {
+          message: 'This operation was aborted',
+          path: ['todo'],
+          locations: [{ line: 3, column: 9 }],
+        },
+      ],
+    });
+  });
+
+  it('should stop the execution when aborted with proper null bubbling', async () => {
+    const abortController = new AbortController();
+    const document = parse(`
+      query {
+        nonNullableTodo {
+          id
+          author {
+            id
+          }
+        }
+      }
+    `);
+
+    const resultPromise = execute({
+      document,
+      schema,
+      abortSignal: abortController.signal,
+      rootValue: {
+        nonNullableTodo: async () =>
+          Promise.resolve({
+            id: '1',
+            text: 'Hello, World!',
+            /* c8 ignore next */
+            author: () => expect.fail('Should not be called'),
+          }),
+      },
+    });
+
+    abortController.abort();
+
+    const result = await resultPromise;
+
+    expect(result.errors?.[0].originalError?.name).to.equal('AbortError');
+
+    expectJSON(result).toDeepEqual({
+      data: null,
+      errors: [
+        {
+          message: 'This operation was aborted',
+          path: ['nonNullableTodo'],
+          locations: [{ line: 3, column: 9 }],
+        },
+      ],
+    });
+  });
+
   it('should stop deferred execution when aborted', async () => {
     const abortController = new AbortController();
     const document = parse(`
@@ -353,14 +445,12 @@ describe('Execute: Cancellation', () => {
     const abortController = new AbortController();
     const document = parse(`
       query {
-        todo {
-          id
-          ... on Todo @defer {
+        ... on Query @defer {
+          todo {
+            id
             text
             author {
-              ... on Author @defer {
-                id
-              }
+              id
             }
           }
         }
@@ -392,31 +482,21 @@ describe('Execute: Cancellation', () => {
 
     expectJSON(result).toDeepEqual([
       {
-        data: {
-          todo: {
-            id: '1',
-          },
-        },
-        pending: [{ id: '0', path: ['todo'] }],
+        data: {},
+        pending: [{ id: '0', path: [] }],
         hasNext: true,
       },
       {
         incremental: [
           {
             data: {
-              text: 'hello world',
-              author: null,
+              todo: null,
             },
             errors: [
               {
-                locations: [
-                  {
-                    column: 13,
-                    line: 7,
-                  },
-                ],
                 message: 'This operation was aborted',
-                path: ['todo', 'author'],
+                path: ['todo'],
+                locations: [{ line: 4, column: 11 }],
               },
             ],
             id: '0',
@@ -448,6 +528,11 @@ describe('Execute: Cancellation', () => {
       },
     });
 
+    await resolveOnNextTick();
+    await resolveOnNextTick();
+    await resolveOnNextTick();
+    await resolveOnNextTick();
+
     abortController.abort();
 
     const result = await resultPromise;

src/execution/__tests__/stream-test.ts

@@ -1661,6 +1661,11 @@ describe('Execute: stream directive', () => {
             items: [{ name: 'Luke' }],
             id: '1',
           },
+        ],
+        hasNext: true,
+      },
+      {
+        incremental: [
           {
             data: { scalarField: null },
             id: '0',

src/execution/execute.ts

@@ -13,6 +13,7 @@ import { addPath, pathToArray } from '../jsutils/Path.js';
 import { promiseForObject } from '../jsutils/promiseForObject.js';
 import type { PromiseOrValue } from '../jsutils/PromiseOrValue.js';
 import { promiseReduce } from '../jsutils/promiseReduce.js';
+import { promiseWithResolvers } from '../jsutils/promiseWithResolvers.js';
 
 import { GraphQLError } from '../error/GraphQLError.js';
 import { locatedError } from '../error/locatedError.js';
@@ -865,7 +866,31 @@ function executeField(
     const result = resolveFn(source, args, contextValue, info, abortSignal);
 
     if (isPromise(result)) {
-      return completePromisedValue(
+      const { promise, resolve, reject } =
+        promiseWithResolvers<GraphQLWrappedResult<unknown>>();
+      abortSignal?.addEventListener(
+        'abort',
+        () => {
+          try {
+            resolve({
+              rawResult: null,
+              incrementalDataRecords: undefined,
+              errors: [
+                buildFieldError(
+                  abortSignal.reason,
+                  returnType,
+                  fieldDetailsList,
+                  path,
+                ),
+              ],
+            });
+          } catch (error) {
+            reject(error);
+          }
+        },
+        { once: true },
+      );
+      completePromisedValue(
         exeContext,
         returnType,
         fieldDetailsList,
@@ -874,7 +899,9 @@ function executeField(
         result,
         incrementalContext,
         deferMap,
-      );
+        // eslint-disable-next-line @typescript-eslint/use-unknown-in-catch-callback-variable
+      ).then(resolve, reject);
+      return promise;
     }
 
     const completed = completeValue(