WIP

Author: JoviDeCroock

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

@@ -0,0 +1,221 @@
+import { expect } from 'chai';
+import { describe, it } from 'mocha';
+
+import { expectJSON } from '../../__testUtils__/expectJSON.js';
+import { resolveOnNextTick } from '../../__testUtils__/resolveOnNextTick.js';
+
+import { parse } from '../../language/parser.js';
+
+import {
+  GraphQLObjectType,
+  GraphQLSchema,
+  GraphQLString,
+} from '../../type/index.js';
+
+import { buildSchema } from '../../utilities/buildASTSchema.js';
+
+import { execute } from '../execute.js';
+
+const schema = buildSchema(/* GraphQL */ `
+  type Todo {
+    id: ID!
+    text: String!
+    completed: Boolean!
+    author: User
+  }
+
+  type User {
+    id: ID!
+    name: String!
+  }
+
+  type Query {
+    todo: Todo
+  }
+
+  type Mutation {
+    foo: String
+    bar: String
+  }
+`);
+
+describe('Abort Signal', () => {
+  it('should stop the execution when aborted in resolver', async () => {
+    const abortController = new AbortController();
+    const document = parse(/* GraphQL */ `
+      query {
+        todo {
+          id
+          author {
+            id
+          }
+        }
+      }
+    `);
+    const result = await execute({
+      document,
+      schema,
+      abortSignal: abortController.signal,
+      rootValue: {
+        todo() {
+          abortController.abort('Aborted');
+          return {
+            id: '1',
+            text: 'Hello, World!',
+            completed: false,
+            /* c8 ignore next 3 */
+            author: () => {
+              expect.fail('Should not be called');
+            },
+          };
+        },
+      },
+    });
+
+    expectJSON(result).toDeepEqual({
+      data: {
+        todo: null,
+      },
+      errors: [
+        {
+          locations: [
+            {
+              column: 9,
+              line: 3,
+            },
+          ],
+          message: 'Aborted',
+          path: ['todo'],
+        },
+      ],
+    });
+  });
+
+  it('should stop the for serial mutation execution', async () => {
+    const abortController = new AbortController();
+    const document = parse(/* GraphQL */ `
+      mutation {
+        foo
+        bar
+      }
+    `);
+    const result = await execute({
+      document,
+      schema,
+      abortSignal: abortController.signal,
+      rootValue: {
+        foo() {
+          abortController.abort('Aborted');
+          return 'baz';
+        },
+        /* c8 ignore next 3 */
+        bar() {
+          expect.fail('Should not be called');
+        },
+      },
+    });
+
+    expectJSON(result).toDeepEqual({
+      data: null,
+      errors: [
+        {
+          message: 'Aborted',
+        },
+      ],
+    });
+  });
+
+  it('should stop the execution when aborted pre-execute', async () => {
+    const abortController = new AbortController();
+    const document = parse(/* GraphQL */ `
+      query {
+        todo {
+          id
+          author {
+            id
+          }
+        }
+      }
+    `);
+    abortController.abort('Aborted');
+    const result = await execute({
+      document,
+      schema,
+      abortSignal: abortController.signal,
+      rootValue: {
+        /* c8 ignore next 3 */
+        todo() {
+          return {};
+        },
+      },
+    });
+
+    expectJSON(result).toDeepEqual({
+      data: null,
+      errors: [
+        {
+          message: 'Aborted',
+        },
+      ],
+    });
+  });
+
+  it('exits early on abort mid-execution', async () => {
+    const asyncObjectType = new GraphQLObjectType({
+      name: 'AsyncObject',
+      fields: {
+        field: {
+          type: GraphQLString,
+          /* c8 ignore next 3 */
+          resolve() {
+            expect.fail('Should not be called');
+          },
+        },
+      },
+    });
+
+    const newSchema = new GraphQLSchema({
+      query: new GraphQLObjectType({
+        name: 'Query',
+        fields: {
+          asyncObject: {
+            type: asyncObjectType,
+            async resolve() {
+              await resolveOnNextTick();
+              return {};
+            },
+          },
+        },
+      }),
+    });
+
+    const document = parse(`
+      {
+        asyncObject {
+          field
+        }
+      }
+    `);
+
+    const abortController = new AbortController();
+
+    const result = execute({
+      schema: newSchema,
+      document,
+      abortSignal: abortController.signal,
+    });
+
+    abortController.abort();
+
+    expectJSON(await result).toDeepEqual({
+      data: { asyncObject: null },
+      errors: [
+        {
+          message: 'AbortError: This operation was aborted',
+          locations: [{ line: 3, column: 9 }],
+          path: ['asyncObject'],
+        },
+      ],
+    });
+  });
+});

src/execution/execute.ts

@@ -157,12 +157,14 @@ export interface ValidatedExecutionArgs {
   ) => PromiseOrValue<ExecutionResult>;
   enableEarlyExecution: boolean;
   hideSuggestions: boolean;
+  abortSignal: AbortSignal | undefined;
 }
 
 export interface ExecutionContext {
   validatedExecutionArgs: ValidatedExecutionArgs;
   errors: Array<GraphQLError> | undefined;
   cancellableStreams: Set<CancellableStreamRecord> | undefined;
+  abortSignal: AbortSignal | undefined;
 }
 
 interface IncrementalContext {
@@ -187,6 +189,7 @@ export interface ExecutionArgs {
   >;
   enableEarlyExecution?: Maybe<boolean>;
   hideSuggestions?: Maybe<boolean>;
+  abortSignal?: AbortSignal | undefined;
 }
 
 export interface StreamUsage {
@@ -309,6 +312,7 @@ export function experimentalExecuteQueryOrMutationOrSubscriptionEvent(
     validatedExecutionArgs,
     errors: undefined,
     cancellableStreams: undefined,
+    abortSignal: validatedExecutionArgs.abortSignal,
   };
   try {
     const {
@@ -318,7 +322,13 @@ export function experimentalExecuteQueryOrMutationOrSubscriptionEvent(
       operation,
       variableValues,
       hideSuggestions,
+      abortSignal,
     } = validatedExecutionArgs;
+
+    if (abortSignal?.aborted) {
+      throw new GraphQLError(abortSignal.reason);
+    }
+
     const rootType = schema.getRootType(operation.operation);
     if (rootType == null) {
       throw new GraphQLError(
@@ -592,6 +602,7 @@ export function validateExecutionArgs(
     perEventExecutor: perEventExecutor ?? executeSubscriptionEvent,
     enableEarlyExecution: enableEarlyExecution === true,
     hideSuggestions,
+    abortSignal: args.abortSignal,
   };
 }
 
@@ -656,6 +667,9 @@ function executeFieldsSerially(
     groupedFieldSet,
     (graphqlWrappedResult, [responseName, fieldDetailsList]) => {
       const fieldPath = addPath(path, responseName, parentType.name);
+      if (exeContext.abortSignal?.aborted) {
+        throw new GraphQLError(exeContext.abortSignal.reason);
+      }
       const result = executeField(
         exeContext,
         parentType,
@@ -706,6 +720,12 @@ function executeFields(
   try {
     for (const [responseName, fieldDetailsList] of groupedFieldSet) {
       const fieldPath = addPath(path, responseName, parentType.name);
+
+      if (exeContext.abortSignal?.aborted) {
+        // We might want to leverage a GraphQL error here
+        throw new GraphQLError(exeContext.abortSignal.reason);
+      }
+
       const result = executeField(
         exeContext,
         parentType,
@@ -1069,6 +1089,7 @@ async function completePromisedValue(
     if (isPromise(completed)) {
       completed = await completed;
     }
+
     return completed;
   } catch (rawError) {
     handleFieldError(