stop resolvers after execution ends

addresses: #3792

src/execution/__tests__/nonnull-test.ts

@@ -2,6 +2,7 @@ import { expect } from 'chai';
 import { describe, it } from 'mocha';
 
 import { expectJSON } from '../../__testUtils__/expectJSON.js';
+import { resolveOnNextTick } from '../../__testUtils__/resolveOnNextTick.js';
 
 import type { PromiseOrValue } from '../../jsutils/PromiseOrValue.js';
 
@@ -526,6 +527,68 @@ describe('Execute: handles non-nullable types', () => {
     });
   });
 
+  describe('cancellation with null bubbling', () => {
+    function nestedPromise(n: number): string {
+      return n > 0 ? `promiseNest { ${nestedPromise(n - 1)} }` : 'promise';
+    }
+
+    it('returns an single error without cancellation', async () => {
+      const query = `
+        {
+          promiseNonNull,
+          ${nestedPromise(4)}
+        }
+      `;
+
+      const result = await executeQuery(query, throwingData);
+      expectJSON(result).toDeepEqual({
+        data: null,
+        errors: [
+          // does not include syncNullError because result returns prior to it being added
+          {
+            message: 'promiseNonNull',
+            path: ['promiseNonNull'],
+            locations: [{ line: 3, column: 11 }],
+          },
+        ],
+      });
+    });
+
+    it('stops running despite error', async () => {
+      const query = `
+        {
+          promiseNonNull,
+          ${nestedPromise(10)}
+        }
+      `;
+
+      let counter = 0;
+      const rootValue = {
+        ...throwingData,
+        promiseNest() {
+          return new Promise((resolve) => {
+            counter++;
+            resolve(rootValue);
+          });
+        },
+      };
+      const result = await executeQuery(query, rootValue);
+      expectJSON(result).toDeepEqual({
+        data: null,
+        errors: [
+          {
+            message: 'promiseNonNull',
+            path: ['promiseNonNull'],
+            locations: [{ line: 3, column: 11 }],
+          },
+        ],
+      });
+      const counterAtExecutionEnd = counter;
+      await resolveOnNextTick();
+      expect(counter).to.equal(counterAtExecutionEnd);
+    });
+  });
+
   describe('Handles non-null argument', () => {
     const schemaWithNonNullArg = new GraphQLSchema({
       query: new GraphQLObjectType({

src/execution/execute.ts

@@ -163,10 +163,12 @@ export interface ValidatedExecutionArgs {
 
 export interface ExecutionContext {
   validatedExecutionArgs: ValidatedExecutionArgs;
+  completed: boolean;
   cancellableStreams: Set<CancellableStreamRecord> | undefined;
 }
 
 interface IncrementalContext {
+  completed: boolean;
   deferUsageSet?: DeferUsageSet | undefined;
 }
 
@@ -312,6 +314,7 @@ export function experimentalExecuteQueryOrMutationOrSubscriptionEvent(
 ): PromiseOrValue<ExecutionResult | ExperimentalIncrementalExecutionResults> {
   const exeContext: ExecutionContext = {
     validatedExecutionArgs,
+    completed: false,
     cancellableStreams: undefined,
   };
   try {
@@ -362,15 +365,23 @@ export function experimentalExecuteQueryOrMutationOrSubscriptionEvent(
 
     if (isPromise(graphqlWrappedResult)) {
       return graphqlWrappedResult.then(
-        (resolved) => buildDataResponse(exeContext, resolved),
-        (error: unknown) => ({
-          data: null,
-          errors: [error as GraphQLError],
-        }),
+        (resolved) => {
+          exeContext.completed = true;
+          return buildDataResponse(exeContext, resolved);
+        },
+        (error: unknown) => {
+          exeContext.completed = true;
+          return {
+            data: null,
+            errors: [error as GraphQLError],
+          };
+        },
       );
     }
+    exeContext.completed = true;
     return buildDataResponse(exeContext, graphqlWrappedResult);
   } catch (error) {
+    exeContext.completed = true;
     return { data: null, errors: [error] };
   }
 }
@@ -1019,6 +1030,14 @@ function completeValue(
   incrementalContext: IncrementalContext | undefined,
   deferMap: ReadonlyMap<DeferUsage, DeferredFragmentRecord> | undefined,
 ): PromiseOrValue<GraphQLWrappedResult<unknown>> {
+  if ((incrementalContext ?? exeContext).completed) {
+    return {
+      rawResult: null,
+      incrementalDataRecords: undefined,
+      errors: undefined,
+    };
+  }
+
   // If result is an Error, throw a located error.
   if (result instanceof Error) {
     throw result;
@@ -2279,6 +2298,7 @@ function collectExecutionGroups(
         path,
         groupedFieldSet,
         {
+          completed: false,
           deferUsageSet,
         },
         deferMap,
@@ -2338,6 +2358,7 @@ function executeExecutionGroup(
       deferMap,
     );
   } catch (error) {
+    incrementalContext.completed = true;
     return {
       pendingExecutionGroup,
       path: pathToArray(path),
@@ -2347,16 +2368,26 @@ function executeExecutionGroup(
 
   if (isPromise(result)) {
     return result.then(
-      (resolved) =>
-        buildCompletedExecutionGroup(pendingExecutionGroup, path, resolved),
-      (error: unknown) => ({
-        pendingExecutionGroup,
-        path: pathToArray(path),
-        errors: [error as GraphQLError],
-      }),
+      (resolved) => {
+        incrementalContext.completed = true;
+        return buildCompletedExecutionGroup(
+          pendingExecutionGroup,
+          path,
+          resolved,
+        );
+      },
+      (error: unknown) => {
+        incrementalContext.completed = true;
+        return {
+          pendingExecutionGroup,
+          path: pathToArray(path),
+          errors: [error as GraphQLError],
+        };
+      },
     );
   }
 
+  incrementalContext.completed = true;
   return buildCompletedExecutionGroup(pendingExecutionGroup, path, result);
 }
 
@@ -2405,7 +2436,7 @@ function buildSyncStreamItemQueue(
         initialPath,
         initialItem,
         exeContext,
-        {},
+        { completed: false },
         fieldDetailsList,
         info,
         itemType,
@@ -2436,7 +2467,7 @@ function buildSyncStreamItemQueue(
           itemPath,
           value,
           exeContext,
-          {},
+          { completed: false },
           fieldDetailsList,
           info,
           itemType,
@@ -2528,7 +2559,7 @@ async function getNextAsyncStreamItemResult(
     itemPath,
     iteration.value,
     exeContext,
-    {},
+    { completed: false },
     fieldDetailsList,
     info,
     itemType,
@@ -2575,10 +2606,16 @@ function completeStreamItem(
       incrementalContext,
       new Map(),
     ).then(
-      (resolvedItem) => buildStreamItemResult(resolvedItem),
-      (error: unknown) => ({
-        errors: [error as GraphQLError],
-      }),
+      (resolvedItem) => {
+        incrementalContext.completed = true;
+        return buildStreamItemResult(resolvedItem);
+      },
+      (error: unknown) => {
+        incrementalContext.completed = true;
+        return {
+          errors: [error as GraphQLError],
+        };
+      },
     );
   }
 
@@ -2605,6 +2642,7 @@ function completeStreamItem(
       };
     }
   } catch (error) {
+    incrementalContext.completed = true;
     return {
       errors: [error],
     };
@@ -2620,13 +2658,20 @@ function completeStreamItem(
         ],
       }))
       .then(
-        (resolvedItem) => buildStreamItemResult(resolvedItem),
-        (error: unknown) => ({
-          errors: [error as GraphQLError],
-        }),
+        (resolvedItem) => {
+          incrementalContext.completed = true;
+          return buildStreamItemResult(resolvedItem);
+        },
+        (error: unknown) => {
+          incrementalContext.completed = true;
+          return {
+            errors: [error as GraphQLError],
+          };
+        },
       );
   }
 
+  incrementalContext.completed = true;
   return buildStreamItemResult(result);
 }