@graphql-tools/executor 1.2.6 → 2.0.0-alpha-20240606221026-cd2a4fabe51906319f8dc07745f98f37ffbcbdee

package/esm/execution/getBySet.js

@@ -0,0 +1,9 @@
+import { isSameSet } from './isSameSet.js';
+export function getBySet(map, setToMatch) {
+    for (const set of map.keys()) {
+        if (isSameSet(set, setToMatch)) {
+            return map.get(set);
+        }
+    }
+    return undefined;
+}

package/esm/execution/isSameSet.js

@@ -0,0 +1,11 @@
+export function isSameSet(setA, setB) {
+    if (setA.size !== setB.size) {
+        return false;
+    }
+    for (const item of setA) {
+        if (!setB.has(item)) {
+            return false;
+        }
+    }
+    return true;
+}

package/esm/execution/promiseWithResolvers.js

@@ -0,0 +1,14 @@
+/**
+ * Based on Promise.withResolvers proposal
+ * https://github.com/tc39/proposal-promise-with-resolvers
+ */
+export function promiseWithResolvers() {
+    // these are assigned synchronously within the Promise constructor
+    let resolve;
+    let reject;
+    const promise = new Promise((res, rej) => {
+        resolve = res;
+        reject = rej;
+    });
+    return { promise, resolve, reject };
+}

package/esm/execution/types.js

@@ -0,0 +1,12 @@
+export function isDeferredGroupedFieldSetRecord(incrementalDataRecord) {
+    return 'deferredFragmentRecords' in incrementalDataRecord;
+}
+export function isDeferredGroupedFieldSetResult(subsequentResult) {
+    return 'deferredGroupedFieldSetRecord' in subsequentResult;
+}
+export function isNonReconcilableDeferredGroupedFieldSetResult(deferredGroupedFieldSetResult) {
+    return deferredGroupedFieldSetResult.errors !== undefined;
+}
+export function isCancellableStreamRecord(subsequentResultRecord) {
+    return 'earlyReturn' in subsequentResultRecord;
+}

package/package.json

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

package/typings/execution/AccumulatorMap.d.cts

@@ -0,0 +1,7 @@
+/**
+ * ES6 Map with additional `add` method to accumulate items.
+ */
+export declare class AccumulatorMap<K, T> extends Map<K, Array<T>> {
+    get [Symbol.toStringTag](): string;
+    add(key: K, item: T): void;
+}

package/typings/execution/AccumulatorMap.d.ts

@@ -0,0 +1,7 @@
+/**
+ * ES6 Map with additional `add` method to accumulate items.
+ */
+export declare class AccumulatorMap<K, T> extends Map<K, Array<T>> {
+    get [Symbol.toStringTag](): string;
+    add(key: K, item: T): void;
+}

package/typings/execution/BoxedPromiseOrValue.d.cts

@@ -0,0 +1,15 @@
+import type { MaybePromise } from '@graphql-tools/utils';
+/**
+ * A BoxedPromiseOrValue is a container for a value or promise where the value
+ * will be updated when the promise resolves.
+ *
+ * A BoxedPromiseOrValue may only be used with promises whose possible
+ * rejection has already been handled, otherwise this will lead to unhandled
+ * promise rejections.
+ *
+ * @internal
+ * */
+export declare class BoxedPromiseOrValue<T> {
+    value: MaybePromise<T>;
+    constructor(value: MaybePromise<T>);
+}

package/typings/execution/BoxedPromiseOrValue.d.ts

@@ -0,0 +1,15 @@
+import type { MaybePromise } from '@graphql-tools/utils';
+/**
+ * A BoxedPromiseOrValue is a container for a value or promise where the value
+ * will be updated when the promise resolves.
+ *
+ * A BoxedPromiseOrValue may only be used with promises whose possible
+ * rejection has already been handled, otherwise this will lead to unhandled
+ * promise rejections.
+ *
+ * @internal
+ * */
+export declare class BoxedPromiseOrValue<T> {
+    value: MaybePromise<T>;
+    constructor(value: MaybePromise<T>);
+}

package/typings/execution/IncrementalGraph.d.cts

@@ -0,0 +1,32 @@
+import type { DeferredFragmentRecord, IncrementalDataRecord, IncrementalDataRecordResult, ReconcilableDeferredGroupedFieldSetResult, StreamRecord, SubsequentResultRecord } from './types.cjs';
+/**
+ * @internal
+ */
+export declare class IncrementalGraph {
+    private _pending;
+    private _deferredFragmentNodes;
+    private _newPending;
+    private _newIncrementalDataRecords;
+    private _completedQueue;
+    private _nextQueue;
+    constructor();
+    addIncrementalDataRecords(incrementalDataRecords: ReadonlyArray<IncrementalDataRecord>): void;
+    addCompletedReconcilableDeferredGroupedFieldSet(reconcilableResult: ReconcilableDeferredGroupedFieldSetResult): void;
+    getNewPending(): ReadonlyArray<SubsequentResultRecord>;
+    completedIncrementalData(): {
+        [Symbol.asyncIterator](): any;
+        next: () => Promise<IteratorResult<Iterable<IncrementalDataRecordResult>>>;
+        return: () => Promise<IteratorResult<Iterable<IncrementalDataRecordResult>>>;
+    };
+    hasNext(): boolean;
+    completeDeferredFragment(deferredFragmentRecord: DeferredFragmentRecord): Array<ReconcilableDeferredGroupedFieldSetResult> | undefined;
+    removeDeferredFragment(deferredFragmentRecord: DeferredFragmentRecord): boolean;
+    removeStream(streamRecord: StreamRecord): void;
+    private _removePending;
+    private _addDeferredGroupedFieldSetRecord;
+    private _addStreamRecord;
+    private _addDeferredFragmentNode;
+    private _onStreamItems;
+    private _yieldCurrentCompletedIncrementalData;
+    private _enqueue;
+}

package/typings/execution/IncrementalGraph.d.ts

@@ -0,0 +1,32 @@
+import type { DeferredFragmentRecord, IncrementalDataRecord, IncrementalDataRecordResult, ReconcilableDeferredGroupedFieldSetResult, StreamRecord, SubsequentResultRecord } from './types.js';
+/**
+ * @internal
+ */
+export declare class IncrementalGraph {
+    private _pending;
+    private _deferredFragmentNodes;
+    private _newPending;
+    private _newIncrementalDataRecords;
+    private _completedQueue;
+    private _nextQueue;
+    constructor();
+    addIncrementalDataRecords(incrementalDataRecords: ReadonlyArray<IncrementalDataRecord>): void;
+    addCompletedReconcilableDeferredGroupedFieldSet(reconcilableResult: ReconcilableDeferredGroupedFieldSetResult): void;
+    getNewPending(): ReadonlyArray<SubsequentResultRecord>;
+    completedIncrementalData(): {
+        [Symbol.asyncIterator](): any;
+        next: () => Promise<IteratorResult<Iterable<IncrementalDataRecordResult>>>;
+        return: () => Promise<IteratorResult<Iterable<IncrementalDataRecordResult>>>;
+    };
+    hasNext(): boolean;
+    completeDeferredFragment(deferredFragmentRecord: DeferredFragmentRecord): Array<ReconcilableDeferredGroupedFieldSetResult> | undefined;
+    removeDeferredFragment(deferredFragmentRecord: DeferredFragmentRecord): boolean;
+    removeStream(streamRecord: StreamRecord): void;
+    private _removePending;
+    private _addDeferredGroupedFieldSetRecord;
+    private _addStreamRecord;
+    private _addDeferredFragmentNode;
+    private _onStreamItems;
+    private _yieldCurrentCompletedIncrementalData;
+    private _enqueue;
+}

package/typings/execution/IncrementalPublisher.d.cts

@@ -0,0 +1,8 @@
+import type { GraphQLError } from 'graphql';
+import type { CancellableStreamRecord, IncrementalDataRecord, IncrementalExecutionResults } from './types.cjs';
+export declare function buildIncrementalResponse<TData = any>(context: IncrementalPublisherContext, result: TData, errors: ReadonlyArray<GraphQLError> | undefined, incrementalDataRecords: ReadonlyArray<IncrementalDataRecord>): IncrementalExecutionResults<TData>;
+interface IncrementalPublisherContext {
+    signal: AbortSignal | undefined;
+    cancellableStreams: Set<CancellableStreamRecord> | undefined;
+}
+export {};

package/typings/execution/IncrementalPublisher.d.ts

@@ -0,0 +1,8 @@
+import type { GraphQLError } from 'graphql';
+import type { CancellableStreamRecord, IncrementalDataRecord, IncrementalExecutionResults } from './types.js';
+export declare function buildIncrementalResponse<TData = any>(context: IncrementalPublisherContext, result: TData, errors: ReadonlyArray<GraphQLError> | undefined, incrementalDataRecords: ReadonlyArray<IncrementalDataRecord>): IncrementalExecutionResults<TData>;
+interface IncrementalPublisherContext {
+    signal: AbortSignal | undefined;
+    cancellableStreams: Set<CancellableStreamRecord> | undefined;
+}
+export {};

package/typings/execution/buildFieldPlan.d.cts

@@ -0,0 +1,7 @@
+import type { DeferUsage, GroupedFieldSet } from './collectFields.cjs';
+export type DeferUsageSet = ReadonlySet<DeferUsage>;
+export interface FieldPlan {
+    groupedFieldSet: GroupedFieldSet;
+    newGroupedFieldSets: Map<DeferUsageSet, GroupedFieldSet>;
+}
+export declare function buildFieldPlan(originalGroupedFieldSet: GroupedFieldSet, parentDeferUsages?: DeferUsageSet): FieldPlan;

package/typings/execution/buildFieldPlan.d.ts

@@ -0,0 +1,7 @@
+import type { DeferUsage, GroupedFieldSet } from './collectFields.js';
+export type DeferUsageSet = ReadonlySet<DeferUsage>;
+export interface FieldPlan {
+    groupedFieldSet: GroupedFieldSet;
+    newGroupedFieldSets: Map<DeferUsageSet, GroupedFieldSet>;
+}
+export declare function buildFieldPlan(originalGroupedFieldSet: GroupedFieldSet, parentDeferUsages?: DeferUsageSet): FieldPlan;

package/typings/execution/collectFields.d.cts

@@ -0,0 +1,40 @@
+import type { FieldNode, FragmentDefinitionNode, GraphQLObjectType, GraphQLSchema, OperationDefinitionNode } from 'graphql';
+export interface DeferUsage {
+    label: string | undefined;
+    parentDeferUsage: DeferUsage | undefined;
+}
+export interface FieldDetails {
+    node: FieldNode;
+    deferUsage: DeferUsage | undefined;
+}
+export type FieldGroup = ReadonlyArray<FieldDetails>;
+export type GroupedFieldSet = ReadonlyMap<string, FieldGroup>;
+/**
+ * Given a selectionSet, collects all of the fields and returns them.
+ *
+ * CollectFields requires the "runtime type" of an object. For a field that
+ * returns an Interface or Union type, the "runtime type" will be the actual
+ * object type returned by that field.
+ *
+ * @internal
+ */
+export declare function collectFields<TVariables = any>(schema: GraphQLSchema, fragments: Record<string, FragmentDefinitionNode>, variableValues: TVariables, runtimeType: GraphQLObjectType, operation: OperationDefinitionNode): {
+    groupedFieldSet: GroupedFieldSet;
+    newDeferUsages: ReadonlyArray<DeferUsage>;
+};
+/**
+ * Given an array of field nodes, collects all of the subfields of the passed
+ * in fields, and returns them at the end.
+ *
+ * CollectSubFields requires the "return type" of an object. For a field that
+ * returns an Interface or Union type, the "return type" will be the actual
+ * object type returned by that field.
+ *
+ * @internal
+ */
+export declare function collectSubfields(schema: GraphQLSchema, fragments: Record<string, FragmentDefinitionNode>, variableValues: {
+    [variable: string]: unknown;
+}, operation: OperationDefinitionNode, returnType: GraphQLObjectType, fieldGroup: FieldGroup): {
+    groupedFieldSet: GroupedFieldSet;
+    newDeferUsages: ReadonlyArray<DeferUsage>;
+};

package/typings/execution/collectFields.d.ts

@@ -0,0 +1,40 @@
+import type { FieldNode, FragmentDefinitionNode, GraphQLObjectType, GraphQLSchema, OperationDefinitionNode } from 'graphql';
+export interface DeferUsage {
+    label: string | undefined;
+    parentDeferUsage: DeferUsage | undefined;
+}
+export interface FieldDetails {
+    node: FieldNode;
+    deferUsage: DeferUsage | undefined;
+}
+export type FieldGroup = ReadonlyArray<FieldDetails>;
+export type GroupedFieldSet = ReadonlyMap<string, FieldGroup>;
+/**
+ * Given a selectionSet, collects all of the fields and returns them.
+ *
+ * CollectFields requires the "runtime type" of an object. For a field that
+ * returns an Interface or Union type, the "runtime type" will be the actual
+ * object type returned by that field.
+ *
+ * @internal
+ */
+export declare function collectFields<TVariables = any>(schema: GraphQLSchema, fragments: Record<string, FragmentDefinitionNode>, variableValues: TVariables, runtimeType: GraphQLObjectType, operation: OperationDefinitionNode): {
+    groupedFieldSet: GroupedFieldSet;
+    newDeferUsages: ReadonlyArray<DeferUsage>;
+};
+/**
+ * Given an array of field nodes, collects all of the subfields of the passed
+ * in fields, and returns them at the end.
+ *
+ * CollectSubFields requires the "return type" of an object. For a field that
+ * returns an Interface or Union type, the "return type" will be the actual
+ * object type returned by that field.
+ *
+ * @internal
+ */
+export declare function collectSubfields(schema: GraphQLSchema, fragments: Record<string, FragmentDefinitionNode>, variableValues: {
+    [variable: string]: unknown;
+}, operation: OperationDefinitionNode, returnType: GraphQLObjectType, fieldGroup: FieldGroup): {
+    groupedFieldSet: GroupedFieldSet;
+    newDeferUsages: ReadonlyArray<DeferUsage>;
+};

package/typings/execution/execute.d.cts

@@ -1,11 +1,7 @@
-import { DocumentNode, FieldNode, FragmentDefinitionNode, GraphQLError, GraphQLField, GraphQLFieldResolver, GraphQLFormattedError, GraphQLObjectType, GraphQLResolveInfo, GraphQLSchema, GraphQLTypeResolver, OperationDefinitionNode } from 'graphql';
+import { DocumentNode, FieldNode, FragmentDefinitionNode, GraphQLError, GraphQLField, GraphQLFieldResolver, GraphQLObjectType, GraphQLResolveInfo, GraphQLSchema, GraphQLTypeResolver, OperationDefinitionNode } from 'graphql';
 import { Maybe, MaybePromise, Path } from '@graphql-tools/utils';
 import { TypedDocumentNode } from '@graphql-typed-document-node/core';
-export interface SingularExecutionResult<TData = any, TExtensions = any> {
-    errors?: ReadonlyArray<GraphQLError>;
-    data?: TData | null;
-    extensions?: TExtensions;
-}
+import { CancellableStreamRecord, IncrementalDataRecord, IncrementalExecutionResults, InitialIncrementalExecutionResult, SingularExecutionResult, SubsequentIncrementalExecutionResult } from './types.cjs';
 /**
  * Terminology
  *
@@ -41,63 +37,12 @@ export interface ExecutionContext<TVariables = any, TContext = any> {
     fieldResolver: GraphQLFieldResolver<any, TContext>;
     typeResolver: GraphQLTypeResolver<any, TContext>;
     subscribeFieldResolver: GraphQLFieldResolver<any, TContext>;
-    errors: Array<GraphQLError>;
-    subsequentPayloads: Set<AsyncPayloadRecord>;
-    signal?: AbortSignal;
-}
-export interface FormattedExecutionResult<TData = Record<string, unknown>, TExtensions = Record<string, unknown>> {
-    errors?: ReadonlyArray<GraphQLFormattedError>;
-    data?: TData | null;
-    extensions?: TExtensions;
-}
-export interface IncrementalExecutionResults<TData = Record<string, unknown>, TExtensions = Record<string, unknown>> {
-    initialResult: InitialIncrementalExecutionResult<TData, TExtensions>;
-    subsequentResults: AsyncGenerator<SubsequentIncrementalExecutionResult<TData, TExtensions>, void, void>;
-}
-export interface InitialIncrementalExecutionResult<TData = Record<string, unknown>, TExtensions = Record<string, unknown>> extends SingularExecutionResult<TData, TExtensions> {
-    hasNext: boolean;
-    incremental?: ReadonlyArray<IncrementalResult<TData, TExtensions>>;
-    extensions?: TExtensions;
-}
-export interface FormattedInitialIncrementalExecutionResult<TData = Record<string, unknown>, TExtensions = Record<string, unknown>> extends FormattedExecutionResult<TData, TExtensions> {
-    hasNext: boolean;
-    incremental?: ReadonlyArray<FormattedIncrementalResult<TData, TExtensions>>;
-    extensions?: TExtensions;
-}
-export interface SubsequentIncrementalExecutionResult<TData = Record<string, unknown>, TExtensions = Record<string, unknown>> {
-    hasNext: boolean;
-    incremental?: ReadonlyArray<IncrementalResult<TData, TExtensions>>;
-    extensions?: TExtensions;
+    enableEarlyExecution: boolean;
+    signal: AbortSignal | undefined;
+    errors: Map<Path | undefined, GraphQLError> | undefined;
+    cancellableStreams: Set<CancellableStreamRecord> | undefined;
+    incrementalDataRecords: Array<IncrementalDataRecord> | undefined;
 }
-export interface FormattedSubsequentIncrementalExecutionResult<TData = Record<string, unknown>, TExtensions = Record<string, unknown>> {
-    hasNext: boolean;
-    incremental?: ReadonlyArray<FormattedIncrementalResult<TData, TExtensions>>;
-    extensions?: TExtensions;
-}
-export interface IncrementalDeferResult<TData = Record<string, unknown>, TExtensions = Record<string, unknown>> extends SingularExecutionResult<TData, TExtensions> {
-    path?: ReadonlyArray<string | number>;
-    label?: string;
-}
-export interface FormattedIncrementalDeferResult<TData = Record<string, unknown>, TExtensions = Record<string, unknown>> extends FormattedExecutionResult<TData, TExtensions> {
-    path?: ReadonlyArray<string | number>;
-    label?: string;
-}
-export interface IncrementalStreamResult<TData = Array<unknown>, TExtensions = Record<string, unknown>> {
-    errors?: ReadonlyArray<GraphQLError>;
-    items?: TData | null;
-    path?: ReadonlyArray<string | number>;
-    label?: string;
-    extensions?: TExtensions;
-}
-export interface FormattedIncrementalStreamResult<TData = Array<unknown>, TExtensions = Record<string, unknown>> {
-    errors?: ReadonlyArray<GraphQLFormattedError>;
-    items?: TData | null;
-    path?: ReadonlyArray<string | number>;
-    label?: string;
-    extensions?: TExtensions;
-}
-export type IncrementalResult<TData = Record<string, unknown>, TExtensions = Record<string, unknown>> = IncrementalDeferResult<TData, TExtensions> | IncrementalStreamResult<TData, TExtensions>;
-export type FormattedIncrementalResult<TData = Record<string, unknown>, TExtensions = Record<string, unknown>> = FormattedIncrementalDeferResult<TData, TExtensions> | FormattedIncrementalStreamResult<TData, TExtensions>;
 export interface ExecutionArgs<TData = any, TVariables = any, TContext = any> {
     schema: GraphQLSchema;
     document: TypedDocumentNode<TData, TVariables>;
@@ -108,6 +53,7 @@ export interface ExecutionArgs<TData = any, TVariables = any, TContext = any> {
     fieldResolver?: Maybe<GraphQLFieldResolver<any, TContext>>;
     typeResolver?: Maybe<GraphQLTypeResolver<any, TContext>>;
     subscribeFieldResolver?: Maybe<GraphQLFieldResolver<any, TContext>>;
+    enableEarlyExecution?: Maybe<boolean>;
     signal?: AbortSignal;
 }
 /**
@@ -205,49 +151,6 @@ export declare const defaultFieldResolver: GraphQLFieldResolver<unknown, unknown
  */
 export declare function subscribe<TData = any, TVariables = any, TContext = any>(args: ExecutionArgs<TData, TVariables, TContext>): MaybePromise<AsyncGenerator<SingularExecutionResult<TData> | InitialIncrementalExecutionResult<TData> | SubsequentIncrementalExecutionResult<TData>, void, void> | SingularExecutionResult<TData>>;
 export declare function flattenIncrementalResults<TData>(incrementalResults: IncrementalExecutionResults<TData>): AsyncGenerator<SubsequentIncrementalExecutionResult<TData, Record<string, unknown>>, void, void>;
-declare class DeferredFragmentRecord {
-    type: 'defer';
-    errors: Array<GraphQLError>;
-    label: string | undefined;
-    path: Array<string | number>;
-    promise: Promise<void>;
-    data: Record<string, unknown> | null;
-    parentContext: AsyncPayloadRecord | undefined;
-    isCompleted: boolean;
-    _exeContext: ExecutionContext;
-    _resolve?: (arg: MaybePromise<Record<string, unknown> | null>) => void;
-    constructor(opts: {
-        label: string | undefined;
-        path: Path | undefined;
-        parentContext: AsyncPayloadRecord | undefined;
-        exeContext: ExecutionContext;
-    });
-    addData(data: MaybePromise<Record<string, unknown> | null>): void;
-}
-declare class StreamRecord {
-    type: 'stream';
-    errors: Array<GraphQLError>;
-    label: string | undefined;
-    path: Array<string | number>;
-    items: Array<unknown> | null;
-    promise: Promise<void>;
-    parentContext: AsyncPayloadRecord | undefined;
-    iterator: AsyncIterator<unknown> | undefined;
-    isCompletedIterator?: boolean;
-    isCompleted: boolean;
-    _exeContext: ExecutionContext;
-    _resolve?: (arg: MaybePromise<Array<unknown> | null>) => void;
-    constructor(opts: {
-        label: string | undefined;
-        path: Path | undefined;
-        iterator?: AsyncIterator<unknown>;
-        parentContext: AsyncPayloadRecord | undefined;
-        exeContext: ExecutionContext;
-    });
-    addItems(items: MaybePromise<Array<unknown> | null>): void;
-    setIsCompletedIterator(): void;
-}
-type AsyncPayloadRecord = DeferredFragmentRecord | StreamRecord;
 /**
  * This method looks up the field on the given type definition.
  * It has special casing for the three introspection fields,
@@ -261,4 +164,3 @@ type AsyncPayloadRecord = DeferredFragmentRecord | StreamRecord;
  */
 export declare function getFieldDef(schema: GraphQLSchema, parentType: GraphQLObjectType, fieldNode: FieldNode): Maybe<GraphQLField<unknown, unknown>>;
 export declare function isIncrementalResult<TData>(result: SingularExecutionResult<TData> | IncrementalExecutionResults<TData>): result is IncrementalExecutionResults<TData>;
-export {};

package/typings/execution/execute.d.ts

@@ -1,11 +1,7 @@
-import { DocumentNode, FieldNode, FragmentDefinitionNode, GraphQLError, GraphQLField, GraphQLFieldResolver, GraphQLFormattedError, GraphQLObjectType, GraphQLResolveInfo, GraphQLSchema, GraphQLTypeResolver, OperationDefinitionNode } from 'graphql';
+import { DocumentNode, FieldNode, FragmentDefinitionNode, GraphQLError, GraphQLField, GraphQLFieldResolver, GraphQLObjectType, GraphQLResolveInfo, GraphQLSchema, GraphQLTypeResolver, OperationDefinitionNode } from 'graphql';
 import { Maybe, MaybePromise, Path } from '@graphql-tools/utils';
 import { TypedDocumentNode } from '@graphql-typed-document-node/core';
-export interface SingularExecutionResult<TData = any, TExtensions = any> {
-    errors?: ReadonlyArray<GraphQLError>;
-    data?: TData | null;
-    extensions?: TExtensions;
-}
+import { CancellableStreamRecord, IncrementalDataRecord, IncrementalExecutionResults, InitialIncrementalExecutionResult, SingularExecutionResult, SubsequentIncrementalExecutionResult } from './types.js';
 /**
  * Terminology
  *
@@ -41,63 +37,12 @@ export interface ExecutionContext<TVariables = any, TContext = any> {
     fieldResolver: GraphQLFieldResolver<any, TContext>;
     typeResolver: GraphQLTypeResolver<any, TContext>;
     subscribeFieldResolver: GraphQLFieldResolver<any, TContext>;
-    errors: Array<GraphQLError>;
-    subsequentPayloads: Set<AsyncPayloadRecord>;
-    signal?: AbortSignal;
-}
-export interface FormattedExecutionResult<TData = Record<string, unknown>, TExtensions = Record<string, unknown>> {
-    errors?: ReadonlyArray<GraphQLFormattedError>;
-    data?: TData | null;
-    extensions?: TExtensions;
-}
-export interface IncrementalExecutionResults<TData = Record<string, unknown>, TExtensions = Record<string, unknown>> {
-    initialResult: InitialIncrementalExecutionResult<TData, TExtensions>;
-    subsequentResults: AsyncGenerator<SubsequentIncrementalExecutionResult<TData, TExtensions>, void, void>;
-}
-export interface InitialIncrementalExecutionResult<TData = Record<string, unknown>, TExtensions = Record<string, unknown>> extends SingularExecutionResult<TData, TExtensions> {
-    hasNext: boolean;
-    incremental?: ReadonlyArray<IncrementalResult<TData, TExtensions>>;
-    extensions?: TExtensions;
-}
-export interface FormattedInitialIncrementalExecutionResult<TData = Record<string, unknown>, TExtensions = Record<string, unknown>> extends FormattedExecutionResult<TData, TExtensions> {
-    hasNext: boolean;
-    incremental?: ReadonlyArray<FormattedIncrementalResult<TData, TExtensions>>;
-    extensions?: TExtensions;
-}
-export interface SubsequentIncrementalExecutionResult<TData = Record<string, unknown>, TExtensions = Record<string, unknown>> {
-    hasNext: boolean;
-    incremental?: ReadonlyArray<IncrementalResult<TData, TExtensions>>;
-    extensions?: TExtensions;
+    enableEarlyExecution: boolean;
+    signal: AbortSignal | undefined;
+    errors: Map<Path | undefined, GraphQLError> | undefined;
+    cancellableStreams: Set<CancellableStreamRecord> | undefined;
+    incrementalDataRecords: Array<IncrementalDataRecord> | undefined;
 }
-export interface FormattedSubsequentIncrementalExecutionResult<TData = Record<string, unknown>, TExtensions = Record<string, unknown>> {
-    hasNext: boolean;
-    incremental?: ReadonlyArray<FormattedIncrementalResult<TData, TExtensions>>;
-    extensions?: TExtensions;
-}
-export interface IncrementalDeferResult<TData = Record<string, unknown>, TExtensions = Record<string, unknown>> extends SingularExecutionResult<TData, TExtensions> {
-    path?: ReadonlyArray<string | number>;
-    label?: string;
-}
-export interface FormattedIncrementalDeferResult<TData = Record<string, unknown>, TExtensions = Record<string, unknown>> extends FormattedExecutionResult<TData, TExtensions> {
-    path?: ReadonlyArray<string | number>;
-    label?: string;
-}
-export interface IncrementalStreamResult<TData = Array<unknown>, TExtensions = Record<string, unknown>> {
-    errors?: ReadonlyArray<GraphQLError>;
-    items?: TData | null;
-    path?: ReadonlyArray<string | number>;
-    label?: string;
-    extensions?: TExtensions;
-}
-export interface FormattedIncrementalStreamResult<TData = Array<unknown>, TExtensions = Record<string, unknown>> {
-    errors?: ReadonlyArray<GraphQLFormattedError>;
-    items?: TData | null;
-    path?: ReadonlyArray<string | number>;
-    label?: string;
-    extensions?: TExtensions;
-}
-export type IncrementalResult<TData = Record<string, unknown>, TExtensions = Record<string, unknown>> = IncrementalDeferResult<TData, TExtensions> | IncrementalStreamResult<TData, TExtensions>;
-export type FormattedIncrementalResult<TData = Record<string, unknown>, TExtensions = Record<string, unknown>> = FormattedIncrementalDeferResult<TData, TExtensions> | FormattedIncrementalStreamResult<TData, TExtensions>;
 export interface ExecutionArgs<TData = any, TVariables = any, TContext = any> {
     schema: GraphQLSchema;
     document: TypedDocumentNode<TData, TVariables>;
@@ -108,6 +53,7 @@ export interface ExecutionArgs<TData = any, TVariables = any, TContext = any> {
     fieldResolver?: Maybe<GraphQLFieldResolver<any, TContext>>;
     typeResolver?: Maybe<GraphQLTypeResolver<any, TContext>>;
     subscribeFieldResolver?: Maybe<GraphQLFieldResolver<any, TContext>>;
+    enableEarlyExecution?: Maybe<boolean>;
     signal?: AbortSignal;
 }
 /**
@@ -205,49 +151,6 @@ export declare const defaultFieldResolver: GraphQLFieldResolver<unknown, unknown
  */
 export declare function subscribe<TData = any, TVariables = any, TContext = any>(args: ExecutionArgs<TData, TVariables, TContext>): MaybePromise<AsyncGenerator<SingularExecutionResult<TData> | InitialIncrementalExecutionResult<TData> | SubsequentIncrementalExecutionResult<TData>, void, void> | SingularExecutionResult<TData>>;
 export declare function flattenIncrementalResults<TData>(incrementalResults: IncrementalExecutionResults<TData>): AsyncGenerator<SubsequentIncrementalExecutionResult<TData, Record<string, unknown>>, void, void>;
-declare class DeferredFragmentRecord {
-    type: 'defer';
-    errors: Array<GraphQLError>;
-    label: string | undefined;
-    path: Array<string | number>;
-    promise: Promise<void>;
-    data: Record<string, unknown> | null;
-    parentContext: AsyncPayloadRecord | undefined;
-    isCompleted: boolean;
-    _exeContext: ExecutionContext;
-    _resolve?: (arg: MaybePromise<Record<string, unknown> | null>) => void;
-    constructor(opts: {
-        label: string | undefined;
-        path: Path | undefined;
-        parentContext: AsyncPayloadRecord | undefined;
-        exeContext: ExecutionContext;
-    });
-    addData(data: MaybePromise<Record<string, unknown> | null>): void;
-}
-declare class StreamRecord {
-    type: 'stream';
-    errors: Array<GraphQLError>;
-    label: string | undefined;
-    path: Array<string | number>;
-    items: Array<unknown> | null;
-    promise: Promise<void>;
-    parentContext: AsyncPayloadRecord | undefined;
-    iterator: AsyncIterator<unknown> | undefined;
-    isCompletedIterator?: boolean;
-    isCompleted: boolean;
-    _exeContext: ExecutionContext;
-    _resolve?: (arg: MaybePromise<Array<unknown> | null>) => void;
-    constructor(opts: {
-        label: string | undefined;
-        path: Path | undefined;
-        iterator?: AsyncIterator<unknown>;
-        parentContext: AsyncPayloadRecord | undefined;
-        exeContext: ExecutionContext;
-    });
-    addItems(items: MaybePromise<Array<unknown> | null>): void;
-    setIsCompletedIterator(): void;
-}
-type AsyncPayloadRecord = DeferredFragmentRecord | StreamRecord;
 /**
  * This method looks up the field on the given type definition.
  * It has special casing for the three introspection fields,
@@ -261,4 +164,3 @@ type AsyncPayloadRecord = DeferredFragmentRecord | StreamRecord;
  */
 export declare function getFieldDef(schema: GraphQLSchema, parentType: GraphQLObjectType, fieldNode: FieldNode): Maybe<GraphQLField<unknown, unknown>>;
 export declare function isIncrementalResult<TData>(result: SingularExecutionResult<TData> | IncrementalExecutionResults<TData>): result is IncrementalExecutionResults<TData>;
-export {};

package/typings/execution/getBySet.d.cts

@@ -0,0 +1 @@
+export declare function getBySet<T, U>(map: ReadonlyMap<ReadonlySet<T>, U>, setToMatch: ReadonlySet<T>): U | undefined;

package/typings/execution/getBySet.d.ts

@@ -0,0 +1 @@
+export declare function getBySet<T, U>(map: ReadonlyMap<ReadonlySet<T>, U>, setToMatch: ReadonlySet<T>): U | undefined;

package/typings/execution/isSameSet.d.cts

@@ -0,0 +1 @@
+export declare function isSameSet<T>(setA: ReadonlySet<T>, setB: ReadonlySet<T>): boolean;

package/typings/execution/isSameSet.d.ts

@@ -0,0 +1 @@
+export declare function isSameSet<T>(setA: ReadonlySet<T>, setB: ReadonlySet<T>): boolean;

package/typings/execution/promiseWithResolvers.d.cts

@@ -0,0 +1,10 @@
+import { MaybePromise } from '@graphql-tools/utils';
+/**
+ * Based on Promise.withResolvers proposal
+ * https://github.com/tc39/proposal-promise-with-resolvers
+ */
+export declare function promiseWithResolvers<T>(): {
+    promise: Promise<T>;
+    resolve: (value: T | MaybePromise<T>) => void;
+    reject: (reason?: any) => void;
+};

package/typings/execution/promiseWithResolvers.d.ts

@@ -0,0 +1,10 @@
+import { MaybePromise } from '@graphql-tools/utils';
+/**
+ * Based on Promise.withResolvers proposal
+ * https://github.com/tc39/proposal-promise-with-resolvers
+ */
+export declare function promiseWithResolvers<T>(): {
+    promise: Promise<T>;
+    resolve: (value: T | MaybePromise<T>) => void;
+    reject: (reason?: any) => void;
+};