Remove initialQueries from CacheProvider

Author: Ephem

src/react/ReactQueryCacheProvider.js

@@ -3,35 +3,18 @@ import {
   queryCache as defaultQueryCache,
   queryCaches,
   makeQueryCache,
-  hydrate,
 } from '../core'
 
 export const queryCacheContext = React.createContext(defaultQueryCache)
 
 export const useQueryCache = () => React.useContext(queryCacheContext)
 
-export function ReactQueryCacheProvider({
-  queryCache,
-  initialQueries,
-  children,
-}) {
+export function ReactQueryCacheProvider({ queryCache, children }) {
   const resolvedQueryCache = React.useMemo(
     () => queryCache || makeQueryCache(),
     [queryCache]
   )
 
-  const initializeQueries = React.useMemo(() => {
-    if (initialQueries) {
-      return hydrate(resolvedQueryCache, initialQueries)
-    }
-  }, [resolvedQueryCache, initialQueries])
-
-  React.useEffect(() => {
-    if (initializeQueries) {
-      initializeQueries()
-    }
-  }, [initializeQueries])
-
   React.useEffect(() => {
     queryCaches.push(resolvedQueryCache)
 

src/react/tests/ReactQueryCacheProvider.test.js

@@ -7,7 +7,6 @@ import {
   useQuery,
   useQueryCache,
   queryCaches,
-  dehydrate,
 } from '../index'
 import { sleep } from './utils'
 
@@ -184,183 +183,4 @@ describe('ReactQueryCacheProvider', () => {
     expect(caches[0].clear).toHaveBeenCalled()
     customCache.clear({ notify: false })
   })
-
-  describe('hydration', () => {
-    const fetchData = value =>
-      new Promise(res => setTimeout(() => res(value), 10))
-    const dataQuery = key => fetchData(key)
-    let stringifiedQueries
-
-    beforeAll(async () => {
-      const serverQueryCache = makeQueryCache()
-      await serverQueryCache.prefetchQuery('string', dataQuery)
-      const dehydrated = dehydrate(serverQueryCache)
-      stringifiedQueries = JSON.stringify(dehydrated)
-      serverQueryCache.clear({ notify: false })
-    })
-
-    test('should hydrate initialQueries to default cache', async () => {
-      const dehydratedQueries = JSON.parse(stringifiedQueries)
-      function Page() {
-        const { data } = useQuery('string', dataQuery)
-
-        return (
-          <div>
-            <h1>{data}</h1>
-          </div>
-        )
-      }
-
-      const rendered = render(
-        <ReactQueryCacheProvider initialQueries={dehydratedQueries}>
-          <Page />
-        </ReactQueryCacheProvider>
-      )
-
-      rendered.getByText('string')
-    })
-
-    test('should hydrate initialQueries to provided cache', async () => {
-      const dehydratedQueries = JSON.parse(stringifiedQueries)
-      const clientQueryCache = makeQueryCache()
-
-      function Page() {
-        const { data } = useQuery('string', dataQuery)
-        return (
-          <div>
-            <h1>{data}</h1>
-          </div>
-        )
-      }
-
-      const rendered = render(
-        <ReactQueryCacheProvider
-          initialQueries={dehydratedQueries}
-          queryCache={clientQueryCache}
-        >
-          <Page />
-        </ReactQueryCacheProvider>
-      )
-
-      rendered.getByText('string')
-      expect(clientQueryCache.getQuery('string').state.isStale).toBe(false)
-      await waitFor(() =>
-        expect(clientQueryCache.getQuery('string').state.isStale).toBe(true)
-      )
-
-      clientQueryCache.clear({ notify: false })
-    })
-
-    test('should hydrate new queries if initialQueries changes', async () => {
-      const dehydratedQueries = JSON.parse(stringifiedQueries)
-      const clientQueryCache = makeQueryCache()
-
-      function Page({ queryKey }) {
-        const { data } = useQuery(queryKey, dataQuery)
-        return (
-          <div>
-            <h1>{data}</h1>
-          </div>
-        )
-      }
-
-      const rendered = render(
-        <ReactQueryCacheProvider
-          initialQueries={dehydratedQueries}
-          queryCache={clientQueryCache}
-        >
-          <Page queryKey={'string'} />
-        </ReactQueryCacheProvider>
-      )
-
-      rendered.getByText('string')
-      expect(clientQueryCache.getQuery('string').state.isStale).toBe(false)
-      await waitFor(() =>
-        expect(clientQueryCache.getQuery('string').state.isStale).toBe(true)
-      )
-
-      const intermediateCache = makeQueryCache()
-      await intermediateCache.prefetchQuery('string', () =>
-        dataQuery('should not change')
-      )
-      await intermediateCache.prefetchQuery('added string', dataQuery)
-      const dehydrated = dehydrate(intermediateCache)
-      intermediateCache.clear({ notify: false })
-
-      rendered.rerender(
-        <ReactQueryCacheProvider
-          initialQueries={dehydrated}
-          queryCache={clientQueryCache}
-        >
-          <Page queryKey={'string'} />
-          <Page queryKey={'added string'} />
-        </ReactQueryCacheProvider>
-      )
-
-      // Existing query data should not be overwritten,
-      // so this should still be the original data
-      rendered.getByText('string')
-      // But new query data should be available immediately
-      rendered.getByText('added string')
-      expect(clientQueryCache.getQuery('added string').state.isStale).toBe(
-        false
-      )
-      await waitFor(() =>
-        expect(clientQueryCache.getQuery('added string').state.isStale).toBe(
-          true
-        )
-      )
-
-      clientQueryCache.clear({ notify: false })
-    })
-
-    test('should hydrate queries to new cache if cache changes', async () => {
-      const dehydratedQueries = JSON.parse(stringifiedQueries)
-      const clientQueryCache = makeQueryCache()
-
-      function Page() {
-        const { data } = useQuery('string', dataQuery)
-        return (
-          <div>
-            <h1>{data}</h1>
-          </div>
-        )
-      }
-
-      const rendered = render(
-        <ReactQueryCacheProvider
-          initialQueries={dehydratedQueries}
-          queryCache={clientQueryCache}
-        >
-          <Page />
-        </ReactQueryCacheProvider>
-      )
-
-      rendered.getByText('string')
-      expect(clientQueryCache.getQuery('string').state.isStale).toBe(false)
-      await waitFor(() =>
-        expect(clientQueryCache.getQuery('string').state.isStale).toBe(true)
-      )
-
-      const newClientQueryCache = makeQueryCache()
-
-      rendered.rerender(
-        <ReactQueryCacheProvider
-          initialQueries={dehydratedQueries}
-          queryCache={newClientQueryCache}
-        >
-          <Page />
-        </ReactQueryCacheProvider>
-      )
-
-      rendered.getByText('string')
-      expect(newClientQueryCache.getQuery('string').state.isStale).toBe(false)
-      await waitFor(() =>
-        expect(newClientQueryCache.getQuery('string').state.isStale).toBe(true)
-      )
-
-      clientQueryCache.clear({ notify: false })
-      newClientQueryCache.clear({ notify: false })
-    })
-  })
 })