@apollo/client 4.0.0-alpha.12 → 4.0.0-alpha.14

package/__cjs/core/ObservableQuery.d.cts

@@ -1,12 +1,12 @@
 import type { DocumentNode } from "graphql";
 import type { InteropObservable, Observer, Subscribable, Subscription } from "rxjs";
-import type { Observable } from "rxjs";
-import type { MissingFieldError } from "@apollo/client/cache";
+import { Observable } from "rxjs";
+import type { Cache, MissingFieldError } from "@apollo/client/cache";
 import type { MissingTree } from "@apollo/client/cache";
 import type { MaybeMasked, Unmasked } from "@apollo/client/masking";
 import type { QueryInfo } from "./QueryInfo.cjs";
 import type { QueryManager } from "./QueryManager.cjs";
-import type { ApolloQueryResult, DefaultContext, ErrorLike, OperationVariables, QueryResult, TypedDocumentNode } from "./types.cjs";
+import type { ApolloQueryResult, DefaultContext, OperationVariables, QueryResult, TypedDocumentNode } from "./types.cjs";
 import type { ErrorPolicy, FetchMoreQueryOptions, NextFetchPolicyContext, RefetchWritePolicy, SubscribeToMoreOptions, UpdateQueryMapFn, WatchQueryFetchPolicy, WatchQueryOptions } from "./watchQueryOptions.cjs";
 export interface FetchMoreOptions<TData = unknown, TVariables = OperationVariables> {
     updateQuery?: (previousQueryResult: TData, options: {
@@ -129,15 +129,40 @@ export declare namespace ObservableQuery {
         */
         variables: TVariables;
     };
+    /**
+    * @internal
+    * This describes the `WatchOptions` used by `ObservableQuery` to
+    * subscribe to the cache.
+    * 
+    * @deprecated This is an internal API and should not be used directly. This can be removed or changed at any time.
+    */
+    interface CacheWatchOptions<TData = unknown, TVariables extends OperationVariables = OperationVariables> extends Cache.WatchOptions<TData, TVariables> {
+        /**
+        * @internal
+        * We cannot suppress the broadcast completely, since that would
+        * result in external updates to be lost if we go from
+        * (external A) -> (own B) -> (external C) when A and C have the same
+        * value.
+        * Without the `own B` being broadcast, the `cache.watch` would swallow
+        * C.
+        * So instead we track the last "own diff" and suppress further processing
+        * in the callback.
+        * 
+        * @deprecated This is an internal API and should not be used directly. This can be removed or changed at any time.
+        */
+        lastOwnDiff?: Cache.DiffResult<TData>;
+    }
 }
 export declare class ObservableQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables> implements Subscribable<ApolloQueryResult<MaybeMasked<TData>>>, InteropObservable<ApolloQueryResult<MaybeMasked<TData>>> {
     /**
-     * @internal
-     * A slot used by the `useQuery` hook to indicate that `client.watchQuery`
-     * should not register the query immediately, but instead wait for the query to
-     * be started registered with the `QueryManager` when `useSyncExternalStore`
-     * actively subscribes to it.
-     */
+    * @internal
+    * A slot used by the `useQuery` hook to indicate that `client.watchQuery`
+    * should not register the query immediately, but instead wait for the query to
+    * be started registered with the `QueryManager` when `useSyncExternalStore`
+    * actively subscribes to it.
+    * 
+    * @deprecated This is an internal API and should not be used directly. This can be removed or changed at any time.
+    */
     private static inactiveOnCreation;
     readonly options: ObservableQuery.Options<TData, TVariables>;
     readonly queryId: string;
@@ -147,19 +172,24 @@ export declare class ObservableQuery<TData = unknown, TVariables extends Operati
      * An object containing the variables that were provided for the query.
      */
     get variables(): TVariables;
+    private unsubscribeFromCache?;
+    private input;
     private subject;
     private readonly observable;
     private isTornDown;
     private queryManager;
     private subscriptions;
-    private waitForOwnResult;
-    private last?;
+    /**
+     * If an `ObservableQuery` is created with a `network-only` fetch policy,
+     * it should actually start receiving cache updates, but not before it has
+     * received the first result from the network.
+     */
+    private waitForNetworkResult;
     private lastQuery;
     private queryInfo;
     private linkSubscription?;
-    private linkObservable?;
     private pollingInfo?;
-    private networkStatus;
+    private get networkStatus();
     constructor({ queryManager, queryInfo, options, }: {
         queryManager: QueryManager;
         queryInfo: QueryInfo;
@@ -169,16 +199,17 @@ export declare class ObservableQuery<TData = unknown, TVariables extends Operati
     pipe: Observable<ApolloQueryResult<MaybeMasked<TData>>>["pipe"];
     [Symbol.observable]: () => Subscribable<ApolloQueryResult<MaybeMasked<TData>>>;
     ["@@observable"]: () => Subscribable<ApolloQueryResult<MaybeMasked<TData>>>;
-    /** @internal */
+    /**
+    * @internal
+    * 
+    * @deprecated This is an internal API and should not be used directly. This can be removed or changed at any time.
+    */
     resetDiff(): void;
+    private getCacheDiff;
     private getInitialResult;
-    private getCurrentFullResult;
-    getCurrentResult(saveAsLastResult?: boolean): ApolloQueryResult<MaybeMasked<TData>>;
-    isDifferentFromLastResult(newResult: ApolloQueryResult<TData>, variables?: TVariables): boolean | undefined;
-    private getLast;
-    getLastResult(variablesMustMatch?: boolean): ApolloQueryResult<TData> | undefined;
-    getLastError(variablesMustMatch?: boolean): ErrorLike | undefined;
-    resetLastResults(): void;
+    private resubscribeCache;
+    private stableLastResult?;
+    getCurrentResult(): ApolloQueryResult<MaybeMasked<TData>>;
     /**
      * Update the variables of this observable query, and fetch the new results.
      * This method should be preferred over `setVariables` in most use cases.
@@ -202,7 +233,11 @@ export declare class ObservableQuery<TData = unknown, TVariables extends Operati
      * This function returns _another_ function that you can call to terminate the subscription.
      */
     subscribeToMore<TSubscriptionData = TData, TSubscriptionVariables extends OperationVariables = TVariables>(options: SubscribeToMoreOptions<TData, TSubscriptionVariables, TSubscriptionData, TVariables>): () => void;
-    /** @internal */
+    /**
+    * @internal
+    * 
+    * @deprecated This is an internal API and should not be used directly. This can be removed or changed at any time.
+    */
     silentSetOptions(newOptions: Partial<ObservableQuery.Options<TData, TVariables>>): void;
     /**
      * Update the variables of this observable query, and fetch the new results
@@ -241,28 +276,55 @@ export declare class ObservableQuery<TData = unknown, TVariables extends Operati
     private fetch;
     private updatePolling;
     private cancelPolling;
-    private updateLastResult;
     /**
      * Reevaluate the query, optionally against new options. New options will be
      * merged with the current options when given.
      */
     reobserve(newOptions?: Partial<ObservableQuery.Options<TData, TVariables>>): Promise<QueryResult<MaybeMasked<TData>>>;
-    private observe;
-    private reportResult;
-    private reportError;
     hasObservers(): boolean;
     private tearDownQuery;
     private transformDocument;
     private maskResult;
     private dirty;
     private notifyTimeout?;
-    /** @internal */
-    protected resetNotifications(): void;
-    private cancelNotifyTimeout;
-    /** @internal */
-    protected scheduleNotify(): void;
-    /** @internal */
-    protected notify(): void;
+    /**
+    * @internal
+    * 
+    * @deprecated This is an internal API and should not be used directly. This can be removed or changed at any time.
+    */
+    private resetNotifications;
+    /**
+    * @internal
+    * 
+    * @deprecated This is an internal API and should not be used directly. This can be removed or changed at any time.
+    */
+    private scheduleNotify;
+    /**
+    * @internal
+    * 
+    * @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 activeOperations;
+    private pushOperation;
+    private calculateNetworkStatus;
+    private abortActiveOperations;
+    /**
+    * @internal
+    * Called from `clearStore`.
+    * * resets the query to its initial state
+    * * cancels all active operations and their subscriptions
+    * 
+    * @deprecated This is an internal API and should not be used directly. This can be removed or changed at any time.
+    */
+    reset(): void;
+    /**
+    * @internal
+    * 
+    * @deprecated This is an internal API and should not be used directly. This can be removed or changed at any time.
+    */
+    private setResult;
+    private operator;
     private reobserveCacheFirst;
     private getVariablesWithDefaults;
 }

package/__cjs/core/QueryInfo.cjs

@@ -3,9 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.QueryInfo = void 0;
 exports.shouldWriteResult = shouldWriteResult;
 const equality_1 = require("@wry/equality");
-const utilities_1 = require("@apollo/client/utilities");
-const utilities_2 = require("@apollo/client/utilities");
-const utilities_3 = require("@apollo/client/utilities");
+const internal_1 = require("@apollo/client/utilities/internal");
 const destructiveMethodCounts = new WeakMap();
 function wrapDestructiveCacheMethod(cache, methodName) {
     const original = cache[methodName];
@@ -40,8 +38,6 @@ class QueryInfo {
     document = null;
     lastRequestId = 1;
     variables;
-    stopped = false;
-    cancelWatch;
     cache;
     constructor(queryManager, queryId = queryManager.generateQueryId()) {
         this.queryId = queryId;
@@ -60,9 +56,7 @@ class QueryInfo {
     }
     init(query) {
         if (!(0, equality_1.equal)(query.variables, this.variables)) {
-            this.lastDiff = void 0;
-            // Ensure we don't continue to receive cache updates for old variables
-            this.cancel();
+            this.resetDiff();
         }
         Object.assign(this, {
             document: query.document,
@@ -70,33 +64,6 @@ class QueryInfo {
         });
         return this;
     }
-    resetDiff() {
-        this.lastDiff = void 0;
-    }
-    getDiff() {
-        const options = this.getDiffOptions();
-        if (this.lastDiff && (0, equality_1.equal)(options, this.lastDiff.options)) {
-            return this.lastDiff.diff;
-        }
-        this.updateWatch(this.variables);
-        const oq = this.observableQuery;
-        if (oq && oq.options.fetchPolicy === "no-cache") {
-            return { result: null, complete: false };
-        }
-        const diff = this.cache.diff(options);
-        this.updateLastDiff(diff, options);
-        return diff;
-    }
-    lastDiff;
-    updateLastDiff(diff, options) {
-        this.lastDiff =
-            diff ?
-                {
-                    diff,
-                    options: options || this.getDiffOptions(),
-                }
-                : void 0;
-    }
     getDiffOptions(variables = this.variables) {
         return {
             query: this.document,
@@ -105,25 +72,6 @@ class QueryInfo {
             optimistic: true,
         };
     }
-    setDiff(diff) {
-        const oldDiff = this.lastDiff && this.lastDiff.diff;
-        // If we are trying to deliver an incomplete cache result, we avoid
-        // reporting it if the query has errored, otherwise we let the broadcast try
-        // and repair the partial result by refetching the query. This check avoids
-        // a situation where a query that errors and another succeeds with
-        // overlapping data does not report the partial data result to the errored
-        // query.
-        //
-        // See https://github.com/apollographql/apollo-client/issues/11400 for more
-        // information on this issue.
-        if (diff && !diff.complete && this.observableQuery?.getLastError()) {
-            return;
-        }
-        this.updateLastDiff(diff);
-        if (!(0, equality_1.equal)(oldDiff && oldDiff.result, diff && diff.result)) {
-            this.observableQuery?.["scheduleNotify"]();
-        }
-    }
     observableQuery = null;
     setObservableQuery(oq) {
         if (oq === this.observableQuery)
@@ -133,40 +81,6 @@ class QueryInfo {
             oq["queryInfo"] = this;
         }
     }
-    stop() {
-        if (!this.stopped) {
-            this.stopped = true;
-            // Cancel the pending notify timeout
-            this.observableQuery?.["resetNotifications"]();
-            this.cancel();
-            const oq = this.observableQuery;
-            if (oq)
-                oq.stopPolling();
-        }
-    }
-    cancel() {
-        this.cancelWatch?.();
-        this.cancelWatch = void 0;
-    }
-    lastWatch;
-    updateWatch(variables = this.variables) {
-        const oq = this.observableQuery;
-        if (oq && oq.options.fetchPolicy === "no-cache") {
-            return;
-        }
-        const watchOptions = {
-            // Although this.getDiffOptions returns Cache.DiffOptions instead of
-            // Cache.WatchOptions, all the overlapping options should be the same, so
-            // we can reuse getDiffOptions here, for consistency.
-            ...this.getDiffOptions(variables),
-            watcher: this,
-            callback: (diff) => this.setDiff(diff),
-        };
-        if (!this.lastWatch || !(0, equality_1.equal)(watchOptions, this.lastWatch)) {
-            this.cancel();
-            this.cancelWatch = this.cache.watch((this.lastWatch = watchOptions));
-        }
-    }
     lastWrite;
     resetLastWrite() {
         this.lastWrite = void 0;
@@ -181,111 +95,110 @@ class QueryInfo {
             (0, equality_1.equal)(variables, lastWrite.variables) &&
             (0, equality_1.equal)(result.data, lastWrite.result.data));
     }
+    resetDiff() {
+        this.lastDiff = void 0;
+    }
+    lastDiff;
     markResult(result, document, options, cacheWriteBehavior) {
-        const merger = new utilities_3.DeepMerger();
         // 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 ("incremental" in result && (0, utilities_1.isNonEmptyArray)(result.incremental)) {
-            const mergedData = (0, utilities_2.mergeIncrementalData)(this.getDiff().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.
+        if (cacheWriteBehavior === 0 /* CacheWriteBehavior.FORBID */) {
+            const diffOptions = this.getDiffOptions(options.variables);
+            const lastDiff = this.lastDiff && (0, equality_1.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,
+            };
         }
-        else if ("hasNext" in result && result.hasNext) {
-            const diff = this.getDiff();
-            result.data = merger.merge(diff.result, result.data);
-        }
-        if (options.fetchPolicy === "no-cache") {
-            this.updateLastDiff({ result: result.data, complete: true }, this.getDiffOptions(options.variables));
-        }
-        else if (cacheWriteBehavior !== 0 /* CacheWriteBehavior.FORBID */) {
+        else {
+            const lastDiff = this.cache.diff(this.getDiffOptions());
+            handleIncrementalResult(result, lastDiff);
             if (shouldWriteResult(result, options.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.performTransaction((cache) => {
-                    if (this.shouldWrite(result, options.variables)) {
-                        cache.writeQuery({
-                            query: document,
-                            data: result.data,
-                            variables: options.variables,
-                            overwrite: cacheWriteBehavior === 1 /* CacheWriteBehavior.OVERWRITE */,
-                        });
-                        this.lastWrite = {
-                            result,
-                            variables: options.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 (this.lastDiff && this.lastDiff.diff.complete) {
-                            // Reuse data from the last good (complete) diff that we
-                            // received, when possible.
-                            result.data = this.lastDiff.diff.result;
-                            return;
+                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, options.variables)) {
+                            cache.writeQuery({
+                                query: document,
+                                data: result.data,
+                                variables: options.variables,
+                                overwrite: cacheWriteBehavior === 1 /* CacheWriteBehavior.OVERWRITE */,
+                            });
+                            this.lastWrite = {
+                                result,
+                                variables: options.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.
                         }
-                        // If the previous this.diff was incomplete, fall through to
-                        // re-reading the latest data with cache.diff, below.
-                    }
-                    const diffOptions = this.getDiffOptions(options.variables);
-                    const diff = cache.diff(diffOptions);
-                    // In case the QueryManager stops this QueryInfo before its
-                    // results are delivered, it's important to avoid restarting the
-                    // cache watch when markResult is called. We also avoid updating
-                    // the watch if we are writing a result that doesn't match the current
-                    // variables to avoid race conditions from broadcasting the wrong
-                    // result.
-                    if (!this.stopped && (0, equality_1.equal)(this.variables, options.variables)) {
-                        // Any time we're about to update this.diff, we need to make
-                        // sure we've started watching the cache.
-                        this.updateWatch(options.variables);
-                    }
-                    // 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.
-                    this.updateLastDiff(diff, diffOptions);
-                    if (diff.complete) {
-                        result.data = diff.result;
-                    }
+                        const diffOptions = this.getDiffOptions(options.variables);
+                        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;
+                        }
+                    },
                 });
             }
             else {
@@ -295,9 +208,24 @@ class QueryInfo {
     }
 }
 exports.QueryInfo = QueryInfo;
+function handleIncrementalResult(result, lastDiff) {
+    if ("incremental" in result && (0, internal_1.isNonEmptyArray)(result.incremental)) {
+        const mergedData = (0, internal_1.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 internal_1.DeepMerger();
+        result.data = merger.merge(lastDiff.result, result.data);
+    }
+}
 function shouldWriteResult(result, errorPolicy = "none") {
     const ignoreErrors = errorPolicy === "ignore" || errorPolicy === "all";
-    let writeWithErrors = !(0, utilities_1.graphQLResultHasError)(result);
+    let writeWithErrors = !(0, internal_1.graphQLResultHasError)(result);
     if (!writeWithErrors && ignoreErrors && result.data) {
         writeWithErrors = true;
     }