Remove invariant forbidding cache-only FetchPolicy in refetch.

Fixes #6702.

src/core/ObservableQuery.ts

@@ -1,4 +1,4 @@
-import { invariant, InvariantError } from 'ts-invariant';
+import { invariant } from 'ts-invariant';
 import { equal } from '@wry/equality';
 
 import { NetworkStatus, isNetworkRequestInFlight } from './networkStatus';
@@ -223,14 +223,6 @@ export class ObservableQuery<
    * the previous values of those variables will be used.
    */
   public refetch(variables?: Partial<TVariables>): Promise<ApolloQueryResult<TData>> {
-    let { fetchPolicy } = this.options;
-    // early return if trying to read from cache during refetch
-    if (fetchPolicy === 'cache-only') {
-      return Promise.reject(new InvariantError(
-        'cache-only fetchPolicy option should not be used together with query refetch.',
-      ));
-    }
-
     const reobserveOptions: Partial<WatchQueryOptions<TVariables, TData>> = {
       // Always disable polling for refetches.
       pollInterval: 0,
@@ -239,6 +231,7 @@ 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' &&
         fetchPolicy !== 'cache-and-network') {
       reobserveOptions.fetchPolicy = 'network-only';

src/core/__tests__/fetchPolicies.ts

@@ -3,6 +3,7 @@ import gql from 'graphql-tag';
 import { ApolloClient, NetworkStatus } from '../../core';
 import { ApolloLink } from '../../link/core';
 import { InMemoryCache } from '../../cache';
+import { Observable } from '../../utilities';
 import {
   stripSymbols,
   subscribeAndCount,
@@ -439,6 +440,62 @@ describe('cache-first', () => {
   });
 });
 
+describe('cache-only', () => {
+  itAsync('allows explicit refetch to happen', (resolve, reject) => {
+    let counter = 0;
+    const client = new ApolloClient({
+      cache: new InMemoryCache,
+      link: new ApolloLink(operation => new Observable(observer => {
+        observer.next({
+          data: {
+            count: ++counter,
+          },
+        });
+        observer.complete();
+      })),
+    });
+
+    const query = gql`query { counter }`;
+
+    const observable = client.watchQuery({
+      query,
+      nextFetchPolicy: 'cache-only',
+    });
+
+    subscribeAndCount(reject, observable, (count, result) => {
+      if (count === 1) {
+        expect(result).toEqual({
+          loading: false,
+          networkStatus: NetworkStatus.ready,
+          data: {
+            count: 1,
+          },
+        });
+
+        expect(observable.options.fetchPolicy).toBe('cache-only');
+
+        observable.refetch().catch(reject);
+
+      } else if (count === 2) {
+        expect(result).toEqual({
+          loading: false,
+          networkStatus: NetworkStatus.ready,
+          data: {
+            count: 2,
+          },
+        });
+
+        expect(observable.options.fetchPolicy).toBe('cache-only');
+
+        setTimeout(resolve, 50);
+
+      } else {
+        reject(`too many results (${count})`);
+      }
+    });
+  });
+});
+
 describe('cache-and-network', function() {
   itAsync('gives appropriate networkStatus for refetched queries', (resolve, reject) => {
     const client = new ApolloClient({