Improvements to options.nextFetchPolicy.

CHANGELOG.md

@@ -5,11 +5,17 @@
 - Check structural equality of diff results in `QueryInfo#setDiff` instead of reference equality. <br/>
   [@benjamn](https://github.com/benjamn) in [#6891](https://github.com/apollographql/apollo-client/pull/6891)
 
+- Use `options.nextFetchPolicy` internally to restore original `FetchPolicy` after polling with `fetchPolicy: "network-only"`, so that polling does not interfere with normal query watching. <br/>
+  [@benjamn](https://github.com/benjamn) in [#6893](https://github.com/apollographql/apollo-client/pull/6893)
+
 ## Improvements
 
 - Substantially improve type inference for data and variables types using `TypedDocumentNode<Data, Variables>` type instead of `DocumentNode`. <br/>
   [@dotansimha](https://github.com/dotansimha) in [#6720](https://github.com/apollographql/apollo-client/pull/6720)
 
+- Allow `options.nextFetchPolicy` to be a function that takes the current `FetchPolicy` and returns a new (or the same) `FetchPolicy`, making `nextFetchPolicy` more suitable for global use in `defaultOptions.watchQuery`. <br/>
+  [@benjamn](https://github.com/benjamn) in [#6893](https://github.com/apollographql/apollo-client/pull/6893)
+
 - Disable feud-stopping logic after any cache eviction. <br/>
   [@benjamn](https://github.com/benjamn) in [#6817](https://github.com/apollographql/apollo-client/pull/6817)
 

src/__tests__/client.ts

@@ -3164,6 +3164,96 @@ describe('@connection', () => {
       });
     });
 
+    itAsync('allows setting nextFetchPolicy in defaultOptions', (resolve, reject) => {
+      let networkCounter = 0;
+      let nextFetchPolicyCallCount = 0;
+
+      const client = new ApolloClient({
+        link: new ApolloLink(operation => new Observable(observer => {
+          observer.next({
+            data: {
+              count: networkCounter++,
+            },
+          });
+          observer.complete();
+        })),
+
+        cache: new InMemoryCache,
+
+        defaultOptions: {
+          watchQuery: {
+            nextFetchPolicy(fetchPolicy) {
+              expect(++nextFetchPolicyCallCount).toBe(1);
+              expect(this.query).toBe(query);
+              expect(fetchPolicy).toBe("cache-first");
+              // Usually options.nextFetchPolicy applies only once, but a
+              // nextFetchPolicy function can set this.nextFetchPolicy
+              // again to perform an additional transition.
+              this.nextFetchPolicy = fetchPolicy => {
+                ++nextFetchPolicyCallCount;
+                expect(fetchPolicy).toBe("cache-and-network");
+                return "cache-first";
+              };
+              return "cache-and-network";
+            },
+          },
+        },
+      });
+
+      const query = gql`
+        query {
+          count
+        }
+      `;
+
+      client.writeQuery({
+        query,
+        data: {
+          count: "initial",
+        },
+      });
+
+      const obs = client.watchQuery({ query });
+
+      subscribeAndCount(reject, obs, (handleCount, result) => {
+        if (handleCount === 1) {
+          expect(nextFetchPolicyCallCount).toBe(1);
+          expect(result.data).toEqual({ count: "initial" });
+          // Refetching makes a copy of the current options, which
+          // includes options.nextFetchPolicy, so the inner
+          // nextFetchPolicy function ends up getting called twice.
+          obs.refetch();
+        } else if (handleCount === 2) {
+          expect(result.data).toEqual({ count: "initial" });
+          expect(nextFetchPolicyCallCount).toBe(2);
+        } else if (handleCount === 3) {
+          expect(result.data).toEqual({ count: 0 });
+          expect(nextFetchPolicyCallCount).toBe(2);
+          client.writeQuery({
+            query,
+            data: {
+              count: "secondary",
+            },
+          });
+        } else if (handleCount === 4) {
+          expect(result.data).toEqual({ count: "secondary" });
+          expect(nextFetchPolicyCallCount).toBe(3);
+        } else if (handleCount === 5) {
+          expect(result.data).toEqual({ count: 1 });
+          expect(nextFetchPolicyCallCount).toBe(3);
+          client.cache.evict({ fieldName: "count" });
+        } else if (handleCount === 6) {
+          expect(result.data).toEqual({ count: 2 });
+          expect(nextFetchPolicyCallCount).toBe(3);
+          expect(obs.options.fetchPolicy).toBe("cache-first");
+          expect(obs.options.nextFetchPolicy).toBeUndefined();
+          setTimeout(resolve, 50);
+        } else {
+          reject("too many results");
+        }
+      });
+    });
+
     itAsync('allows setting default options for query', (resolve, reject) => {
       const errors = [{ message: 'failure', name: 'failure' }];
       const link = mockSingleLink({

src/core/ObservableQuery.ts

@@ -238,7 +238,7 @@ export class ObservableQuery<
         fetchPolicy !== 'cache-and-network') {
       reobserveOptions.fetchPolicy = 'network-only';
       // Go back to the original options.fetchPolicy after this refetch.
-      reobserveOptions.nextFetchPolicy = fetchPolicy;
+      reobserveOptions.nextFetchPolicy = fetchPolicy || "cache-first";
     }
 
     if (variables && !equal(this.options.variables, variables)) {
@@ -436,16 +436,22 @@ once, rather than every time you call fetchMore.`);
     }
 
     let { fetchPolicy = 'cache-first' } = this.options;
+    const reobserveOptions: Partial<WatchQueryOptions<TVariables, TData>> = {
+      fetchPolicy,
+      variables,
+    };
+
     if (fetchPolicy !== 'cache-first' &&
         fetchPolicy !== 'no-cache' &&
         fetchPolicy !== 'network-only') {
-      fetchPolicy = 'cache-and-network';
+      reobserveOptions.fetchPolicy = 'cache-and-network';
+      reobserveOptions.nextFetchPolicy = fetchPolicy;
     }
 
-    return this.reobserve({
-      fetchPolicy,
-      variables,
-    }, NetworkStatus.setVariables);
+    return this.reobserve(
+      reobserveOptions,
+      NetworkStatus.setVariables,
+    );
   }
 
   public updateQuery<TVars = TVariables>(

src/core/QueryManager.ts

@@ -909,7 +909,13 @@ export class QueryManager<TStore> {
     concast.cleanup(() => {
       this.fetchCancelFns.delete(queryId);
 
-      if (options.nextFetchPolicy) {
+      const { nextFetchPolicy } = options;
+      if (nextFetchPolicy) {
+        // The options.nextFetchPolicy transition should happen only once,
+        // but it should be possible for a nextFetchPolicy function to set
+        // this.nextFetchPolicy to perform an additional transition.
+        options.nextFetchPolicy = void 0;
+
         // When someone chooses cache-and-network or network-only as their
         // initial FetchPolicy, they often do not want future cache updates to
         // trigger unconditional network requests, which is what repeatedly
@@ -920,9 +926,9 @@ export class QueryManager<TStore> {
         // The options.nextFetchPolicy option provides an easy way to update
         // options.fetchPolicy after the intial network request, without
         // having to call observableQuery.setOptions.
-        options.fetchPolicy = options.nextFetchPolicy;
-        // The options.nextFetchPolicy transition should happen only once.
-        options.nextFetchPolicy = void 0;
+        options.fetchPolicy = typeof nextFetchPolicy === "function"
+          ? nextFetchPolicy.call(options, options.fetchPolicy || "cache-first")
+          : nextFetchPolicy;
       }
     });
 

src/core/Reobserver.ts

@@ -133,6 +133,7 @@ export class Reobserver<TData, TVars> {
         if (this.shouldFetch && this.shouldFetch()) {
           this.reobserve({
             fetchPolicy: "network-only",
+            nextFetchPolicy: this.options.fetchPolicy || "cache-first",
           }, NetworkStatus.poll).then(poll, poll);
         } else {
           poll();

src/core/watchQueryOptions.ts

@@ -115,7 +115,10 @@ export interface WatchQueryOptions<TVariables = OperationVariables, TData = any>
   /**
    * Specifies the {@link FetchPolicy} to be used after this query has completed.
    */
-  nextFetchPolicy?: WatchQueryFetchPolicy;
+  nextFetchPolicy?: WatchQueryFetchPolicy | ((
+    this: WatchQueryOptions<TVariables, TData>,
+    lastFetchPolicy: WatchQueryFetchPolicy,
+  ) => WatchQueryFetchPolicy);
 }
 
 export interface FetchMoreQueryOptions<TVariables, K extends keyof TVariables, TData = any> {