docs: add pages

Author: boschni

docs/src/manifests/manifest.json

@@ -332,11 +332,21 @@
           "path": "/reference/QueryCache",
           "editUrl": "/reference/QueryCache.md"
         },
+        {
+          "title": "MutationCache",
+          "path": "/reference/MutationCache",
+          "editUrl": "/reference/MutationCache.md"
+        },
         {
           "title": "QueryObserver",
           "path": "/reference/QueryObserver",
           "editUrl": "/reference/QueryObserver.md"
         },
+        {
+          "title": "InfiniteQueryObserver",
+          "path": "/reference/InfiniteQueryObserver",
+          "editUrl": "/reference/InfiniteQueryObserver.md"
+        },
         {
           "title": "QueriesObserver",
           "path": "/reference/QueriesObserver",

docs/src/pages/guides/migrating-to-react-query-3.md

@@ -45,7 +45,7 @@ function Todo() {
 
   const onClickButton = useCallback(() => {
     queryClient.invalidateQueries('posts')
-  }, [client])
+  }, [queryClient])
 
   return <button onClick={onClickButton}>Refetch</button>
 }
@@ -249,11 +249,11 @@ The `queryCache.resetErrorBoundaries()` method has been replaced by the `QueryEr
 
 ### queryCache.getQuery()
 
-The `queryCache.getQuery()` method has been replaced by `cache.find()`.
+The `queryCache.getQuery()` method has been replaced by `queryCache.find()`.
 
 ### queryCache.getQueries()
 
-The `queryCache.getQueries()` method has been replaced by `cache.findAll()`.
+The `queryCache.getQueries()` method has been replaced by `queryCache.findAll()`.
 
 ### queryCache.isFetching
 
@@ -356,6 +356,18 @@ function Overview() {
 }
 ```
 
+## Retry/offline mutations
+
+By default React Query will not retry a mutation on error, but it is possible with the `retry` option:
+
+```js
+const mutation = useMutation(addTodo, {
+  retry: 3,
+})
+```
+
+If mutations fail because the device is offline, they will be retried in the same order when the device reconnects.
+
 #### QueryObserver
 
 A `QueryObserver` can be used to create and/or watch a query:

docs/src/pages/reference/InfiniteQueryObserver.md

@@ -0,0 +1,26 @@
+---
+id: InfiniteQueryObserver
+title: InfiniteQueryObserver
+---
+
+## `InfiniteQueryObserver`
+
+The `InfiniteQueryObserver` can be used to observe and switch between infinite queries.
+
+```js
+const observer = new InfiniteQueryObserver(queryClient, {
+  queryKey: 'posts',
+  queryFn: fetchPosts,
+  getNextPageParam: (lastPage, allPages) => lastPage.nextCursor,
+  getPreviousPageParam: (firstPage, allPages) => firstPage.prevCursor,
+})
+
+const unsubscribe = observer.subscribe(result => {
+  console.log(result)
+  unsubscribe()
+})
+```
+
+**Options**
+
+The options for the `InfiniteQueryObserver` are exactly the same as those of [`useInfiniteQuery`](#useinfinitequery).

docs/src/pages/reference/MutationCache.md

@@ -0,0 +1,65 @@
+---
+id: MutationCache
+title: MutationCache
+---
+
+The `MutationCache` is the storage for mutations.
+
+**Normally, you will not interact with the MutationCache directly and instead use the `QueryClient`.**
+
+```js
+import { MutationCache } from 'react-query'
+
+const mutationCache = new MutationCache()
+```
+
+Its available methods are:
+
+- [`getAll`](#mutationcachegetall)
+- [`subscribe`](#mutationcachesubscribe)
+- [`clear`](#mutationcacheclear)
+
+## `mutationCache.getAll`
+
+`getAll` returns all mutations within the cache.
+
+> Note: This is not typically needed for most applications, but can come in handy when needing more information about a mutation in rare scenarios
+
+```js
+const mutations = mutationCache.getAll()
+```
+
+**Returns**
+
+- `Mutation[]`
+  - Mutation instances from the cache
+
+## `mutationCache.subscribe`
+
+The `subscribe` method can be used to subscribe to the mutation cache as a whole and be informed of safe/known updates to the cache like mutation states changing or mutations being updated, added or removed.
+
+```js
+const callback = mutation => {
+  console.log(mutation)
+}
+
+const unsubscribe = mutationCache.subscribe(callback)
+```
+
+**Options**
+
+- `callback: (mutation?: Mutation) => void`
+  - This function will be called with the mutation cache any time it is updated.
+
+**Returns**
+
+- `unsubscribe: Function => void`
+  - This function will unsubscribe the callback from the mutation cache.
+
+## `mutationCache.clear`
+
+The `clear` method can be used to clear the cache entirely and start fresh.
+
+```js
+mutationCache.clear()
+```

docs/src/pages/reference/QueryClient.md

@@ -8,7 +8,7 @@ title: QueryClient
 The `QueryClient` can be used to interact with a cache:
 
 ```js
-import { QueryClient, QueryCache } from 'react-query'
+import { QueryClient } from 'react-query'
 
 const queryClient = new QueryClient({
   defaultOptions: {
@@ -28,22 +28,30 @@ Its available methods are:
 - [`getQueryData`](#queryclientgetquerydata)
 - [`setQueryData`](#queryclientsetquerydata)
 - [`getQueryState`](#queryclientgetquerystate)
-- [`setQueryDefaults`](#queryclientsetquerydefaults)
-- [`refetchQueries`](#queryclientrefetchqueries)
 - [`invalidateQueries`](#queryclientinvalidatequeries)
+- [`refetchQueries`](#queryclientrefetchqueries)
 - [`cancelQueries`](#queryclientcancelqueries)
 - [`removeQueries`](#queryclientremovequeries)
 - [`isFetching`](#queryclientisfetching)
 - [`getDefaultOptions`](#queryclientsetdefaultoptions)
 - [`setDefaultOptions`](#queryclientgetdefaultoptions)
+- [`getQueryDefaults`](#queryclientgetquerydefaults)
+- [`setQueryDefaults`](#queryclientsetquerydefaults)
+- [`getMutationDefaults`](#queryclientgetmutationdefaults)
+- [`setMutationDefaults`](#queryclientsetmutationdefaults)
+- [`getQueryCache`](#queryclientgetquerycache)
+- [`getMutationCache`](#queryclientgetmutationcache)
+- [`clear`](#queryclientclear)
 
 **Options**
 
-- `queryCache: QueryCache`
+- `queryCache?: QueryCache`
+  - Optional
   - The query cache this client is connected to.
-- `mutationCache: MutationCache`
+- `mutationCache?: MutationCache`
+  - Optional
   - The mutation cache this client is connected to.
-- `defaultOptions: DefaultOptions`
+- `defaultOptions?: DefaultOptions`
   - Optional
   - Define defaults for all queries and mutations using this queryClient.
 
@@ -169,40 +177,6 @@ console.log(state.updatedAt)
 - `queryKey?: QueryKey`: [Query Keys](../guides/query-keys)
 - `filters?: QueryFilters`: [Query Filters](../guides/query-filters)
 
-## `queryClient.setQueryDefaults`
-
-`setQueryDefaults` is a synchronous method to set default options for specific queries:
-
-```js
-queryClient.setQueryDefaults('posts', { queryFn: fetchPosts })
-
-function Component() {
-  const { data } = useQuery('posts')
-}
-```
-
-**Options**
-
-- `queryKey: QueryKey`: [Query Keys](../guides/query-keys)
-- `options: QueryOptions`
-
-## `queryClient.setMutationDefaults`
-
-`setMutationDefaults` is a synchronous method to set default options for specific mutations:
-
-```js
-queryClient.setMutationDefaults('addPost', { mutationFn: addPost })
-
-function Component() {
-  const { data } = useMutation('addPost')
-}
-```
-
-**Options**
-
-- `mutationKey: string | unknown[]`
-- `options: MutationOptions`
-
 ## `queryClient.invalidateQueries`
 
 The `invalidateQueries` method can be used to invalidate and refetch single or multiple queries in the cache based on their query keys or any other functionally accessible property/state of the query. By default, all matching queries are immediately marked as invalid and active queries are refetched in the background.
@@ -340,3 +314,77 @@ queryClient.setDefaultOptions({
   },
 })
 ```
+
+## `queryClient.getQueryDefaults`
+
+The `getQueryDefaults` method returns the default options which have been set for specific queries:
+
+```js
+const defaultOptions = queryClient.getQueryDefaults('posts')
+```
+
+## `queryClient.setQueryDefaults`
+
+`setQueryDefaults` can be used to set default options for specific queries:
+
+```js
+queryClient.setQueryDefaults('posts', { queryFn: fetchPosts })
+
+function Component() {
+  const { data } = useQuery('posts')
+}
+```
+
+**Options**
+
+- `queryKey: QueryKey`: [Query Keys](../guides/query-keys)
+- `options: QueryOptions`
+
+## `queryClient.getMutationDefaults`
+
+The `getMutationDefaults` method returns the default options which have been set for specific mutations:
+
+```js
+const defaultOptions = queryClient.getMutationDefaults('addPost')
+```
+
+## `queryClient.setMutationDefaults`
+
+`setMutationDefaults` can be used to set default options for specific mutations:
+
+```js
+queryClient.setMutationDefaults('addPost', { mutationFn: addPost })
+
+function Component() {
+  const { data } = useMutation('addPost')
+}
+```
+
+**Options**
+
+- `mutationKey: string | unknown[]`
+- `options: MutationOptions`
+
+## `queryClient.getQueryCache`
+
+The `getQueryCache` method returns the query cache this client is connected to.
+
+```js
+const queryCache = queryClient.getQueryCache()
+```
+
+## `queryClient.getMutationCache`
+
+The `getMutationCache` method returns the mutation cache this client is connected to.
+
+```js
+const mutationCache = queryClient.getMutationCache()
+```
+
+## `queryClient.clear`
+
+The `clear` method clears all connected caches.
+
+```js
+queryClient.clear()
+```