@apollo/client 4.3.0-alpha.0 → 4.3.0-alpha.10

package/__cjs/core/ObservableQuery.d.cts

@@ -278,12 +278,8 @@ export declare class ObservableQuery<TData = unknown, TVariables extends Operati
     readonly options: ObservableQuery.Options<TData, TVariables>;
     readonly queryName?: string;
     private variablesUnknown;
-    /**
-    * @internal will be read and written from `QueryInfo`
-    * 
-    * @deprecated This is an internal API and should not be used directly. This can be removed or changed at any time.
-    */
-    _lastWrite?: unknown;
+    private didWarnOnFeud;
+    private lastMissing?;
     get query(): TypedDocumentNode<TData, TVariables>;
     /**
      * An object containing the variables that were provided for the query.
@@ -349,7 +345,7 @@ export declare class ObservableQuery<TData = unknown, TVariables extends Operati
     */
     getCacheDiff({ optimistic }?: {
         optimistic?: boolean | undefined;
-    }): Cache.DiffResult<TData>;
+    }): Cache.InternalDiffResultWithDataState<TData>;
     private getInitialResult;
     private resubscribeCache;
     private stableLastResult?;
@@ -372,7 +368,18 @@ export declare class ObservableQuery<TData = unknown, TVariables extends Operati
     /**
      * A function that helps you fetch the next set of results for a [paginated list field](https://www.apollographql.com/docs/react/pagination/core-api/).
      */
-    fetchMore<TFetchData = TData, TFetchVars extends OperationVariables = TVariables>(options: ObservableQuery.FetchMoreOptions<TData, TVariables, TFetchData, TFetchVars>): Promise<ApolloClient.QueryResult<TFetchData>>;
+    fetchMore<TFetchData = TData, TFetchVars extends OperationVariables = TVariables, TErrorPolicy extends ErrorPolicy = "none">(options: ObservableQuery.FetchMoreOptions<TData, TVariables, TFetchData, TFetchVars> & {
+        /**
+        * Specifies how the query handles a response that returns both GraphQL errors and partial results.
+        * 
+        * For details, see [GraphQL error policies](https://www.apollographql.com/docs/react/data/error-handling/#graphql-error-policies).
+        * 
+        * The default value is `none`, meaning that the query result includes error details but not partial results.
+        * 
+        * @docGroup 1. Operation options
+        */
+        errorPolicy?: TErrorPolicy;
+    }): Promise<ApolloClient.QueryResult<TFetchData, TErrorPolicy>>;
     /**
      * A function that enables you to execute a [subscription](https://www.apollographql.com/docs/react/data/subscriptions/), usually to subscribe to specific fields that were included in the query.
      *
@@ -458,6 +465,7 @@ export declare class ObservableQuery<TData = unknown, TVariables extends Operati
     * @deprecated This is an internal API and should not be used directly. This can be removed or changed at any time.
     */
     notify(scheduled?: boolean): void;
+    private deliverCacheDiff;
     private activeOperations;
     private pushOperation;
     private calculateNetworkStatus;

package/__cjs/core/QueryInfo.cjs

@@ -1,27 +1,16 @@
-"use strict";
+"use strict";;
+const {
+    __DEV__
+} = require("@apollo/client/utilities/environment");
+
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.QueryInfo = void 0;
-const equality_1 = require("@wry/equality");
+const trie_1 = require("@wry/trie");
+const environment_1 = require("@apollo/client/utilities/environment");
 const internal_1 = require("@apollo/client/utilities/internal");
 const invariant_1 = require("@apollo/client/utilities/invariant");
+const networkStatus_js_1 = require("./networkStatus.cjs");
 const IGNORE = {};
-const destructiveMethodCounts = new WeakMap();
-function wrapDestructiveCacheMethod(cache, methodName) {
-    const original = cache[methodName];
-    if (typeof original === "function") {
-        // @ts-expect-error this is just too generic to be typed correctly
-        cache[methodName] = function () {
-            destructiveMethodCounts.set(cache, 
-            // The %1e15 allows the count to wrap around to 0 safely every
-            // quadrillion evictions, so there's no risk of overflow. To be
-            // clear, this is more of a pedantic principle than something
-            // that matters in any conceivable practical scenario.
-            (destructiveMethodCounts.get(cache) + 1) % 1e15);
-            // @ts-expect-error this is just too generic to be typed correctly
-            return original.apply(this, arguments);
-        };
-    }
-}
 const queryInfoIds = new WeakMap();
 // A QueryInfo object represents a single network request, either initiated
 // from the QueryManager or from an ObservableQuery.
@@ -29,182 +18,162 @@ const queryInfoIds = new WeakMap();
 // It is responsible for reporting results to the cache, merging and in a no-cache
 // scenario accumulating the response.
 class QueryInfo {
-    // TODO remove soon - this should be able to be handled by cancelling old operations before starting new ones
-    lastRequestId = 1;
     cache;
     queryManager;
     id;
     observableQuery;
     incremental;
     constructor(queryManager, observableQuery) {
-        const cache = (this.cache = queryManager.cache);
+        this.cache = queryManager.cache;
         const id = (queryInfoIds.get(queryManager) || 0) + 1;
         queryInfoIds.set(queryManager, id);
         this.id = id + "";
         this.observableQuery = observableQuery;
         this.queryManager = queryManager;
-        // Track how often cache.evict is called, since we want eviction to
-        // override the feud-stopping logic in the markQueryResult method, by
-        // causing shouldWrite to return true. Wrapping the cache.evict method
-        // is a bit of a hack, but it saves us from having to make eviction
-        // counting an official part of the ApolloCache API.
-        if (!destructiveMethodCounts.has(cache)) {
-            destructiveMethodCounts.set(cache, 0);
-            wrapDestructiveCacheMethod(cache, "evict");
-            wrapDestructiveCacheMethod(cache, "modify");
-            wrapDestructiveCacheMethod(cache, "reset");
-        }
-    }
-    /**
-    * @internal
-    * For feud-preventing behaviour, `lastWrite` should be shared by all `QueryInfo` instances of an `ObservableQuery`.
-    * In the case of a standalone `QueryInfo`, we will keep a local version.
-    * 
-    * @deprecated This is an internal API and should not be used directly. This can be removed or changed at any time.
-    */
-    _lastWrite;
-    get lastWrite() {
-        return (this.observableQuery || this)._lastWrite;
-    }
-    set lastWrite(value) {
-        (this.observableQuery || this)._lastWrite = value;
-    }
-    resetLastWrite() {
-        this.lastWrite = void 0;
-    }
-    shouldWrite(result, variables) {
-        const { lastWrite } = this;
-        return !(lastWrite &&
-            // If cache.evict has been called since the last time we wrote this
-            // data into the cache, there's a chance writing this result into
-            // the cache will repair what was evicted.
-            lastWrite.dmCount === destructiveMethodCounts.get(this.cache) &&
-            (0, equality_1.equal)(variables, lastWrite.variables) &&
-            (0, equality_1.equal)(result.data, lastWrite.result.data) &&
-            // We have to compare these values because its possible the final chunk
-            // emitted in the incremental result is just `hasNext: false`. This
-            // ensures we trigger a cache write when we get `isLastChunk: true`.
-            result.extensions?.[internal_1.streamInfoSymbol] ===
-                lastWrite.result.extensions?.[internal_1.streamInfoSymbol]);
     }
     get hasNext() {
         return this.incremental ? this.incremental.hasNext : false;
     }
+    get incrementalHandler() {
+        return this.queryManager.incrementalHandler;
+    }
     maybeHandleIncrementalResult(cacheData, incoming, query) {
-        const { incrementalHandler } = this.queryManager;
-        if (incrementalHandler.isIncrementalResult(incoming)) {
-            this.incremental ||= incrementalHandler.startRequest({
+        if (this.incrementalHandler.isIncrementalResult(incoming)) {
+            this.incremental ||= this.incrementalHandler.startRequest({
                 query,
             });
             return this.incremental.handle(cacheData, incoming);
         }
         return incoming;
     }
-    markQueryResult(incoming, { document: query, variables, errorPolicy, cacheWriteBehavior, }) {
+    markQueryResult(incoming, { document: query, variables, errorPolicy, cacheWriteBehavior, returnPartialData, fetchPolicy, networkStatus, prunePendingDeferFragments: prune, }) {
         const diffOptions = {
             query,
             variables,
-            returnPartialData: true,
             optimistic: true,
         };
         // 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"]();
         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;
-        }
-        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 */,
-                            extensions: result.extensions,
-                        });
-                        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;
-                        }
-                        // 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 };
-                    }
-                },
-            });
+        const diff = skipCache ? undefined : (this.getDiff({
+            ...diffOptions,
+            // We usually request partial data to ensure the network incremental
+            // result is merged with all existing data (especially true to
+            // maintain @stream arrays with partial list items in the right order
+            // or when chunk might otherwise replace a partial non-normalized
+            // object), but if we are about to throw away the result anyways due
+            // to the error policy (which early returns below), prune any
+            // pending boundaries so that CombinedGraphQLErrors contains the
+            // right `data` value.
+            returnPartialData: errorPolicy !== "none" ||
+                !this.incrementalHandler.extractErrors(incoming)?.length,
+        }, this.getIncrementalInfo({ prune })));
+        const incrementalResult = this.maybeHandleIncrementalResult(diff?.result, incoming, query);
+        let result = {
+            ...incrementalResult,
+            dataState: incrementalResult.data == null ? "empty" : "complete",
+        };
+        const hasPendingDefer = this.incremental
+            ?.getPendingWithInfo?.()
+            .some((pending) => pending.type === "defer" && !pending.delivered);
+        if (hasPendingDefer ||
+            // The Defer20220824Handler cannot track pending/completed incremental
+            // chunks due to its data format so we naively set dataState to
+            // streaming if we are still processing chunks. The only case where
+            // streaming is incorrect and should actually be complete is when
+            // both a @defer and @stream boundary is present and the @defer chunk
+            // has completed before the `@stream` array.
+            //
+            // Assigning the naive "streaming" value avoids a much more expensive
+            // pass over `result.data` that would otherwise need to traverse the
+            // selection sets and evaluate the data object at each defer boundary
+            // to see if it fulfills the selection set. For such a narrow case where
+            // its incorrect on a format that is now outdated is not worth the
+            // fix so we are ok with reporting a `streaming` here.
+            (!this.incremental?.getPendingWithInfo &&
+                this.hasNext &&
+                (0, internal_1.hasDirectives)(["defer"], query))) {
+            result.dataState = "streaming";
         }
-        else {
-            this.lastWrite = void 0;
+        if (skipCache || !shouldWriteResult(result, errorPolicy)) {
+            return result;
         }
+        // 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) => {
+                cache.writeQuery({
+                    query,
+                    data: result.data,
+                    variables,
+                    overwrite: cacheWriteBehavior === 1 /* CacheWriteBehavior.OVERWRITE */,
+                    extensions: result.extensions,
+                });
+                const { dataState, result: diffResult } = this.getDiff({
+                    ...diffOptions,
+                    returnPartialData: returnPartialData &&
+                        // Never deliver partial data for network-only requests
+                        (fetchPolicy !== "network-only" ||
+                            networkStatus === networkStatus_js_1.NetworkStatus.refetch),
+                }, this.getIncrementalInfo({ prune }));
+                if (dataState === "complete" ||
+                    dataState === "streaming" ||
+                    (returnPartialData && dataState === "partial")) {
+                    result = { ...result, data: diffResult, dataState };
+                }
+                else if (environment_1.__DEV__ &&
+                    // A result that is still streaming is expected to read back
+                    // incomplete until the remaining chunks arrive.
+                    !this.hasNext) {
+                    warnAboutPartialCacheResult(query, result.data, 
+                    // Always show the partial result for debugging, otherwise the user
+                    // sees `null` when `returnPartialData` is false which isn't helpful
+                    // for figuring out where the problem is.
+                    cache.diff({ ...diffOptions, returnPartialData: true }));
+                }
+            },
+        });
         return result;
     }
+    getIncrementalInfo({ prune }) {
+        const pending = this.incremental?.getPendingWithInfo?.() ?? [];
+        const streamInfo = this.incremental?.streamInfo;
+        const incrementalInfo = { streamInfo };
+        // We don't want to deliver stream items or complete defer boundaries
+        // for a network-only request if they haven't yet streamed from the
+        // network. We record all the still-pending paths so that cache.diff
+        // can prune complete defer/stream boundaries at those paths.
+        if (prune) {
+            for (const item of pending) {
+                if (item.type === "defer" && !item.delivered) {
+                    incrementalInfo.deferInfo ||= new trie_1.Trie(true, () => true);
+                    incrementalInfo.deferInfo.lookupArray(item.path.concat(item.label || []));
+                }
+                else if (streamInfo && item.type === "stream") {
+                    streamInfo.lookupArray(item.path).state.truncate = true;
+                }
+            }
+        }
+        return incrementalInfo;
+    }
+    getDiff(options, incrementalInfo) {
+        return (0, internal_1.toDiffWithDataState)(this.cache.diff({
+            ...options,
+            [internal_1.handleIncrementalSymbol]: incrementalInfo,
+        }));
+    }
     markMutationResult(incoming, mutation, cache = this.cache) {
         const cacheWrites = [];
         const skipCache = mutation.cacheWriteBehavior === 0 /* CacheWriteBehavior.FORBID */;
@@ -292,38 +261,34 @@ class QueryInfo {
                     const { update } = mutation;
                     // Determine whether result is a SingleExecutionResult,
                     // or the final ExecutionPatchResult.
-                    if (update) {
-                        if (!skipCache) {
-                            // Re-read the ROOT_MUTATION data we just wrote into the cache
-                            // (the first cache.write call in the cacheWrites.forEach loop
-                            // above), so field read functions have a chance to run for
-                            // fields within mutation result objects.
-                            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,
-                            });
-                            if (diff.complete) {
-                                result = {
-                                    ...result,
-                                    data: diff.result,
-                                };
-                            }
-                        }
-                        // If we've received the whole response, call the update function.
-                        if (!this.hasNext) {
-                            update(cache, result, {
-                                context: mutation.context,
-                                variables: mutation.variables,
-                            });
+                    // Re-read from the cache after writing to it to update `result`
+                    // with any parsed scalar values that might have been written.
+                    if (!skipCache) {
+                        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,
+                        });
+                        if (diff.complete) {
+                            result = {
+                                ...result,
+                                data: diff.result,
+                            };
                         }
                     }
+                    // If we've received the whole response, call the update function.
+                    if (update && !this.hasNext) {
+                        update(cache, result, {
+                            context: mutation.context,
+                            variables: mutation.variables,
+                        });
+                    }
                     // TODO Do this with cache.evict({ id: 'ROOT_MUTATION' }) but make it
                     // shallow to allow rolling back optimistic evictions.
                     if (!skipCache && !mutation.keepRootFields && !this.hasNext) {
@@ -384,12 +349,35 @@ class QueryInfo {
                     variables: variables,
                     extensions: result.extensions,
                 });
+                // Re-read from the cache to get parsed scalar values
+                const diff = this.cache.diff({
+                    // 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(document).asQuery,
+                    id: "ROOT_SUBSCRIPTION",
+                    variables,
+                    optimistic: false,
+                    returnPartialData: true,
+                });
+                if (diff.complete) {
+                    result.data = diff.result;
+                }
             }
             this.queryManager.broadcastQueries();
         }
     }
 }
 exports.QueryInfo = QueryInfo;
+function warnAboutPartialCacheResult(query, networkResult, diff) {
+    __DEV__ && invariant_1.invariant.warn(
+        91,
+        (0, internal_1.getOperationName)(query, "(anonymous)"),
+        diff.missing?.missing,
+        networkResult,
+        diff.result
+    );
+}
 function shouldWriteResult(result, errorPolicy = "none") {
     const ignoreErrors = errorPolicy === "ignore" || errorPolicy === "all";
     let writeWithErrors = !(0, internal_1.graphQLResultHasError)(result);