@apollo/client 4.0.0-alpha.21 → 4.0.0-alpha.23

package/core/QueryInfo.d.ts

@@ -1,9 +1,10 @@
-import type { DocumentNode } from "graphql";
+import type { DocumentNode, FormattedExecutionResult } from "graphql";
 import type { ApolloCache } from "@apollo/client/cache";
 import type { FetchResult } from "@apollo/client/link";
+import type { Unmasked } from "@apollo/client/masking";
 import type { ObservableQuery } from "./ObservableQuery.js";
 import type { QueryManager } from "./QueryManager.js";
-import type { DefaultContext, InternalRefetchQueriesInclude, MutationUpdaterFunction, OnQueryUpdated, OperationVariables, TypedDocumentNode } from "./types.js";
+import type { DefaultContext, InternalRefetchQueriesInclude, MutationUpdaterFunction, NormalizedExecutionResult, OnQueryUpdated, OperationVariables, Streaming, TypedDocumentNode } from "./types.js";
 import type { ErrorPolicy, MutationOptions, WatchQueryOptions } from "./watchQueryOptions.js";
 type UpdateQueries<TData> = MutationOptions<TData, any, any>["updateQueries"];
 export declare const enum CacheWriteBehavior {
@@ -12,7 +13,7 @@ export declare const enum CacheWriteBehavior {
     MERGE = 2
 }
 interface LastWrite {
-    result: FetchResult<any>;
+    result: FormattedExecutionResult<any>;
     variables: WatchQueryOptions["variables"];
     dmCount: number | undefined;
 }
@@ -22,12 +23,13 @@ interface OperationInfo<TData, TVariables extends OperationVariables, AllowedCac
     errorPolicy: ErrorPolicy;
     cacheWriteBehavior: AllowedCacheWriteBehavior;
 }
-export declare class QueryInfo {
+export declare class QueryInfo<TData, TVariables extends OperationVariables = OperationVariables, TCache extends ApolloCache = ApolloCache> {
     lastRequestId: number;
     private cache;
     private queryManager;
     readonly id: string;
     private readonly observableQuery?;
+    private incremental?;
     constructor(queryManager: QueryManager, observableQuery?: ObservableQuery<any, any>);
     /**
     * @internal
@@ -41,25 +43,26 @@ export declare class QueryInfo {
     private set lastWrite(value);
     resetLastWrite(): void;
     private shouldWrite;
-    private lastDiff?;
-    markQueryResult<TData, TVariables extends OperationVariables>(result: FetchResult<TData>, { document: query, variables, errorPolicy, cacheWriteBehavior, }: OperationInfo<TData, TVariables>): void;
-    markMutationResult<TData, TVariables extends OperationVariables, TCache extends ApolloCache>(result: FetchResult<TData>, mutation: OperationInfo<TData, TVariables, CacheWriteBehavior.FORBID | CacheWriteBehavior.MERGE> & {
+    get hasNext(): boolean;
+    private maybeHandleIncrementalResult;
+    markQueryResult(incoming: FetchResult<TData>, { document: query, variables, errorPolicy, cacheWriteBehavior, }: OperationInfo<TData, TVariables>): FormattedExecutionResult<TData | Streaming<TData>>;
+    markMutationResult(incoming: FetchResult<TData>, mutation: OperationInfo<TData, TVariables, CacheWriteBehavior.FORBID | CacheWriteBehavior.MERGE> & {
         context?: DefaultContext;
         updateQueries: UpdateQueries<TData>;
         update?: MutationUpdaterFunction<TData, TVariables, TCache>;
         awaitRefetchQueries?: boolean;
-        refetchQueries?: InternalRefetchQueriesInclude;
+        refetchQueries?: ((result: NormalizedExecutionResult<Unmasked<TData>>) => InternalRefetchQueriesInclude) | InternalRefetchQueriesInclude;
         removeOptimistic?: string;
         onQueryUpdated?: OnQueryUpdated<any>;
         keepRootFields?: boolean;
-    }, cache?: ApolloCache): Promise<FetchResult<TData>>;
-    markMutationOptimistic<TData, TVariables extends OperationVariables, TCache extends ApolloCache>(optimisticResponse: any, mutation: OperationInfo<TData, TVariables, CacheWriteBehavior.FORBID | CacheWriteBehavior.MERGE> & {
+    }, cache?: TCache): Promise<FormattedExecutionResult<TData | Streaming<TData>>>;
+    markMutationOptimistic(optimisticResponse: any, mutation: OperationInfo<TData, TVariables, CacheWriteBehavior.FORBID | CacheWriteBehavior.MERGE> & {
         context?: DefaultContext;
         updateQueries: UpdateQueries<TData>;
         update?: MutationUpdaterFunction<TData, TVariables, TCache>;
         keepRootFields?: boolean;
     }): boolean;
-    markSubscriptionResult<TData, TVariables extends OperationVariables>(result: FetchResult<TData>, { document, variables, errorPolicy, cacheWriteBehavior, }: OperationInfo<TData, TVariables, CacheWriteBehavior.FORBID | CacheWriteBehavior.MERGE>): void;
+    markSubscriptionResult(result: FormattedExecutionResult<TData>, { document, variables, errorPolicy, cacheWriteBehavior, }: OperationInfo<TData, TVariables, CacheWriteBehavior.FORBID | CacheWriteBehavior.MERGE>): void;
 }
 export {};
 //# sourceMappingURL=QueryInfo.d.ts.map

package/core/QueryInfo.js

@@ -1,6 +1,6 @@
 import { __DEV__ } from "@apollo/client/utilities/environment";
 import { equal } from "@wry/equality";
-import { DeepMerger, getOperationName, graphQLResultHasError, isExecutionPatchIncrementalResult, isExecutionPatchResult, isNonEmptyArray, mergeIncrementalData, } from "@apollo/client/utilities/internal";
+import { getOperationName, graphQLResultHasError, } from "@apollo/client/utilities/internal";
 import { invariant } from "@apollo/client/utilities/invariant";
 const IGNORE = {};
 const destructiveMethodCounts = new WeakMap();
@@ -33,6 +33,7 @@ export class QueryInfo {
     queryManager;
     id;
     observableQuery;
+    incremental;
     constructor(queryManager, observableQuery) {
         const cache = (this.cache = queryManager.cache);
         const id = (queryInfoIds.get(queryManager) || 0) + 1;
@@ -79,8 +80,20 @@ export class QueryInfo {
             equal(variables, lastWrite.variables) &&
             equal(result.data, lastWrite.result.data));
     }
-    lastDiff;
-    markQueryResult(result, { document: query, variables, errorPolicy, cacheWriteBehavior, }) {
+    get hasNext() {
+        return this.incremental ? this.incremental.hasNext : false;
+    }
+    maybeHandleIncrementalResult(cacheData, incoming, query) {
+        const { incrementalHandler } = this.queryManager;
+        if (incrementalHandler.isIncrementalResult(incoming)) {
+            this.incremental ||= incrementalHandler.startRequest({
+                query,
+            });
+            return this.incremental.handle(cacheData, incoming);
+        }
+        return incoming;
+    }
+    markQueryResult(incoming, { document: query, variables, errorPolicy, cacheWriteBehavior, }) {
         const diffOptions = {
             query,
             variables,
@@ -90,147 +103,130 @@ export class QueryInfo {
         // Cancel the pending notify timeout (if it exists) to prevent extraneous network
         // requests. To allow future notify timeouts, diff and dirty are reset as well.
         this.observableQuery?.["resetNotifications"]();
-        if (cacheWriteBehavior === 0 /* CacheWriteBehavior.FORBID */) {
-            const lastDiff = this.lastDiff && equal(diffOptions, this.lastDiff.options) ?
-                this.lastDiff.diff
-                : { result: null, complete: false };
-            handleIncrementalResult(result, lastDiff);
-            this.lastDiff = {
-                diff: { result: result.data, complete: true },
-                options: diffOptions,
-            };
+        const skipCache = cacheWriteBehavior === 0 /* CacheWriteBehavior.FORBID */;
+        const lastDiff = skipCache ? undefined : this.cache.diff(diffOptions);
+        let result = this.maybeHandleIncrementalResult(lastDiff?.result, incoming, query);
+        if (skipCache) {
+            return result;
         }
-        else {
-            const lastDiff = this.cache.diff(diffOptions);
-            handleIncrementalResult(result, lastDiff);
-            if (shouldWriteResult(result, errorPolicy)) {
-                // Using a transaction here so we have a chance to read the result
-                // back from the cache before the watch callback fires as a result
-                // of writeQuery, so we can store the new diff quietly and ignore
-                // it when we receive it redundantly from the watch callback.
-                this.cache.batch({
-                    onWatchUpdated: (
-                    // all additional options on ObservableQuery.CacheWatchOptions are
-                    // optional so we can use the type here
-                    watch, diff) => {
-                        if (watch.watcher === this.observableQuery) {
-                            // see comment on `lastOwnDiff` for explanation
-                            watch.lastOwnDiff = diff;
-                        }
-                    },
-                    update: (cache) => {
-                        if (this.shouldWrite(result, variables)) {
-                            cache.writeQuery({
-                                query,
-                                data: result.data,
-                                variables,
-                                overwrite: cacheWriteBehavior === 1 /* CacheWriteBehavior.OVERWRITE */,
-                            });
-                            this.lastWrite = {
-                                result,
-                                variables,
-                                dmCount: destructiveMethodCounts.get(this.cache),
-                            };
-                        }
-                        else {
-                            // If result is the same as the last result we received from
-                            // the network (and the variables match too), avoid writing
-                            // result into the cache again. The wisdom of skipping this
-                            // cache write is far from obvious, since any cache write
-                            // could be the one that puts the cache back into a desired
-                            // state, fixing corruption or missing data. However, if we
-                            // always write every network result into the cache, we enable
-                            // feuds between queries competing to update the same data in
-                            // incompatible ways, which can lead to an endless cycle of
-                            // cache broadcasts and useless network requests. As with any
-                            // feud, eventually one side must step back from the brink,
-                            // letting the other side(s) have the last word(s). There may
-                            // be other points where we could break this cycle, such as
-                            // silencing the broadcast for cache.writeQuery (not a good
-                            // idea, since it just delays the feud a bit) or somehow
-                            // avoiding the network request that just happened (also bad,
-                            // because the server could return useful new data). All
-                            // options considered, skipping this cache write seems to be
-                            // the least damaging place to break the cycle, because it
-                            // reflects the intuition that we recently wrote this exact
-                            // result into the cache, so the cache *should* already/still
-                            // contain this data. If some other query has clobbered that
-                            // data in the meantime, that's too bad, but there will be no
-                            // winners if every query blindly reverts to its own version
-                            // of the data. This approach also gives the network a chance
-                            // to return new data, which will be written into the cache as
-                            // usual, notifying only those queries that are directly
-                            // affected by the cache updates, as usual. In the future, an
-                            // even more sophisticated cache could perhaps prevent or
-                            // mitigate the clobbering somehow, but that would make this
-                            // particular cache write even less important, and thus
-                            // skipping it would be even safer than it is today.
-                            if (lastDiff && lastDiff.complete) {
-                                // Reuse data from the last good (complete) diff that we
-                                // received, when possible.
-                                result.data = lastDiff.result;
-                                return;
-                            }
-                            // If the previous this.diff was incomplete, fall through to
-                            // re-reading the latest data with cache.diff, below.
-                        }
-                        const diff = cache.diff(diffOptions);
-                        // If we're allowed to write to the cache, and we can read a
-                        // complete result from the cache, update result.data to be the
-                        // result from the cache, rather than the raw network result.
-                        // Set without setDiff to avoid triggering a notify call, since
-                        // we have other ways of notifying for this result.
-                        if (diff.complete) {
-                            result.data = diff.result;
+        if (shouldWriteResult(result, errorPolicy)) {
+            // Using a transaction here so we have a chance to read the result
+            // back from the cache before the watch callback fires as a result
+            // of writeQuery, so we can store the new diff quietly and ignore
+            // it when we receive it redundantly from the watch callback.
+            this.cache.batch({
+                onWatchUpdated: (
+                // all additional options on ObservableQuery.CacheWatchOptions are
+                // optional so we can use the type here
+                watch, diff) => {
+                    if (watch.watcher === this.observableQuery) {
+                        // see comment on `lastOwnDiff` for explanation
+                        watch.lastOwnDiff = diff;
+                    }
+                },
+                update: (cache) => {
+                    if (this.shouldWrite(result, variables)) {
+                        cache.writeQuery({
+                            query,
+                            data: result.data,
+                            variables,
+                            overwrite: cacheWriteBehavior === 1 /* CacheWriteBehavior.OVERWRITE */,
+                        });
+                        this.lastWrite = {
+                            result,
+                            variables,
+                            dmCount: destructiveMethodCounts.get(this.cache),
+                        };
+                    }
+                    else {
+                        // If result is the same as the last result we received from
+                        // the network (and the variables match too), avoid writing
+                        // result into the cache again. The wisdom of skipping this
+                        // cache write is far from obvious, since any cache write
+                        // could be the one that puts the cache back into a desired
+                        // state, fixing corruption or missing data. However, if we
+                        // always write every network result into the cache, we enable
+                        // feuds between queries competing to update the same data in
+                        // incompatible ways, which can lead to an endless cycle of
+                        // cache broadcasts and useless network requests. As with any
+                        // feud, eventually one side must step back from the brink,
+                        // letting the other side(s) have the last word(s). There may
+                        // be other points where we could break this cycle, such as
+                        // silencing the broadcast for cache.writeQuery (not a good
+                        // idea, since it just delays the feud a bit) or somehow
+                        // avoiding the network request that just happened (also bad,
+                        // because the server could return useful new data). All
+                        // options considered, skipping this cache write seems to be
+                        // the least damaging place to break the cycle, because it
+                        // reflects the intuition that we recently wrote this exact
+                        // result into the cache, so the cache *should* already/still
+                        // contain this data. If some other query has clobbered that
+                        // data in the meantime, that's too bad, but there will be no
+                        // winners if every query blindly reverts to its own version
+                        // of the data. This approach also gives the network a chance
+                        // to return new data, which will be written into the cache as
+                        // usual, notifying only those queries that are directly
+                        // affected by the cache updates, as usual. In the future, an
+                        // even more sophisticated cache could perhaps prevent or
+                        // mitigate the clobbering somehow, but that would make this
+                        // particular cache write even less important, and thus
+                        // skipping it would be even safer than it is today.
+                        if (lastDiff && lastDiff.complete) {
+                            // Reuse data from the last good (complete) diff that we
+                            // received, when possible.
+                            result = { ...result, data: lastDiff.result };
+                            return;
                         }
-                    },
-                });
-            }
-            else {
-                this.lastWrite = void 0;
-            }
+                        // If the previous this.diff was incomplete, fall through to
+                        // re-reading the latest data with cache.diff, below.
+                    }
+                    const diff = cache.diff(diffOptions);
+                    // If we're allowed to write to the cache, and we can read a
+                    // complete result from the cache, update result.data to be the
+                    // result from the cache, rather than the raw network result.
+                    // Set without setDiff to avoid triggering a notify call, since
+                    // we have other ways of notifying for this result.
+                    if (diff.complete) {
+                        result = { ...result, data: diff.result };
+                    }
+                },
+            });
         }
+        else {
+            this.lastWrite = void 0;
+        }
+        return result;
     }
-    markMutationResult(result, mutation, cache = this.cache) {
+    markMutationResult(incoming, mutation, cache = this.cache) {
         const cacheWrites = [];
         const skipCache = mutation.cacheWriteBehavior === 0 /* CacheWriteBehavior.FORBID */;
+        let result = this.maybeHandleIncrementalResult(skipCache ? undefined : (cache.diff({
+            id: "ROOT_MUTATION",
+            // The cache complains if passed a mutation where it expects a
+            // query, so we transform mutations and subscriptions to queries
+            // (only once, thanks to this.transformCache).
+            query: this.queryManager.getDocumentInfo(mutation.document).asQuery,
+            variables: mutation.variables,
+            optimistic: false,
+            returnPartialData: true,
+        }).result), incoming, mutation.document);
+        if (mutation.errorPolicy === "ignore") {
+            result = { ...result, errors: [] };
+        }
+        if (graphQLResultHasError(result) && mutation.errorPolicy === "none") {
+            return Promise.resolve(result);
+        }
+        const getResultWithDataState = () => ({
+            ...result,
+            dataState: this.hasNext ? "streaming" : "complete",
+        });
         if (!skipCache && shouldWriteResult(result, mutation.errorPolicy)) {
-            if (!isExecutionPatchIncrementalResult(result)) {
-                cacheWrites.push({
-                    result: result.data,
-                    dataId: "ROOT_MUTATION",
-                    query: mutation.document,
-                    variables: mutation.variables,
-                });
-            }
-            if (isExecutionPatchIncrementalResult(result) &&
-                isNonEmptyArray(result.incremental)) {
-                const diff = cache.diff({
-                    id: "ROOT_MUTATION",
-                    // The cache complains if passed a mutation where it expects a
-                    // query, so we transform mutations and subscriptions to queries
-                    // (only once, thanks to this.transformCache).
-                    query: this.queryManager.getDocumentInfo(mutation.document).asQuery,
-                    variables: mutation.variables,
-                    optimistic: false,
-                    returnPartialData: true,
-                });
-                let mergedData;
-                if (diff.result) {
-                    mergedData = mergeIncrementalData(diff.result, result);
-                }
-                if (typeof mergedData !== "undefined") {
-                    // cast the ExecutionPatchResult to FetchResult here since
-                    // ExecutionPatchResult never has `data` when returned from the server
-                    result.data = mergedData;
-                    cacheWrites.push({
-                        result: mergedData,
-                        dataId: "ROOT_MUTATION",
-                        query: mutation.document,
-                        variables: mutation.variables,
-                    });
-                }
-            }
+            cacheWrites.push({
+                result: result.data,
+                dataId: "ROOT_MUTATION",
+                query: mutation.document,
+                variables: mutation.variables,
+            });
             const { updateQueries } = mutation;
             if (updateQueries) {
                 this.queryManager
@@ -248,7 +244,7 @@ export class QueryInfo {
                     if (complete && currentQueryResult) {
                         // Run our reducer using the current query result and the mutation result.
                         const nextQueryResult = updater(currentQueryResult, {
-                            mutationResult: result,
+                            mutationResult: getResultWithDataState(),
                             queryName: (document && getOperationName(document)) || void 0,
                             queryVariables: variables,
                         });
@@ -265,8 +261,12 @@ export class QueryInfo {
                 });
             }
         }
+        let refetchQueries = mutation.refetchQueries;
+        if (typeof refetchQueries === "function") {
+            refetchQueries = refetchQueries(getResultWithDataState());
+        }
         if (cacheWrites.length > 0 ||
-            (mutation.refetchQueries || "").length > 0 ||
+            (refetchQueries || "").length > 0 ||
             mutation.update ||
             mutation.onQueryUpdated ||
             mutation.removeOptimistic) {
@@ -283,8 +283,6 @@ export class QueryInfo {
                     const { update } = mutation;
                     // Determine whether result is a SingleExecutionResult,
                     // or the final ExecutionPatchResult.
-                    const isFinalResult = !isExecutionPatchResult(result) ||
-                        (isExecutionPatchIncrementalResult(result) && !result.hasNext);
                     if (update) {
                         if (!skipCache) {
                             // Re-read the ROOT_MUTATION data we just wrote into the cache
@@ -303,19 +301,14 @@ export class QueryInfo {
                                 returnPartialData: true,
                             });
                             if (diff.complete) {
-                                result = { ...result, data: diff.result };
-                                if ("incremental" in result) {
-                                    delete result.incremental;
-                                }
-                                if ("hasNext" in result) {
-                                    delete result.hasNext;
-                                }
+                                result = {
+                                    ...result,
+                                    data: diff.result,
+                                };
                             }
                         }
-                        // If we've received the whole response,
-                        // either a SingleExecutionResult or the final ExecutionPatchResult,
-                        // call the update function.
-                        if (isFinalResult) {
+                        // If we've received the whole response, call the update function.
+                        if (!this.hasNext) {
                             update(cache, result, {
                                 context: mutation.context,
                                 variables: mutation.variables,
@@ -324,7 +317,7 @@ export class QueryInfo {
                     }
                     // TODO Do this with cache.evict({ id: 'ROOT_MUTATION' }) but make it
                     // shallow to allow rolling back optimistic evictions.
-                    if (!skipCache && !mutation.keepRootFields && isFinalResult) {
+                    if (!skipCache && !mutation.keepRootFields && !this.hasNext) {
                         cache.modify({
                             id: "ROOT_MUTATION",
                             fields(value, { fieldName, DELETE }) {
@@ -333,7 +326,7 @@ export class QueryInfo {
                         });
                     }
                 },
-                include: mutation.refetchQueries,
+                include: refetchQueries,
                 // Write the final mutation.result to the root layer of the cache.
                 optimistic: false,
                 // Remove the corresponding optimistic layer at the same time as we
@@ -386,21 +379,6 @@ export class QueryInfo {
         }
     }
 }
-function handleIncrementalResult(result, lastDiff) {
-    if ("incremental" in result && isNonEmptyArray(result.incremental)) {
-        const mergedData = mergeIncrementalData(lastDiff.result, result);
-        result.data = mergedData;
-        // Detect the first chunk of a deferred query and merge it with existing
-        // cache data. This ensures a `cache-first` fetch policy that returns
-        // partial cache data or a `cache-and-network` fetch policy that already
-        // has full data in the cache does not complain when trying to merge the
-        // initial deferred server data with existing cache data.
-    }
-    else if ("hasNext" in result && result.hasNext) {
-        const merger = new DeepMerger();
-        result.data = merger.merge(lastDiff.result, result.data);
-    }
-}
 function shouldWriteResult(result, errorPolicy = "none") {
     const ignoreErrors = errorPolicy === "ignore" || errorPolicy === "all";
     let writeWithErrors = !graphQLResultHasError(result);