@apollo/client 4.3.0-alpha.6 → 4.3.0-alpha.7

package/core/QueryInfo.d.ts

@@ -16,12 +16,6 @@ export declare const enum CacheWriteBehavior {
     OVERWRITE = 1,
     MERGE = 2
 }
-interface LastWrite {
-    result: FormattedExecutionResult<any, ExtensionsWithStreamInfo>;
-    variables: ApolloClient.WatchQueryOptions["variables"];
-    dmCount: number | undefined;
-    hasNext: boolean;
-}
 interface OperationInfo<TData, TVariables extends OperationVariables, AllowedCacheWriteBehavior = CacheWriteBehavior> {
     document: DocumentNode | TypedDocumentNode<TData, TVariables>;
     variables: TVariables;
@@ -39,24 +33,6 @@ export declare class QueryInfo<TData, TVariables extends OperationVariables = Op
     private readonly observableQuery?;
     private incremental?;
     constructor(queryManager: QueryManager, observableQuery?: ObservableQuery<any, any>);
-    /**
-    * @internal
-    * Tracks the last result written to the cache so that `shouldWrite` can skip
-    * an identical write. Since a `QueryInfo` only ever represents a single
-    * network request, this is shared by all `QueryInfo` instances of an
-    * `ObservableQuery`. A standalone `QueryInfo` keeps a local version.
-    *
-    * A network result that was explicitly asked for always takes precedence over
-    * what is already cached, so `ObservableQuery.refetch` and polling clear this
-    * value before starting their request.
-    * 
-    * @deprecated This is an internal API and should not be used directly. This can be removed or changed at any time.
-    */
-    _lastWrite?: LastWrite;
-    private get lastWrite();
-    private set lastWrite(value);
-    resetLastWrite(): void;
-    private shouldWrite;
     get hasNext(): boolean;
     get incrementalHandler(): Incremental.Handler<Record<string, unknown>>;
     private maybeHandleIncrementalResult;
@@ -86,4 +62,4 @@ export declare class QueryInfo<TData, TVariables extends OperationVariables = Op
     markSubscriptionResult(result: FormattedExecutionResult<TData>, { document, variables, errorPolicy, cacheWriteBehavior, }: OperationInfo<TData, TVariables, CacheWriteBehavior.FORBID | CacheWriteBehavior.MERGE>): void;
 }
 export {};
-//# sourceMappingURL=QueryInfo.d.ts.map
+//# sourceMappingURL=QueryInfo.d.ts.map

package/core/QueryInfo.js

@@ -1,27 +1,9 @@
-import { equal } from "@wry/equality";
 import { Trie } from "@wry/trie";
 import { __DEV__ } from "@apollo/client/utilities/environment";
 import { getOperationName, graphQLResultHasError, handleIncrementalSymbol, hasDirectives, toDiffWithDataState, } from "@apollo/client/utilities/internal";
 import { invariant } from "@apollo/client/utilities/invariant";
 import { NetworkStatus } from "./networkStatus.js";
 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.
@@ -35,60 +17,12 @@ export class QueryInfo {
     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 write-skipping logic in `shouldWrite`, by causing it 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
-    * Tracks the last result written to the cache so that `shouldWrite` can skip
-    * an identical write. Since a `QueryInfo` only ever represents a single
-    * network request, this is shared by all `QueryInfo` instances of an
-    * `ObservableQuery`. A standalone `QueryInfo` keeps a local version.
-    *
-    * A network result that was explicitly asked for always takes precedence over
-    * what is already cached, so `ObservableQuery.refetch` and polling clear this
-    * value before starting their request.
-    * 
-    * @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) ||
-            !equal(variables, lastWrite.variables) ||
-            !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`.
-            lastWrite.hasNext !== this.hasNext);
     }
     get hasNext() {
         return this.incremental ? this.incremental.hasNext : false;
@@ -155,14 +89,9 @@ export class QueryInfo {
                 hasDirectives(["defer"], query))) {
             result.dataState = "streaming";
         }
-        if (skipCache) {
-            return result;
-        }
-        if (!shouldWriteResult(result, errorPolicy)) {
-            this.lastWrite = void 0;
+        if (skipCache || !shouldWriteResult(result, errorPolicy)) {
             return result;
         }
-        let written = false;
         // 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
@@ -178,55 +107,13 @@ export class QueryInfo {
                 }
             },
             update: (cache) => {
-                const shouldWrite = this.shouldWrite(result, variables);
-                // 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 (shouldWrite) {
-                    cache.writeQuery({
-                        query,
-                        data: result.data,
-                        variables,
-                        overwrite: cacheWriteBehavior === 1 /* CacheWriteBehavior.OVERWRITE */,
-                        extensions: result.extensions,
-                    });
-                    this.lastWrite = {
-                        result,
-                        variables,
-                        dmCount: destructiveMethodCounts.get(this.cache),
-                        hasNext: this.hasNext,
-                    };
-                    written = true;
-                }
+                cache.writeQuery({
+                    query,
+                    data: result.data,
+                    variables,
+                    overwrite: cacheWriteBehavior === 1 /* CacheWriteBehavior.OVERWRITE */,
+                    extensions: result.extensions,
+                });
                 const { dataState, result: diffResult } = this.getDiff({
                     ...diffOptions,
                     returnPartialData: returnPartialData &&
@@ -236,11 +123,10 @@ export class QueryInfo {
                 }, this.getIncrementalInfo({ prune }));
                 if (dataState === "complete" ||
                     dataState === "streaming" ||
-                    (returnPartialData && dataState === "partial" && shouldWrite)) {
+                    (returnPartialData && dataState === "partial")) {
                     result = { ...result, data: diffResult, dataState };
                 }
                 else if (__DEV__ &&
-                    written &&
                     // A result that is still streaming is expected to read back
                     // incomplete until the remaining chunks arrive.
                     !this.hasNext) {
@@ -477,7 +363,7 @@ export class QueryInfo {
 }
 function warnAboutPartialCacheResult(query, networkResult, diff) {
     __DEV__ && invariant.warn(
-        89,
+        90,
         getOperationName(query, "(anonymous)"),
         diff.missing?.missing,
         networkResult,