graphql 17.0.0-beta.0 → 17.0.0-beta.2

package/execution/legacyIncremental/BranchingIncrementalPublisher.mjs

@@ -0,0 +1,127 @@
+import { addPath, pathToArray } from "../../jsutils/Path.mjs";
+import { ensureGraphQLError } from "../../error/ensureGraphQLError.mjs";
+import { createWorkQueue } from "../incremental/WorkQueue.mjs";
+import { mapAsyncIterable } from "../mapAsyncIterable.mjs";
+import { withConcurrentAbruptClose } from "../withConcurrentAbruptClose.mjs";
+export class BranchingIncrementalPublisher {
+    constructor() {
+        this._indices = new Map();
+    }
+    buildResponse(data, errors, work, abortSignal, onFinished) {
+        const { initialStreams, events } = createWorkQueue(work);
+        for (const stream of initialStreams) {
+            this._indices.set(stream, stream.initialCount);
+        }
+        function abort() {
+            subsequentResults.throw(abortSignal?.reason).catch(() => {
+            });
+        }
+        if (abortSignal) {
+            abortSignal.addEventListener('abort', abort);
+        }
+        const onWorkQueueFinished = () => {
+            onFinished();
+            abortSignal?.removeEventListener('abort', abort);
+        };
+        const initialResult = errors.length
+            ? { errors, data, hasNext: true }
+            : { data, hasNext: true };
+        const subsequentResults = withConcurrentAbruptClose(mapAsyncIterable(events, (batch) => this._handleBatch(batch, onWorkQueueFinished)), () => onWorkQueueFinished());
+        return {
+            initialResult,
+            subsequentResults,
+        };
+    }
+    _handleBatch(batch, onWorkQueueFinished) {
+        const context = {
+            incremental: [],
+            hasNext: true,
+        };
+        for (const event of batch) {
+            this._handleWorkQueueEvent(event, context, onWorkQueueFinished);
+        }
+        const { incremental, hasNext } = context;
+        const result = { hasNext };
+        if (incremental.length > 0) {
+            result.incremental = incremental;
+        }
+        return result;
+    }
+    _handleWorkQueueEvent(event, context, onWorkQueueFinished) {
+        switch (event.kind) {
+            case 'GROUP_VALUES': {
+                const group = event.group;
+                for (const value of event.values) {
+                    context.incremental.push(buildIncrementalResult({
+                        data: value.data,
+                        path: pathToArray(group.path),
+                    }, group.label, value.errors));
+                }
+                break;
+            }
+            case 'GROUP_SUCCESS': {
+                break;
+            }
+            case 'GROUP_FAILURE': {
+                const group = event.group;
+                context.incremental.push(buildIncrementalResult({
+                    data: null,
+                    path: pathToArray(group.path),
+                }, group.label, [ensureGraphQLError(event.error)]));
+                break;
+            }
+            case 'STREAM_VALUES': {
+                const stream = event.stream;
+                const { values } = event;
+                const items = [];
+                const errors = [];
+                for (const value of values) {
+                    items.push(value.item);
+                    if (value.errors !== undefined) {
+                        errors.push(...value.errors);
+                    }
+                }
+                let index = this._indices.get(stream);
+                if (index === undefined) {
+                    index = stream.initialCount;
+                    this._indices.set(stream, index);
+                }
+                this._indices.set(stream, index + items.length);
+                context.incremental.push(buildIncrementalResult({
+                    items,
+                    path: pathToArray(addPath(stream.path, index, undefined)),
+                }, stream.label, errors.length > 0 ? errors : undefined));
+                break;
+            }
+            case 'STREAM_SUCCESS': {
+                this._indices.delete(event.stream);
+                break;
+            }
+            case 'STREAM_FAILURE': {
+                this._indices.delete(event.stream);
+                const stream = event.stream;
+                context.incremental.push(buildIncrementalResult({
+                    items: null,
+                    path: pathToArray(stream.path),
+                }, stream.label, [ensureGraphQLError(event.error)]));
+                break;
+            }
+            case 'WORK_QUEUE_TERMINATION': {
+                onWorkQueueFinished?.();
+                context.hasNext = false;
+                break;
+            }
+        }
+    }
+}
+function buildIncrementalResult(originalIncrementalResult, label, errors) {
+    const incrementalResult = originalIncrementalResult;
+    if (errors !== undefined) {
+        incrementalResult.errors = errors;
+    }
+    if (label !== undefined) {
+        incrementalResult.label = label;
+    }
+    return incrementalResult;
+}
+//# sourceMappingURL=BranchingIncrementalPublisher.js.map

package/execution/legacyIncremental/BranchingIncrementalPublisher.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"BranchingIncrementalPublisher.js","sourceRoot":"","sources":["../../../src/execution/legacyIncremental/BranchingIncrementalPublisher.ts"],"names":[],"mappings":"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","sourcesContent":["import type { ObjMap } from '../../jsutils/ObjMap.ts';\nimport { addPath, pathToArray } from '../../jsutils/Path.ts';\n\nimport { ensureGraphQLError } from '../../error/ensureGraphQLError.ts';\nimport type { GraphQLError } from '../../error/GraphQLError.ts';\n\nimport type {\n  DeliveryGroup,\n  ExecutionGroupValue,\n  IncrementalWork,\n  ItemStream,\n  StreamItemValue,\n} from '../incremental/IncrementalExecutor.ts';\nimport type { WorkQueueEvent } from '../incremental/WorkQueue.ts';\nimport { createWorkQueue } from '../incremental/WorkQueue.ts';\nimport { mapAsyncIterable } from '../mapAsyncIterable.ts';\nimport { withConcurrentAbruptClose } from '../withConcurrentAbruptClose.ts';\n\nimport type {\n  LegacyExperimentalIncrementalExecutionResults,\n  LegacyIncrementalDeferResult,\n  LegacyIncrementalResult,\n  LegacyIncrementalStreamResult,\n  LegacyInitialIncrementalExecutionResult,\n  LegacySubsequentIncrementalExecutionResult,\n} from './BranchingIncrementalExecutor.ts';\n\ninterface SubsequentIncrementalExecutionResultContext {\n  incremental: Array<LegacyIncrementalResult>;\n  hasNext: boolean;\n}\n\n/** @internal */\nexport class BranchingIncrementalPublisher {\n  private _indices: Map<ItemStream, number>;\n\n  constructor() {\n    this._indices = new Map();\n  }\n\n  buildResponse(\n    data: ObjMap<unknown>,\n    errors: ReadonlyArray<GraphQLError>,\n    work: IncrementalWork,\n    abortSignal: AbortSignal | undefined,\n    onFinished: () => void,\n  ): LegacyExperimentalIncrementalExecutionResults {\n    const { initialStreams, events } = createWorkQueue<\n      ExecutionGroupValue,\n      StreamItemValue,\n      DeliveryGroup,\n      ItemStream\n    >(work);\n\n    for (const stream of initialStreams) {\n      this._indices.set(stream, stream.initialCount);\n    }\n\n    function abort(): void {\n      subsequentResults.throw(abortSignal?.reason).catch(() => {\n        // Ignore errors\n      });\n    }\n\n    if (abortSignal) {\n      abortSignal.addEventListener('abort', abort);\n    }\n    const onWorkQueueFinished = () => {\n      onFinished();\n      abortSignal?.removeEventListener('abort', abort);\n    };\n\n    const initialResult: LegacyInitialIncrementalExecutionResult = errors.length\n      ? { errors, data, hasNext: true }\n      : { data, hasNext: true };\n\n    const subsequentResults = withConcurrentAbruptClose(\n      mapAsyncIterable(events, (batch) =>\n        this._handleBatch(batch, onWorkQueueFinished),\n      ),\n      () => onWorkQueueFinished(),\n    );\n\n    return {\n      initialResult,\n      subsequentResults,\n    };\n  }\n\n  private _handleBatch(\n    batch: ReadonlyArray<\n      WorkQueueEvent<\n        ExecutionGroupValue,\n        StreamItemValue,\n        DeliveryGroup,\n        ItemStream\n      >\n    >,\n    onWorkQueueFinished: (() => void) | undefined,\n  ): LegacySubsequentIncrementalExecutionResult {\n    const context: SubsequentIncrementalExecutionResultContext = {\n      incremental: [],\n      hasNext: true,\n    };\n\n    for (const event of batch) {\n      this._handleWorkQueueEvent(event, context, onWorkQueueFinished);\n    }\n\n    const { incremental, hasNext } = context;\n\n    const result: LegacySubsequentIncrementalExecutionResult = { hasNext };\n    if (incremental.length > 0) {\n      result.incremental = incremental;\n    }\n\n    return result;\n  }\n\n  private _handleWorkQueueEvent(\n    event: WorkQueueEvent<\n      ExecutionGroupValue,\n      StreamItemValue,\n      DeliveryGroup,\n      ItemStream\n    >,\n    context: SubsequentIncrementalExecutionResultContext,\n    onWorkQueueFinished: (() => void) | undefined,\n  ): void {\n    switch (event.kind) {\n      case 'GROUP_VALUES': {\n        const group = event.group;\n        for (const value of event.values) {\n          context.incremental.push(\n            buildIncrementalResult(\n              {\n                data: value.data,\n                path: pathToArray(group.path),\n              },\n              group.label,\n              value.errors,\n            ),\n          );\n        }\n        break;\n      }\n      case 'GROUP_SUCCESS': {\n        break;\n      }\n      case 'GROUP_FAILURE': {\n        const group = event.group;\n        context.incremental.push(\n          buildIncrementalResult(\n            {\n              data: null,\n              path: pathToArray(group.path),\n            },\n            group.label,\n            [ensureGraphQLError(event.error)],\n          ),\n        );\n        break;\n      }\n      case 'STREAM_VALUES': {\n        const stream = event.stream;\n        const { values } = event;\n        const items: Array<unknown> = [];\n        const errors: Array<GraphQLError> = [];\n        for (const value of values) {\n          items.push(value.item);\n          if (value.errors !== undefined) {\n            errors.push(...value.errors);\n          }\n        }\n        let index = this._indices.get(stream);\n        if (index === undefined) {\n          index = stream.initialCount;\n          this._indices.set(stream, index);\n        }\n        this._indices.set(stream, index + items.length);\n        context.incremental.push(\n          buildIncrementalResult(\n            {\n              items,\n              path: pathToArray(addPath(stream.path, index, undefined)),\n            },\n            stream.label,\n            errors.length > 0 ? errors : undefined,\n          ),\n        );\n        break;\n      }\n      case 'STREAM_SUCCESS': {\n        this._indices.delete(event.stream);\n        break;\n      }\n      case 'STREAM_FAILURE': {\n        this._indices.delete(event.stream);\n        const stream = event.stream;\n        context.incremental.push(\n          buildIncrementalResult(\n            {\n              items: null,\n              path: pathToArray(stream.path),\n            },\n            stream.label,\n            [ensureGraphQLError(event.error)],\n          ),\n        );\n        break;\n      }\n      case 'WORK_QUEUE_TERMINATION': {\n        onWorkQueueFinished?.();\n        context.hasNext = false;\n        break;\n      }\n    }\n  }\n}\n\nfunction buildIncrementalResult(\n  originalIncrementalResult:\n    | Omit<LegacyIncrementalDeferResult, 'label' | 'errors'>\n    | Omit<LegacyIncrementalStreamResult, 'label' | 'errors'>,\n  label: string | undefined,\n  errors: ReadonlyArray<GraphQLError> | undefined,\n): LegacyIncrementalResult {\n  const incrementalResult: LegacyIncrementalResult = originalIncrementalResult;\n  if (errors !== undefined) {\n    incrementalResult.errors = errors;\n  }\n  if (label !== undefined) {\n    incrementalResult.label = label;\n  }\n  return incrementalResult;\n}\n"]}

package/execution/legacyIncremental/legacyExecuteIncrementally.d.mts

@@ -0,0 +1,165 @@
+/** @category Legacy Incremental Execution */
+import type { PromiseOrValue } from "../../jsutils/PromiseOrValue.mjs";
+import type { ExecutionArgs, ValidatedExecutionArgs } from "../ExecutionArgs.mjs";
+import type { ExecutionResult } from "../Executor.mjs";
+import type { LegacyExperimentalIncrementalExecutionResults } from "./BranchingIncrementalExecutor.mjs";
+/**
+ * Executes a GraphQL operation with support for `@defer` and `@stream` using
+ * the legacy incremental delivery payload format.
+ *
+ * Prefer `experimentalExecuteIncrementally` for the current incremental
+ * delivery format. In the legacy format, each subsequent incremental payload
+ * identifies its location with `path` and optional `label` fields. The current
+ * format instead tracks pending work by `id` and reports completion through
+ * `completed` entries.
+ * @param args - Execution arguments for the GraphQL operation.
+ * @returns A single execution result or legacy incremental execution results.
+ * @example
+ * ```ts
+ * import assert from 'node:assert';
+ * import { parse } from 'graphql/language';
+ * import { buildSchema } from 'graphql/utilities';
+ * import { legacyExecuteIncrementally } from 'graphql/execution';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     hero: Hero
+ *   }
+ *
+ *   type Hero {
+ *     id: ID!
+ *     name: String!
+ *   }
+ * `);
+ *
+ * const result = await legacyExecuteIncrementally({
+ *   schema,
+ *   document: parse('{ hero { id ... @defer(label: "HeroName") { name } } }'),
+ *   rootValue: { hero: { id: '1', name: 'Luke' } },
+ * });
+ *
+ * assert('initialResult' in result);
+ *
+ * result.initialResult; // => { data: { hero: { id: '1' } }, hasNext: true }
+ *
+ * const deferred = await result.subsequentResults.next();
+ * deferred.value; // => { incremental: [ { data: { name: 'Luke' }, path: ['hero'], label: 'HeroName' } ], hasNext: false }
+ * ```
+ * @example
+ * Compare the legacy payload format with the current incremental delivery
+ * format returned by `experimentalExecuteIncrementally`.
+ * ```ts
+ * import assert from 'node:assert';
+ * import { parse } from 'graphql/language';
+ * import { buildSchema } from 'graphql/utilities';
+ * import {
+ *   experimentalExecuteIncrementally,
+ *   legacyExecuteIncrementally,
+ * } from 'graphql/execution';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     hero: Hero
+ *   }
+ *
+ *   type Hero {
+ *     id: ID!
+ *     name: String!
+ *   }
+ * `);
+ * const document = parse('{ hero { id ... @defer { name } } }');
+ * const rootValue = { hero: { id: '1', name: 'Luke' } };
+ *
+ * const experimental = await experimentalExecuteIncrementally({
+ *   schema,
+ *   document,
+ *   rootValue,
+ * });
+ * const legacy = await legacyExecuteIncrementally({
+ *   schema,
+ *   document,
+ *   rootValue,
+ * });
+ *
+ * assert('initialResult' in experimental);
+ * assert('initialResult' in legacy);
+ *
+ * experimental.initialResult; // => { data: { hero: { id: '1' } }, pending: [ { id: '0', path: ['hero'] } ], hasNext: true }
+ * legacy.initialResult; // => { data: { hero: { id: '1' } }, hasNext: true }
+ *
+ * const experimentalDeferred = await experimental.subsequentResults.next();
+ * experimentalDeferred.value; // => { incremental: [{ data: { name: 'Luke' }, id: '0' }], completed: [{ id: '0' }], hasNext: false }
+ *
+ * const legacyDeferred = await legacy.subsequentResults.next();
+ * legacyDeferred.value; // => { incremental: [ { data: { name: 'Luke' }, path: ['hero'] } ], hasNext: false }
+ * ```
+ * @example
+ * Compare streamed list payloads in the legacy and current incremental
+ * delivery formats.
+ * ```ts
+ * import assert from 'node:assert';
+ * import { parse } from 'graphql/language';
+ * import { buildSchema } from 'graphql/utilities';
+ * import {
+ *   experimentalExecuteIncrementally,
+ *   legacyExecuteIncrementally,
+ * } from 'graphql/execution';
+ *
+ * const schema = buildSchema('type Query { colors: [String] }');
+ * const document = parse('{ colors @stream(initialCount: 1) }');
+ * const rootValue = { colors: ['red', 'green', 'blue'] };
+ *
+ * const experimental = await experimentalExecuteIncrementally({
+ *   schema,
+ *   document,
+ *   rootValue,
+ * });
+ * const legacy = await legacyExecuteIncrementally({
+ *   schema,
+ *   document,
+ *   rootValue,
+ * });
+ *
+ * assert('initialResult' in experimental);
+ * assert('initialResult' in legacy);
+ *
+ * experimental.initialResult; // => { data: { colors: ['red'] }, pending: [ { id: '0', path: ['colors'] } ], hasNext: true }
+ * legacy.initialResult; // => { data: { colors: ['red'] }, hasNext: true }
+ *
+ * const experimentalStream = await experimental.subsequentResults.next();
+ * experimentalStream.value; // => { incremental: [ { items: ['green', 'blue'], id: '0' } ], completed: [{ id: '0' }], hasNext: false }
+ *
+ * const legacyStream = await legacy.subsequentResults.next();
+ * legacyStream.value; // => { incremental: [ { items: ['green', 'blue'], path: ['colors', 1] } ], hasNext: false }
+ * ```
+ */
+export declare function legacyExecuteIncrementally(args: ExecutionArgs): PromiseOrValue<ExecutionResult | LegacyExperimentalIncrementalExecutionResults>;
+/**
+ * Executes a validated operation root selection set with support for `@defer`
+ * and `@stream` using the legacy incremental delivery payload format.
+ * @param validatedExecutionArgs - Validated execution arguments.
+ * @returns A single execution result or legacy incremental execution results.
+ * @example
+ * ```ts
+ * import assert from 'node:assert';
+ * import { parse } from 'graphql/language';
+ * import { buildSchema } from 'graphql/utilities';
+ * import {
+ *   legacyExecuteRootSelectionSet,
+ *   validateExecutionArgs,
+ * } from 'graphql/execution';
+ *
+ * const schema = buildSchema('type Query { greeting: String }');
+ * const validatedArgs = validateExecutionArgs({
+ *   schema,
+ *   document: parse('{ greeting }'),
+ *   rootValue: { greeting: 'Hello' },
+ * });
+ *
+ * assert('schema' in validatedArgs);
+ *
+ * const result = await legacyExecuteRootSelectionSet(validatedArgs);
+ * result; // => { data: { greeting: 'Hello' } }
+ * ```
+ */
+export declare function legacyExecuteRootSelectionSet(validatedExecutionArgs: ValidatedExecutionArgs): PromiseOrValue<ExecutionResult | LegacyExperimentalIncrementalExecutionResults>;

package/execution/legacyIncremental/legacyExecuteIncrementally.d.ts

@@ -0,0 +1,165 @@
+/** @category Legacy Incremental Execution */
+import type { PromiseOrValue } from "../../jsutils/PromiseOrValue.js";
+import type { ExecutionArgs, ValidatedExecutionArgs } from "../ExecutionArgs.js";
+import type { ExecutionResult } from "../Executor.js";
+import type { LegacyExperimentalIncrementalExecutionResults } from "./BranchingIncrementalExecutor.js";
+/**
+ * Executes a GraphQL operation with support for `@defer` and `@stream` using
+ * the legacy incremental delivery payload format.
+ *
+ * Prefer `experimentalExecuteIncrementally` for the current incremental
+ * delivery format. In the legacy format, each subsequent incremental payload
+ * identifies its location with `path` and optional `label` fields. The current
+ * format instead tracks pending work by `id` and reports completion through
+ * `completed` entries.
+ * @param args - Execution arguments for the GraphQL operation.
+ * @returns A single execution result or legacy incremental execution results.
+ * @example
+ * ```ts
+ * import assert from 'node:assert';
+ * import { parse } from 'graphql/language';
+ * import { buildSchema } from 'graphql/utilities';
+ * import { legacyExecuteIncrementally } from 'graphql/execution';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     hero: Hero
+ *   }
+ *
+ *   type Hero {
+ *     id: ID!
+ *     name: String!
+ *   }
+ * `);
+ *
+ * const result = await legacyExecuteIncrementally({
+ *   schema,
+ *   document: parse('{ hero { id ... @defer(label: "HeroName") { name } } }'),
+ *   rootValue: { hero: { id: '1', name: 'Luke' } },
+ * });
+ *
+ * assert('initialResult' in result);
+ *
+ * result.initialResult; // => { data: { hero: { id: '1' } }, hasNext: true }
+ *
+ * const deferred = await result.subsequentResults.next();
+ * deferred.value; // => { incremental: [ { data: { name: 'Luke' }, path: ['hero'], label: 'HeroName' } ], hasNext: false }
+ * ```
+ * @example
+ * Compare the legacy payload format with the current incremental delivery
+ * format returned by `experimentalExecuteIncrementally`.
+ * ```ts
+ * import assert from 'node:assert';
+ * import { parse } from 'graphql/language';
+ * import { buildSchema } from 'graphql/utilities';
+ * import {
+ *   experimentalExecuteIncrementally,
+ *   legacyExecuteIncrementally,
+ * } from 'graphql/execution';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     hero: Hero
+ *   }
+ *
+ *   type Hero {
+ *     id: ID!
+ *     name: String!
+ *   }
+ * `);
+ * const document = parse('{ hero { id ... @defer { name } } }');
+ * const rootValue = { hero: { id: '1', name: 'Luke' } };
+ *
+ * const experimental = await experimentalExecuteIncrementally({
+ *   schema,
+ *   document,
+ *   rootValue,
+ * });
+ * const legacy = await legacyExecuteIncrementally({
+ *   schema,
+ *   document,
+ *   rootValue,
+ * });
+ *
+ * assert('initialResult' in experimental);
+ * assert('initialResult' in legacy);
+ *
+ * experimental.initialResult; // => { data: { hero: { id: '1' } }, pending: [ { id: '0', path: ['hero'] } ], hasNext: true }
+ * legacy.initialResult; // => { data: { hero: { id: '1' } }, hasNext: true }
+ *
+ * const experimentalDeferred = await experimental.subsequentResults.next();
+ * experimentalDeferred.value; // => { incremental: [{ data: { name: 'Luke' }, id: '0' }], completed: [{ id: '0' }], hasNext: false }
+ *
+ * const legacyDeferred = await legacy.subsequentResults.next();
+ * legacyDeferred.value; // => { incremental: [ { data: { name: 'Luke' }, path: ['hero'] } ], hasNext: false }
+ * ```
+ * @example
+ * Compare streamed list payloads in the legacy and current incremental
+ * delivery formats.
+ * ```ts
+ * import assert from 'node:assert';
+ * import { parse } from 'graphql/language';
+ * import { buildSchema } from 'graphql/utilities';
+ * import {
+ *   experimentalExecuteIncrementally,
+ *   legacyExecuteIncrementally,
+ * } from 'graphql/execution';
+ *
+ * const schema = buildSchema('type Query { colors: [String] }');
+ * const document = parse('{ colors @stream(initialCount: 1) }');
+ * const rootValue = { colors: ['red', 'green', 'blue'] };
+ *
+ * const experimental = await experimentalExecuteIncrementally({
+ *   schema,
+ *   document,
+ *   rootValue,
+ * });
+ * const legacy = await legacyExecuteIncrementally({
+ *   schema,
+ *   document,
+ *   rootValue,
+ * });
+ *
+ * assert('initialResult' in experimental);
+ * assert('initialResult' in legacy);
+ *
+ * experimental.initialResult; // => { data: { colors: ['red'] }, pending: [ { id: '0', path: ['colors'] } ], hasNext: true }
+ * legacy.initialResult; // => { data: { colors: ['red'] }, hasNext: true }
+ *
+ * const experimentalStream = await experimental.subsequentResults.next();
+ * experimentalStream.value; // => { incremental: [ { items: ['green', 'blue'], id: '0' } ], completed: [{ id: '0' }], hasNext: false }
+ *
+ * const legacyStream = await legacy.subsequentResults.next();
+ * legacyStream.value; // => { incremental: [ { items: ['green', 'blue'], path: ['colors', 1] } ], hasNext: false }
+ * ```
+ */
+export declare function legacyExecuteIncrementally(args: ExecutionArgs): PromiseOrValue<ExecutionResult | LegacyExperimentalIncrementalExecutionResults>;
+/**
+ * Executes a validated operation root selection set with support for `@defer`
+ * and `@stream` using the legacy incremental delivery payload format.
+ * @param validatedExecutionArgs - Validated execution arguments.
+ * @returns A single execution result or legacy incremental execution results.
+ * @example
+ * ```ts
+ * import assert from 'node:assert';
+ * import { parse } from 'graphql/language';
+ * import { buildSchema } from 'graphql/utilities';
+ * import {
+ *   legacyExecuteRootSelectionSet,
+ *   validateExecutionArgs,
+ * } from 'graphql/execution';
+ *
+ * const schema = buildSchema('type Query { greeting: String }');
+ * const validatedArgs = validateExecutionArgs({
+ *   schema,
+ *   document: parse('{ greeting }'),
+ *   rootValue: { greeting: 'Hello' },
+ * });
+ *
+ * assert('schema' in validatedArgs);
+ *
+ * const result = await legacyExecuteRootSelectionSet(validatedArgs);
+ * result; // => { data: { greeting: 'Hello' } }
+ * ```
+ */
+export declare function legacyExecuteRootSelectionSet(validatedExecutionArgs: ValidatedExecutionArgs): PromiseOrValue<ExecutionResult | LegacyExperimentalIncrementalExecutionResults>;

package/execution/legacyIncremental/legacyExecuteIncrementally.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.legacyExecuteIncrementally = legacyExecuteIncrementally;
+exports.legacyExecuteRootSelectionSet = legacyExecuteRootSelectionSet;
+const execute_ts_1 = require("../execute.js");
+const BranchingIncrementalExecutor_ts_1 = require("./BranchingIncrementalExecutor.js");
+function legacyExecuteIncrementally(args) {
+    const validatedExecutionArgs = (0, execute_ts_1.validateExecutionArgs)(args);
+    if (!('schema' in validatedExecutionArgs)) {
+        return { errors: validatedExecutionArgs };
+    }
+    return legacyExecuteRootSelectionSet(validatedExecutionArgs);
+}
+function legacyExecuteRootSelectionSet(validatedExecutionArgs) {
+    return new BranchingIncrementalExecutor_ts_1.BranchingIncrementalExecutor(validatedExecutionArgs).executeRootSelectionSet();
+}
+//# sourceMappingURL=legacyExecuteIncrementally.js.map

package/execution/legacyIncremental/legacyExecuteIncrementally.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"legacyExecuteIncrementally.js","sourceRoot":"","sources":["../../../src/execution/legacyIncremental/legacyExecuteIncrementally.ts"],"names":[],"mappings":";;AAgJA,gEAeC;AA8BD,sEAQC;AAjMD,8CAAsD;AAQtD,uFAAiF;AAoIjF,SAAgB,0BAA0B,CACxC,IAAmB;IAMnB,MAAM,sBAAsB,GAAG,IAAA,kCAAqB,EAAC,IAAI,CAAC,CAAC;IAG3D,IAAI,CAAC,CAAC,QAAQ,IAAI,sBAAsB,CAAC,EAAE,CAAC;QAC1C,OAAO,EAAE,MAAM,EAAE,sBAAsB,EAAE,CAAC;IAC5C,CAAC;IAED,OAAO,6BAA6B,CAAC,sBAAsB,CAAC,CAAC;AAC/D,CAAC;AA8BD,SAAgB,6BAA6B,CAC3C,sBAA8C;IAI9C,OAAO,IAAI,8DAA4B,CACrC,sBAAsB,CACvB,CAAC,uBAAuB,EAAE,CAAC;AAC9B,CAAC","sourcesContent":["/** @category Legacy Incremental Execution */\n\nimport type { PromiseOrValue } from '../../jsutils/PromiseOrValue.ts';\n\nimport { validateExecutionArgs } from '../execute.ts';\nimport type {\n  ExecutionArgs,\n  ValidatedExecutionArgs,\n} from '../ExecutionArgs.ts';\nimport type { ExecutionResult } from '../Executor.ts';\n\nimport type { LegacyExperimentalIncrementalExecutionResults } from './BranchingIncrementalExecutor.ts';\nimport { BranchingIncrementalExecutor } from './BranchingIncrementalExecutor.ts';\n\n/**\n * Executes a GraphQL operation with support for `@defer` and `@stream` using\n * the legacy incremental delivery payload format.\n *\n * Prefer `experimentalExecuteIncrementally` for the current incremental\n * delivery format. In the legacy format, each subsequent incremental payload\n * identifies its location with `path` and optional `label` fields. The current\n * format instead tracks pending work by `id` and reports completion through\n * `completed` entries.\n * @param args - Execution arguments for the GraphQL operation.\n * @returns A single execution result or legacy incremental execution results.\n * @example\n * ```ts\n * import assert from 'node:assert';\n * import { parse } from 'graphql/language';\n * import { buildSchema } from 'graphql/utilities';\n * import { legacyExecuteIncrementally } from 'graphql/execution';\n *\n * const schema = buildSchema(`\n *   type Query {\n *     hero: Hero\n *   }\n *\n *   type Hero {\n *     id: ID!\n *     name: String!\n *   }\n * `);\n *\n * const result = await legacyExecuteIncrementally({\n *   schema,\n *   document: parse('{ hero { id ... @defer(label: \"HeroName\") { name } } }'),\n *   rootValue: { hero: { id: '1', name: 'Luke' } },\n * });\n *\n * assert('initialResult' in result);\n *\n * result.initialResult; // => { data: { hero: { id: '1' } }, hasNext: true }\n *\n * const deferred = await result.subsequentResults.next();\n * deferred.value; // => { incremental: [ { data: { name: 'Luke' }, path: ['hero'], label: 'HeroName' } ], hasNext: false }\n * ```\n * @example\n * Compare the legacy payload format with the current incremental delivery\n * format returned by `experimentalExecuteIncrementally`.\n * ```ts\n * import assert from 'node:assert';\n * import { parse } from 'graphql/language';\n * import { buildSchema } from 'graphql/utilities';\n * import {\n *   experimentalExecuteIncrementally,\n *   legacyExecuteIncrementally,\n * } from 'graphql/execution';\n *\n * const schema = buildSchema(`\n *   type Query {\n *     hero: Hero\n *   }\n *\n *   type Hero {\n *     id: ID!\n *     name: String!\n *   }\n * `);\n * const document = parse('{ hero { id ... @defer { name } } }');\n * const rootValue = { hero: { id: '1', name: 'Luke' } };\n *\n * const experimental = await experimentalExecuteIncrementally({\n *   schema,\n *   document,\n *   rootValue,\n * });\n * const legacy = await legacyExecuteIncrementally({\n *   schema,\n *   document,\n *   rootValue,\n * });\n *\n * assert('initialResult' in experimental);\n * assert('initialResult' in legacy);\n *\n * experimental.initialResult; // => { data: { hero: { id: '1' } }, pending: [ { id: '0', path: ['hero'] } ], hasNext: true }\n * legacy.initialResult; // => { data: { hero: { id: '1' } }, hasNext: true }\n *\n * const experimentalDeferred = await experimental.subsequentResults.next();\n * experimentalDeferred.value; // => { incremental: [{ data: { name: 'Luke' }, id: '0' }], completed: [{ id: '0' }], hasNext: false }\n *\n * const legacyDeferred = await legacy.subsequentResults.next();\n * legacyDeferred.value; // => { incremental: [ { data: { name: 'Luke' }, path: ['hero'] } ], hasNext: false }\n * ```\n * @example\n * Compare streamed list payloads in the legacy and current incremental\n * delivery formats.\n * ```ts\n * import assert from 'node:assert';\n * import { parse } from 'graphql/language';\n * import { buildSchema } from 'graphql/utilities';\n * import {\n *   experimentalExecuteIncrementally,\n *   legacyExecuteIncrementally,\n * } from 'graphql/execution';\n *\n * const schema = buildSchema('type Query { colors: [String] }');\n * const document = parse('{ colors @stream(initialCount: 1) }');\n * const rootValue = { colors: ['red', 'green', 'blue'] };\n *\n * const experimental = await experimentalExecuteIncrementally({\n *   schema,\n *   document,\n *   rootValue,\n * });\n * const legacy = await legacyExecuteIncrementally({\n *   schema,\n *   document,\n *   rootValue,\n * });\n *\n * assert('initialResult' in experimental);\n * assert('initialResult' in legacy);\n *\n * experimental.initialResult; // => { data: { colors: ['red'] }, pending: [ { id: '0', path: ['colors'] } ], hasNext: true }\n * legacy.initialResult; // => { data: { colors: ['red'] }, hasNext: true }\n *\n * const experimentalStream = await experimental.subsequentResults.next();\n * experimentalStream.value; // => { incremental: [ { items: ['green', 'blue'], id: '0' } ], completed: [{ id: '0' }], hasNext: false }\n *\n * const legacyStream = await legacy.subsequentResults.next();\n * legacyStream.value; // => { incremental: [ { items: ['green', 'blue'], path: ['colors', 1] } ], hasNext: false }\n * ```\n */\nexport function legacyExecuteIncrementally(\n  args: ExecutionArgs,\n): PromiseOrValue<\n  ExecutionResult | LegacyExperimentalIncrementalExecutionResults\n> {\n  // If a valid execution context cannot be created due to incorrect arguments,\n  // a \"Response\" with only errors is returned.\n  const validatedExecutionArgs = validateExecutionArgs(args);\n\n  // Return early errors if execution context failed.\n  if (!('schema' in validatedExecutionArgs)) {\n    return { errors: validatedExecutionArgs };\n  }\n\n  return legacyExecuteRootSelectionSet(validatedExecutionArgs);\n}\n\n/**\n * Executes a validated operation root selection set with support for `@defer`\n * and `@stream` using the legacy incremental delivery payload format.\n * @param validatedExecutionArgs - Validated execution arguments.\n * @returns A single execution result or legacy incremental execution results.\n * @example\n * ```ts\n * import assert from 'node:assert';\n * import { parse } from 'graphql/language';\n * import { buildSchema } from 'graphql/utilities';\n * import {\n *   legacyExecuteRootSelectionSet,\n *   validateExecutionArgs,\n * } from 'graphql/execution';\n *\n * const schema = buildSchema('type Query { greeting: String }');\n * const validatedArgs = validateExecutionArgs({\n *   schema,\n *   document: parse('{ greeting }'),\n *   rootValue: { greeting: 'Hello' },\n * });\n *\n * assert('schema' in validatedArgs);\n *\n * const result = await legacyExecuteRootSelectionSet(validatedArgs);\n * result; // => { data: { greeting: 'Hello' } }\n * ```\n */\nexport function legacyExecuteRootSelectionSet(\n  validatedExecutionArgs: ValidatedExecutionArgs,\n): PromiseOrValue<\n  ExecutionResult | LegacyExperimentalIncrementalExecutionResults\n> {\n  return new BranchingIncrementalExecutor(\n    validatedExecutionArgs,\n  ).executeRootSelectionSet();\n}\n"]}

package/execution/legacyIncremental/legacyExecuteIncrementally.mjs

@@ -0,0 +1,13 @@
+import { validateExecutionArgs } from "../execute.mjs";
+import { BranchingIncrementalExecutor } from "./BranchingIncrementalExecutor.mjs";
+export function legacyExecuteIncrementally(args) {
+    const validatedExecutionArgs = validateExecutionArgs(args);
+    if (!('schema' in validatedExecutionArgs)) {
+        return { errors: validatedExecutionArgs };
+    }
+    return legacyExecuteRootSelectionSet(validatedExecutionArgs);
+}
+export function legacyExecuteRootSelectionSet(validatedExecutionArgs) {
+    return new BranchingIncrementalExecutor(validatedExecutionArgs).executeRootSelectionSet();
+}
+//# sourceMappingURL=legacyExecuteIncrementally.js.map

package/execution/legacyIncremental/legacyExecuteIncrementally.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"legacyExecuteIncrementally.js","sourceRoot":"","sources":["../../../src/execution/legacyIncremental/legacyExecuteIncrementally.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,qBAAqB,EAAE,uBAAsB;AAQtD,OAAO,EAAE,4BAA4B,EAAE,2CAA0C;AAoIjF,MAAM,UAAU,0BAA0B,CACxC,IAAmB;IAMnB,MAAM,sBAAsB,GAAG,qBAAqB,CAAC,IAAI,CAAC,CAAC;IAG3D,IAAI,CAAC,CAAC,QAAQ,IAAI,sBAAsB,CAAC,EAAE,CAAC;QAC1C,OAAO,EAAE,MAAM,EAAE,sBAAsB,EAAE,CAAC;IAC5C,CAAC;IAED,OAAO,6BAA6B,CAAC,sBAAsB,CAAC,CAAC;AAC/D,CAAC;AA8BD,MAAM,UAAU,6BAA6B,CAC3C,sBAA8C;IAI9C,OAAO,IAAI,4BAA4B,CACrC,sBAAsB,CACvB,CAAC,uBAAuB,EAAE,CAAC;AAC9B,CAAC","sourcesContent":["/** @category Legacy Incremental Execution */\n\nimport type { PromiseOrValue } from '../../jsutils/PromiseOrValue.ts';\n\nimport { validateExecutionArgs } from '../execute.ts';\nimport type {\n  ExecutionArgs,\n  ValidatedExecutionArgs,\n} from '../ExecutionArgs.ts';\nimport type { ExecutionResult } from '../Executor.ts';\n\nimport type { LegacyExperimentalIncrementalExecutionResults } from './BranchingIncrementalExecutor.ts';\nimport { BranchingIncrementalExecutor } from './BranchingIncrementalExecutor.ts';\n\n/**\n * Executes a GraphQL operation with support for `@defer` and `@stream` using\n * the legacy incremental delivery payload format.\n *\n * Prefer `experimentalExecuteIncrementally` for the current incremental\n * delivery format. In the legacy format, each subsequent incremental payload\n * identifies its location with `path` and optional `label` fields. The current\n * format instead tracks pending work by `id` and reports completion through\n * `completed` entries.\n * @param args - Execution arguments for the GraphQL operation.\n * @returns A single execution result or legacy incremental execution results.\n * @example\n * ```ts\n * import assert from 'node:assert';\n * import { parse } from 'graphql/language';\n * import { buildSchema } from 'graphql/utilities';\n * import { legacyExecuteIncrementally } from 'graphql/execution';\n *\n * const schema = buildSchema(`\n *   type Query {\n *     hero: Hero\n *   }\n *\n *   type Hero {\n *     id: ID!\n *     name: String!\n *   }\n * `);\n *\n * const result = await legacyExecuteIncrementally({\n *   schema,\n *   document: parse('{ hero { id ... @defer(label: \"HeroName\") { name } } }'),\n *   rootValue: { hero: { id: '1', name: 'Luke' } },\n * });\n *\n * assert('initialResult' in result);\n *\n * result.initialResult; // => { data: { hero: { id: '1' } }, hasNext: true }\n *\n * const deferred = await result.subsequentResults.next();\n * deferred.value; // => { incremental: [ { data: { name: 'Luke' }, path: ['hero'], label: 'HeroName' } ], hasNext: false }\n * ```\n * @example\n * Compare the legacy payload format with the current incremental delivery\n * format returned by `experimentalExecuteIncrementally`.\n * ```ts\n * import assert from 'node:assert';\n * import { parse } from 'graphql/language';\n * import { buildSchema } from 'graphql/utilities';\n * import {\n *   experimentalExecuteIncrementally,\n *   legacyExecuteIncrementally,\n * } from 'graphql/execution';\n *\n * const schema = buildSchema(`\n *   type Query {\n *     hero: Hero\n *   }\n *\n *   type Hero {\n *     id: ID!\n *     name: String!\n *   }\n * `);\n * const document = parse('{ hero { id ... @defer { name } } }');\n * const rootValue = { hero: { id: '1', name: 'Luke' } };\n *\n * const experimental = await experimentalExecuteIncrementally({\n *   schema,\n *   document,\n *   rootValue,\n * });\n * const legacy = await legacyExecuteIncrementally({\n *   schema,\n *   document,\n *   rootValue,\n * });\n *\n * assert('initialResult' in experimental);\n * assert('initialResult' in legacy);\n *\n * experimental.initialResult; // => { data: { hero: { id: '1' } }, pending: [ { id: '0', path: ['hero'] } ], hasNext: true }\n * legacy.initialResult; // => { data: { hero: { id: '1' } }, hasNext: true }\n *\n * const experimentalDeferred = await experimental.subsequentResults.next();\n * experimentalDeferred.value; // => { incremental: [{ data: { name: 'Luke' }, id: '0' }], completed: [{ id: '0' }], hasNext: false }\n *\n * const legacyDeferred = await legacy.subsequentResults.next();\n * legacyDeferred.value; // => { incremental: [ { data: { name: 'Luke' }, path: ['hero'] } ], hasNext: false }\n * ```\n * @example\n * Compare streamed list payloads in the legacy and current incremental\n * delivery formats.\n * ```ts\n * import assert from 'node:assert';\n * import { parse } from 'graphql/language';\n * import { buildSchema } from 'graphql/utilities';\n * import {\n *   experimentalExecuteIncrementally,\n *   legacyExecuteIncrementally,\n * } from 'graphql/execution';\n *\n * const schema = buildSchema('type Query { colors: [String] }');\n * const document = parse('{ colors @stream(initialCount: 1) }');\n * const rootValue = { colors: ['red', 'green', 'blue'] };\n *\n * const experimental = await experimentalExecuteIncrementally({\n *   schema,\n *   document,\n *   rootValue,\n * });\n * const legacy = await legacyExecuteIncrementally({\n *   schema,\n *   document,\n *   rootValue,\n * });\n *\n * assert('initialResult' in experimental);\n * assert('initialResult' in legacy);\n *\n * experimental.initialResult; // => { data: { colors: ['red'] }, pending: [ { id: '0', path: ['colors'] } ], hasNext: true }\n * legacy.initialResult; // => { data: { colors: ['red'] }, hasNext: true }\n *\n * const experimentalStream = await experimental.subsequentResults.next();\n * experimentalStream.value; // => { incremental: [ { items: ['green', 'blue'], id: '0' } ], completed: [{ id: '0' }], hasNext: false }\n *\n * const legacyStream = await legacy.subsequentResults.next();\n * legacyStream.value; // => { incremental: [ { items: ['green', 'blue'], path: ['colors', 1] } ], hasNext: false }\n * ```\n */\nexport function legacyExecuteIncrementally(\n  args: ExecutionArgs,\n): PromiseOrValue<\n  ExecutionResult | LegacyExperimentalIncrementalExecutionResults\n> {\n  // If a valid execution context cannot be created due to incorrect arguments,\n  // a \"Response\" with only errors is returned.\n  const validatedExecutionArgs = validateExecutionArgs(args);\n\n  // Return early errors if execution context failed.\n  if (!('schema' in validatedExecutionArgs)) {\n    return { errors: validatedExecutionArgs };\n  }\n\n  return legacyExecuteRootSelectionSet(validatedExecutionArgs);\n}\n\n/**\n * Executes a validated operation root selection set with support for `@defer`\n * and `@stream` using the legacy incremental delivery payload format.\n * @param validatedExecutionArgs - Validated execution arguments.\n * @returns A single execution result or legacy incremental execution results.\n * @example\n * ```ts\n * import assert from 'node:assert';\n * import { parse } from 'graphql/language';\n * import { buildSchema } from 'graphql/utilities';\n * import {\n *   legacyExecuteRootSelectionSet,\n *   validateExecutionArgs,\n * } from 'graphql/execution';\n *\n * const schema = buildSchema('type Query { greeting: String }');\n * const validatedArgs = validateExecutionArgs({\n *   schema,\n *   document: parse('{ greeting }'),\n *   rootValue: { greeting: 'Hello' },\n * });\n *\n * assert('schema' in validatedArgs);\n *\n * const result = await legacyExecuteRootSelectionSet(validatedArgs);\n * result; // => { data: { greeting: 'Hello' } }\n * ```\n */\nexport function legacyExecuteRootSelectionSet(\n  validatedExecutionArgs: ValidatedExecutionArgs,\n): PromiseOrValue<\n  ExecutionResult | LegacyExperimentalIncrementalExecutionResults\n> {\n  return new BranchingIncrementalExecutor(\n    validatedExecutionArgs,\n  ).executeRootSelectionSet();\n}\n"]}

package/execution/mapAsyncIterable.d.mts

@@ -1,6 +1,8 @@
-import type { PromiseOrValue } from '../jsutils/PromiseOrValue.js';
+import type { PromiseOrValue } from "../jsutils/PromiseOrValue.mjs";
 /**
  * Given an AsyncIterable and a callback function, return an AsyncIterator
  * which produces values mapped via calling the callback function.
+ *
+ * @internal
  */
 export declare function mapAsyncIterable<T, U>(iterable: AsyncGenerator<T> | AsyncIterable<T>, callback: (value: T) => PromiseOrValue<U>): AsyncGenerator<U, void, void>;

package/execution/mapAsyncIterable.d.ts

@@ -1,6 +1,8 @@
-import type { PromiseOrValue } from '../jsutils/PromiseOrValue.js';
+import type { PromiseOrValue } from "../jsutils/PromiseOrValue.js";
 /**
  * Given an AsyncIterable and a callback function, return an AsyncIterator
  * which produces values mapped via calling the callback function.
+ *
+ * @internal
  */
 export declare function mapAsyncIterable<T, U>(iterable: AsyncGenerator<T> | AsyncIterable<T>, callback: (value: T) => PromiseOrValue<U>): AsyncGenerator<U, void, void>;

package/execution/mapAsyncIterable.js

@@ -1,12 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.mapAsyncIterable = mapAsyncIterable;
-const isPromise_js_1 = require("../jsutils/isPromise.js");
-const withConcurrentAbruptClose_js_1 = require("./withConcurrentAbruptClose.js");
-/**
- * Given an AsyncIterable and a callback function, return an AsyncIterator
- * which produces values mapped via calling the callback function.
- */
+const isPromise_ts_1 = require("../jsutils/isPromise.js");
+const withConcurrentAbruptClose_ts_1 = require("./withConcurrentAbruptClose.js");
 function mapAsyncIterable(iterable, callback) {
     const iterator = iterable[Symbol.asyncIterator]();
     const returnFn = iterator.return?.bind(iterator);
@@ -17,20 +13,19 @@ function mapAsyncIterable(iterable, callback) {
     const onThrow = throwFn
         ? (reason) => callIgnoringErrors(() => throwFn(reason))
         : onReturn;
-    return (0, withConcurrentAbruptClose_js_1.withConcurrentAbruptClose)(mapAsyncIterableImpl(iterable, callback), onReturn, onThrow);
+    return (0, withConcurrentAbruptClose_ts_1.withConcurrentAbruptClose)(mapAsyncIterableImpl(iterable, callback), onReturn, onThrow);
 }
 async function callIgnoringErrors(fn) {
     try {
         await fn();
     }
     catch {
-        // ignore error
     }
 }
 async function* mapAsyncIterableImpl(iterable, mapFn) {
     for await (const value of iterable) {
         const result = mapFn(value);
-        if ((0, isPromise_js_1.isPromise)(result)) {
+        if ((0, isPromise_ts_1.isPromise)(result)) {
             yield await result;
             continue;
         }

package/execution/mapAsyncIterable.js.map

@@ -1 +1 @@
-{"version":3,"file":"mapAsyncIterable.js","sourceRoot":"","sources":["../../src/execution/mapAsyncIterable.ts"],"names":[],"mappings":";;AASA,4CAqBC;AA9BD,0DAAoD;AAGpD,iFAA2E;AAE3E;;;GAGG;AACH,SAAgB,gBAAgB,CAC9B,QAA8C,EAC9C,QAAyC;IAEzC,MAAM,QAAQ,GAAG,QAAQ,CAAC,MAAM,CAAC,aAAa,CAAC,EAAE,CAAC;IAClD,MAAM,QAAQ,GAAG,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC;IACjD,MAAM,OAAO,GAAG,QAAQ,CAAC,KAAK,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC;IAE/C,MAAM,QAAQ,GAAG,QAAQ;QACvB,CAAC,CAAC,GAAG,EAAE,CAAC,kBAAkB,CAAC,QAAQ,CAAC;QACpC,CAAC,CAAC,GAAG,EAAE,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC;IAE5B,MAAM,OAAO,GAAG,OAAO;QACrB,CAAC,CAAC,CAAC,MAAgB,EAAE,EAAE,CAAC,kBAAkB,CAAC,GAAG,EAAE,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;QACjE,CAAC,CAAC,QAAQ,CAAC;IAEb,OAAO,IAAA,wDAAyB,EAC9B,oBAAoB,CAAC,QAAQ,EAAE,QAAQ,CAAC,EACxC,QAAQ,EACR,OAAO,CACR,CAAC;AACJ,CAAC;AAED,KAAK,UAAU,kBAAkB,CAAC,EAA0B;IAC1D,IAAI,CAAC;QACH,MAAM,EAAE,EAAE,CAAC;IACb,CAAC;IAAC,MAAM,CAAC;QACP,eAAe;IACjB,CAAC;AACH,CAAC;AAED,KAAK,SAAS,CAAC,CAAC,oBAAoB,CAClC,QAAuD,EACvD,KAAsC;IAEtC,IAAI,KAAK,EAAE,MAAM,KAAK,IAAI,QAAQ,EAAE,CAAC;QACnC,MAAM,MAAM,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC;QAC5B,IAAI,IAAA,wBAAS,EAAC,MAAM,CAAC,EAAE,CAAC;YACtB,MAAM,MAAM,MAAM,CAAC;YACnB,SAAS;QACX,CAAC;QACD,MAAM,MAAM,CAAC;IACf,CAAC;AACH,CAAC","sourcesContent":["import { isPromise } from '../jsutils/isPromise.js';\nimport type { PromiseOrValue } from '../jsutils/PromiseOrValue.js';\n\nimport { withConcurrentAbruptClose } from './withConcurrentAbruptClose.js';\n\n/**\n * Given an AsyncIterable and a callback function, return an AsyncIterator\n * which produces values mapped via calling the callback function.\n */\nexport function mapAsyncIterable<T, U>(\n  iterable: AsyncGenerator<T> | AsyncIterable<T>,\n  callback: (value: T) => PromiseOrValue<U>,\n): AsyncGenerator<U, void, void> {\n  const iterator = iterable[Symbol.asyncIterator]();\n  const returnFn = iterator.return?.bind(iterator);\n  const throwFn = iterator.throw?.bind(iterator);\n\n  const onReturn = returnFn\n    ? () => callIgnoringErrors(returnFn)\n    : () => Promise.resolve();\n\n  const onThrow = throwFn\n    ? (reason?: unknown) => callIgnoringErrors(() => throwFn(reason))\n    : onReturn;\n\n  return withConcurrentAbruptClose(\n    mapAsyncIterableImpl(iterable, callback),\n    onReturn,\n    onThrow,\n  );\n}\n\nasync function callIgnoringErrors(fn: () => Promise<unknown>): Promise<void> {\n  try {\n    await fn();\n  } catch {\n    // ignore error\n  }\n}\n\nasync function* mapAsyncIterableImpl<T, U, R = undefined>(\n  iterable: AsyncGenerator<T, R, void> | AsyncIterable<T>,\n  mapFn: (value: T) => PromiseOrValue<U>,\n): AsyncGenerator<U, void, void> {\n  for await (const value of iterable) {\n    const result = mapFn(value);\n    if (isPromise(result)) {\n      yield await result;\n      continue;\n    }\n    yield result;\n  }\n}\n"]}
+{"version":3,"file":"mapAsyncIterable.js","sourceRoot":"","sources":["../../src/execution/mapAsyncIterable.ts"],"names":[],"mappings":";;AAWA,4CAqBC;AAhCD,0DAAoD;AAGpD,iFAA2E;AAQ3E,SAAgB,gBAAgB,CAC9B,QAA8C,EAC9C,QAAyC;IAEzC,MAAM,QAAQ,GAAG,QAAQ,CAAC,MAAM,CAAC,aAAa,CAAC,EAAE,CAAC;IAClD,MAAM,QAAQ,GAAG,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC;IACjD,MAAM,OAAO,GAAG,QAAQ,CAAC,KAAK,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC;IAE/C,MAAM,QAAQ,GAAG,QAAQ;QACvB,CAAC,CAAC,GAAG,EAAE,CAAC,kBAAkB,CAAC,QAAQ,CAAC;QACpC,CAAC,CAAC,GAAG,EAAE,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC;IAE5B,MAAM,OAAO,GAAG,OAAO;QACrB,CAAC,CAAC,CAAC,MAAgB,EAAE,EAAE,CAAC,kBAAkB,CAAC,GAAG,EAAE,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;QACjE,CAAC,CAAC,QAAQ,CAAC;IAEb,OAAO,IAAA,wDAAyB,EAC9B,oBAAoB,CAAC,QAAQ,EAAE,QAAQ,CAAC,EACxC,QAAQ,EACR,OAAO,CACR,CAAC;AACJ,CAAC;AAED,KAAK,UAAU,kBAAkB,CAAC,EAA0B;IAC1D,IAAI,CAAC;QACH,MAAM,EAAE,EAAE,CAAC;IACb,CAAC;IAAC,MAAM,CAAC;IAET,CAAC;AACH,CAAC;AAED,KAAK,SAAS,CAAC,CAAC,oBAAoB,CAClC,QAAuD,EACvD,KAAsC;IAEtC,IAAI,KAAK,EAAE,MAAM,KAAK,IAAI,QAAQ,EAAE,CAAC;QACnC,MAAM,MAAM,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC;QAC5B,IAAI,IAAA,wBAAS,EAAC,MAAM,CAAC,EAAE,CAAC;YACtB,MAAM,MAAM,MAAM,CAAC;YACnB,SAAS;QACX,CAAC;QACD,MAAM,MAAM,CAAC;IACf,CAAC;AACH,CAAC","sourcesContent":["import { isPromise } from '../jsutils/isPromise.ts';\nimport type { PromiseOrValue } from '../jsutils/PromiseOrValue.ts';\n\nimport { withConcurrentAbruptClose } from './withConcurrentAbruptClose.ts';\n\n/**\n * Given an AsyncIterable and a callback function, return an AsyncIterator\n * which produces values mapped via calling the callback function.\n *\n * @internal\n */\nexport function mapAsyncIterable<T, U>(\n  iterable: AsyncGenerator<T> | AsyncIterable<T>,\n  callback: (value: T) => PromiseOrValue<U>,\n): AsyncGenerator<U, void, void> {\n  const iterator = iterable[Symbol.asyncIterator]();\n  const returnFn = iterator.return?.bind(iterator);\n  const throwFn = iterator.throw?.bind(iterator);\n\n  const onReturn = returnFn\n    ? () => callIgnoringErrors(returnFn)\n    : () => Promise.resolve();\n\n  const onThrow = throwFn\n    ? (reason?: unknown) => callIgnoringErrors(() => throwFn(reason))\n    : onReturn;\n\n  return withConcurrentAbruptClose(\n    mapAsyncIterableImpl(iterable, callback),\n    onReturn,\n    onThrow,\n  );\n}\n\nasync function callIgnoringErrors(fn: () => Promise<unknown>): Promise<void> {\n  try {\n    await fn();\n  } catch {\n    // ignore error\n  }\n}\n\nasync function* mapAsyncIterableImpl<T, U, R = undefined>(\n  iterable: AsyncGenerator<T, R, void> | AsyncIterable<T>,\n  mapFn: (value: T) => PromiseOrValue<U>,\n): AsyncGenerator<U, void, void> {\n  for await (const value of iterable) {\n    const result = mapFn(value);\n    if (isPromise(result)) {\n      yield await result;\n      continue;\n    }\n    yield result;\n  }\n}\n"]}

package/execution/mapAsyncIterable.mjs

@@ -1,9 +1,5 @@
 import { isPromise } from "../jsutils/isPromise.mjs";
 import { withConcurrentAbruptClose } from "./withConcurrentAbruptClose.mjs";
-/**
- * Given an AsyncIterable and a callback function, return an AsyncIterator
- * which produces values mapped via calling the callback function.
- */
 export function mapAsyncIterable(iterable, callback) {
     const iterator = iterable[Symbol.asyncIterator]();
     const returnFn = iterator.return?.bind(iterator);
@@ -21,7 +17,6 @@ async function callIgnoringErrors(fn) {
         await fn();
     }
     catch {
-        // ignore error
     }
 }
 async function* mapAsyncIterableImpl(iterable, mapFn) {