graphql 17.0.0-beta.1 → 17.0.0-beta.2

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

@@ -2,5 +2,7 @@ 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

@@ -2,5 +2,7 @@ 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

@@ -3,10 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.mapAsyncIterable = mapAsyncIterable;
 const isPromise_ts_1 = require("../jsutils/isPromise.js");
 const withConcurrentAbruptClose_ts_1 = require("./withConcurrentAbruptClose.js");
-/**
- * Given an AsyncIterable and a callback function, return an AsyncIterator
- * which produces values mapped via calling the callback function.
- */
 function mapAsyncIterable(iterable, callback) {
     const iterator = iterable[Symbol.asyncIterator]();
     const returnFn = iterator.return?.bind(iterator);
@@ -24,7 +20,6 @@ async function callIgnoringErrors(fn) {
         await fn();
     }
     catch {
-        // ignore error
     }
 }
 async function* mapAsyncIterableImpl(iterable, mapFn) {

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.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 */\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) {

package/execution/mapAsyncIterable.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"mapAsyncIterable.js","sourceRoot":"","sources":["../../src/execution/mapAsyncIterable.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,iCAAgC;AAGpD,OAAO,EAAE,yBAAyB,EAAE,wCAAuC;AAE3E;;;GAGG;AACH,MAAM,UAAU,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,yBAAyB,CAC9B,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,SAAS,CAAC,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 */\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":"AAAA,OAAO,EAAE,SAAS,EAAE,iCAAgC;AAGpD,OAAO,EAAE,yBAAyB,EAAE,wCAAuC;AAQ3E,MAAM,UAAU,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,yBAAyB,CAC9B,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,SAAS,CAAC,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/returnIteratorCatchingErrors.d.mts

@@ -1 +1,2 @@
+/** @internal */
 export declare function returnIteratorCatchingErrors(iterator: AsyncIterator<unknown>): Promise<void>;

package/execution/returnIteratorCatchingErrors.d.ts

@@ -1 +1,2 @@
+/** @internal */
 export declare function returnIteratorCatchingErrors(iterator: AsyncIterator<unknown>): Promise<void>;

package/execution/returnIteratorCatchingErrors.js

@@ -6,7 +6,6 @@ async function returnIteratorCatchingErrors(iterator) {
         await iterator.return?.();
     }
     catch {
-        // ignore errors
     }
 }
 //# sourceMappingURL=returnIteratorCatchingErrors.js.map

package/execution/returnIteratorCatchingErrors.js.map

@@ -1 +1 @@
-{"version":3,"file":"returnIteratorCatchingErrors.js","sourceRoot":"","sources":["../../src/execution/returnIteratorCatchingErrors.ts"],"names":[],"mappings":";;AAAA,oEAQC;AARM,KAAK,UAAU,4BAA4B,CAChD,QAAgC;IAEhC,IAAI,CAAC;QACH,MAAM,QAAQ,CAAC,MAAM,EAAE,EAAE,CAAC;IAC5B,CAAC;IAAC,MAAM,CAAC;QACP,gBAAgB;IAClB,CAAC;AACH,CAAC","sourcesContent":["export async function returnIteratorCatchingErrors(\n  iterator: AsyncIterator<unknown>,\n): Promise<void> {\n  try {\n    await iterator.return?.();\n  } catch {\n    // ignore errors\n  }\n}\n"]}
+{"version":3,"file":"returnIteratorCatchingErrors.js","sourceRoot":"","sources":["../../src/execution/returnIteratorCatchingErrors.ts"],"names":[],"mappings":";;AACA,oEAQC;AARM,KAAK,UAAU,4BAA4B,CAChD,QAAgC;IAEhC,IAAI,CAAC;QACH,MAAM,QAAQ,CAAC,MAAM,EAAE,EAAE,CAAC;IAC5B,CAAC;IAAC,MAAM,CAAC;IAET,CAAC;AACH,CAAC","sourcesContent":["/** @internal */\nexport async function returnIteratorCatchingErrors(\n  iterator: AsyncIterator<unknown>,\n): Promise<void> {\n  try {\n    await iterator.return?.();\n  } catch {\n    // ignore errors\n  }\n}\n"]}

package/execution/returnIteratorCatchingErrors.mjs

@@ -3,7 +3,6 @@ export async function returnIteratorCatchingErrors(iterator) {
         await iterator.return?.();
     }
     catch {
-        // ignore errors
     }
 }
 //# sourceMappingURL=returnIteratorCatchingErrors.js.map

package/execution/returnIteratorCatchingErrors.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"returnIteratorCatchingErrors.js","sourceRoot":"","sources":["../../src/execution/returnIteratorCatchingErrors.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,KAAK,UAAU,4BAA4B,CAChD,QAAgC;IAEhC,IAAI,CAAC;QACH,MAAM,QAAQ,CAAC,MAAM,EAAE,EAAE,CAAC;IAC5B,CAAC;IAAC,MAAM,CAAC;QACP,gBAAgB;IAClB,CAAC;AACH,CAAC","sourcesContent":["export async function returnIteratorCatchingErrors(\n  iterator: AsyncIterator<unknown>,\n): Promise<void> {\n  try {\n    await iterator.return?.();\n  } catch {\n    // ignore errors\n  }\n}\n"]}
+{"version":3,"file":"returnIteratorCatchingErrors.js","sourceRoot":"","sources":["../../src/execution/returnIteratorCatchingErrors.ts"],"names":[],"mappings":"AACA,MAAM,CAAC,KAAK,UAAU,4BAA4B,CAChD,QAAgC;IAEhC,IAAI,CAAC;QACH,MAAM,QAAQ,CAAC,MAAM,EAAE,EAAE,CAAC;IAC5B,CAAC;IAAC,MAAM,CAAC;IAET,CAAC;AACH,CAAC","sourcesContent":["/** @internal */\nexport async function returnIteratorCatchingErrors(\n  iterator: AsyncIterator<unknown>,\n): Promise<void> {\n  try {\n    await iterator.return?.();\n  } catch {\n    // ignore errors\n  }\n}\n"]}

package/execution/values.d.mts

@@ -1,3 +1,4 @@
+/** @category Values */
 import type { Maybe } from "../jsutils/Maybe.mjs";
 import type { ObjMap, ReadOnlyObjMap } from "../jsutils/ObjMap.mjs";
 import { GraphQLError } from "../error/GraphQLError.mjs";
@@ -7,8 +8,18 @@ import type { GraphQLDirective } from "../type/directives.mjs";
 import type { GraphQLSchema } from "../type/schema.mjs";
 import type { FragmentVariableValues } from "./collectFields.mjs";
 import type { GraphQLVariableSignature } from "./getVariableSignature.mjs";
+/**
+ * Coerced variable values prepared for execution.
+ *
+ * The `coerced` map contains runtime values keyed by variable name. The
+ * `sources` map records whether each value came from request input, an operation
+ * default, or a fragment-variable default so utilities can preserve defaults
+ * when replacing variables in literals.
+ */
 export interface VariableValues {
+    /** Source metadata for each variable value keyed by variable name. */
     readonly sources: ReadOnlyObjMap<VariableValueSource>;
+    /** Coerced runtime variable values keyed by variable name. */
     readonly coerced: ReadOnlyObjMap<unknown>;
 }
 interface VariableValueSource {
@@ -25,10 +36,85 @@ type VariableValuesOrErrors = {
 /**
  * Prepares an object map of variableValues of the correct type based on the
  * provided variable definitions and arbitrary input. If the input cannot be
- * parsed to match the variable definitions, a GraphQLError will be thrown.
+ * parsed to match the variable definitions, GraphQLError values are returned.
+ *
+ * Note: Returned maps use null prototypes to avoid collisions with
+ * Object prototype properties.
+ * @param schema - GraphQL schema to use.
+ * @param varDefNodes - The variable definition AST nodes to coerce.
+ * @param inputs - The runtime variable values keyed by variable name.
+ * @param options - Optional configuration for this operation.
+ * @param [options.maxErrors] - Maximum number of coercion errors to report.
+ * @param [options.hideSuggestions] - Whether suggestion text should be omitted
+ * from errors.
+ * @returns Coerced variable values with source metadata, or request errors.
+ * @example
+ * ```ts
+ * // Coerce provided variables and apply operation defaults.
+ * import assert from 'node:assert';
+ * import { parse } from 'graphql/language';
+ * import { buildSchema } from 'graphql/utilities';
+ * import { getVariableValues } from 'graphql/execution';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     reviews(stars: Int!, limit: Int = 10): [String]
+ *   }
+ * `);
+ * const document = parse(`
+ *   query ($stars: Int!, $limit: Int = 10) {
+ *     reviews(stars: $stars, limit: $limit)
+ *   }
+ * `);
+ * const operation = document.definitions[0];
+ *
+ * const result = getVariableValues(
+ *   schema,
+ *   operation.variableDefinitions,
+ *   { stars: '5' },
+ * );
+ *
+ * assert('variableValues' in result);
+ *
+ * result.variableValues.coerced; // => { stars: 5, limit: 10 }
+ * ```
+ * @example
+ * ```ts
+ * // This variant uses maxErrors to cap reported coercion errors.
+ * import assert from 'node:assert';
+ * import { parse } from 'graphql/language';
+ * import { buildSchema } from 'graphql/utilities';
+ * import { getVariableValues } from 'graphql/execution';
+ *
+ * const schema = buildSchema(`
+ *   input ReviewInput {
+ *     stars: Int!
+ *   }
+ *
+ *   type Query {
+ *     review(input: ReviewInput!): String
+ *   }
+ * `);
+ * const document = parse(`
+ *   query ($first: ReviewInput!, $second: ReviewInput!) {
+ *     first: review(input: $first)
+ *     second: review(input: $second)
+ *   }
+ * `);
+ * const operation = document.definitions[0];
+ *
+ * const result = getVariableValues(
+ *   schema,
+ *   operation.variableDefinitions,
+ *   { first: { stars: 'bad' }, second: { stars: 'also bad' } },
+ *   { maxErrors: 1 },
+ * );
  *
- * Note: The `coerced` and `sources` properties of VariableValues use null
- * prototype to avoid collisions with JavaScript's own property names.
+ * assert('errors' in result);
+ *
+ * result.errors.length; // => 2
+ * result.errors[1].message; // matches /error limit reached/
+ * ```
  */
 export declare function getVariableValues(schema: GraphQLSchema, varDefNodes: ReadonlyArray<VariableDefinitionNode>, inputs: {
     readonly [variable: string]: unknown;
@@ -36,13 +122,66 @@ export declare function getVariableValues(schema: GraphQLSchema, varDefNodes: Re
     maxErrors?: number;
     hideSuggestions?: boolean;
 }): VariableValuesOrErrors;
+/** @internal */
 export declare function getFragmentVariableValues(fragmentSpreadNode: FragmentSpreadNode, fragmentSignatures: ReadOnlyObjMap<GraphQLVariableSignature>, variableValues: VariableValues, fragmentVariableValues?: Maybe<FragmentVariableValues>, hideSuggestions?: Maybe<boolean>): FragmentVariableValues;
 /**
  * Prepares an object map of argument values given a list of argument
  * definitions and list of argument AST nodes.
  *
- * Note: The returned value uses a null prototype to avoid collisions with
+ * Note: Returned value uses a null prototype to avoid collisions with
  * JavaScript's own property names.
+ * @param def - Field or directive definition that declares the arguments.
+ * @param node - Field or directive AST node supplying argument literals.
+ * @param variableValues - Operation variable values returned by getVariableValues.
+ * @param fragmentVariableValues - Fragment variable values for the current fragment scope.
+ * @param hideSuggestions - Whether suggestion text should be omitted from errors.
+ * @returns A map of coerced argument values.
+ * @example
+ * ```ts
+ * // Read literal argument values and defaults.
+ * import { parse } from 'graphql/language';
+ * import { buildSchema } from 'graphql/utilities';
+ * import { getArgumentValues } from 'graphql/execution';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     reviews(stars: Int!, limit: Int = 10): [String]
+ *   }
+ * `);
+ * const fieldDef = schema.getQueryType().getFields().reviews;
+ * const document = parse('{ reviews(stars: 5) }');
+ * const fieldNode = document.definitions[0].selectionSet.selections[0];
+ *
+ * getArgumentValues(fieldDef, fieldNode); // => { stars: 5, limit: 10 }
+ * ```
+ * @example
+ * ```ts
+ * // This variant resolves argument values from operation variables.
+ * import assert from 'node:assert';
+ * import { parse } from 'graphql/language';
+ * import { buildSchema } from 'graphql/utilities';
+ * import { getArgumentValues, getVariableValues } from 'graphql/execution';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     reviews(stars: Int!): [String]
+ *   }
+ * `);
+ * const fieldDef = schema.getQueryType().getFields().reviews;
+ * const document = parse('query ($stars: Int!) { reviews(stars: $stars) }');
+ * const operation = document.definitions[0];
+ * const fieldNode = document.definitions[0].selectionSet.selections[0];
+ * const variables = getVariableValues(
+ *   schema,
+ *   operation.variableDefinitions,
+ *   { stars: '5' },
+ * );
+ *
+ * assert('variableValues' in variables);
+ *
+ * getArgumentValues(fieldDef, fieldNode, variables.variableValues); // => { stars: 5 }
+ * getArgumentValues(fieldDef, fieldNode); // throws an error
+ * ```
  */
 export declare function getArgumentValues(def: GraphQLField<unknown, unknown> | GraphQLDirective, node: FieldNode | DirectiveNode, variableValues?: Maybe<VariableValues>, fragmentVariableValues?: Maybe<FragmentVariableValues>, hideSuggestions?: Maybe<boolean>): ObjMap<unknown>;
 /**
@@ -52,8 +191,51 @@ export declare function getArgumentValues(def: GraphQLField<unknown, unknown> |
  *
  * If the directive does not exist on the node, returns undefined.
  *
- * Note: The returned value uses a null prototype to avoid collisions with
+ * Note: Returned value uses a null prototype to avoid collisions with
  * JavaScript's own property names.
+ * @param directiveDef - Directive definition to read argument definitions from.
+ * @param node - AST node that may contain directives.
+ * @param node.directives - The directives on the AST node.
+ * @param variableValues - Operation variable values returned by getVariableValues.
+ * @param fragmentVariableValues - Fragment variable values for the current fragment scope.
+ * @param hideSuggestions - Whether suggestion text should be omitted from errors.
+ * @returns A map of coerced directive argument values, or undefined when absent.
+ * @example
+ * ```ts
+ * // Read literal directive arguments from a node.
+ * import { parse } from 'graphql/language';
+ * import { GraphQLSkipDirective } from 'graphql/type';
+ * import { getDirectiveValues } from 'graphql/execution';
+ *
+ * const document = parse('{ name @skip(if: true) }');
+ * const fieldNode = document.definitions[0].selectionSet.selections[0];
+ *
+ * getDirectiveValues(GraphQLSkipDirective, fieldNode); // => { if: true }
+ * ```
+ * @example
+ * ```ts
+ * // This variant resolves directive arguments from variables and handles absent directives.
+ * import assert from 'node:assert';
+ * import { parse } from 'graphql/language';
+ * import { GraphQLIncludeDirective } from 'graphql/type';
+ * import { buildSchema } from 'graphql/utilities';
+ * import { getDirectiveValues, getVariableValues } from 'graphql/execution';
+ *
+ * const schema = buildSchema('type Query { name: String }');
+ * const document = parse('query ($includeName: Boolean!) { name @include(if: $includeName) }');
+ * const operation = document.definitions[0];
+ * const fieldNode = document.definitions[0].selectionSet.selections[0];
+ * const variables = getVariableValues(
+ *   schema,
+ *   operation.variableDefinitions,
+ *   { includeName: false },
+ * );
+ *
+ * assert('variableValues' in variables);
+ *
+ * getDirectiveValues(GraphQLIncludeDirective, fieldNode, variables.variableValues); // => { if: false }
+ * getDirectiveValues(GraphQLIncludeDirective, { directives: [] }); // => undefined
+ * ```
  */
 export declare function getDirectiveValues(directiveDef: GraphQLDirective, node: {
     readonly directives?: ReadonlyArray<DirectiveNode> | undefined;