@apollo/client 4.0.9 → 4.1.2

package/core/ObservableQuery.js

@@ -1,8 +1,8 @@
 import { equal } from "@wry/equality";
-import { BehaviorSubject, Observable, share, Subject, tap } from "rxjs";
-import { isNetworkRequestInFlight } from "@apollo/client/utilities";
+import { BehaviorSubject, filter, Observable, share, Subject, tap } from "rxjs";
+import { isNetworkRequestInFlight, isNetworkRequestSettled, } from "@apollo/client/utilities";
 import { __DEV__ } from "@apollo/client/utilities/environment";
-import { compact, equalByQuery, filterMap, getOperationDefinition, getOperationName, getQueryDefinition, preventUnhandledRejection, toQueryResult, } from "@apollo/client/utilities/internal";
+import { compact, equalByQuery, extensionsSymbol, filterMap, getOperationDefinition, getOperationName, getQueryDefinition, preventUnhandledRejection, toQueryResult, variablesUnknownSymbol, } from "@apollo/client/utilities/internal";
 import { invariant } from "@apollo/client/utilities/invariant";
 import { NetworkStatus } from "./networkStatus.js";
 const { assign, hasOwnProperty } = Object;
@@ -23,6 +23,7 @@ const empty = {
 export class ObservableQuery {
     options;
     queryName;
+    variablesUnknown = false;
     /**
     * @internal will be read and written from `QueryInfo`
     * 
@@ -60,6 +61,9 @@ export class ObservableQuery {
     get networkStatus() {
         return this.subject.getValue().result.networkStatus;
     }
+    get cache() {
+        return this.queryManager.cache;
+    }
     constructor({ queryManager, options, transformedQuery = queryManager.transform(options.query), }) {
         this.queryManager = queryManager;
         // active state
@@ -71,6 +75,10 @@ export class ObservableQuery {
         const { fetchPolicy = defaultFetchPolicy, 
         // Make sure we don't store "standby" as the initialFetchPolicy.
         initialFetchPolicy = fetchPolicy === "standby" ? defaultFetchPolicy : (fetchPolicy), } = options;
+        if (options[variablesUnknownSymbol]) {
+            invariant(fetchPolicy === "standby", 80);
+            this.variablesUnknown = true;
+        }
         this.lastQuery = transformedQuery;
         this.options = {
             ...options,
@@ -197,7 +205,7 @@ export class ObservableQuery {
     * @deprecated This is an internal API and should not be used directly. This can be removed or changed at any time.
     */
     getCacheDiff({ optimistic = true } = {}) {
-        return this.queryManager.cache.diff({
+        return this.cache.diff({
             query: this.query,
             variables: this.variables,
             returnPartialData: true,
@@ -205,9 +213,11 @@ export class ObservableQuery {
         });
     }
     getInitialResult(initialFetchPolicy) {
-        const fetchPolicy = this.queryManager.prioritizeCacheValues ?
-            "cache-first"
-            : initialFetchPolicy || this.options.fetchPolicy;
+        let fetchPolicy = initialFetchPolicy || this.options.fetchPolicy;
+        if (this.queryManager.prioritizeCacheValues &&
+            (fetchPolicy === "network-only" || fetchPolicy === "cache-and-network")) {
+            fetchPolicy = "cache-first";
+        }
         const cacheResult = () => {
             const diff = this.getCacheDiff();
             // TODO: queryInfo.getDiff should handle this since cache.diff returns a
@@ -308,7 +318,7 @@ export class ObservableQuery {
                 }
             },
         };
-        const cancelWatch = this.queryManager.cache.watch(watch);
+        const cancelWatch = this.cache.watch(watch);
         this.unsubscribeFromCache = Object.assign(() => {
             this.unsubscribeFromCache = undefined;
             cancelWatch();
@@ -372,7 +382,7 @@ export class ObservableQuery {
             const queryDef = getQueryDefinition(this.query);
             const vars = queryDef.variableDefinitions;
             if (!vars || !vars.some((v) => v.variable.name.value === "variables")) {
-                __DEV__ && invariant.warn(77, variables, queryDef.name?.value || queryDef);
+                __DEV__ && invariant.warn(81, variables, queryDef.name?.value || queryDef);
             }
         }
         if (variables && !equal(this.variables, variables)) {
@@ -388,7 +398,7 @@ export class ObservableQuery {
     fetchMore({ query, variables, context, errorPolicy, updateQuery, }) {
         invariant(
             this.options.fetchPolicy !== "cache-only",
-            78,
+            82,
             getOperationName(this.query, "(anonymous)")
         );
         const combinedOptions = {
@@ -422,7 +432,7 @@ export class ObservableQuery {
         let wasUpdated = false;
         const isCached = this.options.fetchPolicy !== "no-cache";
         if (!isCached) {
-            invariant(updateQuery, 79);
+            invariant(updateQuery, 83);
         }
         const { finalize, pushNotification } = this.pushOperation(NetworkStatus.fetchMore);
         pushNotification({
@@ -430,109 +440,149 @@ export class ObservableQuery {
             kind: "N",
             value: {},
         }, { shouldEmit: 3 /* EmitBehavior.networkStatusChange */ });
-        return this.queryManager
-            .fetchQuery(combinedOptions, NetworkStatus.fetchMore)
-            .then((fetchMoreResult) => {
-            // disable the `fetchMore` override that is currently active
-            // the next updates caused by this should not be `fetchMore` anymore,
-            // but `ready` or whatever other calculated loading state is currently
-            // appropriate
-            finalize();
-            if (isCached) {
-                // Separately getting a diff here before the batch - `onWatchUpdated` might be
-                // called with an `undefined` `lastDiff` on the watcher if the cache was just subscribed to.
-                const lastDiff = this.getCacheDiff();
-                // Performing this cache update inside a cache.batch transaction ensures
-                // any affected cache.watch watchers are notified at most once about any
-                // updates. Most watchers will be using the QueryInfo class, which
-                // responds to notifications by calling reobserveCacheFirst to deliver
-                // fetchMore cache results back to this ObservableQuery.
-                this.queryManager.cache.batch({
-                    update: (cache) => {
-                        if (updateQuery) {
-                            cache.updateQuery({
-                                query: this.query,
-                                variables: this.variables,
-                                returnPartialData: true,
-                                optimistic: false,
-                            }, (previous) => updateQuery(previous, {
-                                fetchMoreResult: fetchMoreResult.data,
-                                variables: combinedOptions.variables,
-                            }));
-                        }
-                        else {
-                            // If we're using a field policy instead of updateQuery, the only
-                            // thing we need to do is write the new data to the cache using
-                            // combinedOptions.variables (instead of this.variables, which is
-                            // what this.updateQuery uses, because it works by abusing the
-                            // original field value, keyed by the original variables).
-                            cache.writeQuery({
-                                query: combinedOptions.query,
-                                variables: combinedOptions.variables,
-                                data: fetchMoreResult.data,
-                            });
-                        }
-                    },
-                    onWatchUpdated: (watch, diff) => {
-                        if (watch.watcher === this &&
-                            !equal(diff.result, lastDiff.result)) {
-                            wasUpdated = true;
-                        }
-                    },
-                });
-            }
-            else {
-                // There is a possibility `lastResult` may not be set when
-                // `fetchMore` is called which would cause this to crash. This should
-                // only happen if we haven't previously reported a result. We don't
-                // quite know what the right behavior should be here since this block
-                // of code runs after the fetch result has executed on the network.
-                // We plan to let it crash in the meantime.
-                //
-                // If we get bug reports due to the `data` property access on
-                // undefined, this should give us a real-world scenario that we can
-                // use to test against and determine the right behavior. If we do end
-                // up changing this behavior, this may require, for example, an
-                // adjustment to the types on `updateQuery` since that function
-                // expects that the first argument always contains previous result
-                // data, but not `undefined`.
-                const lastResult = this.getCurrentResult();
-                const data = updateQuery(lastResult.data, {
-                    fetchMoreResult: fetchMoreResult.data,
-                    variables: combinedOptions.variables,
-                });
-                // was reportResult
-                pushNotification({
-                    kind: "N",
-                    value: {
-                        ...lastResult,
-                        networkStatus: NetworkStatus.ready,
-                        // will be overwritten anyways, just here for types sake
-                        loading: false,
-                        data: data,
-                        dataState: lastResult.dataState === "streaming" ? "streaming" : "complete",
-                    },
-                    source: "network",
-                });
-            }
-            return this.maskResult(fetchMoreResult);
-        })
+        const { promise, operator } = getTrackingOperatorPromise();
+        const { observable } = this.queryManager.fetchObservableWithInfo(combinedOptions, { networkStatus: NetworkStatus.fetchMore, exposeExtensions: true });
+        const subscription = observable
+            .pipe(operator, filter((notification) => notification.kind === "N" && notification.source === "network"))
+            .subscribe({
+            next: (notification) => {
+                wasUpdated = false;
+                const fetchMoreResult = notification.value;
+                const extensions = fetchMoreResult[extensionsSymbol];
+                if (isNetworkRequestSettled(notification.value.networkStatus)) {
+                    finalize();
+                }
+                if (isCached) {
+                    // Separately getting a diff here before the batch - `onWatchUpdated` might be
+                    // called with an `undefined` `lastDiff` on the watcher if the cache was just subscribed to.
+                    const lastDiff = this.getCacheDiff();
+                    // Performing this cache update inside a cache.batch transaction ensures
+                    // any affected cache.watch watchers are notified at most once about any
+                    // updates. Most watchers will be using the QueryInfo class, which
+                    // responds to notifications by calling reobserveCacheFirst to deliver
+                    // fetchMore cache results back to this ObservableQuery.
+                    this.cache.batch({
+                        update: (cache) => {
+                            if (updateQuery) {
+                                cache.updateQuery({
+                                    query: this.query,
+                                    variables: this.variables,
+                                    returnPartialData: true,
+                                    optimistic: false,
+                                    extensions,
+                                }, (previous) => updateQuery(previous, {
+                                    fetchMoreResult: fetchMoreResult.data,
+                                    variables: combinedOptions.variables,
+                                }));
+                            }
+                            else {
+                                // If we're using a field policy instead of updateQuery, the only
+                                // thing we need to do is write the new data to the cache using
+                                // combinedOptions.variables (instead of this.variables, which is
+                                // what this.updateQuery uses, because it works by abusing the
+                                // original field value, keyed by the original variables).
+                                cache.writeQuery({
+                                    query: combinedOptions.query,
+                                    variables: combinedOptions.variables,
+                                    data: fetchMoreResult.data,
+                                    extensions,
+                                });
+                            }
+                        },
+                        onWatchUpdated: (watch, diff) => {
+                            if (watch.watcher === this &&
+                                !equal(diff.result, lastDiff.result)) {
+                                wasUpdated = true;
+                                const lastResult = this.getCurrentResult();
+                                // Let the cache watch from resubscribeCache handle the final
+                                // result
+                                if (isNetworkRequestInFlight(fetchMoreResult.networkStatus)) {
+                                    pushNotification({
+                                        kind: "N",
+                                        source: "network",
+                                        value: {
+                                            ...lastResult,
+                                            networkStatus: (fetchMoreResult.networkStatus ===
+                                                NetworkStatus.error) ?
+                                                NetworkStatus.ready
+                                                : fetchMoreResult.networkStatus,
+                                            // will be overwritten anyways, just here for types sake
+                                            loading: false,
+                                            data: diff.result,
+                                            dataState: fetchMoreResult.dataState === "streaming" ?
+                                                "streaming"
+                                                : "complete",
+                                        },
+                                    });
+                                }
+                            }
+                        },
+                    });
+                }
+                else {
+                    // There is a possibility `lastResult` may not be set when
+                    // `fetchMore` is called which would cause this to crash. This should
+                    // only happen if we haven't previously reported a result. We don't
+                    // quite know what the right behavior should be here since this block
+                    // of code runs after the fetch result has executed on the network.
+                    // We plan to let it crash in the meantime.
+                    //
+                    // If we get bug reports due to the `data` property access on
+                    // undefined, this should give us a real-world scenario that we can
+                    // use to test against and determine the right behavior. If we do end
+                    // up changing this behavior, this may require, for example, an
+                    // adjustment to the types on `updateQuery` since that function
+                    // expects that the first argument always contains previous result
+                    // data, but not `undefined`.
+                    const lastResult = this.getCurrentResult();
+                    const data = updateQuery(lastResult.data, {
+                        fetchMoreResult: fetchMoreResult.data,
+                        variables: combinedOptions.variables,
+                    });
+                    pushNotification({
+                        kind: "N",
+                        value: {
+                            ...lastResult,
+                            networkStatus: NetworkStatus.ready,
+                            // will be overwritten anyways, just here for types sake
+                            loading: false,
+                            data: data,
+                            dataState: lastResult.dataState === "streaming" ?
+                                "streaming"
+                                : "complete",
+                        },
+                        source: "network",
+                    });
+                }
+            },
+        });
+        return preventUnhandledRejection(promise
+            .then((result) => toQueryResult(this.maskResult(result)))
             .finally(() => {
-            // call `finalize` a second time in case the `.then` case above was not reached
+            subscription.unsubscribe();
             finalize();
-            // In case the cache writes above did not generate a broadcast
-            // notification (which would have been intercepted by onWatchUpdated),
-            // likely because the written data were the same as what was already in
-            // the cache, we still want fetchMore to deliver its final loading:false
-            // result with the unchanged data.
             if (isCached && !wasUpdated) {
-                pushNotification({
-                    kind: "N",
-                    source: "newNetworkStatus",
-                    value: {},
-                }, { shouldEmit: 1 /* EmitBehavior.force */ });
+                const lastResult = this.getCurrentResult();
+                if (lastResult.dataState === "streaming") {
+                    pushNotification({
+                        kind: "N",
+                        source: "network",
+                        value: {
+                            ...lastResult,
+                            dataState: "complete",
+                            networkStatus: NetworkStatus.ready,
+                        },
+                    });
+                }
+                else {
+                    pushNotification({
+                        kind: "N",
+                        source: "newNetworkStatus",
+                        value: {},
+                    }, { shouldEmit: 1 /* EmitBehavior.force */ });
+                }
             }
-        });
+        }));
     }
     // XXX the subscription variables are separate from the query variables.
     // if you want to update subscription variables, right now you have to do that separately,
@@ -558,7 +608,7 @@ export class ObservableQuery {
                         onError(error);
                     }
                     else {
-                        invariant.error(80, error);
+                        invariant.error(84, error);
                     }
                     return;
                 }
@@ -636,7 +686,7 @@ export class ObservableQuery {
             previousData: result,
         });
         if (newResult) {
-            queryManager.cache.writeQuery({
+            this.cache.writeQuery({
                 query: this.options.query,
                 data: newResult,
                 variables: this.variables,
@@ -802,7 +852,7 @@ export class ObservableQuery {
                 if (!this.didWarnCacheOnlyPolling &&
                     pollInterval &&
                     fetchPolicy === "cache-only") {
-                    __DEV__ && invariant.warn(81, getOperationName(this.query, "(anonymous)"));
+                    __DEV__ && invariant.warn(85, getOperationName(this.query, "(anonymous)"));
                     this.didWarnCacheOnlyPolling = true;
                 }
             }
@@ -877,6 +927,10 @@ export class ObservableQuery {
         const oldVariables = this.variables;
         const oldFetchPolicy = this.options.fetchPolicy;
         const mergedOptions = compact(this.options, newOptions || {});
+        // This request will hit the network, so even if there are no variables,
+        // we now know that's intentional. (see #12996)
+        // Even if that happens only once, we want `variablesUnknown` to stay false permanently.
+        this.variablesUnknown &&= mergedOptions.fetchPolicy === "standby";
         const options = useDisposableObservable ?
             // Disposable Observable fetches receive a shallow copy of this.options
             // (merged with newOptions), leaving this.options unmodified.
@@ -939,15 +993,7 @@ export class ObservableQuery {
             this.cancelPolling();
         }
         this.resubscribeCache();
-        const { promise, operator: promiseOperator } = getTrackingOperatorPromise((value) => {
-            switch (value.kind) {
-                case "E":
-                    throw value.error;
-                case "N":
-                    if (value.source !== "newNetworkStatus" && !value.value.loading)
-                        return value.value;
-            }
-        }, 
+        const { promise, operator: promiseOperator } = getTrackingOperatorPromise(
         // This default value should only be used when using a `fetchPolicy` of
         // `standby` since that fetch policy completes without emitting a
         // result. Since we are converting this to a QueryResult type, we
@@ -1069,8 +1115,8 @@ export class ObservableQuery {
         const { dirty } = this;
         this.resetNotifications();
         if (dirty &&
-            (this.options.fetchPolicy == "cache-only" ||
-                this.options.fetchPolicy == "cache-and-network" ||
+            (this.options.fetchPolicy === "cache-only" ||
+                this.options.fetchPolicy === "cache-and-network" ||
                 !this.activeOperations.size)) {
             const diff = this.getCacheDiff();
             if (
@@ -1154,7 +1200,9 @@ export class ObservableQuery {
         // "fetchMore" having priority over "polling" or "loading" network statuses
         // as for now we just take the "latest" operation that is still active,
         // as that lines up best with previous behavior[]
-        const operation = Array.from(this.activeOperations.values()).findLast((operation) => isEqualQuery(operation, this) && operation.override !== undefined);
+        const operation = Array.from(this.activeOperations.values())
+            .reverse()
+            .find((operation) => isEqualQuery(operation, this) && operation.override !== undefined);
         return operation?.override ?? baseNetworkStatus;
     }
     abortActiveOperations() {
@@ -1298,13 +1346,13 @@ export class ObservableQuery {
 }
 export function logMissingFieldErrors(missing) {
     if (__DEV__ && missing) {
-        __DEV__ && invariant.debug(82, missing);
+        __DEV__ && invariant.debug(86, missing);
     }
 }
 function isEqualQuery(a, b) {
     return !!(a && b && a.query === b.query && equal(a.variables, b.variables));
 }
-function getTrackingOperatorPromise(filterMapCb, defaultValue) {
+function getTrackingOperatorPromise(defaultValue) {
     let lastValue = defaultValue, resolve, reject;
     const promise = new Promise((res, rej) => {
         resolve = res;
@@ -1312,14 +1360,13 @@ function getTrackingOperatorPromise(filterMapCb, defaultValue) {
     });
     const operator = tap({
         next(value) {
-            try {
-                const newValue = filterMapCb(value);
-                if (newValue !== undefined) {
-                    lastValue = newValue;
-                }
+            if (value.kind === "E") {
+                return reject(value.error);
             }
-            catch (error) {
-                reject(error);
+            if (value.kind === "N" &&
+                value.source !== "newNetworkStatus" &&
+                !value.value.loading) {
+                lastValue = value.value;
             }
         },
         finalize: () => {