Local fetch option in WatchQueryOptions

CHANGELOG.md

@@ -4,6 +4,7 @@ Expect active development and potentially significant breaking changes in the `0
 
 ### vNEXT
 
+- Added a "noFetch" option to WatchQueryOptions that only returns available data from the local store (even it is incomplete). [Issue #225] https://github.com/apollostack/apollo-client/issues/225 and [PR #385]
 - **Breaking change** Moved refetch(), startPolling(), and stopPolling() methods from QuerySubscription to ObservableQuery. This shouldn't affect anyone using `react-apollo`, but if you were calling those methods on the subscription directly, you need to call them on the query handle/observable instead. The benefit of this is that developers that want to use RxJS for their observable handling can now have access to these methods. [Issue #194] (https://github.com/apollostack/apollo-client/issues/194) and [PR #362] (https://github.com/apollostack/apollo-client/pull/362)
 - **Breaking change** Unified error handling for GraphQL errors and network errors. Both now result in rejected promises and passed as errors on observables through a new `ApolloError` type. This is a significant departure from the previous method of error handling which passed GraphQL errors in resolvers and `next` methods on subscriptions. [PR #352](https://github.com/apollostack/apollo-client/pull/352)
 

src/QueryManager.ts

@@ -118,6 +118,7 @@ export interface WatchQueryOptions {
   variables?: { [key: string]: any };
   forceFetch?: boolean;
   returnPartialData?: boolean;
+  noFetch?: boolean;
   pollInterval?: number;
   fragments?: FragmentDefinition[];
 }
@@ -308,6 +309,7 @@ export class QueryManager {
             selectionSet: queryStoreValue.query.selectionSet,
             variables: queryStoreValue.variables,
             returnPartialData: options.returnPartialData,
+            noFetch: options.noFetch,
             fragmentMap: queryStoreValue.fragmentMap,
           });
 
@@ -355,6 +357,7 @@ export class QueryManager {
         this.queryListenerForObserver(options, observer)
       );
 
+
       return retQuerySubscription;
     };
 
@@ -364,7 +367,7 @@ export class QueryManager {
 
       // Use the same options as before, but with new variables and forceFetch true
       return this.fetchQuery(queryId, assign(options, {
-        forceFetch: true,
+        forceFetch: options.noFetch ? false : true,
         variables,
       }) as WatchQueryOptions);
     };
@@ -379,7 +382,7 @@ export class QueryManager {
       this.pollingTimers[queryId] = setInterval(() => {
         const pollingOptions = assign({}, options) as WatchQueryOptions;
         // subsequent fetches from polling always reqeust new data
-        pollingOptions.forceFetch = true;
+        pollingOptions.forceFetch = options.noFetch ? false : true;
         this.fetchQuery(queryId, pollingOptions);
       }, pollInterval);
     };
@@ -520,6 +523,7 @@ export class QueryManager {
       variables,
       forceFetch = false,
       returnPartialData = false,
+      noFetch = false,
       fragments = [],
     } = options;
 
@@ -566,7 +570,7 @@ export class QueryManager {
 
       initialResult = result;
 
-      if (missingSelectionSets && missingSelectionSets.length) {
+      if (missingSelectionSets && missingSelectionSets.length && !noFetch) {
         const diffedQuery = queryDocument({
           missingSelectionSets,
           variableDefinitions: queryDef.variableDefinitions,
@@ -602,12 +606,13 @@ export class QueryManager {
       variables,
       forceFetch,
       returnPartialData,
+      noFetch,
       queryId,
       requestId,
       fragmentMap: queryFragmentMap,
     });
 
-    if (! minimizedQuery || returnPartialData) {
+    if (! minimizedQuery || returnPartialData || noFetch) {
       this.store.dispatch({
         type: 'APOLLO_QUERY_RESULT_CLIENT',
         result: {
@@ -666,6 +671,7 @@ export class QueryManager {
                 selectionSet: querySS.selectionSet,
                 variables,
                 returnPartialData: returnPartialData,
+                noFetch: noFetch,
                 fragmentMap: queryFragmentMap,
               });
               // ensure multiple errors don't get thrown
@@ -701,6 +707,9 @@ export class QueryManager {
 
   private startQuery(queryId: string, options: WatchQueryOptions, listener: QueryListener) {
     this.queryListeners[queryId] = listener;
+    if (options.noFetch) {
+      options.pollInterval = null;
+    }
     this.fetchQuery(queryId, options);
 
     if (options.pollInterval) {

src/actions.ts

@@ -43,6 +43,7 @@ export interface QueryInitAction {
   variables: Object;
   forceFetch: boolean;
   returnPartialData: boolean;
+  noFetch: boolean;
   queryId: string;
   requestId: number;
   fragmentMap: FragmentMap;

src/data/readFromStore.ts

@@ -26,11 +26,13 @@ export function readQueryFromStore({
   query,
   variables,
   returnPartialData,
+  noFetch,
 }: {
   store: NormalizedCache,
   query: Document,
   variables?: Object,
   returnPartialData?: boolean,
+  noFetch?: boolean,
 }): Object {
   const queryDef = getQueryDefinition(query);
 
@@ -40,6 +42,7 @@ export function readQueryFromStore({
     selectionSet: queryDef.selectionSet,
     variables,
     returnPartialData,
+    noFetch,
   });
 }
 
@@ -49,12 +52,14 @@ export function readFragmentFromStore({
   rootId,
   variables,
   returnPartialData,
+  noFetch,
 }: {
   store: NormalizedCache,
   fragment: Document,
   rootId: string,
   variables?: Object,
   returnPartialData?: boolean,
+  noFetch?: boolean,
 }): Object {
   const fragmentDef = getFragmentDefinition(fragment);
 
@@ -64,6 +69,7 @@ export function readFragmentFromStore({
     selectionSet: fragmentDef.selectionSet,
     variables,
     returnPartialData,
+    noFetch,
   });
 }
 
@@ -73,13 +79,15 @@ export function readSelectionSetFromStore({
   selectionSet,
   variables,
   returnPartialData = false,
+  noFetch = false,
   fragmentMap,
 }: {
   store: NormalizedCache,
   rootId: string,
   selectionSet: SelectionSet,
   variables: Object,
   returnPartialData?: boolean,
+  noFetch?: boolean,
   fragmentMap?: FragmentMap,
 }): Object {
   const {
@@ -88,7 +96,7 @@ export function readSelectionSetFromStore({
     selectionSet,
     rootId,
     store,
-    throwOnMissingField: !returnPartialData,
+    throwOnMissingField: !returnPartialData && !noFetch,
     variables,
     fragmentMap,
   });

src/queries/store.ts

@@ -39,6 +39,7 @@ export interface QueryStoreValue {
   graphQLErrors: GraphQLError[];
   forceFetch: boolean;
   returnPartialData: boolean;
+  noFetch: boolean;
   lastRequestId: number;
   fragmentMap: FragmentMap;
 }
@@ -70,6 +71,7 @@ export function queries(
       graphQLErrors: null,
       forceFetch: action.forceFetch,
       returnPartialData: action.returnPartialData,
+      noFetch: action.noFetch,
       lastRequestId: action.requestId,
       fragmentMap: action.fragmentMap,
     };

test/QueryManager.ts

@@ -967,6 +967,150 @@ describe('QueryManager', () => {
     });
   });
 
+  it('supports noFetch fetching only cached data', () => {
+    const primeQuery = gql`
+      query primeQuery {
+        luke: people_one(id: 1) {
+          name
+        }
+      }
+    `;
+
+    const complexQuery = gql`
+      query complexQuery {
+        luke: people_one(id: 1) {
+          name
+        }
+        vader: people_one(id: 4) {
+          name
+        }
+      }
+    `;
+
+    const data1 = {
+      luke: {
+        name: 'Luke Skywalker',
+      },
+    };
+
+    const data2 = {
+      luke: {
+        name: 'Luke Skywalker',
+      },
+      vader: {
+        name: 'Darth Vader',
+      },
+    };
+
+    const networkInterface = mockNetworkInterface(
+      {
+        request: { query: primeQuery },
+        result: { data: data1 },
+      },
+      {
+        request: { query: complexQuery },
+        result: { data: data2 },
+      }
+    );
+
+    const queryManager = new QueryManager({
+      networkInterface,
+      store: createApolloStore(),
+      reduxRootKey: 'apollo',
+    });
+
+    // First, prime the cache
+    queryManager.query({
+      query: primeQuery,
+    }).then(() => {
+      const handle = queryManager.watchQuery({
+        query: complexQuery,
+        noFetch: true,
+      });
+
+      return handle.result().then((result) => {
+        assert.equal(result.data['luke'].name, 'Luke Skywalker');
+        assert.notProperty(result.data, 'vader');
+      });
+    });
+  });
+
+  it('supports noFetch refetching only cached data', () => {
+    const primeQuery = gql`
+      query primeQuery {
+        luke: people_one(id: 1) {
+          name
+        }
+      }
+    `;
+
+    const complexQuery = gql`
+      query complexQuery {
+        luke: people_one(id: 1) {
+          name
+        }
+        vader: people_one(id: 4) {
+          name
+        }
+      }
+    `;
+
+    const data1 = {
+      luke: {
+        name: 'Luke Skywalker',
+      },
+    };
+
+    const data2 = {
+      luke: {
+        name: 'Luke Skywalker',
+      },
+      vader: {
+        name: 'Darth Vader',
+      },
+    };
+
+    const networkInterface = mockNetworkInterface(
+      {
+        request: { query: primeQuery },
+        result: { data: data1 },
+      },
+      {
+        request: { query: complexQuery },
+        result: { data: data2 },
+      }
+    );
+
+    const queryManager = new QueryManager({
+      networkInterface,
+      store: createApolloStore(),
+      reduxRootKey: 'apollo',
+    });
+
+    // First, prime the cache
+    queryManager.query({
+      query: primeQuery,
+    }).then(() => {
+      const handle = queryManager.watchQuery({
+        query: complexQuery,
+        noFetch: true,
+      });
+      let handleCount = 0;
+      handle.subscribe({
+        next(result) {
+          handleCount++;
+
+          if (handleCount === 1) {
+            assert.deepEqual(result.data, data1);
+            handle.refetch();
+          } else if (handleCount === 2) {
+            assert.deepEqual(result.data, data1);
+          }
+        },
+      });
+    });
+  });
+
   it('runs a mutation', () => {
     const mutation = gql`
       mutation makeListPrivate {

test/client.ts

@@ -344,6 +344,7 @@ describe('client', () => {
             forceFetch: false,
             fragmentMap: {},
             returnPartialData: false,
+            noFetch: false,
             lastRequestId: 1,
           },
         },

test/readFromStore.ts

@@ -376,6 +376,31 @@ describe('reading from the store', () => {
     }, /field missingField on object/);
   });
 
+  it('does not throw on a missing field if noFetch is true', () => {
+    const result = {
+      id: 'abcd',
+      stringField: 'This is a string!',
+      numberField: 5,
+      nullField: null,
+    } as StoreObject;
+
+    const store = { abcd: result } as NormalizedCache;
+
+    assert.doesNotThrow(() => {
+      readFragmentFromStore({
+        store,
+        fragment: gql`
+          fragment FragmentName on Item {
+            stringField,
+            missingField
+          }
+        `,
+        rootId: 'abcd',
+        noFetch: true,
+      });
+    }, /field missingField on object/);
+  });
+
   it('runs a nested fragment where the reference is null', () => {
     const result = {
       id: 'abcd',