@graphql-tools/executor 2.0.0-alpha-20240620175016-1a4246713c9c2dcf5e3debfccfa47e0efd992528 → 2.0.0-alpha-20240702150657-b50b1dda80c0083a63896cdbfd42efdcdf4c0b98

package/cjs/execution/collectFields.js

@@ -14,7 +14,7 @@ const invariant_js_1 = require("./invariant.js");
  *
  * @internal
  */
-function collectFields(schema, fragments, variableValues, runtimeType, operation) {
+function collectFields(schema, fragments, variableValues, runtimeType, selectionSet, errorWithIncrementalSubscription) {
     const groupedFieldSet = new AccumulatorMap_js_1.AccumulatorMap();
     const newDeferUsages = [];
     const context = {
@@ -22,10 +22,10 @@ function collectFields(schema, fragments, variableValues, runtimeType, operation
         fragments,
         variableValues,
         runtimeType,
-        operation,
+        errorWithIncrementalSubscription,
         visitedFragmentNames: new Set(),
     };
-    collectFieldsImpl(context, operation.selectionSet, groupedFieldSet, newDeferUsages);
+    collectFieldsImpl(context, selectionSet, groupedFieldSet, newDeferUsages);
     return { groupedFieldSet, newDeferUsages };
 }
 exports.collectFields = collectFields;
@@ -39,13 +39,13 @@ exports.collectFields = collectFields;
  *
  * @internal
  */
-function collectSubfields(schema, fragments, variableValues, operation, returnType, fieldGroup) {
+function collectSubfields(schema, fragments, variableValues, errorWithIncrementalSubscription, returnType, fieldGroup) {
     const context = {
         schema,
         fragments,
         variableValues,
         runtimeType: returnType,
-        operation,
+        errorWithIncrementalSubscription,
         visitedFragmentNames: new Set(),
     };
     const subGroupedFieldSet = new AccumulatorMap_js_1.AccumulatorMap();
@@ -63,7 +63,7 @@ function collectSubfields(schema, fragments, variableValues, operation, returnTy
 }
 exports.collectSubfields = collectSubfields;
 function collectFieldsImpl(context, selectionSet, groupedFieldSet, newDeferUsages, deferUsage) {
-    const { schema, fragments, variableValues, runtimeType, operation, visitedFragmentNames } = context;
+    const { schema, fragments, variableValues, runtimeType, errorWithIncrementalSubscription, visitedFragmentNames, } = context;
     for (const selection of selectionSet.selections) {
         switch (selection.kind) {
             case graphql_1.Kind.FIELD: {
@@ -81,7 +81,7 @@ function collectFieldsImpl(context, selectionSet, groupedFieldSet, newDeferUsage
                     !doesFragmentConditionMatch(schema, selection, runtimeType)) {
                     continue;
                 }
-                const newDeferUsage = getDeferUsage(operation, variableValues, selection, deferUsage);
+                const newDeferUsage = getDeferUsage(errorWithIncrementalSubscription, variableValues, selection, deferUsage);
                 if (!newDeferUsage) {
                     collectFieldsImpl(context, selection.selectionSet, groupedFieldSet, newDeferUsages, deferUsage);
                 }
@@ -93,7 +93,7 @@ function collectFieldsImpl(context, selectionSet, groupedFieldSet, newDeferUsage
             }
             case graphql_1.Kind.FRAGMENT_SPREAD: {
                 const fragName = selection.name.value;
-                const newDeferUsage = getDeferUsage(operation, variableValues, selection, deferUsage);
+                const newDeferUsage = getDeferUsage(errorWithIncrementalSubscription, variableValues, selection, deferUsage);
                 if (!newDeferUsage &&
                     (visitedFragmentNames.has(fragName) || !shouldIncludeNode(variableValues, selection))) {
                     continue;
@@ -120,7 +120,7 @@ function collectFieldsImpl(context, selectionSet, groupedFieldSet, newDeferUsage
  * deferred based on the experimental flag, defer directive present and
  * not disabled by the "if" argument.
  */
-function getDeferUsage(operation, variableValues, node, parentDeferUsage) {
+function getDeferUsage(errorWithIncrementalSubscription, variableValues, node, parentDeferUsage) {
     const defer = (0, graphql_1.getDirectiveValues)(utils_1.GraphQLDeferDirective, node, variableValues);
     if (!defer) {
         return;
@@ -128,7 +128,7 @@ function getDeferUsage(operation, variableValues, node, parentDeferUsage) {
     if (defer['if'] === false) {
         return;
     }
-    (0, invariant_js_1.invariant)(operation.operation !== 'subscription', '`@defer` directive not supported on subscription operations. Disable `@defer` by setting the `if` argument to `false`.');
+    (0, invariant_js_1.invariant)(!errorWithIncrementalSubscription, '`@defer` directive not supported on subscription operations. Disable `@defer` by setting the `if` argument to `false`.');
     return {
         label: typeof defer['label'] === 'string' ? defer['label'] : undefined,
         parentDeferUsage,

package/cjs/execution/execute.js

@@ -7,6 +7,7 @@ const BoxedPromiseOrValue_js_1 = require("./BoxedPromiseOrValue.js");
 const buildFieldPlan_js_1 = require("./buildFieldPlan.js");
 const coerceError_js_1 = require("./coerceError.js");
 const collectFields_js_1 = require("./collectFields.js");
+const flattenAsyncIterable_js_1 = require("./flattenAsyncIterable.js");
 const IncrementalPublisher_js_1 = require("./IncrementalPublisher.js");
 const invariant_js_1 = require("./invariant.js");
 const promiseForObject_js_1 = require("./promiseForObject.js");
@@ -17,7 +18,7 @@ const values_js_1 = require("./values.js");
  * type. Memoizing ensures the subfields are not repeatedly calculated, which
  * saves overhead when resolving lists of values.
  */
-const collectSubfields = (0, utils_1.memoize3)((exeContext, returnType, fieldGroup) => (0, collectFields_js_1.collectSubfields)(exeContext.schema, exeContext.fragments, exeContext.variableValues, exeContext.operation, returnType, fieldGroup));
+const collectSubfields = (0, utils_1.memoize3)((exeContext, returnType, fieldGroup) => (0, collectFields_js_1.collectSubfields)(exeContext.schema, exeContext.fragments, exeContext.variableValues, exeContext.errorWithIncrementalSubscription, returnType, fieldGroup));
 /**
  * Implements the "Executing requests" section of the GraphQL specification,
  * including `@defer` and `@stream` as proposed in
@@ -149,7 +150,7 @@ exports.getFragmentsFromDocument = (0, utils_1.memoize1)(function getFragmentsFr
  * @internal
  */
 function buildExecutionContext(args) {
-    const { schema, document, rootValue, contextValue, variableValues: rawVariableValues, operationName, fieldResolver, typeResolver, subscribeFieldResolver, enableEarlyExecution, signal, } = args;
+    const { schema, document, rootValue, contextValue, variableValues: rawVariableValues, operationName, fieldResolver, typeResolver, subscribeFieldResolver, enableEarlyExecution, errorWithIncrementalSubscription, signal, } = args;
     // If the schema used for execution is invalid, throw an error.
     (0, graphql_1.assertValidSchema)(schema);
     const fragments = (0, exports.getFragmentsFromDocument)(document);
@@ -199,6 +200,7 @@ function buildExecutionContext(args) {
         typeResolver: typeResolver ?? exports.defaultTypeResolver,
         subscribeFieldResolver: subscribeFieldResolver ?? exports.defaultFieldResolver,
         enableEarlyExecution: enableEarlyExecution !== false,
+        errorWithIncrementalSubscription: operation.operation === 'subscription' && errorWithIncrementalSubscription !== false,
         signal,
         errors: undefined,
         cancellableStreams: undefined,
@@ -221,14 +223,14 @@ function executeOperation(exeContext) {
         throw exeContext.signal.reason;
     }
     try {
-        const { operation, schema, fragments, variableValues, rootValue } = exeContext;
+        const { operation, schema, fragments, variableValues, rootValue, errorWithIncrementalSubscription, } = exeContext;
         const rootType = (0, utils_1.getDefinedRootType)(schema, operation.operation, [operation]);
         if (rootType == null) {
             (0, utils_1.createGraphQLError)(`Schema is not configured to execute ${operation.operation} operation.`, {
                 nodes: operation,
             });
         }
-        const collectedFields = (0, collectFields_js_1.collectFields)(schema, fragments, variableValues, rootType, operation);
+        const collectedFields = (0, collectFields_js_1.collectFields)(schema, fragments, variableValues, rootType, operation.selectionSet, errorWithIncrementalSubscription);
         let groupedFieldSet = collectedFields.groupedFieldSet;
         const newDeferUsages = collectedFields.newDeferUsages;
         let data;
@@ -537,7 +539,7 @@ function getStreamUsage(exeContext, fieldGroup, path) {
     }
     (0, invariant_js_1.invariant)(typeof stream['initialCount'] === 'number', 'initialCount must be a number');
     (0, invariant_js_1.invariant)(stream['initialCount'] >= 0, 'initialCount must be a positive integer');
-    (0, invariant_js_1.invariant)(exeContext.operation.operation !== 'subscription', '`@stream` directive not supported on subscription operations. Disable `@stream` by setting the `if` argument to `false`.');
+    (0, invariant_js_1.invariant)(!exeContext.errorWithIncrementalSubscription, '`@stream` directive not supported on subscription operations. Disable `@stream` by setting the `if` argument to `false`.');
     const streamedFieldGroup = fieldGroup.map(fieldDetails => ({
         node: fieldDetails.node,
         deferUsage: undefined,
@@ -908,39 +910,6 @@ const defaultFieldResolver = function (source, args, contextValue, info) {
     }
 };
 exports.defaultFieldResolver = defaultFieldResolver;
-/**
- * Implements the "Subscribe" algorithm described in the GraphQL specification,
- * including `@defer` and `@stream` as proposed in
- * https://github.com/graphql/graphql-spec/pull/742
- *
- * Returns a Promise which resolves to either an AsyncIterator (if successful)
- * or an ExecutionResult (error). The promise will be rejected if the schema or
- * other arguments to this function are invalid, or if the resolved event stream
- * is not an async iterable.
- *
- * If the client-provided arguments to this function do not result in a
- * compliant subscription, a GraphQL Response (ExecutionResult) with descriptive
- * errors and no data will be returned.
- *
- * If the source stream could not be created due to faulty subscription resolver
- * logic or underlying systems, the promise will resolve to a single
- * ExecutionResult containing `errors` and no `data`.
- *
- * If the operation succeeded, the promise resolves to an AsyncIterator, which
- * yields a stream of result representing the response stream.
- *
- * Each result may be an ExecutionResult with no `hasNext` (if executing the
- * event did not use `@defer` or `@stream`), or an
- * `InitialIncrementalExecutionResult` or `SubsequentIncrementalExecutionResult`
- * (if executing the event used `@defer` or `@stream`). In the case of
- * incremental execution results, each event produces a single
- * `InitialIncrementalExecutionResult` followed by one or more
- * `SubsequentIncrementalExecutionResult`s; all but the last have `hasNext: true`,
- * and the last has `hasNext: false`. There is no interleaving between results
- * generated from the same original event.
- *
- * Accepts an object with named arguments.
- */
 function subscribe(args) {
     // If a valid execution context cannot be created due to incorrect arguments,
     // a "Response" with only errors is returned.
@@ -1004,6 +973,14 @@ function flattenIncrementalResults(incrementalResults) {
     };
 }
 exports.flattenIncrementalResults = flattenIncrementalResults;
+async function* ensureAsyncIterable(someExecutionResult) {
+    if ('initialResult' in someExecutionResult) {
+        yield* flattenIncrementalResults(someExecutionResult);
+    }
+    else {
+        yield someExecutionResult;
+    }
+}
 function mapSourceToResponse(exeContext, resultOrStream) {
     if (!(0, utils_1.isAsyncIterable)(resultOrStream)) {
         return resultOrStream;
@@ -1014,13 +991,13 @@ 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, utils_1.mapAsyncIterator)(resultOrStream[Symbol.asyncIterator](), (payload) => executeOperation(buildPerEventExecutionContext(exeContext, payload)), (error) => {
+    return (0, flattenAsyncIterable_js_1.flattenAsyncIterable)((0, utils_1.mapAsyncIterator)(resultOrStream[Symbol.asyncIterator](), async (payload) => ensureAsyncIterable(await executeOperation(buildPerEventExecutionContext(exeContext, payload))), (error) => {
         const wrappedError = (0, utils_1.createGraphQLError)(error.message, {
             originalError: error,
             nodes: [exeContext.operation],
         });
         throw wrappedError;
-    });
+    }));
 }
 function createSourceEventStreamImpl(exeContext) {
     try {
@@ -1035,14 +1012,14 @@ function createSourceEventStreamImpl(exeContext) {
     }
 }
 function executeSubscription(exeContext) {
-    const { schema, fragments, operation, variableValues, rootValue } = exeContext;
+    const { schema, fragments, operation, variableValues, rootValue, errorWithIncrementalSubscription, } = exeContext;
     const rootType = schema.getSubscriptionType();
     if (rootType == null) {
         throw (0, utils_1.createGraphQLError)('Schema is not configured to execute subscription operation.', {
             nodes: operation,
         });
     }
-    const { groupedFieldSet } = (0, collectFields_js_1.collectFields)(schema, fragments, variableValues, rootType, operation);
+    const { groupedFieldSet } = (0, collectFields_js_1.collectFields)(schema, fragments, variableValues, rootType, operation.selectionSet, errorWithIncrementalSubscription);
     const firstRootField = [...groupedFieldSet.entries()][0];
     const [responseName, fieldGroup] = firstRootField;
     const fieldName = fieldGroup[0].node.name.value;

package/cjs/execution/flattenAsyncIterable.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.flattenAsyncIterable = void 0;
+/**
+ * Given an AsyncIterable of AsyncIterables, flatten all yielded results into a
+ * single AsyncIterable.
+ */
+function flattenAsyncIterable(iterable) {
+    // You might think this whole function could be replaced with
+    //
+    //    async function* flattenAsyncIterable(iterable) {
+    //      for await (const subIterator of iterable) {
+    //        yield* subIterator;
+    //      }
+    //    }
+    //
+    // but calling `.return()` on the iterator it returns won't interrupt the `for await`.
+    const topIterator = iterable[Symbol.asyncIterator]();
+    let currentNestedIterator;
+    let waitForCurrentNestedIterator;
+    let done = false;
+    async function next() {
+        if (done) {
+            return { value: undefined, done: true };
+        }
+        try {
+            if (!currentNestedIterator) {
+                // Somebody else is getting it already.
+                if (waitForCurrentNestedIterator) {
+                    await waitForCurrentNestedIterator;
+                    return await next();
+                }
+                // Nobody else is getting it. We should!
+                let resolve;
+                waitForCurrentNestedIterator = new Promise(r => {
+                    resolve = r;
+                });
+                const topIteratorResult = await topIterator.next();
+                if (topIteratorResult.done) {
+                    // Given that done only ever transitions from false to true,
+                    // require-atomic-updates is being unnecessarily cautious.
+                    done = true;
+                    return await next();
+                }
+                // eslint is making a reasonable point here, but we've explicitly protected
+                // ourself from the race condition by ensuring that only the single call
+                // that assigns to waitForCurrentNestedIterator is allowed to assign to
+                // currentNestedIterator or waitForCurrentNestedIterator.
+                currentNestedIterator = topIteratorResult.value[Symbol.asyncIterator]();
+                waitForCurrentNestedIterator = undefined;
+                resolve();
+                return await next();
+            }
+            const rememberCurrentNestedIterator = currentNestedIterator;
+            const nestedIteratorResult = await currentNestedIterator.next();
+            if (!nestedIteratorResult.done) {
+                return nestedIteratorResult;
+            }
+            // The nested iterator is done. If it's still the current one, make it not
+            // current. (If it's not the current one, somebody else has made us move on.)
+            if (currentNestedIterator === rememberCurrentNestedIterator) {
+                currentNestedIterator = undefined;
+            }
+            return await next();
+        }
+        catch (err) {
+            done = true;
+            throw err;
+        }
+    }
+    return {
+        next,
+        async return() {
+            done = true;
+            await Promise.all([currentNestedIterator?.return?.(), topIterator.return?.()]);
+            return { value: undefined, done: true };
+        },
+        async throw(error) {
+            done = true;
+            await Promise.all([currentNestedIterator?.throw?.(error), topIterator.throw?.(error)]);
+            /* c8 ignore next */
+            throw error;
+        },
+        [Symbol.asyncIterator]() {
+            return this;
+        },
+    };
+}
+exports.flattenAsyncIterable = flattenAsyncIterable;

package/esm/execution/collectFields.js

@@ -11,7 +11,7 @@ import { invariant } from './invariant.js';
  *
  * @internal
  */
-export function collectFields(schema, fragments, variableValues, runtimeType, operation) {
+export function collectFields(schema, fragments, variableValues, runtimeType, selectionSet, errorWithIncrementalSubscription) {
     const groupedFieldSet = new AccumulatorMap();
     const newDeferUsages = [];
     const context = {
@@ -19,10 +19,10 @@ export function collectFields(schema, fragments, variableValues, runtimeType, op
         fragments,
         variableValues,
         runtimeType,
-        operation,
+        errorWithIncrementalSubscription,
         visitedFragmentNames: new Set(),
     };
-    collectFieldsImpl(context, operation.selectionSet, groupedFieldSet, newDeferUsages);
+    collectFieldsImpl(context, selectionSet, groupedFieldSet, newDeferUsages);
     return { groupedFieldSet, newDeferUsages };
 }
 /**
@@ -35,13 +35,13 @@ export function collectFields(schema, fragments, variableValues, runtimeType, op
  *
  * @internal
  */
-export function collectSubfields(schema, fragments, variableValues, operation, returnType, fieldGroup) {
+export function collectSubfields(schema, fragments, variableValues, errorWithIncrementalSubscription, returnType, fieldGroup) {
     const context = {
         schema,
         fragments,
         variableValues,
         runtimeType: returnType,
-        operation,
+        errorWithIncrementalSubscription,
         visitedFragmentNames: new Set(),
     };
     const subGroupedFieldSet = new AccumulatorMap();
@@ -58,7 +58,7 @@ export function collectSubfields(schema, fragments, variableValues, operation, r
     };
 }
 function collectFieldsImpl(context, selectionSet, groupedFieldSet, newDeferUsages, deferUsage) {
-    const { schema, fragments, variableValues, runtimeType, operation, visitedFragmentNames } = context;
+    const { schema, fragments, variableValues, runtimeType, errorWithIncrementalSubscription, visitedFragmentNames, } = context;
     for (const selection of selectionSet.selections) {
         switch (selection.kind) {
             case Kind.FIELD: {
@@ -76,7 +76,7 @@ function collectFieldsImpl(context, selectionSet, groupedFieldSet, newDeferUsage
                     !doesFragmentConditionMatch(schema, selection, runtimeType)) {
                     continue;
                 }
-                const newDeferUsage = getDeferUsage(operation, variableValues, selection, deferUsage);
+                const newDeferUsage = getDeferUsage(errorWithIncrementalSubscription, variableValues, selection, deferUsage);
                 if (!newDeferUsage) {
                     collectFieldsImpl(context, selection.selectionSet, groupedFieldSet, newDeferUsages, deferUsage);
                 }
@@ -88,7 +88,7 @@ function collectFieldsImpl(context, selectionSet, groupedFieldSet, newDeferUsage
             }
             case Kind.FRAGMENT_SPREAD: {
                 const fragName = selection.name.value;
-                const newDeferUsage = getDeferUsage(operation, variableValues, selection, deferUsage);
+                const newDeferUsage = getDeferUsage(errorWithIncrementalSubscription, variableValues, selection, deferUsage);
                 if (!newDeferUsage &&
                     (visitedFragmentNames.has(fragName) || !shouldIncludeNode(variableValues, selection))) {
                     continue;
@@ -115,7 +115,7 @@ function collectFieldsImpl(context, selectionSet, groupedFieldSet, newDeferUsage
  * deferred based on the experimental flag, defer directive present and
  * not disabled by the "if" argument.
  */
-function getDeferUsage(operation, variableValues, node, parentDeferUsage) {
+function getDeferUsage(errorWithIncrementalSubscription, variableValues, node, parentDeferUsage) {
     const defer = getDirectiveValues(GraphQLDeferDirective, node, variableValues);
     if (!defer) {
         return;
@@ -123,7 +123,7 @@ function getDeferUsage(operation, variableValues, node, parentDeferUsage) {
     if (defer['if'] === false) {
         return;
     }
-    invariant(operation.operation !== 'subscription', '`@defer` directive not supported on subscription operations. Disable `@defer` by setting the `if` argument to `false`.');
+    invariant(!errorWithIncrementalSubscription, '`@defer` directive not supported on subscription operations. Disable `@defer` by setting the `if` argument to `false`.');
     return {
         label: typeof defer['label'] === 'string' ? defer['label'] : undefined,
         parentDeferUsage,

package/esm/execution/execute.js

@@ -4,6 +4,7 @@ import { BoxedPromiseOrValue } from './BoxedPromiseOrValue.js';
 import { buildFieldPlan } from './buildFieldPlan.js';
 import { coerceError } from './coerceError.js';
 import { collectSubfields as _collectSubfields, collectFields, } from './collectFields.js';
+import { flattenAsyncIterable } from './flattenAsyncIterable.js';
 import { buildIncrementalResponse } from './IncrementalPublisher.js';
 import { invariant } from './invariant.js';
 import { promiseForObject } from './promiseForObject.js';
@@ -14,7 +15,7 @@ import { getVariableValues } from './values.js';
  * type. Memoizing ensures the subfields are not repeatedly calculated, which
  * saves overhead when resolving lists of values.
  */
-const collectSubfields = memoize3((exeContext, returnType, fieldGroup) => _collectSubfields(exeContext.schema, exeContext.fragments, exeContext.variableValues, exeContext.operation, returnType, fieldGroup));
+const collectSubfields = memoize3((exeContext, returnType, fieldGroup) => _collectSubfields(exeContext.schema, exeContext.fragments, exeContext.variableValues, exeContext.errorWithIncrementalSubscription, returnType, fieldGroup));
 /**
  * Implements the "Executing requests" section of the GraphQL specification,
  * including `@defer` and `@stream` as proposed in
@@ -143,7 +144,7 @@ export const getFragmentsFromDocument = memoize1(function getFragmentsFromDocume
  * @internal
  */
 export function buildExecutionContext(args) {
-    const { schema, document, rootValue, contextValue, variableValues: rawVariableValues, operationName, fieldResolver, typeResolver, subscribeFieldResolver, enableEarlyExecution, signal, } = args;
+    const { schema, document, rootValue, contextValue, variableValues: rawVariableValues, operationName, fieldResolver, typeResolver, subscribeFieldResolver, enableEarlyExecution, errorWithIncrementalSubscription, signal, } = args;
     // If the schema used for execution is invalid, throw an error.
     assertValidSchema(schema);
     const fragments = getFragmentsFromDocument(document);
@@ -193,6 +194,7 @@ export function buildExecutionContext(args) {
         typeResolver: typeResolver ?? defaultTypeResolver,
         subscribeFieldResolver: subscribeFieldResolver ?? defaultFieldResolver,
         enableEarlyExecution: enableEarlyExecution !== false,
+        errorWithIncrementalSubscription: operation.operation === 'subscription' && errorWithIncrementalSubscription !== false,
         signal,
         errors: undefined,
         cancellableStreams: undefined,
@@ -214,14 +216,14 @@ function executeOperation(exeContext) {
         throw exeContext.signal.reason;
     }
     try {
-        const { operation, schema, fragments, variableValues, rootValue } = exeContext;
+        const { operation, schema, fragments, variableValues, rootValue, errorWithIncrementalSubscription, } = exeContext;
         const rootType = getDefinedRootType(schema, operation.operation, [operation]);
         if (rootType == null) {
             createGraphQLError(`Schema is not configured to execute ${operation.operation} operation.`, {
                 nodes: operation,
             });
         }
-        const collectedFields = collectFields(schema, fragments, variableValues, rootType, operation);
+        const collectedFields = collectFields(schema, fragments, variableValues, rootType, operation.selectionSet, errorWithIncrementalSubscription);
         let groupedFieldSet = collectedFields.groupedFieldSet;
         const newDeferUsages = collectedFields.newDeferUsages;
         let data;
@@ -529,7 +531,7 @@ function getStreamUsage(exeContext, fieldGroup, path) {
     }
     invariant(typeof stream['initialCount'] === 'number', 'initialCount must be a number');
     invariant(stream['initialCount'] >= 0, 'initialCount must be a positive integer');
-    invariant(exeContext.operation.operation !== 'subscription', '`@stream` directive not supported on subscription operations. Disable `@stream` by setting the `if` argument to `false`.');
+    invariant(!exeContext.errorWithIncrementalSubscription, '`@stream` directive not supported on subscription operations. Disable `@stream` by setting the `if` argument to `false`.');
     const streamedFieldGroup = fieldGroup.map(fieldDetails => ({
         node: fieldDetails.node,
         deferUsage: undefined,
@@ -898,39 +900,6 @@ export const defaultFieldResolver = function (source, args, contextValue, info)
         return property;
     }
 };
-/**
- * Implements the "Subscribe" algorithm described in the GraphQL specification,
- * including `@defer` and `@stream` as proposed in
- * https://github.com/graphql/graphql-spec/pull/742
- *
- * Returns a Promise which resolves to either an AsyncIterator (if successful)
- * or an ExecutionResult (error). The promise will be rejected if the schema or
- * other arguments to this function are invalid, or if the resolved event stream
- * is not an async iterable.
- *
- * If the client-provided arguments to this function do not result in a
- * compliant subscription, a GraphQL Response (ExecutionResult) with descriptive
- * errors and no data will be returned.
- *
- * If the source stream could not be created due to faulty subscription resolver
- * logic or underlying systems, the promise will resolve to a single
- * ExecutionResult containing `errors` and no `data`.
- *
- * If the operation succeeded, the promise resolves to an AsyncIterator, which
- * yields a stream of result representing the response stream.
- *
- * Each result may be an ExecutionResult with no `hasNext` (if executing the
- * event did not use `@defer` or `@stream`), or an
- * `InitialIncrementalExecutionResult` or `SubsequentIncrementalExecutionResult`
- * (if executing the event used `@defer` or `@stream`). In the case of
- * incremental execution results, each event produces a single
- * `InitialIncrementalExecutionResult` followed by one or more
- * `SubsequentIncrementalExecutionResult`s; all but the last have `hasNext: true`,
- * and the last has `hasNext: false`. There is no interleaving between results
- * generated from the same original event.
- *
- * Accepts an object with named arguments.
- */
 export function subscribe(args) {
     // If a valid execution context cannot be created due to incorrect arguments,
     // a "Response" with only errors is returned.
@@ -992,6 +961,14 @@ export function flattenIncrementalResults(incrementalResults) {
         },
     };
 }
+async function* ensureAsyncIterable(someExecutionResult) {
+    if ('initialResult' in someExecutionResult) {
+        yield* flattenIncrementalResults(someExecutionResult);
+    }
+    else {
+        yield someExecutionResult;
+    }
+}
 function mapSourceToResponse(exeContext, resultOrStream) {
     if (!isAsyncIterable(resultOrStream)) {
         return resultOrStream;
@@ -1002,13 +979,13 @@ 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 mapAsyncIterator(resultOrStream[Symbol.asyncIterator](), (payload) => executeOperation(buildPerEventExecutionContext(exeContext, payload)), (error) => {
+    return flattenAsyncIterable(mapAsyncIterator(resultOrStream[Symbol.asyncIterator](), async (payload) => ensureAsyncIterable(await executeOperation(buildPerEventExecutionContext(exeContext, payload))), (error) => {
         const wrappedError = createGraphQLError(error.message, {
             originalError: error,
             nodes: [exeContext.operation],
         });
         throw wrappedError;
-    });
+    }));
 }
 function createSourceEventStreamImpl(exeContext) {
     try {
@@ -1023,14 +1000,14 @@ function createSourceEventStreamImpl(exeContext) {
     }
 }
 function executeSubscription(exeContext) {
-    const { schema, fragments, operation, variableValues, rootValue } = exeContext;
+    const { schema, fragments, operation, variableValues, rootValue, errorWithIncrementalSubscription, } = exeContext;
     const rootType = schema.getSubscriptionType();
     if (rootType == null) {
         throw createGraphQLError('Schema is not configured to execute subscription operation.', {
             nodes: operation,
         });
     }
-    const { groupedFieldSet } = collectFields(schema, fragments, variableValues, rootType, operation);
+    const { groupedFieldSet } = collectFields(schema, fragments, variableValues, rootType, operation.selectionSet, errorWithIncrementalSubscription);
     const firstRootField = [...groupedFieldSet.entries()][0];
     const [responseName, fieldGroup] = firstRootField;
     const fieldName = fieldGroup[0].node.name.value;

package/esm/execution/flattenAsyncIterable.js

@@ -0,0 +1,85 @@
+/**
+ * Given an AsyncIterable of AsyncIterables, flatten all yielded results into a
+ * single AsyncIterable.
+ */
+export function flattenAsyncIterable(iterable) {
+    // You might think this whole function could be replaced with
+    //
+    //    async function* flattenAsyncIterable(iterable) {
+    //      for await (const subIterator of iterable) {
+    //        yield* subIterator;
+    //      }
+    //    }
+    //
+    // but calling `.return()` on the iterator it returns won't interrupt the `for await`.
+    const topIterator = iterable[Symbol.asyncIterator]();
+    let currentNestedIterator;
+    let waitForCurrentNestedIterator;
+    let done = false;
+    async function next() {
+        if (done) {
+            return { value: undefined, done: true };
+        }
+        try {
+            if (!currentNestedIterator) {
+                // Somebody else is getting it already.
+                if (waitForCurrentNestedIterator) {
+                    await waitForCurrentNestedIterator;
+                    return await next();
+                }
+                // Nobody else is getting it. We should!
+                let resolve;
+                waitForCurrentNestedIterator = new Promise(r => {
+                    resolve = r;
+                });
+                const topIteratorResult = await topIterator.next();
+                if (topIteratorResult.done) {
+                    // Given that done only ever transitions from false to true,
+                    // require-atomic-updates is being unnecessarily cautious.
+                    done = true;
+                    return await next();
+                }
+                // eslint is making a reasonable point here, but we've explicitly protected
+                // ourself from the race condition by ensuring that only the single call
+                // that assigns to waitForCurrentNestedIterator is allowed to assign to
+                // currentNestedIterator or waitForCurrentNestedIterator.
+                currentNestedIterator = topIteratorResult.value[Symbol.asyncIterator]();
+                waitForCurrentNestedIterator = undefined;
+                resolve();
+                return await next();
+            }
+            const rememberCurrentNestedIterator = currentNestedIterator;
+            const nestedIteratorResult = await currentNestedIterator.next();
+            if (!nestedIteratorResult.done) {
+                return nestedIteratorResult;
+            }
+            // The nested iterator is done. If it's still the current one, make it not
+            // current. (If it's not the current one, somebody else has made us move on.)
+            if (currentNestedIterator === rememberCurrentNestedIterator) {
+                currentNestedIterator = undefined;
+            }
+            return await next();
+        }
+        catch (err) {
+            done = true;
+            throw err;
+        }
+    }
+    return {
+        next,
+        async return() {
+            done = true;
+            await Promise.all([currentNestedIterator?.return?.(), topIterator.return?.()]);
+            return { value: undefined, done: true };
+        },
+        async throw(error) {
+            done = true;
+            await Promise.all([currentNestedIterator?.throw?.(error), topIterator.throw?.(error)]);
+            /* c8 ignore next */
+            throw error;
+        },
+        [Symbol.asyncIterator]() {
+            return this;
+        },
+    };
+}

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@graphql-tools/executor",
-  "version": "2.0.0-alpha-20240620175016-1a4246713c9c2dcf5e3debfccfa47e0efd992528",
+  "version": "2.0.0-alpha-20240702150657-b50b1dda80c0083a63896cdbfd42efdcdf4c0b98",
   "sideEffects": false,
   "peerDependencies": {
     "graphql": "^14.0.0 || ^15.0.0 || ^16.0.0 || ^17.0.0"
   },
   "dependencies": {
-    "@graphql-tools/utils": "10.3.0-alpha-20240620175016-1a4246713c9c2dcf5e3debfccfa47e0efd992528",
+    "@graphql-tools/utils": "10.3.0-alpha-20240702150657-b50b1dda80c0083a63896cdbfd42efdcdf4c0b98",
     "@graphql-typed-document-node/core": "3.2.0",
     "@repeaterjs/repeater": "^3.0.4",
     "tslib": "^2.4.0",

package/typings/execution/collectFields.d.cts

@@ -1,4 +1,4 @@
-import type { FieldNode, FragmentDefinitionNode, GraphQLObjectType, GraphQLSchema, OperationDefinitionNode } from 'graphql';
+import type { FieldNode, FragmentDefinitionNode, GraphQLObjectType, GraphQLSchema, SelectionSetNode } from 'graphql';
 export interface DeferUsage {
     label: string | undefined;
     parentDeferUsage: DeferUsage | undefined;
@@ -18,7 +18,7 @@ export type GroupedFieldSet = ReadonlyMap<string, FieldGroup>;
  *
  * @internal
  */
-export declare function collectFields<TVariables = any>(schema: GraphQLSchema, fragments: Record<string, FragmentDefinitionNode>, variableValues: TVariables, runtimeType: GraphQLObjectType, operation: OperationDefinitionNode): {
+export declare function collectFields<TVariables = any>(schema: GraphQLSchema, fragments: Record<string, FragmentDefinitionNode>, variableValues: TVariables, runtimeType: GraphQLObjectType, selectionSet: SelectionSetNode, errorWithIncrementalSubscription: boolean): {
     groupedFieldSet: GroupedFieldSet;
     newDeferUsages: ReadonlyArray<DeferUsage>;
 };
@@ -34,7 +34,7 @@ export declare function collectFields<TVariables = any>(schema: GraphQLSchema, f
  */
 export declare function collectSubfields(schema: GraphQLSchema, fragments: Record<string, FragmentDefinitionNode>, variableValues: {
     [variable: string]: unknown;
-}, operation: OperationDefinitionNode, returnType: GraphQLObjectType, fieldGroup: FieldGroup): {
+}, errorWithIncrementalSubscription: boolean, returnType: GraphQLObjectType, fieldGroup: FieldGroup): {
     groupedFieldSet: GroupedFieldSet;
     newDeferUsages: ReadonlyArray<DeferUsage>;
 };

package/typings/execution/collectFields.d.ts

@@ -1,4 +1,4 @@
-import type { FieldNode, FragmentDefinitionNode, GraphQLObjectType, GraphQLSchema, OperationDefinitionNode } from 'graphql';
+import type { FieldNode, FragmentDefinitionNode, GraphQLObjectType, GraphQLSchema, SelectionSetNode } from 'graphql';
 export interface DeferUsage {
     label: string | undefined;
     parentDeferUsage: DeferUsage | undefined;
@@ -18,7 +18,7 @@ export type GroupedFieldSet = ReadonlyMap<string, FieldGroup>;
  *
  * @internal
  */
-export declare function collectFields<TVariables = any>(schema: GraphQLSchema, fragments: Record<string, FragmentDefinitionNode>, variableValues: TVariables, runtimeType: GraphQLObjectType, operation: OperationDefinitionNode): {
+export declare function collectFields<TVariables = any>(schema: GraphQLSchema, fragments: Record<string, FragmentDefinitionNode>, variableValues: TVariables, runtimeType: GraphQLObjectType, selectionSet: SelectionSetNode, errorWithIncrementalSubscription: boolean): {
     groupedFieldSet: GroupedFieldSet;
     newDeferUsages: ReadonlyArray<DeferUsage>;
 };
@@ -34,7 +34,7 @@ export declare function collectFields<TVariables = any>(schema: GraphQLSchema, f
  */
 export declare function collectSubfields(schema: GraphQLSchema, fragments: Record<string, FragmentDefinitionNode>, variableValues: {
     [variable: string]: unknown;
-}, operation: OperationDefinitionNode, returnType: GraphQLObjectType, fieldGroup: FieldGroup): {
+}, errorWithIncrementalSubscription: boolean, returnType: GraphQLObjectType, fieldGroup: FieldGroup): {
     groupedFieldSet: GroupedFieldSet;
     newDeferUsages: ReadonlyArray<DeferUsage>;
 };

package/typings/execution/execute.d.cts

@@ -38,6 +38,7 @@ export interface ExecutionContext<TVariables = any, TContext = any> {
     typeResolver: GraphQLTypeResolver<any, TContext>;
     subscribeFieldResolver: GraphQLFieldResolver<any, TContext>;
     enableEarlyExecution: boolean;
+    errorWithIncrementalSubscription: boolean;
     signal: AbortSignal | undefined;
     errors: Map<Path | undefined, GraphQLError> | undefined;
     cancellableStreams: Set<CancellableStreamRecord> | undefined;
@@ -54,6 +55,7 @@ export interface ExecutionArgs<TData = any, TVariables = any, TContext = any> {
     typeResolver?: Maybe<GraphQLTypeResolver<any, TContext>>;
     subscribeFieldResolver?: Maybe<GraphQLFieldResolver<any, TContext>>;
     enableEarlyExecution?: Maybe<boolean>;
+    errorWithIncrementalSubscription?: Maybe<boolean>;
     signal?: AbortSignal;
 }
 /**
@@ -149,6 +151,9 @@ 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> & {
+    errorWithIncrementalSubscription: true | undefined | null;
+}): MaybePromise<AsyncGenerator<SingularExecutionResult<TData>, void, void> | SingularExecutionResult<TData>>;
 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>;
 /**

package/typings/execution/execute.d.ts

@@ -38,6 +38,7 @@ export interface ExecutionContext<TVariables = any, TContext = any> {
     typeResolver: GraphQLTypeResolver<any, TContext>;
     subscribeFieldResolver: GraphQLFieldResolver<any, TContext>;
     enableEarlyExecution: boolean;
+    errorWithIncrementalSubscription: boolean;
     signal: AbortSignal | undefined;
     errors: Map<Path | undefined, GraphQLError> | undefined;
     cancellableStreams: Set<CancellableStreamRecord> | undefined;
@@ -54,6 +55,7 @@ export interface ExecutionArgs<TData = any, TVariables = any, TContext = any> {
     typeResolver?: Maybe<GraphQLTypeResolver<any, TContext>>;
     subscribeFieldResolver?: Maybe<GraphQLFieldResolver<any, TContext>>;
     enableEarlyExecution?: Maybe<boolean>;
+    errorWithIncrementalSubscription?: Maybe<boolean>;
     signal?: AbortSignal;
 }
 /**
@@ -149,6 +151,9 @@ 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> & {
+    errorWithIncrementalSubscription: true | undefined | null;
+}): MaybePromise<AsyncGenerator<SingularExecutionResult<TData>, void, void> | SingularExecutionResult<TData>>;
 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>;
 /**

package/typings/execution/flattenAsyncIterable.d.cts

@@ -0,0 +1,7 @@
+type AsyncIterableOrGenerator<T> = AsyncGenerator<T, void, void> | AsyncIterable<T>;
+/**
+ * Given an AsyncIterable of AsyncIterables, flatten all yielded results into a
+ * single AsyncIterable.
+ */
+export declare function flattenAsyncIterable<T>(iterable: AsyncIterableOrGenerator<AsyncIterableOrGenerator<T>>): AsyncGenerator<T, void, void>;
+export {};

package/typings/execution/flattenAsyncIterable.d.ts

@@ -0,0 +1,7 @@
+type AsyncIterableOrGenerator<T> = AsyncGenerator<T, void, void> | AsyncIterable<T>;
+/**
+ * Given an AsyncIterable of AsyncIterables, flatten all yielded results into a
+ * single AsyncIterable.
+ */
+export declare function flattenAsyncIterable<T>(iterable: AsyncIterableOrGenerator<AsyncIterableOrGenerator<T>>): AsyncGenerator<T, void, void>;
+export {};