@graphql-tools/executor 1.0.0 → 1.1.0-alpha-20230522102854-674fb2cd

package/cjs/execution/execute.js

@@ -135,7 +135,7 @@ exports.getFragmentsFromDocument = (0, utils_1.memoize1)(function getFragmentsFr
  * @internal
  */
 function buildExecutionContext(args) {
-    const { schema, document, rootValue, contextValue, variableValues: rawVariableValues, operationName, fieldResolver, typeResolver, subscribeFieldResolver, } = args;
+    const { schema, document, rootValue, contextValue, variableValues: rawVariableValues, operationName, fieldResolver, typeResolver, subscribeFieldResolver, signal, } = args;
     // If the schema used for execution is invalid, throw an error.
     (0, graphql_1.assertValidSchema)(schema);
     const fragments = (0, exports.getFragmentsFromDocument)(document);
@@ -184,6 +184,7 @@ function buildExecutionContext(args) {
         subscribeFieldResolver: subscribeFieldResolver ?? exports.defaultFieldResolver,
         subsequentPayloads: new Set(),
         errors: [],
+        signal,
     };
 }
 exports.buildExecutionContext = buildExecutionContext;
@@ -226,13 +227,26 @@ function executeOperation(exeContext) {
  * for fields that must be executed serially.
  */
 function executeFieldsSerially(exeContext, parentType, sourceValue, path, fields) {
+    let abortErrorThrown = false;
     return (0, utils_1.promiseReduce)(fields, (results, [responseName, fieldNodes]) => {
         const fieldPath = (0, utils_1.addPath)(path, responseName, parentType.name);
+        if (exeContext.signal?.aborted) {
+            results[responseName] = null;
+            return results;
+        }
         return new value_or_promise_1.ValueOrPromise(() => executeField(exeContext, parentType, sourceValue, fieldNodes, fieldPath)).then(result => {
             if (result === undefined) {
                 return results;
             }
             results[responseName] = result;
+            if (exeContext.signal?.aborted && !abortErrorThrown) {
+                exeContext.errors.push((0, utils_1.createGraphQLError)('Execution aborted', {
+                    nodes: fieldNodes,
+                    path: (0, utils_1.pathToArray)(fieldPath),
+                    originalError: exeContext.signal?.reason,
+                }));
+                abortErrorThrown = true;
+            }
             return results;
         });
     }, Object.create(null)).resolve();
@@ -244,8 +258,13 @@ function executeFieldsSerially(exeContext, parentType, sourceValue, path, fields
 function executeFields(exeContext, parentType, sourceValue, path, fields, asyncPayloadRecord) {
     const results = Object.create(null);
     let containsPromise = false;
+    let abortErrorThrown = false;
     try {
         for (const [responseName, fieldNodes] of fields) {
+            if (exeContext.signal?.aborted) {
+                results[responseName] = null;
+                continue;
+            }
             const fieldPath = (0, utils_1.addPath)(path, responseName, parentType.name);
             const result = executeField(exeContext, parentType, sourceValue, fieldNodes, fieldPath, asyncPayloadRecord);
             if (result !== undefined) {
@@ -254,12 +273,20 @@ function executeFields(exeContext, parentType, sourceValue, path, fields, asyncP
                     containsPromise = true;
                 }
             }
+            if (exeContext.signal?.aborted && !abortErrorThrown) {
+                exeContext.errors.push((0, utils_1.createGraphQLError)('Execution aborted', {
+                    nodes: fieldNodes,
+                    path: (0, utils_1.pathToArray)(fieldPath),
+                    originalError: exeContext.signal?.reason,
+                }));
+                abortErrorThrown = true;
+            }
         }
     }
     catch (error) {
         if (containsPromise) {
             // Ensure that any promises returned by other fields are handled, as they may also reject.
-            return (0, promiseForObject_js_1.promiseForObject)(results).finally(() => {
+            return (0, promiseForObject_js_1.promiseForObject)(results, exeContext.signal).finally(() => {
                 throw error;
             });
         }
@@ -272,7 +299,7 @@ function executeFields(exeContext, parentType, sourceValue, path, fields, asyncP
     // Otherwise, results is a map from field name to the result of resolving that
     // field, which is possibly a promise. Return a promise that will return this
     // same map, but with any promises replaced with the values they resolved to.
-    return (0, promiseForObject_js_1.promiseForObject)(results);
+    return (0, promiseForObject_js_1.promiseForObject)(results, exeContext.signal);
 }
 /**
  * Implements the "Executing fields" section of the spec
@@ -450,6 +477,14 @@ function getStreamValues(exeContext, fieldNodes, path) {
  * recursively until all the results are completed.
  */
 async function completeAsyncIteratorValue(exeContext, itemType, fieldNodes, info, path, iterator, asyncPayloadRecord) {
+    exeContext.signal?.addEventListener('abort', () => {
+        iterator.return?.();
+        exeContext.errors.push((0, utils_1.createGraphQLError)('Execution aborted', {
+            nodes: fieldNodes,
+            path: (0, utils_1.pathToArray)(path),
+            originalError: exeContext.signal?.reason,
+        }));
+    });
     const errors = asyncPayloadRecord?.errors ?? exeContext.errors;
     const stream = getStreamValues(exeContext, fieldNodes, path);
     let containsPromise = false;
@@ -759,10 +794,14 @@ function subscribe(args) {
     return mapSourceToResponse(exeContext, resultOrStream);
 }
 exports.subscribe = subscribe;
-function flattenIncrementalResults(incrementalResults) {
+function flattenIncrementalResults(incrementalResults, signal) {
     const subsequentIterator = incrementalResults.subsequentResults;
     let initialResultSent = false;
     let done = false;
+    signal?.addEventListener('abort', () => {
+        done = true;
+        subsequentIterator.throw?.(signal?.reason);
+    });
     return {
         [Symbol.asyncIterator]() {
             return this;
@@ -794,9 +833,9 @@ function flattenIncrementalResults(incrementalResults) {
     };
 }
 exports.flattenIncrementalResults = flattenIncrementalResults;
-async function* ensureAsyncIterable(someExecutionResult) {
+async function* ensureAsyncIterable(someExecutionResult, signal) {
     if ('initialResult' in someExecutionResult) {
-        yield* flattenIncrementalResults(someExecutionResult);
+        yield* flattenIncrementalResults(someExecutionResult, signal);
     }
     else {
         yield someExecutionResult;
@@ -812,7 +851,7 @@ function mapSourceToResponse(exeContext, resultOrStream) {
     // the GraphQL specification. The `execute` function provides the
     // "ExecuteSubscriptionEvent" algorithm, as it is nearly identical to the
     // "ExecuteQuery" algorithm, for which `execute` is also used.
-    return (0, flattenAsyncIterable_js_1.flattenAsyncIterable)((0, utils_1.mapAsyncIterator)(resultOrStream[Symbol.asyncIterator](), async (payload) => ensureAsyncIterable(await executeImpl(buildPerEventExecutionContext(exeContext, payload))), async function* (error) {
+    return (0, flattenAsyncIterable_js_1.flattenAsyncIterable)((0, utils_1.mapAsyncIterator)(resultOrStream[Symbol.asyncIterator](), async (payload) => ensureAsyncIterable(await executeImpl(buildPerEventExecutionContext(exeContext, payload)), exeContext.signal), async function* (error) {
         const wrappedError = (0, utils_1.createGraphQLError)(error.message, {
             originalError: error,
             nodes: [exeContext.operation],
@@ -868,13 +907,13 @@ function executeSubscription(exeContext) {
                 throw (0, graphql_1.locatedError)(error, fieldNodes, (0, utils_1.pathToArray)(path));
             });
         }
-        return assertEventStream(result);
+        return assertEventStream(result, exeContext.signal);
     }
     catch (error) {
         throw (0, graphql_1.locatedError)(error, fieldNodes, (0, utils_1.pathToArray)(path));
     }
 }
-function assertEventStream(result) {
+function assertEventStream(result, signal) {
     if (result instanceof Error) {
         throw result;
     }
@@ -882,7 +921,15 @@ function assertEventStream(result) {
     if (!(0, utils_1.isAsyncIterable)(result)) {
         throw (0, utils_1.createGraphQLError)('Subscription field must return Async Iterable. ' + `Received: ${(0, utils_1.inspect)(result)}.`);
     }
-    return result;
+    return {
+        [Symbol.asyncIterator]() {
+            const asyncIterator = result[Symbol.asyncIterator]();
+            signal?.addEventListener('abort', () => {
+                asyncIterator.return?.();
+            });
+            return asyncIterator;
+        },
+    };
 }
 function executeDeferredFragment(exeContext, parentType, sourceValue, fields, label, path, parentContext) {
     const asyncPayloadRecord = new DeferredFragmentRecord({

package/cjs/execution/normalizedExecutor.js

@@ -15,7 +15,7 @@ function normalizedExecutor(args) {
     return new value_or_promise_1.ValueOrPromise(() => (0, execute_js_1.execute)(args))
         .then((result) => {
         if ('initialResult' in result) {
-            return (0, execute_js_1.flattenIncrementalResults)(result);
+            return (0, execute_js_1.flattenIncrementalResults)(result, args.signal);
         }
         return result;
     })

package/cjs/execution/promiseForObject.js

@@ -8,11 +8,16 @@ exports.promiseForObject = void 0;
  * This is akin to bluebird's `Promise.props`, but implemented only using
  * `Promise.all` so it will work with any implementation of ES6 promises.
  */
-async function promiseForObject(object) {
+async function promiseForObject(object, signal) {
     const resolvedObject = Object.create(null);
-    await Promise.all(Object.entries(object).map(async ([key, value]) => {
-        resolvedObject[key] = await value;
-    }));
+    await new Promise((resolve, reject) => {
+        signal?.addEventListener('abort', () => {
+            resolve();
+        });
+        Promise.all(Object.entries(object).map(async ([key, value]) => {
+            resolvedObject[key] = await value;
+        })).then(() => resolve(), reject);
+    });
     return resolvedObject;
 }
 exports.promiseForObject = promiseForObject;

package/esm/execution/execute.js

@@ -129,7 +129,7 @@ export const getFragmentsFromDocument = memoize1(function getFragmentsFromDocume
  * @internal
  */
 export function buildExecutionContext(args) {
-    const { schema, document, rootValue, contextValue, variableValues: rawVariableValues, operationName, fieldResolver, typeResolver, subscribeFieldResolver, } = args;
+    const { schema, document, rootValue, contextValue, variableValues: rawVariableValues, operationName, fieldResolver, typeResolver, subscribeFieldResolver, signal, } = args;
     // If the schema used for execution is invalid, throw an error.
     assertValidSchema(schema);
     const fragments = getFragmentsFromDocument(document);
@@ -178,6 +178,7 @@ export function buildExecutionContext(args) {
         subscribeFieldResolver: subscribeFieldResolver ?? defaultFieldResolver,
         subsequentPayloads: new Set(),
         errors: [],
+        signal,
     };
 }
 function buildPerEventExecutionContext(exeContext, payload) {
@@ -219,13 +220,26 @@ function executeOperation(exeContext) {
  * for fields that must be executed serially.
  */
 function executeFieldsSerially(exeContext, parentType, sourceValue, path, fields) {
+    let abortErrorThrown = false;
     return promiseReduce(fields, (results, [responseName, fieldNodes]) => {
         const fieldPath = addPath(path, responseName, parentType.name);
+        if (exeContext.signal?.aborted) {
+            results[responseName] = null;
+            return results;
+        }
         return new ValueOrPromise(() => executeField(exeContext, parentType, sourceValue, fieldNodes, fieldPath)).then(result => {
             if (result === undefined) {
                 return results;
             }
             results[responseName] = result;
+            if (exeContext.signal?.aborted && !abortErrorThrown) {
+                exeContext.errors.push(createGraphQLError('Execution aborted', {
+                    nodes: fieldNodes,
+                    path: pathToArray(fieldPath),
+                    originalError: exeContext.signal?.reason,
+                }));
+                abortErrorThrown = true;
+            }
             return results;
         });
     }, Object.create(null)).resolve();
@@ -237,8 +251,13 @@ function executeFieldsSerially(exeContext, parentType, sourceValue, path, fields
 function executeFields(exeContext, parentType, sourceValue, path, fields, asyncPayloadRecord) {
     const results = Object.create(null);
     let containsPromise = false;
+    let abortErrorThrown = false;
     try {
         for (const [responseName, fieldNodes] of fields) {
+            if (exeContext.signal?.aborted) {
+                results[responseName] = null;
+                continue;
+            }
             const fieldPath = addPath(path, responseName, parentType.name);
             const result = executeField(exeContext, parentType, sourceValue, fieldNodes, fieldPath, asyncPayloadRecord);
             if (result !== undefined) {
@@ -247,12 +266,20 @@ function executeFields(exeContext, parentType, sourceValue, path, fields, asyncP
                     containsPromise = true;
                 }
             }
+            if (exeContext.signal?.aborted && !abortErrorThrown) {
+                exeContext.errors.push(createGraphQLError('Execution aborted', {
+                    nodes: fieldNodes,
+                    path: pathToArray(fieldPath),
+                    originalError: exeContext.signal?.reason,
+                }));
+                abortErrorThrown = true;
+            }
         }
     }
     catch (error) {
         if (containsPromise) {
             // Ensure that any promises returned by other fields are handled, as they may also reject.
-            return promiseForObject(results).finally(() => {
+            return promiseForObject(results, exeContext.signal).finally(() => {
                 throw error;
             });
         }
@@ -265,7 +292,7 @@ function executeFields(exeContext, parentType, sourceValue, path, fields, asyncP
     // Otherwise, results is a map from field name to the result of resolving that
     // field, which is possibly a promise. Return a promise that will return this
     // same map, but with any promises replaced with the values they resolved to.
-    return promiseForObject(results);
+    return promiseForObject(results, exeContext.signal);
 }
 /**
  * Implements the "Executing fields" section of the spec
@@ -442,6 +469,14 @@ function getStreamValues(exeContext, fieldNodes, path) {
  * recursively until all the results are completed.
  */
 async function completeAsyncIteratorValue(exeContext, itemType, fieldNodes, info, path, iterator, asyncPayloadRecord) {
+    exeContext.signal?.addEventListener('abort', () => {
+        iterator.return?.();
+        exeContext.errors.push(createGraphQLError('Execution aborted', {
+            nodes: fieldNodes,
+            path: pathToArray(path),
+            originalError: exeContext.signal?.reason,
+        }));
+    });
     const errors = asyncPayloadRecord?.errors ?? exeContext.errors;
     const stream = getStreamValues(exeContext, fieldNodes, path);
     let containsPromise = false;
@@ -748,10 +783,14 @@ export function subscribe(args) {
     }
     return mapSourceToResponse(exeContext, resultOrStream);
 }
-export function flattenIncrementalResults(incrementalResults) {
+export function flattenIncrementalResults(incrementalResults, signal) {
     const subsequentIterator = incrementalResults.subsequentResults;
     let initialResultSent = false;
     let done = false;
+    signal?.addEventListener('abort', () => {
+        done = true;
+        subsequentIterator.throw?.(signal?.reason);
+    });
     return {
         [Symbol.asyncIterator]() {
             return this;
@@ -782,9 +821,9 @@ export function flattenIncrementalResults(incrementalResults) {
         },
     };
 }
-async function* ensureAsyncIterable(someExecutionResult) {
+async function* ensureAsyncIterable(someExecutionResult, signal) {
     if ('initialResult' in someExecutionResult) {
-        yield* flattenIncrementalResults(someExecutionResult);
+        yield* flattenIncrementalResults(someExecutionResult, signal);
     }
     else {
         yield someExecutionResult;
@@ -800,7 +839,7 @@ function mapSourceToResponse(exeContext, resultOrStream) {
     // the GraphQL specification. The `execute` function provides the
     // "ExecuteSubscriptionEvent" algorithm, as it is nearly identical to the
     // "ExecuteQuery" algorithm, for which `execute` is also used.
-    return flattenAsyncIterable(mapAsyncIterator(resultOrStream[Symbol.asyncIterator](), async (payload) => ensureAsyncIterable(await executeImpl(buildPerEventExecutionContext(exeContext, payload))), async function* (error) {
+    return flattenAsyncIterable(mapAsyncIterator(resultOrStream[Symbol.asyncIterator](), async (payload) => ensureAsyncIterable(await executeImpl(buildPerEventExecutionContext(exeContext, payload)), exeContext.signal), async function* (error) {
         const wrappedError = createGraphQLError(error.message, {
             originalError: error,
             nodes: [exeContext.operation],
@@ -856,13 +895,13 @@ function executeSubscription(exeContext) {
                 throw locatedError(error, fieldNodes, pathToArray(path));
             });
         }
-        return assertEventStream(result);
+        return assertEventStream(result, exeContext.signal);
     }
     catch (error) {
         throw locatedError(error, fieldNodes, pathToArray(path));
     }
 }
-function assertEventStream(result) {
+function assertEventStream(result, signal) {
     if (result instanceof Error) {
         throw result;
     }
@@ -870,7 +909,15 @@ function assertEventStream(result) {
     if (!isAsyncIterable(result)) {
         throw createGraphQLError('Subscription field must return Async Iterable. ' + `Received: ${inspect(result)}.`);
     }
-    return result;
+    return {
+        [Symbol.asyncIterator]() {
+            const asyncIterator = result[Symbol.asyncIterator]();
+            signal?.addEventListener('abort', () => {
+                asyncIterator.return?.();
+            });
+            return asyncIterator;
+        },
+    };
 }
 function executeDeferredFragment(exeContext, parentType, sourceValue, fields, label, path, parentContext) {
     const asyncPayloadRecord = new DeferredFragmentRecord({

package/esm/execution/normalizedExecutor.js

@@ -12,7 +12,7 @@ export function normalizedExecutor(args) {
     return new ValueOrPromise(() => execute(args))
         .then((result) => {
         if ('initialResult' in result) {
-            return flattenIncrementalResults(result);
+            return flattenIncrementalResults(result, args.signal);
         }
         return result;
     })

package/esm/execution/promiseForObject.js

@@ -5,10 +5,15 @@
  * This is akin to bluebird's `Promise.props`, but implemented only using
  * `Promise.all` so it will work with any implementation of ES6 promises.
  */
-export async function promiseForObject(object) {
+export async function promiseForObject(object, signal) {
     const resolvedObject = Object.create(null);
-    await Promise.all(Object.entries(object).map(async ([key, value]) => {
-        resolvedObject[key] = await value;
-    }));
+    await new Promise((resolve, reject) => {
+        signal?.addEventListener('abort', () => {
+            resolve();
+        });
+        Promise.all(Object.entries(object).map(async ([key, value]) => {
+            resolvedObject[key] = await value;
+        })).then(() => resolve(), reject);
+    });
     return resolvedObject;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@graphql-tools/executor",
-  "version": "1.0.0",
+  "version": "1.1.0-alpha-20230522102854-674fb2cd",
   "sideEffects": false,
   "peerDependencies": {
     "graphql": "^14.0.0 || ^15.0.0 || ^16.0.0 || ^17.0.0"

package/typings/execution/execute.d.cts

@@ -44,6 +44,7 @@ export interface ExecutionContext<TVariables = any, TContext = any> {
     subscribeFieldResolver: GraphQLFieldResolver<any, TContext>;
     errors: Array<GraphQLError>;
     subsequentPayloads: Set<AsyncPayloadRecord>;
+    signal?: AbortSignal;
 }
 export interface FormattedExecutionResult<TData = Record<string, unknown>, TExtensions = Record<string, unknown>> {
     errors?: ReadonlyArray<GraphQLFormattedError>;
@@ -108,6 +109,7 @@ export interface ExecutionArgs<TData = any, TVariables = any, TContext = any> {
     fieldResolver?: Maybe<GraphQLFieldResolver<any, TContext>>;
     typeResolver?: Maybe<GraphQLTypeResolver<any, TContext>>;
     subscribeFieldResolver?: Maybe<GraphQLFieldResolver<any, TContext>>;
+    signal?: AbortSignal;
 }
 /**
  * Implements the "Executing requests" section of the GraphQL specification,
@@ -203,7 +205,7 @@ export declare const defaultFieldResolver: GraphQLFieldResolver<unknown, unknown
  * Accepts an object with named arguments.
  */
 export declare function subscribe<TData = any, TVariables = any, TContext = any>(args: ExecutionArgs<TData, TVariables, TContext>): MaybePromise<AsyncGenerator<SingularExecutionResult<TData> | InitialIncrementalExecutionResult<TData> | SubsequentIncrementalExecutionResult<TData>, void, void> | SingularExecutionResult<TData>>;
-export declare function flattenIncrementalResults<TData>(incrementalResults: IncrementalExecutionResults<TData>): AsyncGenerator<SubsequentIncrementalExecutionResult<TData, Record<string, unknown>>, void, void>;
+export declare function flattenIncrementalResults<TData>(incrementalResults: IncrementalExecutionResults<TData>, signal?: AbortSignal): AsyncGenerator<SubsequentIncrementalExecutionResult<TData, Record<string, unknown>>, void, void>;
 declare class DeferredFragmentRecord {
     type: 'defer';
     errors: Array<GraphQLError>;

package/typings/execution/execute.d.ts

@@ -44,6 +44,7 @@ export interface ExecutionContext<TVariables = any, TContext = any> {
     subscribeFieldResolver: GraphQLFieldResolver<any, TContext>;
     errors: Array<GraphQLError>;
     subsequentPayloads: Set<AsyncPayloadRecord>;
+    signal?: AbortSignal;
 }
 export interface FormattedExecutionResult<TData = Record<string, unknown>, TExtensions = Record<string, unknown>> {
     errors?: ReadonlyArray<GraphQLFormattedError>;
@@ -108,6 +109,7 @@ export interface ExecutionArgs<TData = any, TVariables = any, TContext = any> {
     fieldResolver?: Maybe<GraphQLFieldResolver<any, TContext>>;
     typeResolver?: Maybe<GraphQLTypeResolver<any, TContext>>;
     subscribeFieldResolver?: Maybe<GraphQLFieldResolver<any, TContext>>;
+    signal?: AbortSignal;
 }
 /**
  * Implements the "Executing requests" section of the GraphQL specification,
@@ -203,7 +205,7 @@ export declare const defaultFieldResolver: GraphQLFieldResolver<unknown, unknown
  * Accepts an object with named arguments.
  */
 export declare function subscribe<TData = any, TVariables = any, TContext = any>(args: ExecutionArgs<TData, TVariables, TContext>): MaybePromise<AsyncGenerator<SingularExecutionResult<TData> | InitialIncrementalExecutionResult<TData> | SubsequentIncrementalExecutionResult<TData>, void, void> | SingularExecutionResult<TData>>;
-export declare function flattenIncrementalResults<TData>(incrementalResults: IncrementalExecutionResults<TData>): AsyncGenerator<SubsequentIncrementalExecutionResult<TData, Record<string, unknown>>, void, void>;
+export declare function flattenIncrementalResults<TData>(incrementalResults: IncrementalExecutionResults<TData>, signal?: AbortSignal): AsyncGenerator<SubsequentIncrementalExecutionResult<TData, Record<string, unknown>>, void, void>;
 declare class DeferredFragmentRecord {
     type: 'defer';
     errors: Array<GraphQLError>;

package/typings/execution/promiseForObject.d.cts

@@ -8,5 +8,5 @@ type ResolvedObject<TData> = {
  * This is akin to bluebird's `Promise.props`, but implemented only using
  * `Promise.all` so it will work with any implementation of ES6 promises.
  */
-export declare function promiseForObject<TData>(object: TData): Promise<ResolvedObject<TData>>;
+export declare function promiseForObject<TData>(object: TData, signal?: AbortSignal): Promise<ResolvedObject<TData>>;
 export {};

package/typings/execution/promiseForObject.d.ts

@@ -8,5 +8,5 @@ type ResolvedObject<TData> = {
  * This is akin to bluebird's `Promise.props`, but implemented only using
  * `Promise.all` so it will work with any implementation of ES6 promises.
  */
-export declare function promiseForObject<TData>(object: TData): Promise<ResolvedObject<TData>>;
+export declare function promiseForObject<TData>(object: TData, signal?: AbortSignal): Promise<ResolvedObject<TData>>;
 export {};