Fix caching (#413)

* try to fix caching test (?)

* also fix typo in test

* cache tweeks, better test, trying to find cause of error

* fix another query

* version number 0.2.60

Author: jellegerbrandy

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "@daostack/client",
-  "version": "0.2.59",
+  "version": "0.2.60",
   "description": "",
   "keywords": [],
   "main": "dist/lib/index.js",
@@ -102,8 +102,8 @@
     "u": "^0.1.0"
   },
   "dependencies": {
-    "apollo-cache-inmemory": "^1.6.2",
-    "apollo-client": "^2.6.3",
+    "apollo-cache-inmemory": "^1.6.5",
+    "apollo-client": "^2.6.8",
     "apollo-client-ws": "^2.5.0",
     "apollo-link-error": "^1.1.12",
     "apollo-link-http": "^1.5.15",

package.json

@@ -98,15 +98,15 @@ export function createApolloClient(options: {
   const cache = new InMemoryCache({
     cacheRedirects: {
       Query: {
-        // competition: (_, args, { getCacheKey }) => {
-        //   return getCacheKey({ __typename: 'CompetitionProposal', id: args.id })
-        // },
         competitionProposal: (_, args, { getCacheKey }) => {
           return getCacheKey({ __typename: 'CompetitionProposal', id: args.id })
         },
         competitionSuggestion: (_, args, { getCacheKey }) => {
           return getCacheKey({ __typename: 'CompetitionSuggestion', id: args.id })
         },
+        // suggestion: (_, args, { getCacheKey }) => {
+        //   return getCacheKey({ __typename: 'CompetitionSuggestion', id: args.id })
+        // },
         competitionVote: (_, args, { getCacheKey }) => {
           return getCacheKey({ __typename: 'CompetitionVote', id: args.id })
         },
@@ -134,8 +134,7 @@ export function createApolloClient(options: {
       switch (object.__typename) {
         case 'ProposalVote': return undefined
         case 'ProposalStake': return undefined
-        case 'CompetitionSuggestion': return undefined
-        case 'CompetitionVote': return undefined
+        // case 'CompetitionVote': return undefined
         default: return defaultDataIdFromObject(object) // fall back to default handling
       }
     }

src/graphnode.ts

@@ -303,7 +303,7 @@ export class Scheme extends SchemeBase  {
   }
 
   public state(apolloQueryOptions: IApolloQueryOptions = {}): Observable<ISchemeState> {
-    const query = gql`query SchemeState
+    const query = gql`query SchemeStateById
       {
         controllerScheme (id: "${this.id}") {
           ...SchemeFields

src/scheme.ts

@@ -83,7 +83,7 @@ export interface ICompetitionVoteState {
 
 export class CompetitionScheme extends SchemeBase {
   public state(apolloQueryOptions: IApolloQueryOptions = {}): Observable<ISchemeState> {
-    const query = gql`query SchemeState
+    const query = gql`query SchemeStateById
       {
         controllerScheme (id: "${this.id}") {
           ...SchemeFields
@@ -486,6 +486,9 @@ export class Competition { // extends Proposal {
     const observable = proposal.state().pipe(
       first(),
       concatMap((competitionState: IProposalState) => {
+        if (competitionState === null) {
+          throw Error(`Cannot vote on this suggestion, because the competition with id ${this.id} could not be foound`)
+        }
         const scheme = new CompetitionScheme(competitionState.scheme, this.context)
         return scheme.voteSuggestion({ suggestionId })
       })
@@ -541,7 +544,7 @@ export class CompetitionSuggestion implements IStateful<ICompetitionSuggestionSt
       id
       suggestionId
       proposal {
-        id
+       id
       }
       descriptionHash
       title
@@ -689,7 +692,7 @@ constructor(
   }
 
   public state(apolloQueryOptions: IApolloQueryOptions = {}): Observable < ICompetitionSuggestionState > {
-    const query = gql`query SchemeState
+    const query = gql`query CompetitionSuggestionById
       {
         competitionSuggestion (id: "${this.id}") {
           ...CompetitionSuggestionFields
@@ -783,6 +786,7 @@ export class CompetitionVote implements IStateful<ICompetitionVoteState> {
       query = gql`query CompetitionVoteSearchBySuggestion
         {
           competitionSuggestion (id: "${options.where.suggestion}") {
+            id
             votes ${createGraphQlQuery({ where: { ...options.where, suggestion: undefined}})} {
               ...CompetitionVoteFields
             }

src/schemes/competition.ts

@@ -710,41 +710,90 @@ describe('Competition Proposal', () => {
     arc.setAccount(address0)
   })
 
-  // TODO!! unskip this test. It passes locally but fails often (but not always) on travis :-(
-  it.skip('pre-fetching competition.suggestions works', async () => {
+  it('pre-fetching competition.suggestions works', async () => {
     // find a proposal in a scheme that has > 1 votes
     const competition =  await createCompetition()
     // check if the competition has indeed some suggestions
 
     const suggestions = await competition.suggestions().pipe(first()).toPromise()
     expect(suggestions.length).toBeGreaterThan(0)
 
-    // now we have our objects, reset the cache
+      // now we have our objects, reset the cache
     await (arc.apolloClient as any).cache.reset()
     expect((arc.apolloClient as any).cache.data.data).toEqual({})
 
-    // // construct our superquery that will fill the cache
+      // // construct our superquery that will fill the cache
     const query = gql`query {
-      proposals (where: { id: "${competition.id}"}) {
-        competition {
+        proposals (where: { id: "${competition.id}"}) {
+          ...ProposalFields
           id
-          suggestions { ...CompetitionSuggestionFields }
+          competition {
+            id
+            suggestions {
+              ...CompetitionSuggestionFields
+              }
+          }
         }
-        ...ProposalFields
       }
-    }
-    ${Proposal.fragments.ProposalFields}
-    ${Scheme.fragments.SchemeFields}
-    ${CompetitionSuggestion.fragments.CompetitionSuggestionFields}
-    `
+      ${Proposal.fragments.ProposalFields}
+      ${Scheme.fragments.SchemeFields}
+      ${CompetitionSuggestion.fragments.CompetitionSuggestionFields}
+      `
 
     await arc.sendQuery(query)
 
-    // now see if we can get our informatino directly from the cache
-    const cachedSugestions = await competition.suggestions({}, { fetchPolicy: 'cache-only'})
-      .pipe(first()).toPromise()
-    expect(cachedSugestions.map((v: CompetitionSuggestion) => v.id))
-      .toEqual(suggestions.map((v: CompetitionSuggestion) => v.id))
+      // now see if we can get our informatino directly from the cache
+    const cachedSuggestions = await competition.suggestions({}, { fetchPolicy: 'cache-only'})
+        .pipe(first()).toPromise()
+    expect(cachedSuggestions.map((v: CompetitionSuggestion) => v.id))
+        .toEqual(suggestions.map((v: CompetitionSuggestion) => v.id))
+
+    const cachedSuggestionState = await cachedSuggestions[0]
+      .state({ fetchPolicy: 'cache-only'}).pipe(first()).toPromise()
+    expect(cachedSuggestionState.id).toEqual(cachedSuggestions[0].id)
+
+  })
+
+  it('pre-fetching competition.suggestions works also without resetting the cache', async () => {
+    // find a proposal in a scheme that has > 1 votes
+    const competition =  await createCompetition()
+    // check if the competition has indeed some suggestions
+
+    const suggestions = await competition.suggestions().pipe(first()).toPromise()
+    expect(suggestions.length).toBeGreaterThan(0)
+
+    // add some exiting data to the cache to seeif we can mess things up
+    await  arc.proposal(competition.id).state().pipe(first()).toPromise()
+
+    // construct our superquery that will fill the cache
+    const query = gql`query {
+        proposals (where: { id: "${competition.id}"}) {
+          # id
+          ...ProposalFields
+          competition {
+            id
+            suggestions {
+              ...CompetitionSuggestionFields
+              }
+          }
+        }
+      }
+      ${Proposal.fragments.ProposalFields}
+      ${Scheme.fragments.SchemeFields}
+      ${CompetitionSuggestion.fragments.CompetitionSuggestionFields}
+      `
+
+    await arc.sendQuery(query)
+
+      // now see if we can get our informatino directly from the cache
+    const cachedSuggestions = await competition.suggestions({}, { fetchPolicy: 'cache-only'})
+        .pipe(first()).toPromise()
+    expect(cachedSuggestions.map((v: CompetitionSuggestion) => v.id))
+        .toEqual(suggestions.map((v: CompetitionSuggestion) => v.id))
+
+    const cachedSuggestionState = await cachedSuggestions[0]
+      .state({ fetchPolicy: 'cache-only'}).pipe(first()).toPromise()
+    expect(cachedSuggestionState.id).toEqual(cachedSuggestions[0].id)
 
   })
 
@@ -771,7 +820,7 @@ describe('Competition Proposal', () => {
     // // construct our superquery that will fill the cache
     const query = gql`query
       {
-        competitionSuggestion(id: '${suggestion1.id}') {
+        competitionSuggestion(id: "${suggestion1.id}") {
           id
           votes {
             ...CompetitionVoteFields
@@ -784,19 +833,15 @@ describe('Competition Proposal', () => {
       ${CompetitionVote.fragments.CompetitionVoteFields}
     `
 
-    let subscribed = false
-    const results: any[] = []
-    arc.getObservable(query, { subscribe: true, fetchPolicy: 'no-cache'}).subscribe((x: any) => {
-      subscribed = true
-      results.push(x)
-    })
-    await waitUntilTrue(() => subscribed)
+    await arc.sendQuery(query)
 
-    // now see if we can get our information directly from the cache
     const cachedVotes = await suggestion1.votes({}, { fetchPolicy: 'cache-only'})
       .pipe(first()).toPromise()
     expect(cachedVotes.map((v: CompetitionVote) => v.id))
       .toEqual(votes.map((v: CompetitionVote) => v.id))
 
+    const cachedVoteState = await cachedVotes[0].state({ fetchPolicy: 'cache-only'})
+      .pipe(first()).toPromise()
+    expect(cachedVoteState.id).toEqual(cachedVotes[0].id)
   })
 })