@apollo/client 4.0.0-alpha.6 → 4.0.0-alpha.8

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");
@@ -18,6 +18,14 @@ const networkStatus_js_1 = require("./networkStatus.cjs");
 const { assign, hasOwnProperty } = Object;
 const newNetworkStatusSymbol = Symbol();
 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;
@@ -58,9 +66,14 @@ class ObservableQuery {
             networkStatus: this.networkStatus,
             partial: true,
         };
+        let startedInactive = ObservableQuery.inactiveOnCreation.getValue();
         this.subject = new rxjs_1.BehaviorSubject(this.initialResult);
         this.observable = this.subject.pipe((0, rxjs_1.tap)({
             subscribe: () => {
+                if (startedInactive) {
+                    queryManager["queries"].set(this.queryId, queryInfo);
+                    startedInactive = false;
+                }
                 if (!this.subject.observed) {
                     this.reobserve();
                     // TODO: See if we can rework updatePolling to better handle this.
@@ -272,7 +285,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(69, 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)) {
@@ -331,7 +344,7 @@ class ObservableQuery {
         const updateQuery = fetchMoreOptions?.updateQuery;
         const isCached = this.options.fetchPolicy !== "no-cache";
         if (!isCached) {
-            (0, invariant_1.invariant)(updateQuery, 70);
+            (0, invariant_1.invariant)(updateQuery, 68);
         }
         return this.queryManager
             .fetchQuery(qid, combinedOptions, networkStatus_js_1.NetworkStatus.fetchMore)
@@ -416,7 +429,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 +457,7 @@ class ObservableQuery {
                         onError(error);
                     }
                     else {
-                        __DEV__ && invariant_1.invariant.error(71, error);
+                        __DEV__ && invariant_1.invariant.error(69, error);
                     }
                     return;
                 }
@@ -588,8 +601,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() {
@@ -608,7 +622,7 @@ class ObservableQuery {
         if (pollingInfo && pollingInfo.interval === pollInterval) {
             return;
         }
-        (0, invariant_1.invariant)(pollInterval, 72);
+        (0, invariant_1.invariant)(pollInterval, 70);
         const info = pollingInfo || (this.pollingInfo = {});
         info.interval = pollInterval;
         const maybeFetch = () => {
@@ -844,41 +858,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(73, missing);
+        __DEV__ && invariant_1.invariant.debug(71, missing);
     }
 }
 function skipCacheDataFor(fetchPolicy /* `undefined` would mean `"cache-first"` */) {