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

package/core/ObservableQuery.js

@@ -9,6 +9,7 @@ import { equalByQuery } from "./equalByQuery.js";
 import { isNetworkRequestInFlight, NetworkStatus } from "./networkStatus.js";
 const { assign, hasOwnProperty } = Object;
 const newNetworkStatusSymbol = Symbol();
+const uninitialized = {};
 export class ObservableQuery {
     /**
      * @internal
@@ -38,7 +39,6 @@ export class ObservableQuery {
     }
     subject;
     observable;
-    initialResult;
     isTornDown;
     queryManager;
     subscriptions = new Set();
@@ -52,14 +52,8 @@ export class ObservableQuery {
     networkStatus;
     constructor({ queryManager, queryInfo, options, }) {
         this.networkStatus = NetworkStatus.loading;
-        this.initialResult = {
-            data: undefined,
-            loading: true,
-            networkStatus: this.networkStatus,
-            partial: true,
-        };
         let startedInactive = ObservableQuery.inactiveOnCreation.getValue();
-        this.subject = new BehaviorSubject(this.initialResult);
+        this.subject = new BehaviorSubject(uninitialized);
         this.observable = this.subject.pipe(tap({
             subscribe: () => {
                 if (startedInactive) {
@@ -67,6 +61,22 @@ export class ObservableQuery {
                     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
@@ -81,19 +91,14 @@ export class ObservableQuery {
                     this.tearDownQuery();
                 }
             },
-        }), 
-        // TODO: Conditionally filter when notifyOnNetworkStatusChange is true or
-        // not. We want to emit the loading result if notifyOnNetworkStatusChange
-        // is true.
-        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));
+        }), 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;
@@ -138,6 +143,50 @@ export 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.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.ready : 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.loading,
+                };
+            case "standby":
+                return {
+                    ...defaultResult,
+                    loading: false,
+                    networkStatus: 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);
@@ -313,6 +362,7 @@ export 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();
@@ -605,10 +655,7 @@ export 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) {
@@ -646,6 +693,13 @@ export 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.
@@ -697,6 +751,7 @@ export 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.
@@ -707,10 +762,10 @@ export class ObservableQuery {
                 newOptions.variables &&
                 !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")) {
@@ -728,6 +783,14 @@ export class ObservableQuery {
                 !equal(newOptions.variables, oldVariables)) {
                 newNetworkStatus = 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.ready;
+            }
+        }
+        if (fetchPolicy === "standby") {
+            this.cancelPolling();
         }
         this.networkStatus = newNetworkStatus;
         this.waitForOwnResult &&= skipCacheDataFor(options.fetchPolicy);
@@ -737,7 +800,7 @@ export 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 &&
             isNetworkRequestInFlight(newNetworkStatus), query);