@apollo/client 4.0.0-alpha.9 → 4.0.0-rc.0

package/core/ObservableQuery.js

@@ -1,123 +1,77 @@
 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 { BehaviorSubject, Observable, share, Subject, tap } from "rxjs";
 import { __DEV__ } from "@apollo/client/utilities/environment";
-import { toQueryResult } from "@apollo/client/utilities/internal";
+import { compact, filterMap, getOperationDefinition, getOperationName, getQueryDefinition, preventUnhandledRejection, 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 = {};
+const uninitialized = {
+    loading: true,
+    networkStatus: NetworkStatus.loading,
+    data: undefined,
+    dataState: "empty",
+    partial: true,
+};
+const empty = {
+    loading: false,
+    networkStatus: NetworkStatus.ready,
+    data: undefined,
+    dataState: "empty",
+    partial: true,
+};
 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;
+    /**
+    * @internal will be read and written from `QueryInfo`
+    * 
+    * @deprecated This is an internal API and should not be used directly. This can be removed or changed at any time.
+    */
+    _lastWrite;
     // The `query` computed property will always reflect the document transformed
     // by the last run query. `this.options.query` will always reflect the raw
     // 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.
      */
     get variables() {
         return this.options.variables;
     }
+    unsubscribeFromCache;
+    input;
     subject;
-    observable;
     isTornDown;
     queryManager;
     subscriptions = new Set();
-    waitForOwnResult;
-    last;
+    /**
+     * If an `ObservableQuery` is created with a `network-only` fetch policy,
+     * it should actually start receiving cache updates, but not before it has
+     * received the first result from the network.
+     */
+    waitForNetworkResult;
     lastQuery;
-    queryInfo;
     linkSubscription;
-    linkObservable;
     pollingInfo;
-    networkStatus;
-    constructor({ queryManager, queryInfo, options, }) {
-        this.networkStatus = NetworkStatus.loading;
-        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
-                    // called before the subject is subscribed to so `updatePolling`
-                    // can't accurately detect if there is an active subscription.
-                    // Calling it again here ensures that it can detect if it can poll
-                    setTimeout(() => this.updatePolling());
-                }
-            },
-            unsubscribe: () => {
-                if (!this.subject.observed) {
-                    this.tearDownQuery();
-                }
-            },
-        }), 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;
-        }
-        this.pipe = this.observable.pipe.bind(this.observable);
-        this.subscribe = this.observable.subscribe.bind(this.observable);
-        // related classes
-        this.queryInfo = queryInfo;
+    get networkStatus() {
+        return this.subject.getValue().result.networkStatus;
+    }
+    constructor({ queryManager, options, transformedQuery = queryManager.transform(options.query), }) {
         this.queryManager = queryManager;
         // active state
-        this.waitForOwnResult = skipCacheDataFor(options.fetchPolicy);
+        this.waitForNetworkResult = options.fetchPolicy === "network-only";
         this.isTornDown = false;
-        this.subscribe = this.subscribe.bind(this);
         this.subscribeToMore = this.subscribeToMore.bind(this);
         this.maskResult = this.maskResult.bind(this);
         const { watchQuery: { fetchPolicy: defaultFetchPolicy = "cache-first" } = {}, } = queryManager.defaultOptions;
         const { fetchPolicy = defaultFetchPolicy, 
         // Make sure we don't store "standby" as the initialFetchPolicy.
         initialFetchPolicy = fetchPolicy === "standby" ? defaultFetchPolicy : (fetchPolicy), } = options;
+        this.lastQuery = transformedQuery;
         this.options = {
             ...options,
             // Remember the initial options.fetchPolicy so we can revert back to this
@@ -127,11 +81,84 @@ 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();
+        this.initializeObservablesQueue();
+        this["@@observable"] = () => this;
+        if (Symbol.observable) {
+            this[Symbol.observable] = () => this;
+        }
         const opDef = getOperationDefinition(this.query);
         this.queryName = opDef && opDef.name && opDef.name.value;
     }
+    initializeObservablesQueue() {
+        this.subject = new BehaviorSubject({
+            query: this.query,
+            variables: this.variables,
+            result: uninitialized,
+            meta: {},
+        });
+        const observable = this.subject.pipe(tap({
+            subscribe: () => {
+                if (!this.subject.observed) {
+                    this.reobserve();
+                    // TODO: See if we can rework updatePolling to better handle this.
+                    // reobserve calls updatePolling but this `subscribe` callback is
+                    // called before the subject is subscribed to so `updatePolling`
+                    // can't accurately detect if there is an active subscription.
+                    // Calling it again here ensures that it can detect if it can poll
+                    setTimeout(() => this.updatePolling());
+                }
+            },
+            unsubscribe: () => {
+                if (!this.subject.observed) {
+                    this.tearDownQuery();
+                }
+            },
+        }), filterMap(({ query, variables, result: current, meta }, context) => {
+            const { shouldEmit } = meta;
+            if (current === uninitialized) {
+                // reset internal state after `ObservableQuery.reset()`
+                context.previous = undefined;
+                context.previousVariables = undefined;
+            }
+            if (this.options.fetchPolicy === "standby" ||
+                shouldEmit === 2 /* EmitBehavior.never */)
+                return;
+            if (shouldEmit === 1 /* EmitBehavior.force */)
+                return emit();
+            const { previous, previousVariables } = context;
+            if (previous) {
+                const documentInfo = this.queryManager.getDocumentInfo(query);
+                const dataMasking = this.queryManager.dataMasking;
+                const maskedQuery = dataMasking ? documentInfo.nonReactiveQuery : query;
+                const resultIsEqual = dataMasking || documentInfo.hasNonreactiveDirective ?
+                    equalByQuery(maskedQuery, previous, current, variables)
+                    : equal(previous, current);
+                if (resultIsEqual && equal(previousVariables, variables)) {
+                    return;
+                }
+            }
+            if (shouldEmit === 3 /* EmitBehavior.networkStatusChange */ &&
+                (!this.options.notifyOnNetworkStatusChange ||
+                    equal(previous, current))) {
+                return;
+            }
+            return emit();
+            function emit() {
+                context.previous = current;
+                context.previousVariables = variables;
+                return current;
+            }
+        }, () => ({})));
+        this.pipe = observable.pipe.bind(observable);
+        this.subscribe = observable.subscribe.bind(observable);
+        this.input = new Subject();
+        // we want to feed many streams into `this.subject`, but none of them should
+        // be able to close `this.input`
+        this.input.complete = () => { };
+        this.input.pipe(this.operator).subscribe(this.subject);
+    }
     // We can't use Observable['subscribe'] here as the type as it conflicts with
     // the ability to infer T from Subscribable<T>. This limits the surface area
     // to the non-deprecated signature which works properly with type inference.
@@ -139,36 +166,48 @@ export class ObservableQuery {
     pipe;
     [Symbol.observable];
     ["@@observable"];
-    /** @internal */
-    resetDiff() {
-        this.queryInfo.resetDiff();
+    /**
+    * @internal
+    * 
+    * @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({
+            query: this.query,
+            variables: this.variables,
+            returnPartialData: true,
+            optimistic,
+        });
     }
-    getInitialResult() {
+    getInitialResult(initialFetchPolicy) {
         const fetchPolicy = this.queryManager.prioritizeCacheValues ?
             "cache-first"
-            : this.options.fetchPolicy;
-        const defaultResult = {
-            data: undefined,
-            loading: true,
-            networkStatus: NetworkStatus.loading,
-            partial: true,
-        };
+            : initialFetchPolicy || this.options.fetchPolicy;
         const cacheResult = () => {
-            const diff = this.queryInfo.getDiff();
+            const diff = this.getCacheDiff();
+            // TODO: queryInfo.getDiff should handle this since cache.diff returns a
+            // null when returnPartialData is false
+            const data = this.options.returnPartialData || diff.complete ?
+                diff.result ?? undefined
+                : undefined;
             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,
+                data,
+                dataState: diff.complete ? "complete"
+                    : data === undefined ? "empty"
+                        : "partial",
                 loading: !diff.complete,
                 networkStatus: diff.complete ? NetworkStatus.ready : NetworkStatus.loading,
                 partial: !diff.complete,
             });
         };
         switch (fetchPolicy) {
-            case "cache-only":
+            case "cache-only": {
+                return {
+                    ...cacheResult(),
+                    loading: false,
+                    networkStatus: NetworkStatus.ready,
+                };
+            }
             case "cache-first":
                 return cacheResult();
             case "cache-and-network":
@@ -178,127 +217,102 @@ export class ObservableQuery {
                     networkStatus: NetworkStatus.loading,
                 };
             case "standby":
-                return {
-                    ...defaultResult,
-                    loading: false,
-                    networkStatus: NetworkStatus.ready,
-                };
+                return empty;
             default:
-                return defaultResult;
-        }
-    }
-    getCurrentFullResult(saveAsLastResult = true) {
-        // Use the last result as long as the variables match this.variables.
-        const lastResult = this.getLastResult(true);
-        const networkStatus = this.networkStatus;
-        const result = {
-            data: undefined,
-            partial: true,
-            ...lastResult,
-            loading: isNetworkRequestInFlight(networkStatus),
-            networkStatus,
-        };
-        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.
-        skipCacheDataFor(fetchPolicy) ||
-            // If this.options.query has @client(always: true) fields, we cannot
-            // trust diff.result, since it was read from the cache without running
-            // local resolvers (and it's too late to run resolvers now, since we must
-            // return a result synchronously).
-            this.queryManager.getDocumentInfo(this.query).hasForcedResolvers) {
-            // Fall through.
-        }
-        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.
-            this.queryInfo["updateWatch"]();
+                return uninitialized;
         }
-        else {
-            const diff = this.queryInfo.getDiff();
-            result.partial = !diff.complete;
-            if (diff.complete || this.options.returnPartialData) {
-                result.data = diff.result;
-            }
-            if (result.data === null) {
-                result.data = void 0;
-            }
-            if (diff.complete) {
-                // If the diff is complete, and we're using a FetchPolicy that
-                // terminates after a complete cache read, we can assume the next result
-                // we receive will have NetworkStatus.ready and !loading.
-                if (diff.complete &&
-                    result.networkStatus === NetworkStatus.loading &&
-                    (fetchPolicy === "cache-first" || fetchPolicy === "cache-only")) {
-                    result.networkStatus = NetworkStatus.ready;
-                    result.loading = false;
+    }
+    resubscribeCache() {
+        const { variables, fetchPolicy } = this.options;
+        const query = this.query;
+        const shouldUnsubscribe = fetchPolicy === "standby" ||
+            fetchPolicy === "no-cache" ||
+            this.waitForNetworkResult;
+        const shouldResubscribe = !isEqualQuery({ query, variables }, this.unsubscribeFromCache) &&
+            !this.waitForNetworkResult;
+        if (shouldUnsubscribe || shouldResubscribe) {
+            this.unsubscribeFromCache?.();
+        }
+        if (shouldUnsubscribe || !shouldResubscribe) {
+            return;
+        }
+        const watch = {
+            query,
+            variables,
+            optimistic: true,
+            watcher: this,
+            callback: (diff) => {
+                const info = this.queryManager.getDocumentInfo(query);
+                if (info.hasClientExports || info.hasForcedResolvers) {
+                    // If this is not set to something different than `diff`, we will
+                    // not be notified about future cache changes with an equal `diff`.
+                    // That would be the case if we are working with client-only fields
+                    // that are forced or with `exports` fields that might change, causing
+                    // local resovlers to return a new result.
+                    // This is based on an implementation detail of `InMemoryCache`, which
+                    // is not optimal - but the only alternative to this would be to
+                    // resubscribe to the cache asynchonouly, which would bear the risk of
+                    // missing further synchronous updates.
+                    watch.lastDiff = undefined;
                 }
-            }
-            // We need to check for both both `error` and `errors` field because there
-            // are cases where sometimes `error` is set, but not `errors` and
-            // vice-versa. This will be updated in the next major version when
-            // `errors` is deprecated in favor of `error`.
-            if (result.networkStatus === NetworkStatus.ready && result.error) {
-                result.networkStatus = NetworkStatus.error;
-            }
-            if (__DEV__ &&
-                !diff.complete &&
-                !result.loading &&
-                !result.data &&
-                !result.error) {
-                logMissingFieldErrors(diff.missing);
-            }
-        }
-        if (saveAsLastResult) {
-            this.updateLastResult(result);
-        }
-        return result;
-    }
-    getCurrentResult(saveAsLastResult = true) {
-        return this.maskResult(this.getCurrentFullResult(saveAsLastResult));
-    }
-    // Compares newResult to the snapshot we took of this.lastResult when it was
-    // first received.
-    isDifferentFromLastResult(newResult, variables) {
-        if (!this.last) {
-            return true;
-        }
-        const documentInfo = this.queryManager.getDocumentInfo(this.query);
-        const dataMasking = this.queryManager.dataMasking;
-        const query = dataMasking ? documentInfo.nonReactiveQuery : this.query;
-        const resultIsDifferent = dataMasking || documentInfo.hasNonreactiveDirective ?
-            !equalByQuery(query, this.last.result, newResult, this.variables)
-            : !equal(this.last.result, newResult);
-        return (resultIsDifferent || (variables && !equal(this.last.variables, variables)));
-    }
-    getLast(key, variablesMustMatch) {
-        const last = this.last;
-        if (last &&
-            last[key] &&
-            (!variablesMustMatch || equal(last.variables, this.variables))) {
-            return last[key];
-        }
-    }
-    // TODO: Consider deprecating this function
-    getLastResult(variablesMustMatch) {
-        return this.getLast("result", variablesMustMatch);
-    }
-    // TODO: Consider deprecating this function
-    getLastError(variablesMustMatch) {
-        return this.getLast("error", variablesMustMatch);
-    }
-    // TODO: Consider deprecating this function
-    resetLastResults() {
-        delete this.last;
-        // TODO: This will need to be removed when tearing down an ObservableQuery
-        // since the observable will terminate.
-        this.isTornDown = false;
+                if (watch.lastOwnDiff === diff) {
+                    // skip cache updates that were caused by our own writes
+                    return;
+                }
+                const { result: previousResult } = this.subject.getValue();
+                if (!diff.complete &&
+                    // If we are trying to deliver an incomplete cache result, we avoid
+                    // reporting it if the query has errored, otherwise we let the broadcast try
+                    // and repair the partial result by refetching the query. This check avoids
+                    // a situation where a query that errors and another succeeds with
+                    // overlapping data does not report the partial data result to the errored
+                    // query.
+                    //
+                    // See https://github.com/apollographql/apollo-client/issues/11400 for more
+                    // information on this issue.
+                    (previousResult.error ||
+                        // Prevent to schedule a notify directly after the `ObservableQuery`
+                        // has been `reset` (which will set the `previousResult` to `uninitialized` or `empty`)
+                        // as in those cases, `resetCache` will manually call `refetch` with more intentional timing.
+                        previousResult === uninitialized ||
+                        previousResult === empty)) {
+                    return;
+                }
+                if (!equal(previousResult.data, diff.result)) {
+                    this.scheduleNotify();
+                }
+            },
+        };
+        const cancelWatch = this.queryManager.cache.watch(watch);
+        this.unsubscribeFromCache = Object.assign(() => {
+            this.unsubscribeFromCache = undefined;
+            cancelWatch();
+        }, { query, variables });
+    }
+    stableLastResult;
+    getCurrentResult() {
+        const { result: current } = this.subject.getValue();
+        let value = (
+        // if the `current` result is in an error state, we will always return that
+        // error state, even if we have no observers
+        (current.networkStatus === NetworkStatus.error ||
+            // if we have observers, we are watching the cache and
+            // this.subject.getValue() will always be up to date
+            this.hasObservers() || // if we are using a `no-cache` fetch policy in which case this
+        // `ObservableQuery` cannot have been updated from the outside - in
+        // that case, we prefer to keep the current value
+        this.options.fetchPolicy === "no-cache")) ?
+            current
+            // otherwise, the `current` value might be outdated due to missed
+            // external updates - calculate it again
+            : this.getInitialResult();
+        if (value === uninitialized) {
+            value = this.getInitialResult();
+        }
+        if (!equal(this.stableLastResult, value)) {
+            this.stableLastResult = value;
+        }
+        return this.stableLastResult;
     }
     /**
      * Update the variables of this observable query, and fetch the new results.
@@ -308,6 +322,7 @@ export class ObservableQuery {
      * the previous values of those variables will be used.
      */
     refetch(variables) {
+        const { fetchPolicy } = this.options;
         const reobserveOptions = {
             // Always disable polling for refetches.
             pollInterval: 0,
@@ -315,7 +330,6 @@ export class ObservableQuery {
         // Unless the provided fetchPolicy always consults the network
         // (no-cache, network-only, or cache-and-network), override it with
         // network-only to force the refetch for this fetchQuery call.
-        const { fetchPolicy } = this.options;
         if (fetchPolicy === "no-cache") {
             reobserveOptions.fetchPolicy = "no-cache";
         }
@@ -326,35 +340,37 @@ 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(79, 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,
-            [newNetworkStatusSymbol]: NetworkStatus.refetch,
+        this._lastWrite = undefined;
+        return this._reobserve(reobserveOptions, {
+            newNetworkStatus: 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/).
      */
-    fetchMore(fetchMoreOptions) {
+    fetchMore({ query, variables, context, errorPolicy, updateQuery, }) {
+        invariant(
+            this.options.fetchPolicy !== "cache-only",
+            80,
+            getOperationName(this.query, "(anonymous)")
+        );
         const combinedOptions = {
-            ...(fetchMoreOptions.query ? fetchMoreOptions : ({
-                ...this.options,
-                query: this.options.query,
-                ...fetchMoreOptions,
-                variables: {
-                    ...this.options.variables,
-                    ...fetchMoreOptions.variables,
-                },
+            ...compact(this.options, { errorPolicy: "none" }, {
+                query,
+                context,
+                errorPolicy,
+            }),
+            variables: (query ? variables : ({
+                ...this.variables,
+                ...variables,
             })),
             // The fetchMore request goes immediately to the network and does
             // not automatically write its result to the cache (hence no-cache
@@ -365,36 +381,34 @@ export class ObservableQuery {
             notifyOnNetworkStatusChange: this.options.notifyOnNetworkStatusChange,
         };
         combinedOptions.query = this.transformDocument(combinedOptions.query);
-        const qid = this.queryManager.generateQueryId();
         // If a temporary query is passed to `fetchMore`, we don't want to store
         // it as the last query result since it may be an optimized query for
         // pagination. We will however run the transforms on the original document
         // as well as the document passed in `fetchMoreOptions` to ensure the cache
         // uses the most up-to-date document which may rely on runtime conditionals.
         this.lastQuery =
-            fetchMoreOptions.query ?
+            query ?
                 this.transformDocument(this.options.query)
                 : combinedOptions.query;
-        // Simulate a loading result for the original query with
-        // result.networkStatus === NetworkStatus.fetchMore.
-        const originalNetworkStatus = this.networkStatus;
-        this.networkStatus = NetworkStatus.fetchMore;
-        if (combinedOptions.notifyOnNetworkStatusChange) {
-            this.observe();
-        }
-        const updatedQuerySet = new Set();
-        const updateQuery = fetchMoreOptions?.updateQuery;
+        let wasUpdated = false;
         const isCached = this.options.fetchPolicy !== "no-cache";
         if (!isCached) {
-            invariant(updateQuery, 68);
+            invariant(updateQuery, 81);
         }
+        const { finalize, pushNotification } = this.pushOperation(NetworkStatus.fetchMore);
+        pushNotification({
+            source: "newNetworkStatus",
+            kind: "N",
+            value: {},
+        }, { shouldEmit: 3 /* EmitBehavior.networkStatusChange */ });
         return this.queryManager
-            .fetchQuery(qid, combinedOptions, NetworkStatus.fetchMore)
+            .fetchQuery(combinedOptions, NetworkStatus.fetchMore)
             .then((fetchMoreResult) => {
-            this.queryManager.removeQuery(qid);
-            if (this.networkStatus === NetworkStatus.fetchMore) {
-                this.networkStatus = originalNetworkStatus;
-            }
+            // 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) {
                 // Performing this cache update inside a cache.batch transaction ensures
                 // any affected cache.watch watchers are notified at most once about any
@@ -403,7 +417,6 @@ export class ObservableQuery {
                 // fetchMore cache results back to this ObservableQuery.
                 this.queryManager.cache.batch({
                     update: (cache) => {
-                        const { updateQuery } = fetchMoreOptions;
                         if (updateQuery) {
                             cache.updateQuery({
                                 query: this.query,
@@ -429,9 +442,9 @@ export class ObservableQuery {
                         }
                     },
                     onWatchUpdated: (watch) => {
-                        // Record the DocumentNode associated with any watched query whose
-                        // data were updated by the cache writes above.
-                        updatedQuerySet.add(watch.query);
+                        if (watch.watcher === this) {
+                            wasUpdated = true;
+                        }
                     },
                 });
             }
@@ -450,28 +463,41 @@ export class ObservableQuery {
                 // 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.getLast("result");
+                const lastResult = this.getCurrentResult();
                 const data = updateQuery(lastResult.data, {
                     fetchMoreResult: fetchMoreResult.data,
                     variables: combinedOptions.variables,
                 });
-                this.reportResult({
-                    ...lastResult,
-                    networkStatus: originalNetworkStatus,
-                    loading: isNetworkRequestInFlight(originalNetworkStatus),
-                    data: data,
-                }, this.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(() => {
+            // 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 && !updatedQuerySet.has(this.query)) {
-                this.reobserveCacheFirst();
+            if (isCached && !wasUpdated) {
+                pushNotification({
+                    kind: "N",
+                    source: "newNetworkStatus",
+                    value: {},
+                }, { shouldEmit: 1 /* EmitBehavior.force */ });
             }
         });
     }
@@ -499,7 +525,7 @@ export class ObservableQuery {
                         onError(error);
                     }
                     else {
-                        __DEV__ && invariant.error(69, error);
+                        __DEV__ && invariant.error(82, error);
                     }
                     return;
                 }
@@ -518,10 +544,15 @@ export class ObservableQuery {
             }
         };
     }
-    /** @internal */
-    silentSetOptions(newOptions) {
+    /**
+    * @internal
+    * 
+    * @deprecated This is an internal API and should not be used directly. This can be removed or changed at any time.
+    */
+    applyOptions(newOptions) {
         const mergedOptions = compact(this.options, newOptions || {});
         assign(this.options, mergedOptions);
+        this.updatePolling();
     }
     /**
      * Update the variables of this observable query, and fetch the new results
@@ -542,23 +573,23 @@ 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 toQueryResult(this.subject.getValue());
+            return toQueryResult(this.getCurrentResult());
         }
         this.options.variables = variables;
         // See comment above
         if (!this.hasObservers()) {
-            return toQueryResult(this.subject.getValue());
+            return toQueryResult(this.getCurrentResult());
         }
-        return this.reobserve({
+        return this._reobserve({
             // Reset options.fetchPolicy to its original value.
             fetchPolicy: this.options.initialFetchPolicy,
             variables,
-            [newNetworkStatusSymbol]: NetworkStatus.setVariables,
-        });
+        }, { newNetworkStatus: NetworkStatus.setVariables });
     }
     /**
      * A function that enables you to update the query's cached result without executing a followup GraphQL operation.
@@ -567,12 +598,7 @@ export class ObservableQuery {
      */
     updateQuery(mapFn) {
         const { queryManager } = this;
-        const { result, complete } = queryManager.cache.diff({
-            query: this.options.query,
-            variables: this.variables,
-            returnPartialData: true,
-            optimistic: false,
-        });
+        const { result, complete } = this.getCacheDiff({ optimistic: false });
         const newResult = mapFn(result, {
             variables: this.variables,
             complete: !!complete,
@@ -624,12 +650,7 @@ export class ObservableQuery {
                 // that end, the options.nextFetchPolicy option provides an easy way to
                 // update options.fetchPolicy after the initial network request, without
                 // having to call observableQuery.reobserve.
-                options.fetchPolicy = options.nextFetchPolicy(fetchPolicy, {
-                    reason,
-                    options,
-                    observable: this,
-                    initialFetchPolicy,
-                });
+                options.fetchPolicy = options.nextFetchPolicy.call(options, fetchPolicy, { reason, options, observable: this, initialFetchPolicy });
             }
             else if (reason === "variables-changed") {
                 options.fetchPolicy = initialFetchPolicy;
@@ -640,35 +661,133 @@ export class ObservableQuery {
         }
         return options.fetchPolicy;
     }
-    fetch(options, newNetworkStatus, emitLoadingState, query) {
+    fetch(options, networkStatus, fetchQuery, operator) {
         // TODO Make sure we update the networkStatus (and infer fetchVariables)
         // before actually committing to the fetch.
-        const queryInfo = this.queryManager.getOrCreateQuery(this.queryId);
-        queryInfo.setObservableQuery(this);
-        return this.queryManager.fetchObservableWithInfo(queryInfo, options, newNetworkStatus, query, emitLoadingState);
+        const initialFetchPolicy = this.options.fetchPolicy;
+        options.context ??= {};
+        let synchronouslyEmitted = false;
+        const onCacheHit = () => {
+            synchronouslyEmitted = true;
+        };
+        const fetchQueryOperator = // we cannot use `tap` here, since it allows only for a "before subscription"
+         
+        // hook with `subscribe` and we care for "directly before and after subscription"
+        (source) => new Observable((subscriber) => {
+            try {
+                return source.subscribe({
+                    next(value) {
+                        synchronouslyEmitted = true;
+                        subscriber.next(value);
+                    },
+                    error: (error) => subscriber.error(error),
+                    complete: () => subscriber.complete(),
+                });
+            }
+            finally {
+                if (!synchronouslyEmitted) {
+                    operation.override = networkStatus;
+                    this.input.next({
+                        kind: "N",
+                        source: "newNetworkStatus",
+                        value: {
+                            resetError: true,
+                        },
+                        query,
+                        variables,
+                        meta: {
+                            shouldEmit: 3 /* EmitBehavior.networkStatusChange */,
+                            /*
+                             * The moment this notification is emitted, `nextFetchPolicy`
+                             * might already have switched from a `network-only` to a
+                             * `cache-something` policy, so we want to ensure that the
+                             * loading state emit doesn't accidentally read from the cache
+                             * in those cases.
+                             */
+                            fetchPolicy: initialFetchPolicy,
+                        },
+                    });
+                }
+            }
+        });
+        let { observable, fromLink } = this.queryManager.fetchObservableWithInfo(options, {
+            networkStatus,
+            query: fetchQuery,
+            onCacheHit,
+            fetchQueryOperator,
+            observableQuery: this,
+        });
+        // track query and variables from the start of the operation
+        const { query, variables } = this;
+        const operation = {
+            abort: () => {
+                subscription.unsubscribe();
+            },
+            query,
+            variables,
+        };
+        this.activeOperations.add(operation);
+        let forceFirstValueEmit = networkStatus == NetworkStatus.refetch ||
+            networkStatus == NetworkStatus.setVariables;
+        observable = observable.pipe(operator, share());
+        const subscription = observable
+            .pipe(tap({
+            next: (notification) => {
+                if (notification.source === "newNetworkStatus" ||
+                    (notification.kind === "N" && notification.value.loading)) {
+                    operation.override = networkStatus;
+                }
+                else {
+                    delete operation.override;
+                }
+            },
+            finalize: () => this.activeOperations.delete(operation),
+        }))
+            .subscribe({
+            next: (value) => {
+                const meta = {};
+                if (forceFirstValueEmit &&
+                    value.kind === "N" &&
+                    "loading" in value.value &&
+                    !value.value.loading) {
+                    forceFirstValueEmit = false;
+                    meta.shouldEmit = 1 /* EmitBehavior.force */;
+                }
+                this.input.next({ ...value, query, variables, meta });
+            },
+        });
+        return { fromLink, subscription, observable };
     }
     // Turns polling on or off based on this.options.pollInterval.
+    didWarnCacheOnlyPolling = false;
     updatePolling() {
         // Avoid polling in SSR mode
         if (this.queryManager.ssrMode) {
             return;
         }
-        const { pollingInfo, options: { pollInterval }, } = this;
-        if (!pollInterval || !this.hasObservers()) {
+        const { pollingInfo, options: { fetchPolicy, pollInterval }, } = this;
+        if (!pollInterval || !this.hasObservers() || fetchPolicy === "cache-only") {
+            if (__DEV__) {
+                if (!this.didWarnCacheOnlyPolling &&
+                    pollInterval &&
+                    fetchPolicy === "cache-only") {
+                    __DEV__ && invariant.warn(83, getOperationName(this.query, "(anonymous)"));
+                    this.didWarnCacheOnlyPolling = true;
+                }
+            }
             this.cancelPolling();
             return;
         }
-        if (pollingInfo && pollingInfo.interval === pollInterval) {
+        if (pollingInfo?.interval === pollInterval) {
             return;
         }
-        invariant(pollInterval, 70);
         const info = pollingInfo || (this.pollingInfo = {});
         info.interval = pollInterval;
         const maybeFetch = () => {
             if (this.pollingInfo) {
                 if (!isNetworkRequestInFlight(this.networkStatus) &&
                     !this.options.skipPollAttempt?.()) {
-                    this.reobserve({
+                    this._reobserve({
                         // Most fetchPolicy options don't make sense to use in a polling context, as
                         // users wouldn't want to be polling the cache directly. However, network-only and
                         // no-cache are both useful for when the user wants to control whether or not the
@@ -676,7 +795,8 @@ export class ObservableQuery {
                         fetchPolicy: this.options.initialFetchPolicy === "no-cache" ?
                             "no-cache"
                             : "network-only",
-                        [newNetworkStatusSymbol]: NetworkStatus.poll,
+                    }, {
+                        newNetworkStatus: NetworkStatus.poll,
                     }).then(poll, poll);
                 }
                 else {
@@ -700,45 +820,27 @@ export class ObservableQuery {
             delete this.pollingInfo;
         }
     }
-    updateLastResult(newResult, variables = this.variables) {
-        let error = this.getLastError();
-        // Preserve this.last.error unless the variables have changed.
-        if (error && this.last && !equal(variables, this.last.variables)) {
-            error = void 0;
-        }
-        return (this.last = {
-            result: this.queryManager.assumeImmutableResults ?
-                newResult
-                : cloneDeep(newResult),
-            variables,
-            ...(error ? { error } : null),
-        });
-    }
     /**
      * Reevaluate the query, optionally against new options. New options will be
      * merged with the current options when given.
      */
     reobserve(newOptions) {
+        return this._reobserve(newOptions);
+    }
+    _reobserve(newOptions, internalOptions) {
         this.isTornDown = false;
-        let newNetworkStatus;
-        if (newOptions) {
-            newNetworkStatus = newOptions[newNetworkStatusSymbol];
-            // Avoid setting the symbol option in this.options
-            delete newOptions[newNetworkStatusSymbol];
-        }
+        let { newNetworkStatus } = internalOptions || {};
+        this.queryManager.obsQueries.add(this);
         const useDisposableObservable = 
         // Refetching uses a disposable Observable to allow refetches using different
-        // options/variables, without permanently altering the options of the
+        // options, without permanently altering the options of the
         // original ObservableQuery.
         newNetworkStatus === NetworkStatus.refetch ||
-            // The fetchMore method does not actually call the reobserve method, but,
-            // if it did, it would definitely use a disposable Observable.
-            newNetworkStatus === NetworkStatus.fetchMore ||
             // Polling uses a disposable Observable so the polling options (which force
             // 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 ?
@@ -751,8 +853,17 @@ 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;
+        // 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();
@@ -762,13 +873,14 @@ export class ObservableQuery {
                 newOptions.variables &&
                 !equal(newOptions.variables, oldVariables) &&
                 // Don't mess with the fetchPolicy if it's currently "standby".
-                fetchPolicy !== "standby" &&
+                options.fetchPolicy !== "standby" &&
                 // If we're changing the fetchPolicy anyway, don't try to change it here
                 // using applyNextFetchPolicy. The explicit options.fetchPolicy wins.
-                (fetchPolicy === oldFetchPolicy ||
+                (options.fetchPolicy === oldFetchPolicy ||
                     // 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;
@@ -785,187 +897,334 @@ export class ObservableQuery {
             }
             // QueryManager does not emit any values for standby fetch policies so we
             // want ensure that the networkStatus remains ready.
-            if (fetchPolicy === "standby") {
+            if (options.fetchPolicy === "standby") {
                 newNetworkStatus = NetworkStatus.ready;
             }
         }
-        if (fetchPolicy === "standby") {
+        if (options.fetchPolicy === "standby") {
             this.cancelPolling();
         }
-        this.networkStatus = newNetworkStatus;
-        this.waitForOwnResult &&= skipCacheDataFor(options.fetchPolicy);
-        const finishWaitingForOwnResult = () => {
-            if (this.linkObservable === observable) {
-                this.waitForOwnResult = false;
+        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 variables = options.variables && { ...options.variables };
-        const { notifyOnNetworkStatusChange = true } = options;
-        const { observable, fromLink } = this.fetch(options, newNetworkStatus, notifyOnNetworkStatusChange &&
-            oldNetworkStatus !== newNetworkStatus &&
-            isNetworkRequestInFlight(newNetworkStatus), query);
-        const observer = {
-            next: (result) => {
-                if (equal(this.variables, variables)) {
-                    finishWaitingForOwnResult();
-                    this.reportResult(result, variables);
-                }
-            },
-            error: (error) => {
-                if (equal(this.variables, variables)) {
-                    finishWaitingForOwnResult();
-                    this.reportError(error, variables);
-                }
-            },
-        };
+        }, 
+        // 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.
+        options.fetchPolicy === "standby" ?
+            { data: undefined }
+            : undefined);
+        const { subscription, observable, fromLink } = this.fetch(options, newNetworkStatus, query, promiseOperator);
         if (!useDisposableObservable && (fromLink || !this.linkSubscription)) {
             if (this.linkSubscription) {
                 this.linkSubscription.unsubscribe();
             }
-            this.linkObservable = observable;
-            this.linkSubscription = observable.subscribe(observer);
+            this.linkSubscription = subscription;
         }
-        else {
-            observable.subscribe(observer);
-        }
-        return preventUnhandledRejection(
-        // 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, {
-            // 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.
-    observe() {
-        this.reportResult(
-        // Passing false is important so that this.getCurrentResult doesn't
-        // save the fetchMore result as this.lastResult, causing it to be
-        // ignored due to the this.isDifferentFromLastResult check in
-        // this.reportResult.
-        this.getCurrentFullResult(false), this.variables);
-    }
-    reportResult(result, variables) {
-        const lastError = this.getLastError();
-        const isDifferent = this.isDifferentFromLastResult(result, variables);
-        // Update the last result even when isDifferentFromLastResult returns false,
-        // because the query may be using the @nonreactive directive, and we want to
-        // save the the latest version of any nonreactive subtrees (in case
-        // getCurrentResult is called), even though we skip broadcasting changes.
-        this.updateLastResult(result, variables);
-        this.networkStatus = result.networkStatus;
-        if (lastError || isDifferent) {
-            this.subject.next(this.maskResult(result));
-        }
-    }
-    reportError(error, variables) {
-        // Since we don't get the current result on errors, only the error, we
-        // must mirror the updates that occur in QueryStore.markQueryError here
-        const errorResult = {
-            data: undefined,
-            partial: true,
-            ...this.getLastResult(),
-            error,
-            networkStatus: NetworkStatus.error,
-            loading: false,
-        };
-        this.updateLastResult(errorResult, variables);
-        this.networkStatus = NetworkStatus.error;
-        this.last.error = error;
-        this.subject.next(errorResult);
+        const ret = Object.assign(preventUnhandledRejection(promise
+            .then((result) => toQueryResult(this.maskResult(result)))
+            .finally(() => {
+            if (!this.hasObservers() && this.activeOperations.size === 0) {
+                // If `reobserve` was called on a query without any obervers,
+                // the teardown logic would never be called, so we need to
+                // call it here to ensure the query is properly torn down.
+                this.tearDownQuery();
+            }
+        })), {
+            retain: () => {
+                const subscription = observable.subscribe({});
+                const unsubscribe = () => subscription.unsubscribe();
+                promise.then(unsubscribe, unsubscribe);
+                return ret;
+            },
+        });
+        return ret;
     }
     hasObservers() {
         return this.subject.observed;
     }
+    /**
+     * Tears down the `ObservableQuery` and stops all active operations by sending a `complete` notification.
+     */
+    stop() {
+        this.subject.complete();
+        this.initializeObservablesQueue();
+        this.tearDownQuery();
+    }
     tearDownQuery() {
         if (this.isTornDown)
             return;
-        if (this.linkObservable && this.linkSubscription) {
+        this.resetNotifications();
+        this.unsubscribeFromCache?.();
+        if (this.linkSubscription) {
             this.linkSubscription.unsubscribe();
-            delete this.linkObservable;
             delete this.linkSubscription;
         }
         this.stopPolling();
         // stop all active GraphQL subscriptions
         this.subscriptions.forEach((sub) => sub.unsubscribe());
         this.subscriptions.clear();
-        this.queryManager.stopQuery(this.queryId);
+        this.queryManager.obsQueries.delete(this);
         this.isTornDown = true;
+        this.abortActiveOperations();
+        this._lastWrite = undefined;
     }
     transformDocument(document) {
         return this.queryManager.transform(document);
     }
     maskResult(result) {
-        return result && "data" in result ?
-            {
-                ...result,
-                data: this.queryManager.maskOperation({
-                    document: this.query,
-                    data: result.data,
-                    fetchPolicy: this.options.fetchPolicy,
-                    id: this.queryId,
-                }),
-            }
-            : result;
+        const masked = this.queryManager.maskOperation({
+            document: this.query,
+            data: result.data,
+            fetchPolicy: this.options.fetchPolicy,
+            cause: this,
+        });
+        // Maintain object identity as much as possible
+        return masked === result.data ? result : { ...result, data: masked };
     }
     dirty = false;
     notifyTimeout;
-    /** @internal */
+    /**
+    * @internal
+    * 
+    * @deprecated This is an internal API and should not be used directly. This can be removed or changed at any time.
+    */
     resetNotifications() {
-        this.cancelNotifyTimeout();
-        this.dirty = false;
-    }
-    cancelNotifyTimeout() {
         if (this.notifyTimeout) {
             clearTimeout(this.notifyTimeout);
             this.notifyTimeout = void 0;
         }
+        this.dirty = false;
     }
-    /** @internal */
+    /**
+    * @internal
+    * 
+    * @deprecated This is an internal API and should not be used directly. This can be removed or changed at any time.
+    */
     scheduleNotify() {
         if (this.dirty)
             return;
         this.dirty = true;
         if (!this.notifyTimeout) {
-            this.notifyTimeout = setTimeout(() => this.notify(), 0);
+            this.notifyTimeout = setTimeout(() => this.notify(true), 0);
         }
     }
-    /** @internal */
-    notify() {
-        this.cancelNotifyTimeout();
-        if (this.dirty) {
-            if (this.options.fetchPolicy == "cache-only" ||
+    /**
+    * @internal
+    * 
+    * @deprecated This is an internal API and should not be used directly. This can be removed or changed at any time.
+    */
+    notify(scheduled = false) {
+        if (!scheduled) {
+            // For queries with client exports or forced resolvers, we don't want to
+            // synchronously reobserve the cache on broadcast,
+            // but actually wait for the `scheduleNotify` timeout triggered by the
+            // `cache.watch` callback from `resubscribeCache`.
+            const info = this.queryManager.getDocumentInfo(this.query);
+            if (info.hasClientExports || info.hasForcedResolvers) {
+                return;
+            }
+        }
+        const { dirty } = this;
+        this.resetNotifications();
+        if (dirty &&
+            (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();
-                }
-                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.activeOperations.size)) {
+            const diff = this.getCacheDiff();
+            if (
+            // `fromOptimisticTransaction` is not avaiable through the `cache.diff`
+            // code path, so we need to check it this way
+            equal(diff.result, this.getCacheDiff({ optimistic: false }).result)) {
+                //If this diff did not come from an optimistic transaction
+                // 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, distinctUntilChanged still has a
+                // chance to catch it before delivery to ObservableQuery subscribers.
+                this.reobserveCacheFirst();
+            }
+            else {
+                // 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.input.next({
+                    kind: "N",
+                    value: {
+                        data: diff.result,
+                        dataState: diff.complete ? "complete"
+                            : diff.result ? "partial"
+                                : "empty",
+                        networkStatus: NetworkStatus.ready,
+                        loading: false,
+                        error: undefined,
+                        partial: !diff.complete,
+                    },
+                    source: "cache",
+                    query: this.query,
+                    variables: this.variables,
+                    meta: {},
+                });
             }
         }
-        this.dirty = false;
     }
+    activeOperations = new Set();
+    pushOperation(networkStatus) {
+        let aborted = false;
+        // track query and variables from the start of the operation
+        const { query, variables } = this;
+        const finalize = () => {
+            this.activeOperations.delete(operation);
+        };
+        const operation = {
+            override: networkStatus,
+            abort: () => {
+                aborted = true;
+                finalize();
+            },
+            query,
+            variables,
+        };
+        this.activeOperations.add(operation);
+        return {
+            finalize,
+            pushNotification: (notification, additionalMeta) => {
+                if (!aborted) {
+                    this.input.next({
+                        ...notification,
+                        query,
+                        variables,
+                        meta: { ...additionalMeta },
+                    });
+                }
+            },
+        };
+    }
+    calculateNetworkStatus(baseNetworkStatus) {
+        if (baseNetworkStatus === NetworkStatus.streaming) {
+            return baseNetworkStatus;
+        }
+        // in the future, this could be more complex logic, e.g. "refetch" and
+        // "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);
+        return operation?.override ?? baseNetworkStatus;
+    }
+    abortActiveOperations() {
+        this.activeOperations.forEach((operation) => operation.abort());
+    }
+    /**
+    * @internal
+    * Called from `clearStore`.
+    * * resets the query to its initial state
+    * * cancels all active operations and their subscriptions
+    * 
+    * @deprecated This is an internal API and should not be used directly. This can be removed or changed at any time.
+    */
+    reset() {
+        // exception for cache-only queries - we reset them into a "ready" state
+        // as we won't trigger a refetch for them
+        const resetToEmpty = this.options.fetchPolicy === "cache-only";
+        this.setResult(resetToEmpty ? empty : uninitialized, {
+            shouldEmit: resetToEmpty ? 1 /* EmitBehavior.force */ : 2 /* EmitBehavior.never */,
+        });
+        this.abortActiveOperations();
+    }
+    /**
+    * @internal
+    * 
+    * @deprecated This is an internal API and should not be used directly. This can be removed or changed at any time.
+    */
+    setResult(result, additionalMeta) {
+        this.input.next({
+            source: "setResult",
+            kind: "N",
+            value: result,
+            query: this.query,
+            variables: this.variables,
+            meta: { ...additionalMeta },
+        });
+    }
+    operator = filterMap((notification) => {
+        const { query, variables, meta } = notification;
+        if (notification.source === "setResult") {
+            return { query, variables, result: notification.value, meta };
+        }
+        if (notification.kind === "C" || !isEqualQuery(notification, this)) {
+            return;
+        }
+        let result;
+        const previous = this.subject.getValue();
+        if (notification.source === "cache") {
+            result = notification.value;
+            if (result.networkStatus === NetworkStatus.ready &&
+                result.partial &&
+                (!this.options.returnPartialData ||
+                    previous.result.networkStatus === NetworkStatus.error) &&
+                this.options.fetchPolicy !== "cache-only") {
+                return;
+            }
+        }
+        else if (notification.source === "network") {
+            if (this.waitForNetworkResult) {
+                this.waitForNetworkResult = false;
+                this.resubscribeCache();
+            }
+            result =
+                notification.kind === "E" ?
+                    {
+                        ...(isEqualQuery(previous, notification) ?
+                            previous.result
+                            : { data: undefined, dataState: "empty", partial: true }),
+                        error: notification.error,
+                        networkStatus: NetworkStatus.error,
+                        loading: false,
+                    }
+                    : notification.value;
+            if (notification.kind === "E" && result.dataState === "streaming") {
+                result.dataState = "complete";
+            }
+            if (result.error) {
+                meta.shouldEmit = 1 /* EmitBehavior.force */;
+            }
+        }
+        else if (notification.source === "newNetworkStatus") {
+            const baseResult = isEqualQuery(previous, notification) ?
+                previous.result
+                : this.getInitialResult(meta.fetchPolicy);
+            const { resetError } = notification.value;
+            const error = resetError ? undefined : baseResult.error;
+            const networkStatus = error ? NetworkStatus.error : NetworkStatus.ready;
+            result = {
+                ...baseResult,
+                error,
+                networkStatus,
+            };
+        }
+        // every code path until here should have either returned or set a result,
+        // but typescript needs a little help
+        invariant(result);
+        // normalize result shape
+        if (!result.error)
+            delete result.error;
+        result.networkStatus = this.calculateNetworkStatus(result.networkStatus);
+        result.loading = isNetworkRequestInFlight(result.networkStatus);
+        result = this.maskResult(result);
+        return { query, variables, result, meta };
+    });
     // 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
@@ -976,7 +1235,7 @@ export class ObservableQuery {
     reobserveCacheFirst() {
         const { fetchPolicy, nextFetchPolicy } = this.options;
         if (fetchPolicy === "cache-and-network" || fetchPolicy === "network-only") {
-            return this.reobserve({
+            this.reobserve({
                 fetchPolicy: "cache-first",
                 // Use a temporary nextFetchPolicy function that replaces itself with the
                 // previous nextFetchPolicy value and returns the original fetchPolicy.
@@ -994,17 +1253,58 @@ export class ObservableQuery {
                 },
             });
         }
-        return this.reobserve();
+        else {
+            this.reobserve();
+        }
+    }
+    getVariablesWithDefaults(variables) {
+        return this.queryManager.getVariables(this.query, variables);
     }
 }
 export function logMissingFieldErrors(missing) {
     if (__DEV__ && missing) {
-        __DEV__ && invariant.debug(71, missing);
+        __DEV__ && invariant.debug(84, missing);
     }
 }
-function skipCacheDataFor(fetchPolicy /* `undefined` would mean `"cache-first"` */) {
-    return (fetchPolicy === "network-only" ||
-        fetchPolicy === "no-cache" ||
-        fetchPolicy === "standby");
+function isEqualQuery(a, b) {
+    return !!(a && b && a.query === b.query && equal(a.variables, b.variables));
+}
+function getTrackingOperatorPromise(filterMapCb, defaultValue) {
+    let lastValue = defaultValue, resolve, reject;
+    const promise = new Promise((res, rej) => {
+        resolve = res;
+        reject = rej;
+    });
+    const operator = tap({
+        next(value) {
+            try {
+                const newValue = filterMapCb(value);
+                if (newValue !== undefined) {
+                    lastValue = newValue;
+                }
+            }
+            catch (error) {
+                reject(error);
+            }
+        },
+        finalize: () => {
+            if (lastValue) {
+                resolve(lastValue);
+            }
+            else {
+                const message = "The operation was aborted.";
+                const name = "AbortError";
+                reject(typeof DOMException !== "undefined" ?
+                    new DOMException(message, name)
+                    // some environments do not have `DOMException`, e.g. node
+                    // uses a normal `Error` with a `name` property instead: https://github.com/phryneas/node/blob/d0579b64f0f6b722f8e49bf8a471dd0d0604a21e/lib/internal/errors.js#L964
+                    // error.code is a legacy property that is not used anymore,
+                    // and also inconsistent across environments (in supporting
+                    // browsers it is `20`, in node `'ABORT_ERR'`) so we omit that.
+                    : Object.assign(new Error(message), { name }));
+            }
+        },
+    });
+    return { promise, operator };
 }
 //# sourceMappingURL=ObservableQuery.js.map