Reset store returns a promise

AUTHORS

@@ -68,3 +68,4 @@ Andrew E. Rhyne <rhyneandrew@gmail.com>
 Miroslav Simulcik <simulcik.miro@gmail.com>
 Stephen Potter <me@stevepotter.me>
 Michaël De Boey <info@michaeldeboey.be>
+Andreas Bergenwall <abergenw@gmail.com>

CHANGELOG.md

@@ -1,8 +1,8 @@
 # Change log
 
 ### vNEXT
+- Make ApolloClient.resetStore() and QueryManager.resetStore() return a promise instead of void [PR #1674](https://github.com/apollographql/apollo-client/pull/1674)
 - Fix bug that caused errors in `writeToStore` to be rethrown as uncaught errors [PR #1673](https://github.com/apollographql/apollo-client/pull/1673)
-
 - Feature: Pass a function to `optimisticResponse` and it will be called with the `variables` passed to the mutation.
 
 ### 1.2.2

src/ApolloClient.ts

@@ -495,10 +495,8 @@ export default class ApolloClient implements DataProxy {
    * re-execute any queries then you should make sure to stop watching any
    * active queries.
    */
-  public resetStore() {
-    if (this.queryManager) {
-      this.queryManager.resetStore();
-    }
+  public resetStore(): Promise<ApolloQueryResult<any>[]>|null {
+    return this.queryManager ? this.queryManager.resetStore() : null;
   }
 
   public getInitialState(): { data: Object } {

src/core/QueryManager.ts

@@ -796,7 +796,7 @@ export class QueryManager {
     }
   }
 
-  public resetStore(): void {
+  public resetStore(): Promise<ApolloQueryResult<any>[]> {
     // Before we have sent the reset action to the store,
     // we can no longer rely on the results returned by in-flight
     // requests since these may depend on values that previously existed
@@ -819,15 +819,18 @@ export class QueryManager {
     // watched. If there is an existing query in flight when the store is reset,
     // the promise for it will be rejected and its results will not be written to the
     // store.
+    const observableQueryPromises: Promise<ApolloQueryResult<any>>[] = [];
     Object.keys(this.observableQueries).forEach((queryId) => {
       const storeQuery = this.reduxRootSelector(this.store.getState()).queries[queryId];
 
       const fetchPolicy = this.observableQueries[queryId].observableQuery.options.fetchPolicy;
 
       if (fetchPolicy !== 'cache-only' && fetchPolicy !== 'standby') {
-        this.observableQueries[queryId].observableQuery.refetch();
+        observableQueryPromises.push(this.observableQueries[queryId].observableQuery.refetch());
       }
     });
+
+    return Promise.all(observableQueryPromises);
   }
 
   public startQuery<T>(queryId: string, options: WatchQueryOptions, listener: QueryListener) {

test/QueryManager.ts

@@ -2343,6 +2343,98 @@ describe('QueryManager', () => {
   });
 
   describe('store resets', () => {
+    it('returns a promise resolving when all queries have been refetched', () => {
+      const query = gql`
+        query {
+          author {
+            firstName
+            lastName
+          }
+        }`;
+
+      const data = {
+        author: {
+          firstName: 'John',
+          lastName: 'Smith',
+        },
+      };
+
+      const dataChanged = {
+        author: {
+          firstName: 'John changed',
+          lastName: 'Smith',
+        },
+      };
+
+      const query2 = gql`
+        query {
+          author2 {
+            firstName
+            lastName
+          }
+        }`;
+
+      const data2 = {
+        author2: {
+          firstName: 'John',
+          lastName: 'Smith',
+        },
+      };
+
+      const data2Changed = {
+        author2: {
+          firstName: 'John changed',
+          lastName: 'Smith',
+        },
+      };
+
+      const queryManager = createQueryManager({
+        networkInterface: mockNetworkInterface(
+          {
+            request: {query},
+            result: {data},
+          },
+          {
+            request: {query: query2},
+            result: {data: data2},
+          },
+          {
+            request: {query},
+            result: {data: dataChanged},
+          },
+          {
+            request: {query: query2},
+            result: {data: data2Changed},
+          },
+        ),
+      });
+
+      const observable = queryManager.watchQuery<any>({ query });
+      const observable2 = queryManager.watchQuery<any>({ query: query2 });
+
+      return Promise.all([
+        observableToPromise({ observable },
+          result => assert.deepEqual(result.data, data),
+        ),
+        observableToPromise({ observable: observable2 },
+          result => assert.deepEqual(result.data, data2),
+        ),
+      ]).then(() => {
+        observable.subscribe({ next: () => null });
+        observable2.subscribe({ next: () => null });
+
+        return queryManager.resetStore().then(() => {
+          const result = queryManager.getCurrentQueryResult(observable);
+          assert.isFalse(result.partial);
+          assert.deepEqual(result.data, dataChanged);
+
+          const result2 = queryManager.getCurrentQueryResult(observable2);
+          assert.isFalse(result2.partial);
+          assert.deepEqual(result2.data, data2Changed);
+        });
+      });
+    });
+
     it('should change the store state to an empty state', () => {
       const queryManager = createQueryManager({});