@graphql-tools/executor 1.1.0 → 1.2.0-alpha-20230809163713-4e6faf66

package/cjs/execution/execute.js

@@ -2,12 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isIncrementalResult = exports.getFieldDef = exports.flattenIncrementalResults = exports.subscribe = exports.defaultFieldResolver = exports.defaultTypeResolver = exports.buildResolveInfo = exports.buildExecutionContext = exports.getFragmentsFromDocument = exports.assertValidExecutionArguments = exports.executeSync = exports.execute = void 0;
 const graphql_1 = require("graphql");
+const value_or_promise_1 = require("value-or-promise");
 const utils_1 = require("@graphql-tools/utils");
-const values_js_1 = require("./values.js");
-const promiseForObject_js_1 = require("./promiseForObject.js");
 const flattenAsyncIterable_js_1 = require("./flattenAsyncIterable.js");
 const invariant_js_1 = require("./invariant.js");
-const value_or_promise_1 = require("value-or-promise");
+const promiseForObject_js_1 = require("./promiseForObject.js");
+const values_js_1 = require("./values.js");
 /**
  * A memoized collection of relevant subfields with regard to the return
  * type. Memoizing ensures the subfields are not repeatedly calculated, which
@@ -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);
@@ -145,7 +145,9 @@ function buildExecutionContext(args) {
             case graphql_1.Kind.OPERATION_DEFINITION:
                 if (operationName == null) {
                     if (operation !== undefined) {
-                        return [(0, utils_1.createGraphQLError)('Must provide operation name if query contains multiple operations.')];
+                        return [
+                            (0, utils_1.createGraphQLError)('Must provide operation name if query contains multiple operations.'),
+                        ];
                     }
                     operation = definition;
                 }
@@ -184,6 +186,7 @@ function buildExecutionContext(args) {
         subscribeFieldResolver: subscribeFieldResolver ?? exports.defaultFieldResolver,
         subsequentPayloads: new Set(),
         errors: [],
+        signal,
     };
 }
 exports.buildExecutionContext = buildExecutionContext;
@@ -226,13 +229,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 +260,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 +275,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 +301,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 +479,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;
@@ -772,20 +809,24 @@ 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;
         },
-        async next() {
+        next() {
             if (done) {
-                return {
+                return Promise.resolve({
                     value: undefined,
                     done,
-                };
+                });
             }
             if (initialResultSent) {
                 return subsequentIterator.next();
@@ -807,9 +848,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;
@@ -825,7 +866,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],
@@ -851,14 +892,18 @@ function executeSubscription(exeContext) {
     const { schema, fragments, operation, variableValues, rootValue } = exeContext;
     const rootType = schema.getSubscriptionType();
     if (rootType == null) {
-        throw (0, utils_1.createGraphQLError)('Schema is not configured to execute subscription operation.', { nodes: operation });
+        throw (0, utils_1.createGraphQLError)('Schema is not configured to execute subscription operation.', {
+            nodes: operation,
+        });
     }
     const { fields: rootFields } = (0, utils_1.collectFields)(schema, fragments, variableValues, rootType, operation.selectionSet);
     const [responseName, fieldNodes] = [...rootFields.entries()][0];
     const fieldName = fieldNodes[0].name.value;
     const fieldDef = getFieldDef(schema, rootType, fieldNodes[0]);
     if (!fieldDef) {
-        throw (0, utils_1.createGraphQLError)(`The subscription field "${fieldName}" is not defined.`, { nodes: fieldNodes });
+        throw (0, utils_1.createGraphQLError)(`The subscription field "${fieldName}" is not defined.`, {
+            nodes: fieldNodes,
+        });
     }
     const path = (0, utils_1.addPath)(undefined, responseName, rootType.name);
     const info = buildResolveInfo(exeContext, fieldDef, fieldNodes, rootType, path);
@@ -881,13 +926,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;
     }
@@ -895,7 +940,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

@@ -2,8 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.normalizedExecutor = void 0;
 const graphql_1 = require("graphql");
-const execute_js_1 = require("./execute.js");
 const value_or_promise_1 = require("value-or-promise");
+const execute_js_1 = require("./execute.js");
 function normalizedExecutor(args) {
     const operationAST = (0, graphql_1.getOperationAST)(args.document, args.operationName);
     if (operationAST == null) {
@@ -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

@@ -1,10 +1,10 @@
-import { locatedError, Kind, isAbstractType, isLeafType, isListType, isNonNullType, isObjectType, assertValidSchema, getDirectiveValues, SchemaMetaFieldDef, TypeMetaFieldDef, TypeNameMetaFieldDef, GraphQLError, } from 'graphql';
-import { createGraphQLError, inspect, isAsyncIterable, isIterableObject, isObjectLike, isPromise, pathToArray, addPath, getArgumentValues, promiseReduce, memoize3, getDefinedRootType, mapAsyncIterator, GraphQLStreamDirective, collectFields, collectSubFields as _collectSubfields, memoize1, } from '@graphql-tools/utils';
-import { getVariableValues } from './values.js';
-import { promiseForObject } from './promiseForObject.js';
+import { assertValidSchema, getDirectiveValues, GraphQLError, isAbstractType, isLeafType, isListType, isNonNullType, isObjectType, Kind, locatedError, SchemaMetaFieldDef, TypeMetaFieldDef, TypeNameMetaFieldDef, } from 'graphql';
+import { ValueOrPromise } from 'value-or-promise';
+import { collectSubFields as _collectSubfields, addPath, collectFields, createGraphQLError, getArgumentValues, getDefinedRootType, GraphQLStreamDirective, inspect, isAsyncIterable, isIterableObject, isObjectLike, isPromise, mapAsyncIterator, memoize1, memoize3, pathToArray, promiseReduce, } from '@graphql-tools/utils';
 import { flattenAsyncIterable } from './flattenAsyncIterable.js';
 import { invariant } from './invariant.js';
-import { ValueOrPromise } from 'value-or-promise';
+import { promiseForObject } from './promiseForObject.js';
+import { getVariableValues } from './values.js';
 /**
  * A memoized collection of relevant subfields with regard to the return
  * type. Memoizing ensures the subfields are not repeatedly calculated, which
@@ -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);
@@ -139,7 +139,9 @@ export function buildExecutionContext(args) {
             case Kind.OPERATION_DEFINITION:
                 if (operationName == null) {
                     if (operation !== undefined) {
-                        return [createGraphQLError('Must provide operation name if query contains multiple operations.')];
+                        return [
+                            createGraphQLError('Must provide operation name if query contains multiple operations.'),
+                        ];
                     }
                     operation = definition;
                 }
@@ -178,6 +180,7 @@ export function buildExecutionContext(args) {
         subscribeFieldResolver: subscribeFieldResolver ?? defaultFieldResolver,
         subsequentPayloads: new Set(),
         errors: [],
+        signal,
     };
 }
 function buildPerEventExecutionContext(exeContext, payload) {
@@ -219,13 +222,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 +253,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 +268,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 +294,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 +471,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;
@@ -761,20 +798,24 @@ 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;
         },
-        async next() {
+        next() {
             if (done) {
-                return {
+                return Promise.resolve({
                     value: undefined,
                     done,
-                };
+                });
             }
             if (initialResultSent) {
                 return subsequentIterator.next();
@@ -795,9 +836,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;
@@ -813,7 +854,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],
@@ -839,14 +880,18 @@ function executeSubscription(exeContext) {
     const { schema, fragments, operation, variableValues, rootValue } = exeContext;
     const rootType = schema.getSubscriptionType();
     if (rootType == null) {
-        throw createGraphQLError('Schema is not configured to execute subscription operation.', { nodes: operation });
+        throw createGraphQLError('Schema is not configured to execute subscription operation.', {
+            nodes: operation,
+        });
     }
     const { fields: rootFields } = collectFields(schema, fragments, variableValues, rootType, operation.selectionSet);
     const [responseName, fieldNodes] = [...rootFields.entries()][0];
     const fieldName = fieldNodes[0].name.value;
     const fieldDef = getFieldDef(schema, rootType, fieldNodes[0]);
     if (!fieldDef) {
-        throw createGraphQLError(`The subscription field "${fieldName}" is not defined.`, { nodes: fieldNodes });
+        throw createGraphQLError(`The subscription field "${fieldName}" is not defined.`, {
+            nodes: fieldNodes,
+        });
     }
     const path = addPath(undefined, responseName, rootType.name);
     const info = buildResolveInfo(exeContext, fieldDef, fieldNodes, rootType, path);
@@ -869,13 +914,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;
     }
@@ -883,7 +928,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

@@ -1,6 +1,6 @@
 import { getOperationAST } from 'graphql';
-import { execute, flattenIncrementalResults, subscribe } from './execute.js';
 import { ValueOrPromise } from 'value-or-promise';
+import { execute, flattenIncrementalResults, subscribe } from './execute.js';
 export function normalizedExecutor(args) {
     const operationAST = getOperationAST(args.document, args.operationName);
     if (operationAST == null) {
@@ -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/esm/execution/values.js

@@ -1,4 +1,4 @@
-import { print, isInputType, isNonNullType, coerceInputValue, typeFromAST, valueFromAST, } from 'graphql';
+import { coerceInputValue, isInputType, isNonNullType, print, typeFromAST, valueFromAST, } from 'graphql';
 import { createGraphQLError, hasOwnProperty, inspect, printPathArray } from '@graphql-tools/utils';
 /**
  * Prepares an object map of variableValues of the correct type based on the

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "@graphql-tools/executor",
-  "version": "1.1.0",
+  "version": "1.2.0-alpha-20230809163713-4e6faf66",
   "sideEffects": false,
   "peerDependencies": {
     "graphql": "^14.0.0 || ^15.0.0 || ^16.0.0 || ^17.0.0"
   },
   "dependencies": {
-    "@repeaterjs/repeater": "^3.0.4",
     "@graphql-tools/utils": "^10.0.0",
     "@graphql-typed-document-node/core": "3.2.0",
+    "@repeaterjs/repeater": "^3.0.4",
     "tslib": "^2.4.0",
     "value-or-promise": "^1.0.12"
   },

package/typings/execution/execute.d.cts

@@ -1,5 +1,5 @@
-import { GraphQLFormattedError, FieldNode, FragmentDefinitionNode, OperationDefinitionNode, GraphQLField, GraphQLFieldResolver, GraphQLObjectType, GraphQLResolveInfo, GraphQLTypeResolver, GraphQLSchema, DocumentNode, GraphQLError } from 'graphql';
-import { Path, Maybe, MaybePromise } from '@graphql-tools/utils';
+import { DocumentNode, FieldNode, FragmentDefinitionNode, GraphQLError, GraphQLField, GraphQLFieldResolver, GraphQLFormattedError, GraphQLObjectType, GraphQLResolveInfo, GraphQLSchema, GraphQLTypeResolver, OperationDefinitionNode } from 'graphql';
+import { Maybe, MaybePromise, Path } from '@graphql-tools/utils';
 import { TypedDocumentNode } from '@graphql-typed-document-node/core';
 export interface SingularExecutionResult<TData = any, TExtensions = any> {
     errors?: ReadonlyArray<GraphQLError>;
@@ -43,6 +43,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>;
@@ -107,6 +108,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,
@@ -202,7 +204,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

@@ -1,5 +1,5 @@
-import { GraphQLFormattedError, FieldNode, FragmentDefinitionNode, OperationDefinitionNode, GraphQLField, GraphQLFieldResolver, GraphQLObjectType, GraphQLResolveInfo, GraphQLTypeResolver, GraphQLSchema, DocumentNode, GraphQLError } from 'graphql';
-import { Path, Maybe, MaybePromise } from '@graphql-tools/utils';
+import { DocumentNode, FieldNode, FragmentDefinitionNode, GraphQLError, GraphQLField, GraphQLFieldResolver, GraphQLFormattedError, GraphQLObjectType, GraphQLResolveInfo, GraphQLSchema, GraphQLTypeResolver, OperationDefinitionNode } from 'graphql';
+import { Maybe, MaybePromise, Path } from '@graphql-tools/utils';
 import { TypedDocumentNode } from '@graphql-typed-document-node/core';
 export interface SingularExecutionResult<TData = any, TExtensions = any> {
     errors?: ReadonlyArray<GraphQLError>;
@@ -43,6 +43,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>;
@@ -107,6 +108,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,
@@ -202,7 +204,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/normalizedExecutor.d.cts

@@ -1,3 +1,3 @@
-import { MaybeAsyncIterable, ExecutionResult, MaybePromise } from '@graphql-tools/utils';
+import { ExecutionResult, MaybeAsyncIterable, MaybePromise } from '@graphql-tools/utils';
 import { ExecutionArgs } from './execute.cjs';
 export declare function normalizedExecutor<TData = any, TVariables = any, TContext = any>(args: ExecutionArgs<TData, TVariables, TContext>): MaybePromise<MaybeAsyncIterable<ExecutionResult<TData>>>;

package/typings/execution/normalizedExecutor.d.ts

@@ -1,3 +1,3 @@
-import { MaybeAsyncIterable, ExecutionResult, MaybePromise } from '@graphql-tools/utils';
+import { ExecutionResult, MaybeAsyncIterable, MaybePromise } from '@graphql-tools/utils';
 import { ExecutionArgs } from './execute.js';
 export declare function normalizedExecutor<TData = any, TVariables = any, TContext = any>(args: ExecutionArgs<TData, TVariables, TContext>): MaybePromise<MaybeAsyncIterable<ExecutionResult<TData>>>;

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 {};

package/typings/execution/values.d.cts

@@ -1,4 +1,4 @@
-import { GraphQLError, VariableDefinitionNode, GraphQLSchema } from 'graphql';
+import { GraphQLError, GraphQLSchema, VariableDefinitionNode } from 'graphql';
 type CoercedVariableValues = {
     errors: ReadonlyArray<GraphQLError>;
     coerced?: never;

package/typings/execution/values.d.ts

@@ -1,4 +1,4 @@
-import { GraphQLError, VariableDefinitionNode, GraphQLSchema } from 'graphql';
+import { GraphQLError, GraphQLSchema, VariableDefinitionNode } from 'graphql';
 type CoercedVariableValues = {
     errors: ReadonlyArray<GraphQLError>;
     coerced?: never;