@apollo/client 4.0.12-beta.0 → 4.0.13

package/__cjs/core/ApolloClient.d.cts

@@ -1,6 +1,6 @@
 import type { DocumentNode } from "graphql";
 import type { Observable } from "rxjs";
-import type { ApolloCache, Cache, IgnoreModifier, Reference } from "@apollo/client/cache";
+import type { ApolloCache, IgnoreModifier, Reference } from "@apollo/client/cache";
 import type { Incremental } from "@apollo/client/incremental";
 import type { ApolloLink } from "@apollo/client/link";
 import type { ClientAwarenessLink } from "@apollo/client/link/client-awareness";
@@ -87,14 +87,6 @@ export declare namespace ApolloClient {
          * queries.
          */
         incrementalHandler?: Incremental.Handler<any>;
-        /**
-         * @experimental
-         * Allows passing in "experiments", experimental features that might one day
-         * become part of Apollo Client's core functionality.
-         * Keep in mind that these features might change the core of Apollo Client.
-         * Do not pass in experiments that are not provided by Apollo.
-         */
-        experiments?: ApolloClient.Experiment[];
     }
     interface DevtoolsOptions {
         /**
@@ -384,13 +376,7 @@ export declare namespace ApolloClient {
         extensions?: Record<string, unknown>;
     }
     type WatchFragmentOptions<TData = unknown, TVariables extends OperationVariables = OperationVariables> = ApolloCache.WatchFragmentOptions<TData, TVariables>;
-    type WatchFragmentResult<TData = unknown> = ApolloCache.WatchFragmentResult<MaybeMasked<TData>>;
-    interface ObservableFragment<TData = unknown> extends Observable<ApolloClient.WatchFragmentResult<TData>> {
-        /**
-         * Return the current result for the fragment.
-         */
-        getCurrentResult: () => ApolloClient.WatchFragmentResult<TData>;
-    }
+    type WatchFragmentResult<TData = unknown> = ApolloCache.WatchFragmentResult<TData>;
     /**
      * Watched query options.
      */
@@ -537,6 +523,12 @@ export declare namespace ApolloClient {
     }
     namespace Base {
         interface ReadFragmentOptions<TData, TVariables extends OperationVariables> {
+            /**
+             * The root id to be used. This id should take the same form as the
+             * value returned by the `cache.identify` function. If a value with your
+             * id does not exist in the store, `null` will be returned.
+             */
+            id?: string;
             /**
              * A GraphQL document created using the `gql` template string tag
              * with one or more fragments which will be used to determine
@@ -565,27 +557,7 @@ export declare namespace ApolloClient {
             optimistic?: boolean;
         }
     }
-    namespace DocumentationTypes {
-        interface ReadFragmentOptions<TData, TVariables extends OperationVariables> extends Base.ReadFragmentOptions<TData, TVariables> {
-            /**
-             * The root id to be used. This id should take the same form as the
-             * value returned by the `cache.identify` function. If a value with your
-             * id does not exist in the store, `null` will be returned.
-             */
-            id?: string;
-            /**
-             * An object containing a `__typename` and primary key fields
-             * (such as `id`) identifying the entity object from which the fragment will
-             * be retrieved, or a `{ __ref: "..." }` reference, or a `string` ID
-             * (uncommon).
-             *
-             * @remarks
-             * `from` is given precedence over `id` when both are provided.
-             */
-            from?: ApolloCache.FromOptionValue<TData>;
-        }
-    }
-    type ReadFragmentOptions<TData, TVariables extends OperationVariables> = Base.ReadFragmentOptions<TData, TVariables> & VariablesOption<TVariables> & Cache.CacheIdentifierOption<TData>;
+    type ReadFragmentOptions<TData, TVariables extends OperationVariables> = Base.ReadFragmentOptions<TData, TVariables> & VariablesOption<TVariables>;
     namespace DocumentationTypes {
         interface WriteQueryOptions<TData, TVariables extends OperationVariables> extends Base.WriteQueryOptions<TData, TVariables> {
             /**
@@ -623,11 +595,6 @@ export declare namespace ApolloClient {
              * @defaultValue false
              */
             overwrite?: boolean;
-            /**
-             * GraphQL extensions for the write operation. Any provided `extensions`
-             * are available in `merge` functions.
-             */
-            extensions?: Record<string, unknown>;
         }
     }
     type WriteQueryOptions<TData, TVariables extends OperationVariables> = Base.WriteQueryOptions<TData, TVariables> & VariablesOption<TVariables>;
@@ -641,6 +608,12 @@ export declare namespace ApolloClient {
     }
     namespace Base {
         interface WriteFragmentOptions<TData, TVariables extends OperationVariables> {
+            /**
+             * The root id to be used. This id should take the same form as the
+             * value returned by the `cache.identify` function. If a value with your
+             * id does not exist in the store, `null` will be returned.
+             */
+            id?: string;
             /**
              * A GraphQL document created using the `gql` template string tag from
              * `graphql-tag` with one or more fragments which will be used to determine
@@ -672,35 +645,15 @@ export declare namespace ApolloClient {
             overwrite?: boolean;
         }
     }
-    type WriteFragmentOptions<TData, TVariables extends OperationVariables> = Base.WriteFragmentOptions<TData, TVariables> & VariablesOption<TVariables> & Cache.CacheIdentifierOption<TData>;
+    type WriteFragmentOptions<TData, TVariables extends OperationVariables> = Base.WriteFragmentOptions<TData, TVariables> & VariablesOption<TVariables>;
     namespace DocumentationTypes {
         interface WriteFragmentOptions<TData, TVariables extends OperationVariables> extends Base.WriteFragmentOptions<TData, TVariables> {
-            /**
-             * The root id to be used. This id should take the same form as the
-             * value returned by the `cache.identify` function. If a value with your
-             * id does not exist in the store, `null` will be returned.
-             */
-            id?: string;
-            /**
-             * An object containing a `__typename` and primary key fields
-             * (such as `id`) identifying the entity object from which the fragment will
-             * be retrieved, or a `{ __ref: "..." }` reference, or a `string` ID
-             * (uncommon).
-             *
-             * @remarks
-             * `from` is given precedence over `id` when both are provided.
-             */
-            from?: ApolloCache.FromOptionValue<TData>;
             /**
              * Any variables that your GraphQL fragments depend on.
              */
             variables?: TVariables;
         }
     }
-    interface Experiment {
-        (this: ApolloClient, options: ApolloClient.Options): void;
-        v: 1;
-    }
 }
 /**
  * This is the primary Apollo Client class. It is used to send GraphQL documents (i.e. queries
@@ -873,86 +826,7 @@ export declare class ApolloClient {
      * the cache to identify the fragment and optionally specify whether to react
      * to optimistic updates.
      */
-    watchFragment<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options: ApolloClient.WatchFragmentOptions<TData, TVariables> & {
-        from: Array<ApolloCache.FromOptionValue<TData>>;
-    }): ApolloClient.ObservableFragment<Array<TData>>;
-    /**
-    * Watches the cache store of the fragment according to the options specified
-    * and returns an `Observable`. We can subscribe to this
-    * `Observable` and receive updated results through an
-    * observer when the cache store changes.
-    * 
-    * You must pass in a GraphQL document with a single fragment or a document
-    * with multiple fragments that represent what you are reading. If you pass
-    * in a document with multiple fragments then you must also specify a
-    * `fragmentName`.
-    * 
-    * @since 3.10.0
-    * @param options - An object of type `WatchFragmentOptions` that allows
-    * the cache to identify the fragment and optionally specify whether to react
-    * to optimistic updates.
-    */
-    watchFragment<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options: ApolloClient.WatchFragmentOptions<TData, TVariables> & {
-        from: Array<null>;
-    }): ApolloClient.ObservableFragment<Array<null>>;
-    watchFragment<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options: ApolloClient.WatchFragmentOptions<TData, TVariables> & {
-        from: Array<ApolloCache.FromOptionValue<TData> | null>;
-    }): ApolloClient.ObservableFragment<Array<TData | null>>;
-    /**
-    * Watches the cache store of the fragment according to the options specified
-    * and returns an `Observable`. We can subscribe to this
-    * `Observable` and receive updated results through an
-    * observer when the cache store changes.
-    * 
-    * You must pass in a GraphQL document with a single fragment or a document
-    * with multiple fragments that represent what you are reading. If you pass
-    * in a document with multiple fragments then you must also specify a
-    * `fragmentName`.
-    * 
-    * @since 3.10.0
-    * @param options - An object of type `WatchFragmentOptions` that allows
-    * the cache to identify the fragment and optionally specify whether to react
-    * to optimistic updates.
-    */
-    watchFragment<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options: ApolloClient.WatchFragmentOptions<TData, TVariables> & {
-        from: null;
-    }): ApolloClient.ObservableFragment<null>;
-    /**
-    * Watches the cache store of the fragment according to the options specified
-    * and returns an `Observable`. We can subscribe to this
-    * `Observable` and receive updated results through an
-    * observer when the cache store changes.
-    * 
-    * You must pass in a GraphQL document with a single fragment or a document
-    * with multiple fragments that represent what you are reading. If you pass
-    * in a document with multiple fragments then you must also specify a
-    * `fragmentName`.
-    * 
-    * @since 3.10.0
-    * @param options - An object of type `WatchFragmentOptions` that allows
-    * the cache to identify the fragment and optionally specify whether to react
-    * to optimistic updates.
-    */
-    watchFragment<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options: ApolloClient.WatchFragmentOptions<TData, TVariables> & {
-        from: ApolloCache.FromOptionValue<TData>;
-    }): ApolloClient.ObservableFragment<TData>;
-    /**
-    * Watches the cache store of the fragment according to the options specified
-    * and returns an `Observable`. We can subscribe to this
-    * `Observable` and receive updated results through an
-    * observer when the cache store changes.
-    * 
-    * You must pass in a GraphQL document with a single fragment or a document
-    * with multiple fragments that represent what you are reading. If you pass
-    * in a document with multiple fragments then you must also specify a
-    * `fragmentName`.
-    * 
-    * @since 3.10.0
-    * @param options - An object of type `WatchFragmentOptions` that allows
-    * the cache to identify the fragment and optionally specify whether to react
-    * to optimistic updates.
-    */
-    watchFragment<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options: ApolloClient.WatchFragmentOptions<TData, TVariables>): ApolloClient.ObservableFragment<TData | null>;
+    watchFragment<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options: ApolloClient.WatchFragmentOptions<TData, TVariables>): Observable<ApolloClient.WatchFragmentResult<MaybeMasked<TData>>>;
     /**
      * Tries to read some data from the store in the shape of the provided
      * GraphQL fragment without making a network request. This method will read a

package/__cjs/core/ObservableQuery.cjs

@@ -69,9 +69,6 @@ class ObservableQuery {
     get networkStatus() {
         return this.subject.getValue().result.networkStatus;
     }
-    get cache() {
-        return this.queryManager.cache;
-    }
     constructor({ queryManager, options, transformedQuery = queryManager.transform(options.query), }) {
         this.queryManager = queryManager;
         // active state
@@ -84,7 +81,7 @@ class ObservableQuery {
         // Make sure we don't store "standby" as the initialFetchPolicy.
         initialFetchPolicy = fetchPolicy === "standby" ? defaultFetchPolicy : (fetchPolicy), } = options;
         if (options[internal_1.variablesUnknownSymbol]) {
-            (0, invariant_1.invariant)(fetchPolicy === "standby", 80);
+            (0, invariant_1.invariant)(fetchPolicy === "standby", 77);
             this.variablesUnknown = true;
         }
         this.lastQuery = transformedQuery;
@@ -213,7 +210,7 @@ class ObservableQuery {
     * @deprecated This is an internal API and should not be used directly. This can be removed or changed at any time.
     */
     getCacheDiff({ optimistic = true } = {}) {
-        return this.cache.diff({
+        return this.queryManager.cache.diff({
             query: this.query,
             variables: this.variables,
             returnPartialData: true,
@@ -324,7 +321,7 @@ class ObservableQuery {
                 }
             },
         };
-        const cancelWatch = this.cache.watch(watch);
+        const cancelWatch = this.queryManager.cache.watch(watch);
         this.unsubscribeFromCache = Object.assign(() => {
             this.unsubscribeFromCache = undefined;
             cancelWatch();
@@ -388,7 +385,7 @@ class ObservableQuery {
             const queryDef = (0, internal_1.getQueryDefinition)(this.query);
             const vars = queryDef.variableDefinitions;
             if (!vars || !vars.some((v) => v.variable.name.value === "variables")) {
-                __DEV__ && invariant_1.invariant.warn(81, variables, queryDef.name?.value || queryDef);
+                __DEV__ && invariant_1.invariant.warn(78, variables, queryDef.name?.value || queryDef);
             }
         }
         if (variables && !(0, equality_1.equal)(this.variables, variables)) {
@@ -404,7 +401,7 @@ class ObservableQuery {
     fetchMore({ query, variables, context, errorPolicy, updateQuery, }) {
         (0, invariant_1.invariant)(
             this.options.fetchPolicy !== "cache-only",
-            82,
+            79,
             (0, internal_1.getOperationName)(this.query, "(anonymous)")
         );
         const combinedOptions = {
@@ -438,7 +435,7 @@ class ObservableQuery {
         let wasUpdated = false;
         const isCached = this.options.fetchPolicy !== "no-cache";
         if (!isCached) {
-            (0, invariant_1.invariant)(updateQuery, 83);
+            (0, invariant_1.invariant)(updateQuery, 80);
         }
         const { finalize, pushNotification } = this.pushOperation(networkStatus_js_1.NetworkStatus.fetchMore);
         pushNotification({
@@ -446,149 +443,109 @@ class ObservableQuery {
             kind: "N",
             value: {},
         }, { shouldEmit: 3 /* EmitBehavior.networkStatusChange */ });
-        const { promise, operator } = getTrackingOperatorPromise();
-        const { observable } = this.queryManager.fetchObservableWithInfo(combinedOptions, { networkStatus: networkStatus_js_1.NetworkStatus.fetchMore, exposeExtensions: true });
-        const subscription = observable
-            .pipe(operator, (0, rxjs_1.filter)((notification) => notification.kind === "N" && notification.source === "network"))
-            .subscribe({
-            next: (notification) => {
-                wasUpdated = false;
-                const fetchMoreResult = notification.value;
-                const extensions = fetchMoreResult[internal_1.extensionsSymbol];
-                if ((0, utilities_1.isNetworkRequestSettled)(notification.value.networkStatus)) {
-                    finalize();
-                }
-                if (isCached) {
-                    // Separately getting a diff here before the batch - `onWatchUpdated` might be
-                    // called with an `undefined` `lastDiff` on the watcher if the cache was just subscribed to.
-                    const lastDiff = this.getCacheDiff();
-                    // Performing this cache update inside a cache.batch transaction ensures
-                    // any affected cache.watch watchers are notified at most once about any
-                    // updates. Most watchers will be using the QueryInfo class, which
-                    // responds to notifications by calling reobserveCacheFirst to deliver
-                    // fetchMore cache results back to this ObservableQuery.
-                    this.cache.batch({
-                        update: (cache) => {
-                            if (updateQuery) {
-                                cache.updateQuery({
-                                    query: this.query,
-                                    variables: this.variables,
-                                    returnPartialData: true,
-                                    optimistic: false,
-                                    extensions,
-                                }, (previous) => updateQuery(previous, {
-                                    fetchMoreResult: fetchMoreResult.data,
-                                    variables: combinedOptions.variables,
-                                }));
-                            }
-                            else {
-                                // If we're using a field policy instead of updateQuery, the only
-                                // thing we need to do is write the new data to the cache using
-                                // combinedOptions.variables (instead of this.variables, which is
-                                // what this.updateQuery uses, because it works by abusing the
-                                // original field value, keyed by the original variables).
-                                cache.writeQuery({
-                                    query: combinedOptions.query,
-                                    variables: combinedOptions.variables,
-                                    data: fetchMoreResult.data,
-                                    extensions,
-                                });
-                            }
-                        },
-                        onWatchUpdated: (watch, diff) => {
-                            if (watch.watcher === this &&
-                                !(0, equality_1.equal)(diff.result, lastDiff.result)) {
-                                wasUpdated = true;
-                                const lastResult = this.getCurrentResult();
-                                // Let the cache watch from resubscribeCache handle the final
-                                // result
-                                if ((0, utilities_1.isNetworkRequestInFlight)(fetchMoreResult.networkStatus)) {
-                                    pushNotification({
-                                        kind: "N",
-                                        source: "network",
-                                        value: {
-                                            ...lastResult,
-                                            networkStatus: (fetchMoreResult.networkStatus ===
-                                                networkStatus_js_1.NetworkStatus.error) ?
-                                                networkStatus_js_1.NetworkStatus.ready
-                                                : fetchMoreResult.networkStatus,
-                                            // will be overwritten anyways, just here for types sake
-                                            loading: false,
-                                            data: diff.result,
-                                            dataState: fetchMoreResult.dataState === "streaming" ?
-                                                "streaming"
-                                                : "complete",
-                                        },
-                                    });
-                                }
-                            }
-                        },
-                    });
-                }
-                else {
-                    // There is a possibility `lastResult` may not be set when
-                    // `fetchMore` is called which would cause this to crash. This should
-                    // only happen if we haven't previously reported a result. We don't
-                    // quite know what the right behavior should be here since this block
-                    // of code runs after the fetch result has executed on the network.
-                    // We plan to let it crash in the meantime.
-                    //
-                    // If we get bug reports due to the `data` property access on
-                    // undefined, this should give us a real-world scenario that we can
-                    // use to test against and determine the right behavior. If we do end
-                    // up changing this behavior, this may require, for example, an
-                    // adjustment to the types on `updateQuery` since that function
-                    // expects that the first argument always contains previous result
-                    // data, but not `undefined`.
-                    const lastResult = this.getCurrentResult();
-                    const data = updateQuery(lastResult.data, {
-                        fetchMoreResult: fetchMoreResult.data,
-                        variables: combinedOptions.variables,
-                    });
-                    pushNotification({
-                        kind: "N",
-                        value: {
-                            ...lastResult,
-                            networkStatus: networkStatus_js_1.NetworkStatus.ready,
-                            // will be overwritten anyways, just here for types sake
-                            loading: false,
-                            data: data,
-                            dataState: lastResult.dataState === "streaming" ?
-                                "streaming"
-                                : "complete",
-                        },
-                        source: "network",
-                    });
-                }
-            },
-        });
-        return (0, internal_1.preventUnhandledRejection)(promise
-            .then((result) => (0, internal_1.toQueryResult)(this.maskResult(result)))
+        return this.queryManager
+            .fetchQuery(combinedOptions, networkStatus_js_1.NetworkStatus.fetchMore)
+            .then((fetchMoreResult) => {
+            // disable the `fetchMore` override that is currently active
+            // the next updates caused by this should not be `fetchMore` anymore,
+            // but `ready` or whatever other calculated loading state is currently
+            // appropriate
+            finalize();
+            if (isCached) {
+                // Separately getting a diff here before the batch - `onWatchUpdated` might be
+                // called with an `undefined` `lastDiff` on the watcher if the cache was just subscribed to.
+                const lastDiff = this.getCacheDiff();
+                // Performing this cache update inside a cache.batch transaction ensures
+                // any affected cache.watch watchers are notified at most once about any
+                // updates. Most watchers will be using the QueryInfo class, which
+                // responds to notifications by calling reobserveCacheFirst to deliver
+                // fetchMore cache results back to this ObservableQuery.
+                this.queryManager.cache.batch({
+                    update: (cache) => {
+                        if (updateQuery) {
+                            cache.updateQuery({
+                                query: this.query,
+                                variables: this.variables,
+                                returnPartialData: true,
+                                optimistic: false,
+                            }, (previous) => updateQuery(previous, {
+                                fetchMoreResult: fetchMoreResult.data,
+                                variables: combinedOptions.variables,
+                            }));
+                        }
+                        else {
+                            // If we're using a field policy instead of updateQuery, the only
+                            // thing we need to do is write the new data to the cache using
+                            // combinedOptions.variables (instead of this.variables, which is
+                            // what this.updateQuery uses, because it works by abusing the
+                            // original field value, keyed by the original variables).
+                            cache.writeQuery({
+                                query: combinedOptions.query,
+                                variables: combinedOptions.variables,
+                                data: fetchMoreResult.data,
+                            });
+                        }
+                    },
+                    onWatchUpdated: (watch, diff) => {
+                        if (watch.watcher === this &&
+                            !(0, equality_1.equal)(diff.result, lastDiff.result)) {
+                            wasUpdated = true;
+                        }
+                    },
+                });
+            }
+            else {
+                // There is a possibility `lastResult` may not be set when
+                // `fetchMore` is called which would cause this to crash. This should
+                // only happen if we haven't previously reported a result. We don't
+                // quite know what the right behavior should be here since this block
+                // of code runs after the fetch result has executed on the network.
+                // We plan to let it crash in the meantime.
+                //
+                // If we get bug reports due to the `data` property access on
+                // undefined, this should give us a real-world scenario that we can
+                // use to test against and determine the right behavior. If we do end
+                // up changing this behavior, this may require, for example, an
+                // adjustment to the types on `updateQuery` since that function
+                // expects that the first argument always contains previous result
+                // data, but not `undefined`.
+                const lastResult = this.getCurrentResult();
+                const data = updateQuery(lastResult.data, {
+                    fetchMoreResult: fetchMoreResult.data,
+                    variables: combinedOptions.variables,
+                });
+                // was reportResult
+                pushNotification({
+                    kind: "N",
+                    value: {
+                        ...lastResult,
+                        networkStatus: networkStatus_js_1.NetworkStatus.ready,
+                        // will be overwritten anyways, just here for types sake
+                        loading: false,
+                        data: data,
+                        dataState: lastResult.dataState === "streaming" ? "streaming" : "complete",
+                    },
+                    source: "network",
+                });
+            }
+            return this.maskResult(fetchMoreResult);
+        })
             .finally(() => {
-            subscription.unsubscribe();
+            // call `finalize` a second time in case the `.then` case above was not reached
             finalize();
+            // In case the cache writes above did not generate a broadcast
+            // notification (which would have been intercepted by onWatchUpdated),
+            // likely because the written data were the same as what was already in
+            // the cache, we still want fetchMore to deliver its final loading:false
+            // result with the unchanged data.
             if (isCached && !wasUpdated) {
-                const lastResult = this.getCurrentResult();
-                if (lastResult.dataState === "streaming") {
-                    pushNotification({
-                        kind: "N",
-                        source: "network",
-                        value: {
-                            ...lastResult,
-                            dataState: "complete",
-                            networkStatus: networkStatus_js_1.NetworkStatus.ready,
-                        },
-                    });
-                }
-                else {
-                    pushNotification({
-                        kind: "N",
-                        source: "newNetworkStatus",
-                        value: {},
-                    }, { shouldEmit: 1 /* EmitBehavior.force */ });
-                }
+                pushNotification({
+                    kind: "N",
+                    source: "newNetworkStatus",
+                    value: {},
+                }, { shouldEmit: 1 /* EmitBehavior.force */ });
             }
-        }));
+        });
     }
     // XXX the subscription variables are separate from the query variables.
     // if you want to update subscription variables, right now you have to do that separately,
@@ -614,7 +571,7 @@ class ObservableQuery {
                         onError(error);
                     }
                     else {
-                        invariant_1.invariant.error(84, error);
+                        invariant_1.invariant.error(81, error);
                     }
                     return;
                 }
@@ -692,7 +649,7 @@ class ObservableQuery {
             previousData: result,
         });
         if (newResult) {
-            this.cache.writeQuery({
+            queryManager.cache.writeQuery({
                 query: this.options.query,
                 data: newResult,
                 variables: this.variables,
@@ -858,7 +815,7 @@ class ObservableQuery {
                 if (!this.didWarnCacheOnlyPolling &&
                     pollInterval &&
                     fetchPolicy === "cache-only") {
-                    __DEV__ && invariant_1.invariant.warn(85, (0, internal_1.getOperationName)(this.query, "(anonymous)"));
+                    __DEV__ && invariant_1.invariant.warn(82, (0, internal_1.getOperationName)(this.query, "(anonymous)"));
                     this.didWarnCacheOnlyPolling = true;
                 }
             }
@@ -999,7 +956,15 @@ class ObservableQuery {
             this.cancelPolling();
         }
         this.resubscribeCache();
-        const { promise, operator: promiseOperator } = getTrackingOperatorPromise(
+        const { promise, operator: promiseOperator } = getTrackingOperatorPromise((value) => {
+            switch (value.kind) {
+                case "E":
+                    throw value.error;
+                case "N":
+                    if (value.source !== "newNetworkStatus" && !value.value.loading)
+                        return value.value;
+            }
+        }, 
         // This default value should only be used when using a `fetchPolicy` of
         // `standby` since that fetch policy completes without emitting a
         // result. Since we are converting this to a QueryResult type, we
@@ -1121,8 +1086,8 @@ class ObservableQuery {
         const { dirty } = this;
         this.resetNotifications();
         if (dirty &&
-            (this.options.fetchPolicy === "cache-only" ||
-                this.options.fetchPolicy === "cache-and-network" ||
+            (this.options.fetchPolicy == "cache-only" ||
+                this.options.fetchPolicy == "cache-and-network" ||
                 !this.activeOperations.size)) {
             const diff = this.getCacheDiff();
             if (
@@ -1353,13 +1318,13 @@ class ObservableQuery {
 exports.ObservableQuery = ObservableQuery;
 function logMissingFieldErrors(missing) {
     if (environment_1.__DEV__ && missing) {
-        __DEV__ && invariant_1.invariant.debug(86, missing);
+        __DEV__ && invariant_1.invariant.debug(83, missing);
     }
 }
 function isEqualQuery(a, b) {
     return !!(a && b && a.query === b.query && (0, equality_1.equal)(a.variables, b.variables));
 }
-function getTrackingOperatorPromise(defaultValue) {
+function getTrackingOperatorPromise(filterMapCb, defaultValue) {
     let lastValue = defaultValue, resolve, reject;
     const promise = new Promise((res, rej) => {
         resolve = res;
@@ -1367,13 +1332,14 @@ function getTrackingOperatorPromise(defaultValue) {
     });
     const operator = (0, rxjs_1.tap)({
         next(value) {
-            if (value.kind === "E") {
-                return reject(value.error);
+            try {
+                const newValue = filterMapCb(value);
+                if (newValue !== undefined) {
+                    lastValue = newValue;
+                }
             }
-            if (value.kind === "N" &&
-                value.source !== "newNetworkStatus" &&
-                !value.value.loading) {
-                lastValue = value.value;
+            catch (error) {
+                reject(error);
             }
         },
         finalize: () => {