@apollo/client 4.0.0-alpha.1 → 4.0.0-alpha.11

package/core/ObservableQuery.js

@@ -1,12 +1,24 @@
 import { equal } from "@wry/equality";
+import { Slot } from "optimism";
 import { BehaviorSubject, filter, lastValueFrom, tap } from "rxjs";
 import { cloneDeep, compact, getOperationDefinition, getQueryDefinition, preventUnhandledRejection, } from "@apollo/client/utilities";
 import { __DEV__ } from "@apollo/client/utilities/environment";
+import { toQueryResult } from "@apollo/client/utilities/internal";
 import { invariant } from "@apollo/client/utilities/invariant";
 import { equalByQuery } from "./equalByQuery.js";
 import { isNetworkRequestInFlight, NetworkStatus } from "./networkStatus.js";
 const { assign, hasOwnProperty } = Object;
+const newNetworkStatusSymbol = Symbol();
+const uninitialized = {};
 export 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 Slot();
     options;
     queryId;
     queryName;
@@ -15,10 +27,8 @@ export class ObservableQuery {
     // untransformed query to ensure document transforms with runtime conditionals
     // are run on the original document.
     get query() {
-        return this.lastQuery || this.options.query;
+        return this.lastQuery;
     }
-    // Computed shorthand for this.options.variables, preserved for
-    // backwards compatibility.
     /**
      * An object containing the variables that were provided for the query.
      */
@@ -27,7 +37,6 @@ export class ObservableQuery {
     }
     subject;
     observable;
-    initialResult;
     isTornDown;
     queryManager;
     subscriptions = new Set();
@@ -41,16 +50,31 @@ export class ObservableQuery {
     networkStatus;
     constructor({ queryManager, queryInfo, options, }) {
         this.networkStatus = NetworkStatus.loading;
-        this.initialResult = {
-            data: undefined,
-            loading: true,
-            networkStatus: this.networkStatus,
-            partial: true,
-        };
-        this.subject = new BehaviorSubject(this.initialResult);
+        let startedInactive = ObservableQuery.inactiveOnCreation.getValue();
+        this.subject = new BehaviorSubject(uninitialized);
         this.observable = this.subject.pipe(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
@@ -65,18 +89,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.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;
@@ -96,6 +116,7 @@ export class ObservableQuery {
         const { fetchPolicy = defaultFetchPolicy, 
         // Make sure we don't store "standby" as the initialFetchPolicy.
         initialFetchPolicy = fetchPolicy === "standby" ? defaultFetchPolicy : (fetchPolicy), } = options;
+        this.lastQuery = options.query;
         this.options = {
             ...options,
             // Remember the initial options.fetchPolicy so we can revert back to this
@@ -105,6 +126,7 @@ export class ObservableQuery {
             // This ensures this.options.fetchPolicy always has a string value, in
             // case options.fetchPolicy was not provided.
             fetchPolicy,
+            variables: this.getVariablesWithDefaults(options.variables),
         };
         this.queryId = queryInfo.queryId || queryManager.generateQueryId();
         const opDef = getOperationDefinition(this.query);
@@ -121,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);
@@ -132,7 +198,11 @@ export class ObservableQuery {
             loading: isNetworkRequestInFlight(networkStatus),
             networkStatus,
         };
-        const { fetchPolicy = "cache-first" } = this.options;
+        let { fetchPolicy = "cache-first" } = this.options;
+        const { prioritizeCacheValues } = this.queryManager;
+        if (prioritizeCacheValues) {
+            fetchPolicy = "cache-first";
+        }
         if (
         // These fetch policies should never deliver data from the cache, unless
         // redelivering a previously delivered result.
@@ -144,7 +214,7 @@ export class ObservableQuery {
             this.queryManager.getDocumentInfo(this.query).hasForcedResolvers) {
             // Fall through.
         }
-        else if (this.waitForOwnResult) {
+        else if (this.waitForOwnResult && !prioritizeCacheValues) {
             // This would usually be a part of `QueryInfo.getDiff()`.
             // which we skip in the waitForOwnResult case since we are not
             // interested in the diff.
@@ -256,18 +326,19 @@ 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(67, variables, queryDef.name?.value || queryDef);
+                __DEV__ && invariant.warn(69, variables, queryDef.name?.value || queryDef);
             }
         }
-        if (variables && !equal(this.options.variables, variables)) {
+        if (variables && !equal(this.variables, variables)) {
             // Update the existing options with new variables
-            reobserveOptions.variables = this.options.variables = {
-                ...this.options.variables,
-                ...variables,
-            };
+            reobserveOptions.variables = this.options.variables =
+                this.getVariablesWithDefaults({ ...this.variables, ...variables });
         }
         this.queryInfo.resetLastWrite();
-        return this.reobserve(reobserveOptions, NetworkStatus.refetch);
+        return this.reobserve({
+            ...reobserveOptions,
+            [newNetworkStatusSymbol]: NetworkStatus.refetch,
+        });
     }
     /**
      * A function that helps you fetch the next set of results for a [paginated list field](https://www.apollographql.com/docs/react/pagination/core-api/).
@@ -279,7 +350,7 @@ export class ObservableQuery {
                 query: this.options.query,
                 ...fetchMoreOptions,
                 variables: {
-                    ...this.options.variables,
+                    ...this.variables,
                     ...fetchMoreOptions.variables,
                 },
             })),
@@ -289,6 +360,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();
@@ -312,7 +384,7 @@ export class ObservableQuery {
         const updateQuery = fetchMoreOptions?.updateQuery;
         const isCached = this.options.fetchPolicy !== "no-cache";
         if (!isCached) {
-            invariant(updateQuery, 68);
+            invariant(updateQuery, 70);
         }
         return this.queryManager
             .fetchQuery(qid, combinedOptions, NetworkStatus.fetchMore)
@@ -397,7 +469,7 @@ export 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();
             }
         });
     }
@@ -418,7 +490,17 @@ export class ObservableQuery {
         })
             .subscribe({
             next: (subscriptionData) => {
-                const { updateQuery } = options;
+                const { updateQuery, onError } = options;
+                const { error } = subscriptionData;
+                if (error) {
+                    if (onError) {
+                        onError(error);
+                    }
+                    else {
+                        __DEV__ && invariant.error(71, error);
+                    }
+                    return;
+                }
                 if (updateQuery) {
                     this.updateQuery((previous, updateOptions) => updateQuery(previous, {
                         subscriptionData: subscriptionData,
@@ -426,13 +508,6 @@ export class ObservableQuery {
                     }));
                 }
             },
-            error: (err) => {
-                if (options.onError) {
-                    options.onError(err);
-                    return;
-                }
-                __DEV__ && invariant.error(69, err);
-            },
         });
         this.subscriptions.add(subscription);
         return () => {
@@ -441,9 +516,7 @@ export class ObservableQuery {
             }
         };
     }
-    setOptions(newOptions) {
-        return this.reobserve(newOptions);
-    }
+    /** @internal */
     silentSetOptions(newOptions) {
         const mergedOptions = compact(this.options, newOptions || {});
         assign(this.options, mergedOptions);
@@ -467,22 +540,24 @@ export class ObservableQuery {
      * the previous values of those variables will be used.
      */
     async setVariables(variables) {
+        variables = this.getVariablesWithDefaults(variables);
         if (equal(this.variables, variables)) {
             // If we have no observers, then we don't actually want to make a network
             // request. As soon as someone observes the query, the request will kick
             // off. For now, we just store any changes. (See #1077)
-            return this.subject.getValue();
+            return toQueryResult(this.subject.getValue());
         }
         this.options.variables = variables;
         // See comment above
         if (!this.hasObservers()) {
-            return this.subject.getValue();
+            return toQueryResult(this.subject.getValue());
         }
         return this.reobserve({
             // Reset options.fetchPolicy to its original value.
             fetchPolicy: this.options.initialFetchPolicy,
             variables,
-        }, NetworkStatus.setVariables);
+            [newNetworkStatusSymbol]: NetworkStatus.setVariables,
+        });
     }
     /**
      * A function that enables you to update the query's cached result without executing a followup GraphQL operation.
@@ -547,13 +622,8 @@ export class ObservableQuery {
                 // requests to be triggered only if the cache result is incomplete. To
                 // that end, the options.nextFetchPolicy option provides an easy way to
                 // update options.fetchPolicy after the initial network request, without
-                // having to call observableQuery.setOptions.
-                options.fetchPolicy = options.nextFetchPolicy(fetchPolicy, {
-                    reason,
-                    options,
-                    observable: this,
-                    initialFetchPolicy,
-                });
+                // having to call observableQuery.reobserve.
+                options.fetchPolicy = options.nextFetchPolicy.call(options, fetchPolicy, { reason, options, observable: this, initialFetchPolicy });
             }
             else if (reason === "variables-changed") {
                 options.fetchPolicy = initialFetchPolicy;
@@ -567,8 +637,9 @@ export 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() {
@@ -578,16 +649,13 @@ 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) {
             return;
         }
-        invariant(pollInterval, 70);
+        invariant(pollInterval, 72);
         const info = pollingInfo || (this.pollingInfo = {});
         info.interval = pollInterval;
         const maybeFetch = () => {
@@ -602,7 +670,8 @@ export class ObservableQuery {
                         fetchPolicy: this.options.initialFetchPolicy === "no-cache" ?
                             "no-cache"
                             : "network-only",
-                    }, NetworkStatus.poll).then(poll, poll);
+                        [newNetworkStatusSymbol]: NetworkStatus.poll,
+                    }).then(poll, poll);
                 }
                 else {
                     poll();
@@ -618,6 +687,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.
@@ -632,10 +708,18 @@ export class ObservableQuery {
             ...(error ? { error } : null),
         });
     }
-    // TODO: catch `EmptyError` and rethrow as network error if `complete`
-    // notification is emitted without a value.
-    reobserve(newOptions, newNetworkStatus) {
+    /**
+     * Reevaluate the query, optionally against new options. New options will be
+     * merged with the current options when given.
+     */
+    reobserve(newOptions) {
         this.isTornDown = false;
+        let newNetworkStatus;
+        if (newOptions) {
+            newNetworkStatus = newOptions[newNetworkStatusSymbol];
+            // Avoid setting the symbol option in this.options
+            delete newOptions[newNetworkStatusSymbol];
+        }
         const useDisposableObservable = 
         // Refetching uses a disposable Observable to allow refetches using different
         // options/variables, without permanently altering the options of the
@@ -648,7 +732,7 @@ export class ObservableQuery {
             // fetchPolicy to be "network-only" or "no-cache") won't override the original options.
             newNetworkStatus === NetworkStatus.poll;
         // Save the old variables, since Object.assign may modify them below.
-        const oldVariables = this.options.variables;
+        const oldVariables = this.variables;
         const oldFetchPolicy = this.options.fetchPolicy;
         const mergedOptions = compact(this.options, newOptions || {});
         const options = useDisposableObservable ?
@@ -662,6 +746,16 @@ export class ObservableQuery {
         // time a request is made against the original query.
         const query = this.transformDocument(options.query);
         this.lastQuery = query;
+        // Reevaluate variables to allow resetting variables with variables: undefined,
+        // otherwise `compact` will ignore the `variables` key in `newOptions`. We
+        // do this after we run the query transform to ensure we get default
+        // variables from the transformed query.
+        //
+        // Note: updating options.variables may mutate this.options.variables
+        // in the case of a non-disposable query. This is intentional.
+        if (newOptions && "variables" in newOptions) {
+            options.variables = this.getVariablesWithDefaults(newOptions.variables);
+        }
         if (!useDisposableObservable) {
             // We can skip calling updatePolling if we're not changing this.options.
             this.updatePolling();
@@ -678,6 +772,7 @@ export class ObservableQuery {
                     // A `nextFetchPolicy` function has even higher priority, though,
                     // so in that case `applyNextFetchPolicy` must be called.
                     typeof options.nextFetchPolicy === "function")) {
+                // This might mutate options.fetchPolicy
                 this.applyNextFetchPolicy("variables-changed", options);
                 if (newNetworkStatus === void 0) {
                     newNetworkStatus = NetworkStatus.setVariables;
@@ -692,6 +787,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 (options.fetchPolicy === "standby") {
+                newNetworkStatus = NetworkStatus.ready;
+            }
+        }
+        if (options.fetchPolicy === "standby") {
+            this.cancelPolling();
         }
         this.networkStatus = newNetworkStatus;
         this.waitForOwnResult &&= skipCacheDataFor(options.fetchPolicy);
@@ -700,8 +803,8 @@ export class ObservableQuery {
                 this.waitForOwnResult = false;
             }
         };
-        const variables = options.variables && { ...options.variables };
-        const { notifyOnNetworkStatusChange = false } = options;
+        const variables = { ...options.variables };
+        const { notifyOnNetworkStatusChange = true } = options;
         const { observable, fromLink } = this.fetch(options, newNetworkStatus, notifyOnNetworkStatusChange &&
             oldNetworkStatus !== newNetworkStatus &&
             isNetworkRequestInFlight(newNetworkStatus), query);
@@ -733,7 +836,13 @@ export class ObservableQuery {
         // Note: lastValueFrom will create a separate subscription to the
         // observable which means that terminating this ObservableQuery will not
         // cancel the request from the link chain.
-        lastValueFrom(observable).then(this.maskResult));
+        lastValueFrom(observable, {
+            // 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
+            // omit the extra fields from ApolloQueryResult in the default value.
+            defaultValue: { data: undefined },
+        }).then((result) => toQueryResult(this.maskResult(result))));
     }
     // (Re)deliver the current result to this.observers without applying fetch
     // policies or making network requests.
@@ -789,7 +898,7 @@ export class ObservableQuery {
         // stop all active GraphQL subscriptions
         this.subscriptions.forEach((sub) => sub.unsubscribe());
         this.subscriptions.clear();
-        this.queryManager.stopQuery(this.queryId);
+        this.queryManager.removeQuery(this.queryId);
         this.isTornDown = true;
     }
     transformDocument(document) {
@@ -808,40 +917,96 @@ export class ObservableQuery {
             }
             : result;
     }
-}
-// 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.
-export 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" ||
+                !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();
+    }
+    getVariablesWithDefaults(variables) {
+        return this.queryManager.getVariables(this.query, variables);
     }
-    return obsQuery.reobserve();
 }
 export function logMissingFieldErrors(missing) {
     if (__DEV__ && missing) {
-        __DEV__ && invariant.debug(71, missing);
+        __DEV__ && invariant.debug(73, missing);
     }
 }
 function skipCacheDataFor(fetchPolicy /* `undefined` would mean `"cache-first"` */) {