diff --git a/src/execution/IncrementalGraph.ts b/src/execution/IncrementalGraph.ts index cc31c21207..ac45cefe8a 100644 --- a/src/execution/IncrementalGraph.ts +++ b/src/execution/IncrementalGraph.ts @@ -7,24 +7,21 @@ import type { GraphQLError } from '../error/GraphQLError.js'; import type { DeferredFragmentRecord, - DeferredGroupedFieldSetRecord, + DeliveryGroup, IncrementalDataRecord, IncrementalDataRecordResult, - ReconcilableDeferredGroupedFieldSetResult, + PendingExecutionGroup, StreamItemRecord, StreamRecord, - SubsequentResultRecord, -} from './types.js'; -import { - isDeferredFragmentRecord, - isDeferredGroupedFieldSetRecord, + SuccessfulExecutionGroup, } from './types.js'; +import { isDeferredFragmentRecord, isPendingExecutionGroup } from './types.js'; /** * @internal */ export class IncrementalGraph { - private _rootNodes: Set; + private _rootNodes: Set; private _completedQueue: Array; private _nextQueue: Array< @@ -39,8 +36,8 @@ export class IncrementalGraph { getNewRootNodes( incrementalDataRecords: ReadonlyArray, - ): ReadonlyArray { - const initialResultChildren = new Set(); + ): ReadonlyArray { + const initialResultChildren = new Set(); this._addIncrementalDataRecords( incrementalDataRecords, undefined, @@ -49,23 +46,25 @@ export class IncrementalGraph { return this._promoteNonEmptyToRoot(initialResultChildren); } - addCompletedReconcilableDeferredGroupedFieldSet( - reconcilableResult: ReconcilableDeferredGroupedFieldSetResult, + addCompletedSuccessfulExecutionGroup( + successfulExecutionGroup: SuccessfulExecutionGroup, ): void { - for (const deferredFragmentRecord of reconcilableResult - .deferredGroupedFieldSetRecord.deferredFragmentRecords) { - deferredFragmentRecord.deferredGroupedFieldSetRecords.delete( - reconcilableResult.deferredGroupedFieldSetRecord, + for (const deferredFragmentRecord of successfulExecutionGroup + .pendingExecutionGroup.deferredFragmentRecords) { + deferredFragmentRecord.pendingExecutionGroups.delete( + successfulExecutionGroup.pendingExecutionGroup, + ); + deferredFragmentRecord.successfulExecutionGroups.add( + successfulExecutionGroup, ); - deferredFragmentRecord.reconcilableResults.add(reconcilableResult); } - const incrementalDataRecords = reconcilableResult.incrementalDataRecords; + const incrementalDataRecords = + successfulExecutionGroup.incrementalDataRecords; if (incrementalDataRecords !== undefined) { this._addIncrementalDataRecords( incrementalDataRecords, - reconcilableResult.deferredGroupedFieldSetRecord - .deferredFragmentRecords, + successfulExecutionGroup.pendingExecutionGroup.deferredFragmentRecords, ); } } @@ -104,32 +103,32 @@ export class IncrementalGraph { completeDeferredFragment(deferredFragmentRecord: DeferredFragmentRecord): | { - newRootNodes: ReadonlyArray; - reconcilableResults: ReadonlyArray; + newRootNodes: ReadonlyArray; + successfulExecutionGroups: ReadonlyArray; } | undefined { if ( !this._rootNodes.has(deferredFragmentRecord) || - deferredFragmentRecord.deferredGroupedFieldSetRecords.size > 0 + deferredFragmentRecord.pendingExecutionGroups.size > 0 ) { return; } - const reconcilableResults = Array.from( - deferredFragmentRecord.reconcilableResults, + const successfulExecutionGroups = Array.from( + deferredFragmentRecord.successfulExecutionGroups, ); this._removeRootNode(deferredFragmentRecord); - for (const reconcilableResult of reconcilableResults) { - for (const otherDeferredFragmentRecord of reconcilableResult - .deferredGroupedFieldSetRecord.deferredFragmentRecords) { - otherDeferredFragmentRecord.reconcilableResults.delete( - reconcilableResult, + for (const successfulExecutionGroup of successfulExecutionGroups) { + for (const otherDeferredFragmentRecord of successfulExecutionGroup + .pendingExecutionGroup.deferredFragmentRecords) { + otherDeferredFragmentRecord.successfulExecutionGroups.delete( + successfulExecutionGroup, ); } } const newRootNodes = this._promoteNonEmptyToRoot( deferredFragmentRecord.children, ); - return { newRootNodes, reconcilableResults }; + return { newRootNodes, successfulExecutionGroups }; } removeDeferredFragment( @@ -146,30 +145,28 @@ export class IncrementalGraph { this._removeRootNode(streamRecord); } - private _removeRootNode( - subsequentResultRecord: SubsequentResultRecord, - ): void { - this._rootNodes.delete(subsequentResultRecord); + private _removeRootNode(deliveryGroup: DeliveryGroup): void { + this._rootNodes.delete(deliveryGroup); } private _addIncrementalDataRecords( incrementalDataRecords: ReadonlyArray, parents: ReadonlyArray | undefined, - initialResultChildren?: Set | undefined, + initialResultChildren?: Set | undefined, ): void { for (const incrementalDataRecord of incrementalDataRecords) { - if (isDeferredGroupedFieldSetRecord(incrementalDataRecord)) { + if (isPendingExecutionGroup(incrementalDataRecord)) { for (const deferredFragmentRecord of incrementalDataRecord.deferredFragmentRecords) { this._addDeferredFragment( deferredFragmentRecord, initialResultChildren, ); - deferredFragmentRecord.deferredGroupedFieldSetRecords.add( + deferredFragmentRecord.pendingExecutionGroups.add( incrementalDataRecord, ); } if (this._completesRootNode(incrementalDataRecord)) { - this._onDeferredGroupedFieldSet(incrementalDataRecord); + this._onExecutionGroup(incrementalDataRecord); } } else if (parents === undefined) { invariant(initialResultChildren !== undefined); @@ -184,15 +181,15 @@ export class IncrementalGraph { } private _promoteNonEmptyToRoot( - maybeEmptyNewRootNodes: Set, - ): ReadonlyArray { - const newRootNodes: Array = []; + maybeEmptyNewRootNodes: Set, + ): ReadonlyArray { + const newRootNodes: Array = []; for (const node of maybeEmptyNewRootNodes) { if (isDeferredFragmentRecord(node)) { - if (node.deferredGroupedFieldSetRecords.size > 0) { - for (const deferredGroupedFieldSetRecord of node.deferredGroupedFieldSetRecords) { - if (!this._completesRootNode(deferredGroupedFieldSetRecord)) { - this._onDeferredGroupedFieldSet(deferredGroupedFieldSetRecord); + if (node.pendingExecutionGroups.size > 0) { + for (const pendingExecutionGroup of node.pendingExecutionGroups) { + if (!this._completesRootNode(pendingExecutionGroup)) { + this._onExecutionGroup(pendingExecutionGroup); } } this._rootNodes.add(node); @@ -214,16 +211,16 @@ export class IncrementalGraph { } private _completesRootNode( - deferredGroupedFieldSetRecord: DeferredGroupedFieldSetRecord, + pendingExecutionGroup: PendingExecutionGroup, ): boolean { - return deferredGroupedFieldSetRecord.deferredFragmentRecords.some( + return pendingExecutionGroup.deferredFragmentRecords.some( (deferredFragmentRecord) => this._rootNodes.has(deferredFragmentRecord), ); } private _addDeferredFragment( deferredFragmentRecord: DeferredFragmentRecord, - initialResultChildren: Set | undefined, + initialResultChildren: Set | undefined, ): void { if (this._rootNodes.has(deferredFragmentRecord)) { return; @@ -238,14 +235,14 @@ export class IncrementalGraph { this._addDeferredFragment(parent, initialResultChildren); } - private _onDeferredGroupedFieldSet( - deferredGroupedFieldSetRecord: DeferredGroupedFieldSetRecord, + private _onExecutionGroup( + pendingExecutionGroup: PendingExecutionGroup, ): void { - let deferredGroupedFieldSetResult = deferredGroupedFieldSetRecord.result; - if (!(deferredGroupedFieldSetResult instanceof BoxedPromiseOrValue)) { - deferredGroupedFieldSetResult = deferredGroupedFieldSetResult(); + let completedExecutionGroup = pendingExecutionGroup.result; + if (!(completedExecutionGroup instanceof BoxedPromiseOrValue)) { + completedExecutionGroup = completedExecutionGroup(); } - const value = deferredGroupedFieldSetResult.value; + const value = completedExecutionGroup.value; if (isPromise(value)) { // eslint-disable-next-line @typescript-eslint/no-floating-promises value.then((resolved) => this._enqueue(resolved)); diff --git a/src/execution/IncrementalPublisher.ts b/src/execution/IncrementalPublisher.ts index dd27033ed8..51815d56e9 100644 --- a/src/execution/IncrementalPublisher.ts +++ b/src/execution/IncrementalPublisher.ts @@ -7,9 +7,10 @@ import type { GraphQLError } from '../error/GraphQLError.js'; import { IncrementalGraph } from './IncrementalGraph.js'; import type { CancellableStreamRecord, + CompletedExecutionGroup, CompletedResult, DeferredFragmentRecord, - DeferredGroupedFieldSetResult, + DeliveryGroup, ExperimentalIncrementalExecutionResults, IncrementalDataRecord, IncrementalDataRecordResult, @@ -20,12 +21,11 @@ import type { PendingResult, StreamItemsResult, SubsequentIncrementalExecutionResult, - SubsequentResultRecord, } from './types.js'; import { isCancellableStreamRecord, - isDeferredGroupedFieldSetResult, - isNonReconcilableDeferredGroupedFieldSetResult, + isCompletedExecutionGroup, + isFailedExecutionGroup, } from './types.js'; export function buildIncrementalResponse( @@ -92,7 +92,7 @@ class IncrementalPublisher { } private _toPendingResults( - newRootNodes: ReadonlyArray, + newRootNodes: ReadonlyArray, ): Array { const pendingResults: Array = []; for (const node of newRootNodes) { @@ -207,27 +207,20 @@ class IncrementalPublisher { completedIncrementalData: IncrementalDataRecordResult, context: SubsequentIncrementalExecutionResultContext, ): void { - if (isDeferredGroupedFieldSetResult(completedIncrementalData)) { - this._handleCompletedDeferredGroupedFieldSet( - completedIncrementalData, - context, - ); + if (isCompletedExecutionGroup(completedIncrementalData)) { + this._handleCompletedExecutionGroup(completedIncrementalData, context); } else { this._handleCompletedStreamItems(completedIncrementalData, context); } } - private _handleCompletedDeferredGroupedFieldSet( - deferredGroupedFieldSetResult: DeferredGroupedFieldSetResult, + private _handleCompletedExecutionGroup( + completedExecutionGroup: CompletedExecutionGroup, context: SubsequentIncrementalExecutionResultContext, ): void { - if ( - isNonReconcilableDeferredGroupedFieldSetResult( - deferredGroupedFieldSetResult, - ) - ) { - for (const deferredFragmentRecord of deferredGroupedFieldSetResult - .deferredGroupedFieldSetRecord.deferredFragmentRecords) { + if (isFailedExecutionGroup(completedExecutionGroup)) { + for (const deferredFragmentRecord of completedExecutionGroup + .pendingExecutionGroup.deferredFragmentRecords) { const id = deferredFragmentRecord.id; if ( !this._incrementalGraph.removeDeferredFragment(deferredFragmentRecord) @@ -238,18 +231,18 @@ class IncrementalPublisher { invariant(id !== undefined); context.completed.push({ id, - errors: deferredGroupedFieldSetResult.errors, + errors: completedExecutionGroup.errors, }); } return; } - this._incrementalGraph.addCompletedReconcilableDeferredGroupedFieldSet( - deferredGroupedFieldSetResult, + this._incrementalGraph.addCompletedSuccessfulExecutionGroup( + completedExecutionGroup, ); - for (const deferredFragmentRecord of deferredGroupedFieldSetResult - .deferredGroupedFieldSetRecord.deferredFragmentRecords) { + for (const deferredFragmentRecord of completedExecutionGroup + .pendingExecutionGroup.deferredFragmentRecords) { const completion = this._incrementalGraph.completeDeferredFragment( deferredFragmentRecord, ); @@ -259,16 +252,16 @@ class IncrementalPublisher { const id = deferredFragmentRecord.id; invariant(id !== undefined); const incremental = context.incremental; - const { newRootNodes, reconcilableResults } = completion; + const { newRootNodes, successfulExecutionGroups } = completion; context.pending.push(...this._toPendingResults(newRootNodes)); - for (const reconcilableResult of reconcilableResults) { + for (const successfulExecutionGroup of successfulExecutionGroups) { const { bestId, subPath } = this._getBestIdAndSubPath( id, deferredFragmentRecord, - reconcilableResult, + successfulExecutionGroup, ); const incrementalEntry: IncrementalDeferResult = { - ...reconcilableResult.result, + ...successfulExecutionGroup.result, id: bestId, }; if (subPath !== undefined) { @@ -329,13 +322,13 @@ class IncrementalPublisher { private _getBestIdAndSubPath( initialId: string, initialDeferredFragmentRecord: DeferredFragmentRecord, - deferredGroupedFieldSetResult: DeferredGroupedFieldSetResult, + completedExecutionGroup: CompletedExecutionGroup, ): { bestId: string; subPath: ReadonlyArray | undefined } { let maxLength = pathToArray(initialDeferredFragmentRecord.path).length; let bestId = initialId; - for (const deferredFragmentRecord of deferredGroupedFieldSetResult - .deferredGroupedFieldSetRecord.deferredFragmentRecords) { + for (const deferredFragmentRecord of completedExecutionGroup + .pendingExecutionGroup.deferredFragmentRecords) { if (deferredFragmentRecord === initialDeferredFragmentRecord) { continue; } @@ -352,7 +345,7 @@ class IncrementalPublisher { bestId = id; } } - const subPath = deferredGroupedFieldSetResult.path.slice(maxLength); + const subPath = completedExecutionGroup.path.slice(maxLength); return { bestId, subPath: subPath.length > 0 ? subPath : undefined, diff --git a/src/execution/buildFieldPlan.ts b/src/execution/buildExecutionPlan.ts similarity index 95% rename from src/execution/buildFieldPlan.ts rename to src/execution/buildExecutionPlan.ts index 51e2fdf8bb..205141fd1d 100644 --- a/src/execution/buildFieldPlan.ts +++ b/src/execution/buildExecutionPlan.ts @@ -9,15 +9,15 @@ import type { export type DeferUsageSet = ReadonlySet; -export interface FieldPlan { +export interface ExecutionPlan { groupedFieldSet: GroupedFieldSet; newGroupedFieldSets: Map; } -export function buildFieldPlan( +export function buildExecutionPlan( originalGroupedFieldSet: GroupedFieldSet, parentDeferUsages: DeferUsageSet = new Set(), -): FieldPlan { +): ExecutionPlan { const groupedFieldSet = new Map(); const newGroupedFieldSets = new Map>(); for (const [responseKey, fieldGroup] of originalGroupedFieldSet) { diff --git a/src/execution/execute.ts b/src/execution/execute.ts index 68a901f4b7..acc3f86040 100644 --- a/src/execution/execute.ts +++ b/src/execution/execute.ts @@ -48,8 +48,8 @@ import { GraphQLStreamDirective } from '../type/directives.js'; import type { GraphQLSchema } from '../type/schema.js'; import { assertValidSchema } from '../type/validate.js'; -import type { DeferUsageSet, FieldPlan } from './buildFieldPlan.js'; -import { buildFieldPlan } from './buildFieldPlan.js'; +import type { DeferUsageSet, ExecutionPlan } from './buildExecutionPlan.js'; +import { buildExecutionPlan } from './buildExecutionPlan.js'; import type { DeferUsage, FieldGroup, @@ -63,11 +63,11 @@ import { buildIncrementalResponse } from './IncrementalPublisher.js'; import { mapAsyncIterable } from './mapAsyncIterable.js'; import type { CancellableStreamRecord, - DeferredGroupedFieldSetRecord, - DeferredGroupedFieldSetResult, + CompletedExecutionGroup, ExecutionResult, ExperimentalIncrementalExecutionResults, IncrementalDataRecord, + PendingExecutionGroup, StreamItemRecord, StreamItemResult, StreamRecord, @@ -296,9 +296,9 @@ function executeOperation( undefined, ); } else { - const fieldPLan = buildFieldPlan(groupedFieldSet); - groupedFieldSet = fieldPLan.groupedFieldSet; - const newGroupedFieldSets = fieldPLan.newGroupedFieldSets; + const executionPlan = buildExecutionPlan(groupedFieldSet); + groupedFieldSet = executionPlan.groupedFieldSet; + const newGroupedFieldSets = executionPlan.newGroupedFieldSets; const newDeferMap = addNewDeferredFragments(newDeferUsages, new Map()); graphqlWrappedResult = executeRootGroupedFieldSet( @@ -311,20 +311,19 @@ function executeOperation( ); if (newGroupedFieldSets.size > 0) { - const newDeferredGroupedFieldSetRecords = - executeDeferredGroupedFieldSets( - exeContext, - rootType, - rootValue, - undefined, - undefined, - newGroupedFieldSets, - newDeferMap, - ); - - graphqlWrappedResult = withNewDeferredGroupedFieldSets( + const newPendingExecutionGroups = collectExecutionGroups( + exeContext, + rootType, + rootValue, + undefined, + undefined, + newGroupedFieldSets, + newDeferMap, + ); + + graphqlWrappedResult = withNewExecutionGroups( graphqlWrappedResult, - newDeferredGroupedFieldSetRecords, + newPendingExecutionGroups, ); } } @@ -347,18 +346,18 @@ function executeOperation( } } -function withNewDeferredGroupedFieldSets( +function withNewExecutionGroups( result: PromiseOrValue>>, - newDeferredGroupedFieldSetRecords: ReadonlyArray, + newPendingExecutionGroups: ReadonlyArray, ): PromiseOrValue>> { if (isPromise(result)) { return result.then((resolved) => { - addIncrementalDataRecords(resolved, newDeferredGroupedFieldSetRecords); + addIncrementalDataRecords(resolved, newPendingExecutionGroups); return resolved; }); } - addIncrementalDataRecords(result, newDeferredGroupedFieldSetRecords); + addIncrementalDataRecords(result, newPendingExecutionGroups); return result; } @@ -1738,13 +1737,13 @@ function collectAndExecuteSubfields( undefined, ); } - const subFieldPlan = buildSubFieldPlan( + const subExecutionPlan = buildSubExecutionPlan( groupedFieldSet, incrementalContext?.deferUsageSet, ); - groupedFieldSet = subFieldPlan.groupedFieldSet; - const newGroupedFieldSets = subFieldPlan.newGroupedFieldSets; + groupedFieldSet = subExecutionPlan.groupedFieldSet; + const newGroupedFieldSets = subExecutionPlan.newGroupedFieldSets; const newDeferMap = addNewDeferredFragments( newDeferUsages, new Map(deferMap), @@ -1762,7 +1761,7 @@ function collectAndExecuteSubfields( ); if (newGroupedFieldSets.size > 0) { - const newDeferredGroupedFieldSetRecords = executeDeferredGroupedFieldSets( + const newPendingExecutionGroups = collectExecutionGroups( exeContext, returnType, result, @@ -1772,28 +1771,26 @@ function collectAndExecuteSubfields( newDeferMap, ); - return withNewDeferredGroupedFieldSets( - subFields, - newDeferredGroupedFieldSetRecords, - ); + return withNewExecutionGroups(subFields, newPendingExecutionGroups); } return subFields; } -function buildSubFieldPlan( +function buildSubExecutionPlan( originalGroupedFieldSet: GroupedFieldSet, deferUsageSet: DeferUsageSet | undefined, -): FieldPlan { - let fieldPlan = ( - originalGroupedFieldSet as unknown as { _fieldPlan: FieldPlan } - )._fieldPlan; - if (fieldPlan !== undefined) { - return fieldPlan; - } - fieldPlan = buildFieldPlan(originalGroupedFieldSet, deferUsageSet); - (originalGroupedFieldSet as unknown as { _fieldPlan: FieldPlan })._fieldPlan = - fieldPlan; - return fieldPlan; +): ExecutionPlan { + let executionPlan = ( + originalGroupedFieldSet as unknown as { _executionPlan: ExecutionPlan } + )._executionPlan; + if (executionPlan !== undefined) { + return executionPlan; + } + executionPlan = buildExecutionPlan(originalGroupedFieldSet, deferUsageSet); + ( + originalGroupedFieldSet as unknown as { _executionPlan: ExecutionPlan } + )._executionPlan = executionPlan; + return executionPlan; } /** @@ -2088,7 +2085,7 @@ function assertEventStream(result: unknown): AsyncIterable { return result; } -function executeDeferredGroupedFieldSets( +function collectExecutionGroups( exeContext: ExecutionContext, parentType: GraphQLObjectType, sourceValue: unknown, @@ -2096,9 +2093,8 @@ function executeDeferredGroupedFieldSets( parentDeferUsages: DeferUsageSet | undefined, newGroupedFieldSets: Map, deferMap: ReadonlyMap, -): ReadonlyArray { - const newDeferredGroupedFieldSetRecords: Array = - []; +): ReadonlyArray { + const newPendingExecutionGroups: Array = []; for (const [deferUsageSet, groupedFieldSet] of newGroupedFieldSets) { const deferredFragmentRecords = getDeferredFragmentRecords( @@ -2106,15 +2102,15 @@ function executeDeferredGroupedFieldSets( deferMap, ); - const deferredGroupedFieldSetRecord: DeferredGroupedFieldSetRecord = { + const pendingExecutionGroup: PendingExecutionGroup = { deferredFragmentRecords, result: - undefined as unknown as BoxedPromiseOrValue, + undefined as unknown as BoxedPromiseOrValue, }; const executor = () => - executeDeferredGroupedFieldSet( - deferredGroupedFieldSetRecord, + executeExecutionGroup( + pendingExecutionGroup, exeContext, parentType, sourceValue, @@ -2128,20 +2124,19 @@ function executeDeferredGroupedFieldSets( ); if (exeContext.enableEarlyExecution) { - deferredGroupedFieldSetRecord.result = new BoxedPromiseOrValue( + pendingExecutionGroup.result = new BoxedPromiseOrValue( shouldDefer(parentDeferUsages, deferUsageSet) ? Promise.resolve().then(executor) : executor(), ); } else { - deferredGroupedFieldSetRecord.result = () => - new BoxedPromiseOrValue(executor()); + pendingExecutionGroup.result = () => new BoxedPromiseOrValue(executor()); } - newDeferredGroupedFieldSetRecords.push(deferredGroupedFieldSetRecord); + newPendingExecutionGroups.push(pendingExecutionGroup); } - return newDeferredGroupedFieldSetRecords; + return newPendingExecutionGroups; } function shouldDefer( @@ -2160,8 +2155,8 @@ function shouldDefer( ); } -function executeDeferredGroupedFieldSet( - deferredGroupedFieldSetRecord: DeferredGroupedFieldSetRecord, +function executeExecutionGroup( + pendingExecutionGroup: PendingExecutionGroup, exeContext: ExecutionContext, parentType: GraphQLObjectType, sourceValue: unknown, @@ -2169,7 +2164,7 @@ function executeDeferredGroupedFieldSet( groupedFieldSet: GroupedFieldSet, incrementalContext: IncrementalContext, deferMap: ReadonlyMap, -): PromiseOrValue { +): PromiseOrValue { let result; try { result = executeFields( @@ -2183,7 +2178,7 @@ function executeDeferredGroupedFieldSet( ); } catch (error) { return { - deferredGroupedFieldSetRecord, + pendingExecutionGroup, path: pathToArray(path), errors: withError(incrementalContext.errors, error), }; @@ -2192,36 +2187,36 @@ function executeDeferredGroupedFieldSet( if (isPromise(result)) { return result.then( (resolved) => - buildDeferredGroupedFieldSetResult( + buildCompletedExecutionGroup( incrementalContext.errors, - deferredGroupedFieldSetRecord, + pendingExecutionGroup, path, resolved, ), (error) => ({ - deferredGroupedFieldSetRecord, + pendingExecutionGroup, path: pathToArray(path), errors: withError(incrementalContext.errors, error), }), ); } - return buildDeferredGroupedFieldSetResult( + return buildCompletedExecutionGroup( incrementalContext.errors, - deferredGroupedFieldSetRecord, + pendingExecutionGroup, path, result, ); } -function buildDeferredGroupedFieldSetResult( +function buildCompletedExecutionGroup( errors: ReadonlyArray | undefined, - deferredGroupedFieldSetRecord: DeferredGroupedFieldSetRecord, + pendingExecutionGroup: PendingExecutionGroup, path: Path | undefined, result: GraphQLWrappedResult>, -): DeferredGroupedFieldSetResult { +): CompletedExecutionGroup { return { - deferredGroupedFieldSetRecord, + pendingExecutionGroup, path: pathToArray(path), result: errors === undefined ? { data: result[0] } : { data: result[0], errors }, diff --git a/src/execution/types.ts b/src/execution/types.ts index c88ae9986e..d300a4481c 100644 --- a/src/execution/types.ts +++ b/src/execution/types.ts @@ -88,7 +88,7 @@ export interface FormattedSubsequentIncrementalExecutionResult< extensions?: TExtensions; } -interface BareDeferredGroupedFieldSetResult> { +interface ExecutionGroupResult> { errors?: ReadonlyArray; data: TData; } @@ -96,7 +96,7 @@ interface BareDeferredGroupedFieldSetResult> { export interface IncrementalDeferResult< TData = ObjMap, TExtensions = ObjMap, -> extends BareDeferredGroupedFieldSetResult { +> extends ExecutionGroupResult { id: string; subPath?: ReadonlyArray; extensions?: TExtensions; @@ -113,7 +113,7 @@ export interface FormattedIncrementalDeferResult< extensions?: TExtensions; } -interface BareStreamItemsResult> { +interface StreamItemsRecordResult> { errors?: ReadonlyArray; items: TData; } @@ -121,7 +121,7 @@ interface BareStreamItemsResult> { export interface IncrementalStreamResult< TData = ReadonlyArray, TExtensions = ObjMap, -> extends BareStreamItemsResult { +> extends StreamItemsRecordResult { id: string; subPath?: ReadonlyArray; extensions?: TExtensions; @@ -166,53 +166,53 @@ export interface FormattedCompletedResult { errors?: ReadonlyArray; } -export function isDeferredGroupedFieldSetRecord( +export function isPendingExecutionGroup( incrementalDataRecord: IncrementalDataRecord, -): incrementalDataRecord is DeferredGroupedFieldSetRecord { +): incrementalDataRecord is PendingExecutionGroup { return 'deferredFragmentRecords' in incrementalDataRecord; } -export type DeferredGroupedFieldSetResult = - | ReconcilableDeferredGroupedFieldSetResult - | NonReconcilableDeferredGroupedFieldSetResult; +export type CompletedExecutionGroup = + | SuccessfulExecutionGroup + | FailedExecutionGroup; -export function isDeferredGroupedFieldSetResult( - subsequentResult: DeferredGroupedFieldSetResult | StreamItemsResult, -): subsequentResult is DeferredGroupedFieldSetResult { - return 'deferredGroupedFieldSetRecord' in subsequentResult; +export function isCompletedExecutionGroup( + subsequentResult: CompletedExecutionGroup | StreamItemsResult, +): subsequentResult is CompletedExecutionGroup { + return 'pendingExecutionGroup' in subsequentResult; } -export interface ReconcilableDeferredGroupedFieldSetResult { - deferredGroupedFieldSetRecord: DeferredGroupedFieldSetRecord; +export interface SuccessfulExecutionGroup { + pendingExecutionGroup: PendingExecutionGroup; path: Array; - result: BareDeferredGroupedFieldSetResult; + result: ExecutionGroupResult; incrementalDataRecords: ReadonlyArray | undefined; errors?: never; } -interface NonReconcilableDeferredGroupedFieldSetResult { - deferredGroupedFieldSetRecord: DeferredGroupedFieldSetRecord; +interface FailedExecutionGroup { + pendingExecutionGroup: PendingExecutionGroup; path: Array; errors: ReadonlyArray; result?: never; } -export function isNonReconcilableDeferredGroupedFieldSetResult( - deferredGroupedFieldSetResult: DeferredGroupedFieldSetResult, -): deferredGroupedFieldSetResult is NonReconcilableDeferredGroupedFieldSetResult { - return deferredGroupedFieldSetResult.errors !== undefined; +export function isFailedExecutionGroup( + completedExecutionGroup: CompletedExecutionGroup, +): completedExecutionGroup is FailedExecutionGroup { + return completedExecutionGroup.errors !== undefined; } type ThunkIncrementalResult = | BoxedPromiseOrValue | (() => BoxedPromiseOrValue); -export interface DeferredGroupedFieldSetRecord { +export interface PendingExecutionGroup { deferredFragmentRecords: ReadonlyArray; - result: ThunkIncrementalResult; + result: ThunkIncrementalResult; } -export type SubsequentResultRecord = DeferredFragmentRecord | StreamRecord; +export type DeliveryGroup = DeferredFragmentRecord | StreamRecord; /** @internal */ export class DeferredFragmentRecord { @@ -220,9 +220,9 @@ export class DeferredFragmentRecord { label: string | undefined; id?: string | undefined; parent: DeferredFragmentRecord | undefined; - deferredGroupedFieldSetRecords: Set; - reconcilableResults: Set; - children: Set; + pendingExecutionGroups: Set; + successfulExecutionGroups: Set; + children: Set; constructor( path: Path | undefined, @@ -232,16 +232,16 @@ export class DeferredFragmentRecord { this.path = path; this.label = label; this.parent = parent; - this.deferredGroupedFieldSetRecords = new Set(); - this.reconcilableResults = new Set(); + this.pendingExecutionGroups = new Set(); + this.successfulExecutionGroups = new Set(); this.children = new Set(); } } export function isDeferredFragmentRecord( - subsequentResultRecord: SubsequentResultRecord, -): subsequentResultRecord is DeferredFragmentRecord { - return subsequentResultRecord instanceof DeferredFragmentRecord; + deliveryGroup: DeliveryGroup, +): deliveryGroup is DeferredFragmentRecord { + return deliveryGroup instanceof DeferredFragmentRecord; } export interface StreamItemResult { @@ -261,9 +261,9 @@ export interface StreamRecord { export interface StreamItemsResult { streamRecord: StreamRecord; - result?: BareStreamItemsResult | undefined; + errors?: ReadonlyArray; + result?: StreamItemsRecordResult; incrementalDataRecords?: ReadonlyArray | undefined; - errors?: ReadonlyArray | undefined; } export interface CancellableStreamRecord extends StreamRecord { @@ -271,15 +271,13 @@ export interface CancellableStreamRecord extends StreamRecord { } export function isCancellableStreamRecord( - subsequentResultRecord: SubsequentResultRecord, -): subsequentResultRecord is CancellableStreamRecord { - return 'earlyReturn' in subsequentResultRecord; + deliveryGroup: DeliveryGroup, +): deliveryGroup is CancellableStreamRecord { + return 'earlyReturn' in deliveryGroup; } -export type IncrementalDataRecord = - | DeferredGroupedFieldSetRecord - | StreamRecord; +export type IncrementalDataRecord = PendingExecutionGroup | StreamRecord; export type IncrementalDataRecordResult = - | DeferredGroupedFieldSetResult + | CompletedExecutionGroup | StreamItemsResult;