Expose a way to read an object given an id

src/data/readFromStore.ts

@@ -17,9 +17,28 @@ import {
   NormalizedCache,
 } from './store';
 
-// import {
-//   printAST,
-// } from './debug';
+// Read an object from the store given that object's id.
+// This function performs a deep read, i.e. it will read the fields of the object
+// from the normalized store structure as well.
+export function readObjectByIdFromStore({
+  store,
+  id,
+  fragment,
+  variables,
+}: {
+  store: NormalizedCache,
+  id: string,
+  fragment: Document,
+  variables?: Object,
+}): any {
+  return readFragmentFromStore({
+    store,
+    fragment,
+    rootId: id,
+    variables,
+  });
+}
+
 
 export function readQueryFromStore({
   store,

src/index.ts

@@ -28,6 +28,10 @@ import {
   ApolloReducerConfig,
 } from './store';
 
+import {
+  readObjectByIdFromStore,
+} from './data/readFromStore';
+
 import {
   QueryManager,
 } from './QueryManager';
@@ -294,6 +298,17 @@ export default class ApolloClient {
     }));
   };
 
+  // Given a particular id, this method returns a deep read in the normalized
+  // store starting from that id. The `fragment` is used to select the fields of the
+  // object with the given id that will be returned.
+  public readObjectById(id: string, fragment: Document) {
+    return readObjectByIdFromStore({
+      store: this.store.getState().apollo.data,
+      id,
+      fragment,
+    });
+  }
+
   private setStore = (store: ApolloStore) => {
     // ensure existing store has apolloReducer
     if (isUndefined(store.getState()[this.reduxRootKey])) {

test/client.ts

@@ -1,6 +1,7 @@
 import * as chai from 'chai';
 const { assert } = chai;
 import * as sinon from 'sinon';
+import * as _ from 'lodash';
 
 import ApolloClient, {
   createFragment,
@@ -15,6 +16,7 @@ import {
   GraphQLError,
   OperationDefinition,
   GraphQLResult,
+  Document,
 } from 'graphql';
 
 import {
@@ -1594,4 +1596,135 @@ describe('client', () => {
       done();
     });
   });
+
+  describe('read by id', () => {
+    const setupClient = (primeQuery: Document, primeResult: Object) => {
+      return new ApolloClient({
+        networkInterface: mockNetworkInterface({
+          request: { query: primeQuery },
+          result: { data: primeResult },
+        }),
+      });
+    };
+
+    it('should be able to read an object from the store by its id', (done) => {
+      const primeQuery = gql`
+        query {
+          person {
+            name
+          }
+        }`;
+      const primeResult = {
+        person: {
+          name: 'John Smith',
+        },
+      };
+      const client = setupClient(primeQuery, primeResult);
+      client.query({ query: primeQuery }).then((result) => {
+        const person = client.readObjectById('$ROOT_QUERY.person', gql`
+          fragment details on Person {
+            name
+          }`);
+        assert.deepEqual(person, primeResult.person);
+        done();
+      });
+    });
+
+    it('should be able to limit the fields it reads from the store by id', (done) => {
+      const primeQuery = gql`
+        query {
+          person {
+            firstName
+            lastName
+          }
+        }`;
+      const primeResult = {
+        person: {
+          firstName: 'John',
+          lastName: 'Smith',
+        },
+      };
+      const client = setupClient(primeQuery, primeResult);
+      client.query({ query: primeQuery }).then((result) => {
+        const person = client.readObjectById('$ROOT_QUERY.person', gql`
+          fragment details on Person {
+            firstName
+          }`);
+        assert.deepEqual(person, _.omit(primeResult.person, 'lastName'));
+        done();
+      });
+    });
+
+    it('should be able to pick data from multiple past writes', (done) => {
+      const primeQuery = gql`
+        query {
+          person {
+            name
+            friend(id: 1) {
+              name
+            }
+          }
+        }`;
+
+      const primeResult = {
+        person: {
+          name: 'John Smith',
+          friend: {
+            name: 'Jane Smith',
+          },
+        },
+      };
+      const secondaryQuery = gql`
+        query {
+          person {
+            name
+            friend(id: 2) {
+              name
+            }
+          }
+        }`;
+      const secondaryResult = {
+        person: {
+          name: 'John Smith',
+          friend: {
+            name: 'Jack Smith',
+          },
+        },
+      };
+      const client = new ApolloClient({
+        networkInterface: mockNetworkInterface(
+          {
+            request: { query: primeQuery },
+            result: { data: primeResult },
+          },
+          {
+            request: { query: secondaryQuery },
+            result: { data: secondaryResult },
+          }
+        ),
+      });
+      client.query({ query: primeQuery }).then(() => {
+        client.query({ query: secondaryQuery }).then(() => {
+          let person = client.readObjectById('$ROOT_QUERY.person', gql`
+            fragment details on Person {
+              name
+              friend(id: 2) {
+                name
+              }
+            }`);
+          assert.deepEqual(person, secondaryResult.person);
+
+          person = client.readObjectById('$ROOT_QUERY.person', gql`
+            fragment details on Person {
+              name
+              friend(id: 1) {
+                name
+              }
+            }`);
+          assert.deepEqual(person, primeResult.person);
+          done();
+        });
+      });
+    });
+  });
 });