@apollo/client 4.0.12-beta.0 → 4.0.13

package/core/ObservableQuery.js

@@ -1,8 +1,8 @@
 import { equal } from "@wry/equality";
-import { BehaviorSubject, filter, Observable, share, Subject, tap } from "rxjs";
-import { isNetworkRequestInFlight, isNetworkRequestSettled, } from "@apollo/client/utilities";
+import { BehaviorSubject, Observable, share, Subject, tap } from "rxjs";
+import { isNetworkRequestInFlight } from "@apollo/client/utilities";
 import { __DEV__ } from "@apollo/client/utilities/environment";
-import { compact, equalByQuery, extensionsSymbol, filterMap, getOperationDefinition, getOperationName, getQueryDefinition, preventUnhandledRejection, toQueryResult, variablesUnknownSymbol, } from "@apollo/client/utilities/internal";
+import { compact, equalByQuery, 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;
@@ -61,9 +61,6 @@ 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
@@ -76,7 +73,7 @@ export class ObservableQuery {
         // Make sure we don't store "standby" as the initialFetchPolicy.
         initialFetchPolicy = fetchPolicy === "standby" ? defaultFetchPolicy : (fetchPolicy), } = options;
         if (options[variablesUnknownSymbol]) {
-            invariant(fetchPolicy === "standby", 80);
+            invariant(fetchPolicy === "standby", 77);
             this.variablesUnknown = true;
         }
         this.lastQuery = transformedQuery;
@@ -205,7 +202,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.cache.diff({
+        return this.queryManager.cache.diff({
             query: this.query,
             variables: this.variables,
             returnPartialData: true,
@@ -316,7 +313,7 @@ export class ObservableQuery {
                 }
             },
         };
-        const cancelWatch = this.cache.watch(watch);
+        const cancelWatch = this.queryManager.cache.watch(watch);
         this.unsubscribeFromCache = Object.assign(() => {
             this.unsubscribeFromCache = undefined;
             cancelWatch();
@@ -380,7 +377,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(81, variables, queryDef.name?.value || queryDef);
+                __DEV__ && invariant.warn(78, variables, queryDef.name?.value || queryDef);
             }
         }
         if (variables && !equal(this.variables, variables)) {
@@ -396,7 +393,7 @@ export class ObservableQuery {
     fetchMore({ query, variables, context, errorPolicy, updateQuery, }) {
         invariant(
             this.options.fetchPolicy !== "cache-only",
-            82,
+            79,
             getOperationName(this.query, "(anonymous)")
         );
         const combinedOptions = {
@@ -430,7 +427,7 @@ export class ObservableQuery {
         let wasUpdated = false;
         const isCached = this.options.fetchPolicy !== "no-cache";
         if (!isCached) {
-            invariant(updateQuery, 83);
+            invariant(updateQuery, 80);
         }
         const { finalize, pushNotification } = this.pushOperation(NetworkStatus.fetchMore);
         pushNotification({
@@ -438,149 +435,109 @@ export class ObservableQuery {
             kind: "N",
             value: {},
         }, { shouldEmit: 3 /* EmitBehavior.networkStatusChange */ });
-        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)))
+        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);
+        })
             .finally(() => {
-            subscription.unsubscribe();
+            // call `finalize` a second time in case the `.then` case above was not reached
             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) {
-                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 */ });
-                }
+                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,
@@ -606,7 +563,7 @@ export class ObservableQuery {
                         onError(error);
                     }
                     else {
-                        invariant.error(84, error);
+                        invariant.error(81, error);
                     }
                     return;
                 }
@@ -684,7 +641,7 @@ export class ObservableQuery {
             previousData: result,
         });
         if (newResult) {
-            this.cache.writeQuery({
+            queryManager.cache.writeQuery({
                 query: this.options.query,
                 data: newResult,
                 variables: this.variables,
@@ -850,7 +807,7 @@ export class ObservableQuery {
                 if (!this.didWarnCacheOnlyPolling &&
                     pollInterval &&
                     fetchPolicy === "cache-only") {
-                    __DEV__ && invariant.warn(85, getOperationName(this.query, "(anonymous)"));
+                    __DEV__ && invariant.warn(82, getOperationName(this.query, "(anonymous)"));
                     this.didWarnCacheOnlyPolling = true;
                 }
             }
@@ -991,7 +948,15 @@ export class ObservableQuery {
             this.cancelPolling();
         }
         this.resubscribeCache();
-        const { promise, operator: promiseOperator } = getTrackingOperatorPromise(
+        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;
+            }
+        }, 
         // 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
@@ -1113,8 +1078,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 (
@@ -1344,13 +1309,13 @@ export class ObservableQuery {
 }
 export function logMissingFieldErrors(missing) {
     if (__DEV__ && missing) {
-        __DEV__ && invariant.debug(86, missing);
+        __DEV__ && invariant.debug(83, missing);
     }
 }
 function isEqualQuery(a, b) {
     return !!(a && b && a.query === b.query && equal(a.variables, b.variables));
 }
-function getTrackingOperatorPromise(defaultValue) {
+function getTrackingOperatorPromise(filterMapCb, defaultValue) {
     let lastValue = defaultValue, resolve, reject;
     const promise = new Promise((res, rej) => {
         resolve = res;
@@ -1358,13 +1323,14 @@ function getTrackingOperatorPromise(defaultValue) {
     });
     const operator = tap({
         next(value) {
-            if (value.kind === "E") {
-                return reject(value.error);
+            try {
+                const newValue = filterMapCb(value);
+                if (newValue !== undefined) {
+                    lastValue = newValue;
+                }
             }
-            if (value.kind === "N" &&
-                value.source !== "newNetworkStatus" &&
-                !value.value.loading) {
-                lastValue = value.value;
+            catch (error) {
+                reject(error);
             }
         },
         finalize: () => {