@graphql-tools/executor 1.2.6 → 2.0.0-alpha-20240606144658-8963c8b8f661638eaee0e101a55f3b6e46cc03ff

package/typings/execution/types.d.cts

@@ -0,0 +1,155 @@
+import type { GraphQLError, GraphQLFormattedError } from 'graphql';
+import type { Path } from '@graphql-tools/utils';
+import type { BoxedPromiseOrValue } from './BoxedPromiseOrValue.cjs';
+/**
+ * The result of GraphQL execution.
+ *
+ *   - `errors` is included when any errors occurred as a non-empty array.
+ *   - `data` is the result of a successful execution of the query.
+ *   - `hasNext` is true if a future payload is expected.
+ *   - `extensions` is reserved for adding non-standard properties.
+ *   - `incremental` is a list of the results from defer/stream directives.
+ */
+export interface SingularExecutionResult<TData = any, TExtensions = any> {
+    errors?: ReadonlyArray<GraphQLError>;
+    data?: TData | null;
+    extensions?: TExtensions;
+}
+export interface FormattedExecutionResult<TData = Record<string, unknown>, TExtensions = Record<string, unknown>> {
+    errors?: ReadonlyArray<GraphQLFormattedError>;
+    data?: TData | null;
+    extensions?: TExtensions;
+}
+export interface IncrementalExecutionResults<TData = 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> {
+    data: TData;
+    pending: ReadonlyArray<PendingResult>;
+    hasNext: true;
+    extensions?: TExtensions;
+}
+export interface FormattedInitialIncrementalExecutionResult<TData = Record<string, unknown>, TExtensions = Record<string, unknown>> extends FormattedExecutionResult<TData, TExtensions> {
+    data: TData;
+    pending: ReadonlyArray<PendingResult>;
+    hasNext: boolean;
+    extensions?: TExtensions;
+}
+export interface SubsequentIncrementalExecutionResult<TData = unknown, TExtensions = Record<string, unknown>> {
+    pending?: ReadonlyArray<PendingResult>;
+    incremental?: ReadonlyArray<IncrementalResult<TData, TExtensions>>;
+    completed?: ReadonlyArray<CompletedResult>;
+    hasNext: boolean;
+    extensions?: TExtensions;
+}
+export interface FormattedSubsequentIncrementalExecutionResult<TData = unknown, TExtensions = Record<string, unknown>> {
+    hasNext: boolean;
+    pending?: ReadonlyArray<PendingResult>;
+    incremental?: ReadonlyArray<FormattedIncrementalResult<TData, TExtensions>>;
+    completed?: ReadonlyArray<FormattedCompletedResult>;
+    extensions?: TExtensions;
+}
+interface BareDeferredGroupedFieldSetResult<TData = Record<string, unknown>> {
+    errors?: ReadonlyArray<GraphQLError>;
+    data: TData;
+}
+export interface IncrementalDeferResult<TData = Record<string, unknown>, TExtensions = Record<string, unknown>> extends BareDeferredGroupedFieldSetResult<TData> {
+    id: string;
+    subPath?: ReadonlyArray<string | number>;
+    extensions?: TExtensions;
+}
+export interface FormattedIncrementalDeferResult<TData = Record<string, unknown>, TExtensions = Record<string, unknown>> {
+    errors?: ReadonlyArray<GraphQLFormattedError>;
+    data: TData;
+    id: string;
+    subPath?: ReadonlyArray<string | number>;
+    extensions?: TExtensions;
+}
+interface BareStreamItemsResult<TData = ReadonlyArray<unknown>> {
+    errors?: ReadonlyArray<GraphQLError>;
+    items: TData;
+}
+export interface IncrementalStreamResult<TData = ReadonlyArray<unknown>, TExtensions = Record<string, unknown>> extends BareStreamItemsResult<TData> {
+    id: string;
+    subPath?: ReadonlyArray<string | number>;
+    extensions?: TExtensions;
+}
+export interface FormattedIncrementalStreamResult<TData = Array<unknown>, TExtensions = Record<string, unknown>> {
+    errors?: ReadonlyArray<GraphQLFormattedError>;
+    items: TData;
+    id: string;
+    subPath?: ReadonlyArray<string | number>;
+    extensions?: TExtensions;
+}
+export type IncrementalResult<TData = unknown, TExtensions = Record<string, unknown>> = IncrementalDeferResult<TData, TExtensions> | IncrementalStreamResult<TData, TExtensions>;
+export type FormattedIncrementalResult<TData = unknown, TExtensions = Record<string, unknown>> = FormattedIncrementalDeferResult<TData, TExtensions> | FormattedIncrementalStreamResult<TData, TExtensions>;
+export interface PendingResult {
+    id: string;
+    path: ReadonlyArray<string | number>;
+    label?: string;
+}
+export interface CompletedResult {
+    id: string;
+    errors?: ReadonlyArray<GraphQLError>;
+}
+export interface FormattedCompletedResult {
+    path: ReadonlyArray<string | number>;
+    label?: string;
+    errors?: ReadonlyArray<GraphQLError>;
+}
+export declare function isDeferredGroupedFieldSetRecord(incrementalDataRecord: IncrementalDataRecord): incrementalDataRecord is DeferredGroupedFieldSetRecord;
+export type DeferredGroupedFieldSetResult = ReconcilableDeferredGroupedFieldSetResult | NonReconcilableDeferredGroupedFieldSetResult;
+export declare function isDeferredGroupedFieldSetResult(subsequentResult: DeferredGroupedFieldSetResult | StreamItemsResult): subsequentResult is DeferredGroupedFieldSetResult;
+export interface ReconcilableDeferredGroupedFieldSetResult {
+    deferredGroupedFieldSetRecord: DeferredGroupedFieldSetRecord;
+    path: Array<string | number>;
+    result: BareDeferredGroupedFieldSetResult;
+    incrementalDataRecords: ReadonlyArray<IncrementalDataRecord> | undefined;
+    errors?: never;
+}
+interface NonReconcilableDeferredGroupedFieldSetResult {
+    deferredGroupedFieldSetRecord: DeferredGroupedFieldSetRecord;
+    path: Array<string | number>;
+    errors: ReadonlyArray<GraphQLError>;
+    result?: never;
+}
+export declare function isNonReconcilableDeferredGroupedFieldSetResult(deferredGroupedFieldSetResult: DeferredGroupedFieldSetResult): deferredGroupedFieldSetResult is NonReconcilableDeferredGroupedFieldSetResult;
+export interface DeferredGroupedFieldSetRecord {
+    path: Path | undefined;
+    deferredFragmentRecords: ReadonlyArray<DeferredFragmentRecord>;
+    result: BoxedPromiseOrValue<DeferredGroupedFieldSetResult> | (() => BoxedPromiseOrValue<DeferredGroupedFieldSetResult>);
+}
+export type SubsequentResultRecord = DeferredFragmentRecord | StreamRecord;
+export interface DeferredFragmentRecord {
+    path: Path | undefined;
+    label: string | undefined;
+    id?: string | undefined;
+    parent: DeferredFragmentRecord | undefined;
+}
+export interface StreamItemResult {
+    path: Path;
+    item?: unknown;
+    incrementalDataRecords?: ReadonlyArray<IncrementalDataRecord> | undefined;
+    errors?: ReadonlyArray<GraphQLError> | undefined;
+}
+export type StreamItemRecord = BoxedPromiseOrValue<StreamItemResult> | (() => BoxedPromiseOrValue<StreamItemResult>);
+export interface StreamRecord {
+    path: Path;
+    label: string | undefined;
+    id?: string | undefined;
+    streamItemQueue: Array<StreamItemRecord>;
+}
+export interface StreamItemsResult {
+    streamRecord: StreamRecord;
+    result?: BareStreamItemsResult | undefined;
+    incrementalDataRecords?: ReadonlyArray<IncrementalDataRecord> | undefined;
+    errors?: ReadonlyArray<GraphQLError> | undefined;
+}
+export interface CancellableStreamRecord extends StreamRecord {
+    earlyReturn: () => Promise<unknown>;
+}
+export declare function isCancellableStreamRecord(subsequentResultRecord: SubsequentResultRecord): subsequentResultRecord is CancellableStreamRecord;
+export type IncrementalDataRecord = DeferredGroupedFieldSetRecord | StreamRecord;
+export type IncrementalDataRecordResult = DeferredGroupedFieldSetResult | StreamItemsResult;
+export {};

package/typings/execution/types.d.ts

@@ -0,0 +1,155 @@
+import type { GraphQLError, GraphQLFormattedError } from 'graphql';
+import type { Path } from '@graphql-tools/utils';
+import type { BoxedPromiseOrValue } from './BoxedPromiseOrValue.js';
+/**
+ * The result of GraphQL execution.
+ *
+ *   - `errors` is included when any errors occurred as a non-empty array.
+ *   - `data` is the result of a successful execution of the query.
+ *   - `hasNext` is true if a future payload is expected.
+ *   - `extensions` is reserved for adding non-standard properties.
+ *   - `incremental` is a list of the results from defer/stream directives.
+ */
+export interface SingularExecutionResult<TData = any, TExtensions = any> {
+    errors?: ReadonlyArray<GraphQLError>;
+    data?: TData | null;
+    extensions?: TExtensions;
+}
+export interface FormattedExecutionResult<TData = Record<string, unknown>, TExtensions = Record<string, unknown>> {
+    errors?: ReadonlyArray<GraphQLFormattedError>;
+    data?: TData | null;
+    extensions?: TExtensions;
+}
+export interface IncrementalExecutionResults<TData = 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> {
+    data: TData;
+    pending: ReadonlyArray<PendingResult>;
+    hasNext: true;
+    extensions?: TExtensions;
+}
+export interface FormattedInitialIncrementalExecutionResult<TData = Record<string, unknown>, TExtensions = Record<string, unknown>> extends FormattedExecutionResult<TData, TExtensions> {
+    data: TData;
+    pending: ReadonlyArray<PendingResult>;
+    hasNext: boolean;
+    extensions?: TExtensions;
+}
+export interface SubsequentIncrementalExecutionResult<TData = unknown, TExtensions = Record<string, unknown>> {
+    pending?: ReadonlyArray<PendingResult>;
+    incremental?: ReadonlyArray<IncrementalResult<TData, TExtensions>>;
+    completed?: ReadonlyArray<CompletedResult>;
+    hasNext: boolean;
+    extensions?: TExtensions;
+}
+export interface FormattedSubsequentIncrementalExecutionResult<TData = unknown, TExtensions = Record<string, unknown>> {
+    hasNext: boolean;
+    pending?: ReadonlyArray<PendingResult>;
+    incremental?: ReadonlyArray<FormattedIncrementalResult<TData, TExtensions>>;
+    completed?: ReadonlyArray<FormattedCompletedResult>;
+    extensions?: TExtensions;
+}
+interface BareDeferredGroupedFieldSetResult<TData = Record<string, unknown>> {
+    errors?: ReadonlyArray<GraphQLError>;
+    data: TData;
+}
+export interface IncrementalDeferResult<TData = Record<string, unknown>, TExtensions = Record<string, unknown>> extends BareDeferredGroupedFieldSetResult<TData> {
+    id: string;
+    subPath?: ReadonlyArray<string | number>;
+    extensions?: TExtensions;
+}
+export interface FormattedIncrementalDeferResult<TData = Record<string, unknown>, TExtensions = Record<string, unknown>> {
+    errors?: ReadonlyArray<GraphQLFormattedError>;
+    data: TData;
+    id: string;
+    subPath?: ReadonlyArray<string | number>;
+    extensions?: TExtensions;
+}
+interface BareStreamItemsResult<TData = ReadonlyArray<unknown>> {
+    errors?: ReadonlyArray<GraphQLError>;
+    items: TData;
+}
+export interface IncrementalStreamResult<TData = ReadonlyArray<unknown>, TExtensions = Record<string, unknown>> extends BareStreamItemsResult<TData> {
+    id: string;
+    subPath?: ReadonlyArray<string | number>;
+    extensions?: TExtensions;
+}
+export interface FormattedIncrementalStreamResult<TData = Array<unknown>, TExtensions = Record<string, unknown>> {
+    errors?: ReadonlyArray<GraphQLFormattedError>;
+    items: TData;
+    id: string;
+    subPath?: ReadonlyArray<string | number>;
+    extensions?: TExtensions;
+}
+export type IncrementalResult<TData = unknown, TExtensions = Record<string, unknown>> = IncrementalDeferResult<TData, TExtensions> | IncrementalStreamResult<TData, TExtensions>;
+export type FormattedIncrementalResult<TData = unknown, TExtensions = Record<string, unknown>> = FormattedIncrementalDeferResult<TData, TExtensions> | FormattedIncrementalStreamResult<TData, TExtensions>;
+export interface PendingResult {
+    id: string;
+    path: ReadonlyArray<string | number>;
+    label?: string;
+}
+export interface CompletedResult {
+    id: string;
+    errors?: ReadonlyArray<GraphQLError>;
+}
+export interface FormattedCompletedResult {
+    path: ReadonlyArray<string | number>;
+    label?: string;
+    errors?: ReadonlyArray<GraphQLError>;
+}
+export declare function isDeferredGroupedFieldSetRecord(incrementalDataRecord: IncrementalDataRecord): incrementalDataRecord is DeferredGroupedFieldSetRecord;
+export type DeferredGroupedFieldSetResult = ReconcilableDeferredGroupedFieldSetResult | NonReconcilableDeferredGroupedFieldSetResult;
+export declare function isDeferredGroupedFieldSetResult(subsequentResult: DeferredGroupedFieldSetResult | StreamItemsResult): subsequentResult is DeferredGroupedFieldSetResult;
+export interface ReconcilableDeferredGroupedFieldSetResult {
+    deferredGroupedFieldSetRecord: DeferredGroupedFieldSetRecord;
+    path: Array<string | number>;
+    result: BareDeferredGroupedFieldSetResult;
+    incrementalDataRecords: ReadonlyArray<IncrementalDataRecord> | undefined;
+    errors?: never;
+}
+interface NonReconcilableDeferredGroupedFieldSetResult {
+    deferredGroupedFieldSetRecord: DeferredGroupedFieldSetRecord;
+    path: Array<string | number>;
+    errors: ReadonlyArray<GraphQLError>;
+    result?: never;
+}
+export declare function isNonReconcilableDeferredGroupedFieldSetResult(deferredGroupedFieldSetResult: DeferredGroupedFieldSetResult): deferredGroupedFieldSetResult is NonReconcilableDeferredGroupedFieldSetResult;
+export interface DeferredGroupedFieldSetRecord {
+    path: Path | undefined;
+    deferredFragmentRecords: ReadonlyArray<DeferredFragmentRecord>;
+    result: BoxedPromiseOrValue<DeferredGroupedFieldSetResult> | (() => BoxedPromiseOrValue<DeferredGroupedFieldSetResult>);
+}
+export type SubsequentResultRecord = DeferredFragmentRecord | StreamRecord;
+export interface DeferredFragmentRecord {
+    path: Path | undefined;
+    label: string | undefined;
+    id?: string | undefined;
+    parent: DeferredFragmentRecord | undefined;
+}
+export interface StreamItemResult {
+    path: Path;
+    item?: unknown;
+    incrementalDataRecords?: ReadonlyArray<IncrementalDataRecord> | undefined;
+    errors?: ReadonlyArray<GraphQLError> | undefined;
+}
+export type StreamItemRecord = BoxedPromiseOrValue<StreamItemResult> | (() => BoxedPromiseOrValue<StreamItemResult>);
+export interface StreamRecord {
+    path: Path;
+    label: string | undefined;
+    id?: string | undefined;
+    streamItemQueue: Array<StreamItemRecord>;
+}
+export interface StreamItemsResult {
+    streamRecord: StreamRecord;
+    result?: BareStreamItemsResult | undefined;
+    incrementalDataRecords?: ReadonlyArray<IncrementalDataRecord> | undefined;
+    errors?: ReadonlyArray<GraphQLError> | undefined;
+}
+export interface CancellableStreamRecord extends StreamRecord {
+    earlyReturn: () => Promise<unknown>;
+}
+export declare function isCancellableStreamRecord(subsequentResultRecord: SubsequentResultRecord): subsequentResultRecord is CancellableStreamRecord;
+export type IncrementalDataRecord = DeferredGroupedFieldSetRecord | StreamRecord;
+export type IncrementalDataRecordResult = DeferredGroupedFieldSetResult | StreamItemsResult;
+export {};

package/cjs/execution/flattenAsyncIterable.js

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

package/esm/execution/flattenAsyncIterable.js

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

package/typings/execution/flattenAsyncIterable.d.cts

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

package/typings/execution/flattenAsyncIterable.d.ts

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