@apollo/client 4.0.0-alpha.7 → 4.0.0-alpha.9

package/__cjs/core/ObservableQuery.cjs

@@ -5,9 +5,9 @@ const {
 
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ObservableQuery = void 0;
-exports.reobserveCacheFirst = reobserveCacheFirst;
 exports.logMissingFieldErrors = logMissingFieldErrors;
 const equality_1 = require("@wry/equality");
+const optimism_1 = require("optimism");
 const rxjs_1 = require("rxjs");
 const utilities_1 = require("@apollo/client/utilities");
 const environment_1 = require("@apollo/client/utilities/environment");
@@ -17,7 +17,16 @@ const equalByQuery_js_1 = require("./equalByQuery.cjs");
 const networkStatus_js_1 = require("./networkStatus.cjs");
 const { assign, hasOwnProperty } = Object;
 const newNetworkStatusSymbol = Symbol();
+const uninitialized = {};
 class ObservableQuery {
+    /**
+     * @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.
+     */
+    static inactiveOnCreation = new optimism_1.Slot();
     options;
     queryId;
     queryName;
@@ -38,7 +47,6 @@ class ObservableQuery {
     }
     subject;
     observable;
-    initialResult;
     isTornDown;
     queryManager;
     subscriptions = new Set();
@@ -52,16 +60,31 @@ class ObservableQuery {
     networkStatus;
     constructor({ queryManager, queryInfo, options, }) {
         this.networkStatus = networkStatus_js_1.NetworkStatus.loading;
-        this.initialResult = {
-            data: undefined,
-            loading: true,
-            networkStatus: this.networkStatus,
-            partial: true,
-        };
-        this.subject = new rxjs_1.BehaviorSubject(this.initialResult);
+        let startedInactive = ObservableQuery.inactiveOnCreation.getValue();
+        this.subject = new rxjs_1.BehaviorSubject(uninitialized);
         this.observable = this.subject.pipe((0, rxjs_1.tap)({
             subscribe: () => {
+                if (startedInactive) {
+                    queryManager["queries"].set(this.queryId, queryInfo);
+                    startedInactive = false;
+                }
                 if (!this.subject.observed) {
+                    if (this.subject.value === uninitialized) {
+                        // Emitting a value in the `subscribe` callback of `tap` gives
+                        // the subject a chance to save this initial result without
+                        // emitting the placeholder value since this callback is executed
+                        // before `tap` subscribes to the source observable (the subject).
+                        // `reobserve` also has the chance to update this value if it
+                        // synchronously emits one (usually due to reporting a cache
+                        // value).
+                        //
+                        // We don't initialize the `BehaviorSubject` with
+                        // `getInitialResult` because its possible the cache might have
+                        // updated between when the `ObservableQuery` was instantiated and
+                        // when it is subscribed to. Updating the value here ensures we
+                        // report the most up-to-date result from the cache.
+                        this.subject.next(this.getInitialResult());
+                    }
                     this.reobserve();
                     // TODO: See if we can rework updatePolling to better handle this.
                     // reobserve calls updatePolling but this `subscribe` callback is
@@ -76,19 +99,14 @@ class ObservableQuery {
                     this.tearDownQuery();
                 }
             },
-        }), 
-        // TODO: Conditionally filter when notifyOnNetworkStatusChange is true or
-        // not. We want to emit the loading result if notifyOnNetworkStatusChange
-        // is true.
-        (0, rxjs_1.filter)((result) => 
-        // TODO: Remove this behavior when unifying loading state for notifyOnNetworkStatusChange
-        (this.options.fetchPolicy === "no-cache" &&
-            this.options.notifyOnNetworkStatusChange) ||
-            // TODO: Remove this behavior when unifying loading state for notifyOnNetworkStatusChange
-            (this.options.fetchPolicy === "network-only" &&
-                !this.queryManager.prioritizeCacheValues &&
-                this.queryInfo.getDiff().complete) ||
-            result !== this.initialResult));
+        }), (0, rxjs_1.filter)((result) => {
+            return (this.options.fetchPolicy !== "standby" &&
+                (this.options.notifyOnNetworkStatusChange ||
+                    !result.loading ||
+                    // data could be defined for cache-and-network fetch policies
+                    // when emitting the cache result while loading the network result
+                    !!result.data));
+        }));
         this["@@observable"] = () => this;
         if (Symbol.observable) {
             this[Symbol.observable] = () => this;
@@ -133,6 +151,50 @@ class ObservableQuery {
     resetDiff() {
         this.queryInfo.resetDiff();
     }
+    getInitialResult() {
+        const fetchPolicy = this.queryManager.prioritizeCacheValues ?
+            "cache-first"
+            : this.options.fetchPolicy;
+        const defaultResult = {
+            data: undefined,
+            loading: true,
+            networkStatus: networkStatus_js_1.NetworkStatus.loading,
+            partial: true,
+        };
+        const cacheResult = () => {
+            const diff = this.queryInfo.getDiff();
+            return this.maskResult({
+                data: 
+                // TODO: queryInfo.getDiff should handle this since cache.diff returns a
+                // null when returnPartialData is false
+                this.options.returnPartialData || diff.complete ?
+                    diff.result ?? undefined
+                    : undefined,
+                loading: !diff.complete,
+                networkStatus: diff.complete ? networkStatus_js_1.NetworkStatus.ready : networkStatus_js_1.NetworkStatus.loading,
+                partial: !diff.complete,
+            });
+        };
+        switch (fetchPolicy) {
+            case "cache-only":
+            case "cache-first":
+                return cacheResult();
+            case "cache-and-network":
+                return {
+                    ...cacheResult(),
+                    loading: true,
+                    networkStatus: networkStatus_js_1.NetworkStatus.loading,
+                };
+            case "standby":
+                return {
+                    ...defaultResult,
+                    loading: false,
+                    networkStatus: networkStatus_js_1.NetworkStatus.ready,
+                };
+            default:
+                return defaultResult;
+        }
+    }
     getCurrentFullResult(saveAsLastResult = true) {
         // Use the last result as long as the variables match this.variables.
         const lastResult = this.getLastResult(true);
@@ -272,7 +334,7 @@ class ObservableQuery {
             const queryDef = (0, utilities_1.getQueryDefinition)(this.query);
             const vars = queryDef.variableDefinitions;
             if (!vars || !vars.some((v) => v.variable.name.value === "variables")) {
-                __DEV__ && invariant_1.invariant.warn(65, variables, queryDef.name?.value || queryDef);
+                __DEV__ && invariant_1.invariant.warn(67, variables, queryDef.name?.value || queryDef);
             }
         }
         if (variables && !(0, equality_1.equal)(this.options.variables, variables)) {
@@ -308,6 +370,7 @@ class ObservableQuery {
             // fetchMore to provide an updateQuery callback that determines how
             // the data gets written to the cache.
             fetchPolicy: "no-cache",
+            notifyOnNetworkStatusChange: this.options.notifyOnNetworkStatusChange,
         };
         combinedOptions.query = this.transformDocument(combinedOptions.query);
         const qid = this.queryManager.generateQueryId();
@@ -331,7 +394,7 @@ class ObservableQuery {
         const updateQuery = fetchMoreOptions?.updateQuery;
         const isCached = this.options.fetchPolicy !== "no-cache";
         if (!isCached) {
-            (0, invariant_1.invariant)(updateQuery, 66);
+            (0, invariant_1.invariant)(updateQuery, 68);
         }
         return this.queryManager
             .fetchQuery(qid, combinedOptions, networkStatus_js_1.NetworkStatus.fetchMore)
@@ -416,7 +479,7 @@ class ObservableQuery {
             // the cache, we still want fetchMore to deliver its final loading:false
             // result with the unchanged data.
             if (isCached && !updatedQuerySet.has(this.query)) {
-                reobserveCacheFirst(this);
+                this.reobserveCacheFirst();
             }
         });
     }
@@ -444,7 +507,7 @@ class ObservableQuery {
                         onError(error);
                     }
                     else {
-                        __DEV__ && invariant_1.invariant.error(67, error);
+                        __DEV__ && invariant_1.invariant.error(69, error);
                     }
                     return;
                 }
@@ -588,8 +651,9 @@ class ObservableQuery {
     fetch(options, newNetworkStatus, emitLoadingState, query) {
         // TODO Make sure we update the networkStatus (and infer fetchVariables)
         // before actually committing to the fetch.
-        this.queryManager.setObservableQuery(this);
-        return this.queryManager.fetchObservableWithInfo(this.queryId, options, newNetworkStatus, query, emitLoadingState);
+        const queryInfo = this.queryManager.getOrCreateQuery(this.queryId);
+        queryInfo.setObservableQuery(this);
+        return this.queryManager.fetchObservableWithInfo(queryInfo, options, newNetworkStatus, query, emitLoadingState);
     }
     // Turns polling on or off based on this.options.pollInterval.
     updatePolling() {
@@ -599,16 +663,13 @@ class ObservableQuery {
         }
         const { pollingInfo, options: { pollInterval }, } = this;
         if (!pollInterval || !this.hasObservers()) {
-            if (pollingInfo) {
-                clearTimeout(pollingInfo.timeout);
-                delete this.pollingInfo;
-            }
+            this.cancelPolling();
             return;
         }
         if (pollingInfo && pollingInfo.interval === pollInterval) {
             return;
         }
-        (0, invariant_1.invariant)(pollInterval, 68);
+        (0, invariant_1.invariant)(pollInterval, 70);
         const info = pollingInfo || (this.pollingInfo = {});
         info.interval = pollInterval;
         const maybeFetch = () => {
@@ -640,6 +701,13 @@ class ObservableQuery {
         };
         poll();
     }
+    // This differs from stopPolling in that it does not set pollInterval to 0
+    cancelPolling() {
+        if (this.pollingInfo) {
+            clearTimeout(this.pollingInfo.timeout);
+            delete this.pollingInfo;
+        }
+    }
     updateLastResult(newResult, variables = this.variables) {
         let error = this.getLastError();
         // Preserve this.last.error unless the variables have changed.
@@ -691,6 +759,7 @@ class ObservableQuery {
         // We want to ensure we can re-run the custom document transforms the next
         // time a request is made against the original query.
         const query = this.transformDocument(options.query);
+        const { fetchPolicy } = options;
         this.lastQuery = query;
         if (!useDisposableObservable) {
             // We can skip calling updatePolling if we're not changing this.options.
@@ -701,10 +770,10 @@ class ObservableQuery {
                 newOptions.variables &&
                 !(0, equality_1.equal)(newOptions.variables, oldVariables) &&
                 // Don't mess with the fetchPolicy if it's currently "standby".
-                options.fetchPolicy !== "standby" &&
+                fetchPolicy !== "standby" &&
                 // If we're changing the fetchPolicy anyway, don't try to change it here
                 // using applyNextFetchPolicy. The explicit options.fetchPolicy wins.
-                (options.fetchPolicy === oldFetchPolicy ||
+                (fetchPolicy === oldFetchPolicy ||
                     // A `nextFetchPolicy` function has even higher priority, though,
                     // so in that case `applyNextFetchPolicy` must be called.
                     typeof options.nextFetchPolicy === "function")) {
@@ -722,6 +791,14 @@ class ObservableQuery {
                 !(0, equality_1.equal)(newOptions.variables, oldVariables)) {
                 newNetworkStatus = networkStatus_js_1.NetworkStatus.setVariables;
             }
+            // QueryManager does not emit any values for standby fetch policies so we
+            // want ensure that the networkStatus remains ready.
+            if (fetchPolicy === "standby") {
+                newNetworkStatus = networkStatus_js_1.NetworkStatus.ready;
+            }
+        }
+        if (fetchPolicy === "standby") {
+            this.cancelPolling();
         }
         this.networkStatus = newNetworkStatus;
         this.waitForOwnResult &&= skipCacheDataFor(options.fetchPolicy);
@@ -731,7 +808,7 @@ class ObservableQuery {
             }
         };
         const variables = options.variables && { ...options.variables };
-        const { notifyOnNetworkStatusChange = false } = options;
+        const { notifyOnNetworkStatusChange = true } = options;
         const { observable, fromLink } = this.fetch(options, newNetworkStatus, notifyOnNetworkStatusChange &&
             oldNetworkStatus !== newNetworkStatus &&
             (0, networkStatus_js_1.isNetworkRequestInFlight)(newNetworkStatus), query);
@@ -844,41 +921,94 @@ class ObservableQuery {
             }
             : result;
     }
-}
-exports.ObservableQuery = ObservableQuery;
-// Reobserve with fetchPolicy effectively set to "cache-first", triggering
-// delivery of any new data from the cache, possibly falling back to the network
-// if any cache data are missing. This allows _complete_ cache results to be
-// delivered without also kicking off unnecessary network requests when
-// this.options.fetchPolicy is "cache-and-network" or "network-only". When
-// this.options.fetchPolicy is any other policy ("cache-first", "cache-only",
-// "standby", or "no-cache"), we call this.reobserve() as usual.
-function reobserveCacheFirst(obsQuery) {
-    const { fetchPolicy, nextFetchPolicy } = obsQuery.options;
-    if (fetchPolicy === "cache-and-network" || fetchPolicy === "network-only") {
-        return obsQuery.reobserve({
-            fetchPolicy: "cache-first",
-            // Use a temporary nextFetchPolicy function that replaces itself with the
-            // previous nextFetchPolicy value and returns the original fetchPolicy.
-            nextFetchPolicy(currentFetchPolicy, context) {
-                // Replace this nextFetchPolicy function in the options object with the
-                // original this.options.nextFetchPolicy value.
-                this.nextFetchPolicy = nextFetchPolicy;
-                // If the original nextFetchPolicy value was a function, give it a
-                // chance to decide what happens here.
-                if (typeof this.nextFetchPolicy === "function") {
-                    return this.nextFetchPolicy(currentFetchPolicy, context);
+    dirty = false;
+    notifyTimeout;
+    /** @internal */
+    resetNotifications() {
+        this.cancelNotifyTimeout();
+        this.dirty = false;
+    }
+    cancelNotifyTimeout() {
+        if (this.notifyTimeout) {
+            clearTimeout(this.notifyTimeout);
+            this.notifyTimeout = void 0;
+        }
+    }
+    /** @internal */
+    scheduleNotify() {
+        if (this.dirty)
+            return;
+        this.dirty = true;
+        if (!this.notifyTimeout) {
+            this.notifyTimeout = setTimeout(() => this.notify(), 0);
+        }
+    }
+    /** @internal */
+    notify() {
+        this.cancelNotifyTimeout();
+        if (this.dirty) {
+            if (this.options.fetchPolicy == "cache-only" ||
+                this.options.fetchPolicy == "cache-and-network" ||
+                !(0, networkStatus_js_1.isNetworkRequestInFlight)(this.networkStatus)) {
+                const diff = this.queryInfo.getDiff();
+                if (diff.fromOptimisticTransaction) {
+                    // If this diff came from an optimistic transaction, deliver the
+                    // current cache data to the ObservableQuery, but don't perform a
+                    // reobservation, since oq.reobserveCacheFirst might make a network
+                    // request, and we never want to trigger network requests in the
+                    // middle of optimistic updates.
+                    this.observe();
                 }
-                // Otherwise go back to the original this.options.fetchPolicy.
-                return fetchPolicy;
-            },
-        });
+                else {
+                    // Otherwise, make the ObservableQuery "reobserve" the latest data
+                    // using a temporary fetch policy of "cache-first", so complete cache
+                    // results have a chance to be delivered without triggering additional
+                    // network requests, even when options.fetchPolicy is "network-only"
+                    // or "cache-and-network". All other fetch policies are preserved by
+                    // this method, and are handled by calling oq.reobserve(). If this
+                    // reobservation is spurious, isDifferentFromLastResult still has a
+                    // chance to catch it before delivery to ObservableQuery subscribers.
+                    this.reobserveCacheFirst();
+                }
+            }
+        }
+        this.dirty = false;
+    }
+    // Reobserve with fetchPolicy effectively set to "cache-first", triggering
+    // delivery of any new data from the cache, possibly falling back to the network
+    // if any cache data are missing. This allows _complete_ cache results to be
+    // delivered without also kicking off unnecessary network requests when
+    // this.options.fetchPolicy is "cache-and-network" or "network-only". When
+    // this.options.fetchPolicy is any other policy ("cache-first", "cache-only",
+    // "standby", or "no-cache"), we call this.reobserve() as usual.
+    reobserveCacheFirst() {
+        const { fetchPolicy, nextFetchPolicy } = this.options;
+        if (fetchPolicy === "cache-and-network" || fetchPolicy === "network-only") {
+            return this.reobserve({
+                fetchPolicy: "cache-first",
+                // Use a temporary nextFetchPolicy function that replaces itself with the
+                // previous nextFetchPolicy value and returns the original fetchPolicy.
+                nextFetchPolicy(currentFetchPolicy, context) {
+                    // Replace this nextFetchPolicy function in the options object with the
+                    // original this.options.nextFetchPolicy value.
+                    this.nextFetchPolicy = nextFetchPolicy;
+                    // If the original nextFetchPolicy value was a function, give it a
+                    // chance to decide what happens here.
+                    if (typeof this.nextFetchPolicy === "function") {
+                        return this.nextFetchPolicy(currentFetchPolicy, context);
+                    }
+                    // Otherwise go back to the original this.options.fetchPolicy.
+                    return fetchPolicy;
+                },
+            });
+        }
+        return this.reobserve();
     }
-    return obsQuery.reobserve();
 }
+exports.ObservableQuery = ObservableQuery;
 function logMissingFieldErrors(missing) {
     if (environment_1.__DEV__ && missing) {
-        __DEV__ && invariant_1.invariant.debug(69, missing);
+        __DEV__ && invariant_1.invariant.debug(71, missing);
     }
 }
 function skipCacheDataFor(fetchPolicy /* `undefined` would mean `"cache-first"` */) {