diff --git a/infinite/index.ts b/infinite/index.ts
index 2fc261957..56297fc95 100644
--- a/infinite/index.ts
+++ b/infinite/index.ts
@@ -9,10 +9,12 @@ import useSWR, {
   Middleware,
   BareFetcher
 } from 'swr'
+
 import { useIsomorphicLayoutEffect } from '../src/utils/env'
 import { serialize } from '../src/utils/serialize'
 import { isUndefined, isFunction, UNDEFINED } from '../src/utils/helper'
 import { withMiddleware } from '../src/utils/with-middleware'
+import { createCacheHelper } from '../src/utils/cache'
 
 import type {
   SWRInfiniteConfiguration,
@@ -52,34 +54,35 @@ export const infinite = (<Data, Error>(useSWRNext: SWRHook) =>
       revalidateOnMount = false
     } = config
 
-    // The serialized key of the first page.
-    let firstPageKey: string | null = null
+    // The serialized key of the first page. This key will be used to store
+    // metadata of this SWR infinite hook.
+    let infiniteKey: string | undefined
     try {
-      firstPageKey = getFirstPageKey(getKey)
+      infiniteKey = getFirstPageKey(getKey)
+      if (infiniteKey) infiniteKey = INFINITE_PREFIX + infiniteKey
     } catch (err) {
-      // not ready
+      // Not ready yet.
     }
 
-    // We use cache to pass extra info (context) to fetcher so it can be globally
-    // shared. The key of the context data is based on the first page key.
-    let contextCacheKey: string | null = null
-
-    // Page size is also cached to share the page data between hooks with the
-    // same key.
-    let pageSizeCacheKey: string | null = null
-
-    if (firstPageKey) {
-      contextCacheKey = '$ctx$' + firstPageKey
-      pageSizeCacheKey = '$len$' + firstPageKey
-    }
+    const [get, set] = createCacheHelper<
+      Data,
+      {
+        // We use cache to pass extra info (context) to fetcher so it can be globally
+        // shared. The key of the context data is based on the first page key.
+        $ctx: [boolean] | [boolean, Data[] | undefined]
+        // Page size is also cached to share the page data between hooks with the
+        // same key.
+        $len: number
+      }
+    >(cache, infiniteKey)
 
     const resolvePageSize = useCallback((): number => {
-      const cachedPageSize = cache.get(pageSizeCacheKey)
+      const cachedPageSize = get().$len
       return isUndefined(cachedPageSize) ? initialSize : cachedPageSize
 
       // `cache` isn't allowed to change during the lifecycle
       // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [pageSizeCacheKey, initialSize])
+    }, [infiniteKey, initialSize])
     // keep the last page size to restore it with the persistSize option
     const lastPageSizeRef = useRef<number>(resolvePageSize())
 
@@ -90,28 +93,24 @@ export const infinite = (<Data, Error>(useSWRNext: SWRHook) =>
         return
       }
 
-      if (firstPageKey) {
+      if (infiniteKey) {
         // If the key has been changed, we keep the current page size if persistSize is enabled
-        cache.set(
-          pageSizeCacheKey,
-          persistSize ? lastPageSizeRef.current : initialSize
-        )
+        set({ $len: persistSize ? lastPageSizeRef.current : initialSize })
       }
 
       // `initialSize` isn't allowed to change during the lifecycle
       // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [firstPageKey])
+    }, [infiniteKey])
 
     // Needs to check didMountRef during mounting, not in the fetcher
     const shouldRevalidateOnMount = revalidateOnMount && !didMountRef.current
 
     // Actual SWR hook to load all pages in one fetcher.
     const swr = useSWRNext<Data[], Error>(
-      firstPageKey ? INFINITE_PREFIX + firstPageKey : null,
+      infiniteKey,
       async () => {
         // get the revalidate context
-        const [forceRevalidateAll, originalData] =
-          cache.get(contextCacheKey) || []
+        const [forceRevalidateAll, originalData] = get().$ctx || []
 
         // return an array of page data
         const data: Data[] = []
@@ -128,7 +127,7 @@ export const infinite = (<Data, Error>(useSWRNext: SWRHook) =>
           }
 
           // Get the cached page data.
-          let pageData = cache.get(pageKey)
+          let pageData = cache.get(pageKey)?.data
 
           // should fetch (or revalidate) if:
           // - `revalidateAll` is enabled
@@ -149,7 +148,7 @@ export const infinite = (<Data, Error>(useSWRNext: SWRHook) =>
 
           if (fn && shouldFetchPage) {
             pageData = await fn(pageArg)
-            cache.set(pageKey, pageData)
+            cache.set(pageKey, { ...cache.get(pageKey), data: pageData })
           }
 
           data.push(pageData)
@@ -157,7 +156,7 @@ export const infinite = (<Data, Error>(useSWRNext: SWRHook) =>
         }
 
         // once we executed the data fetching based on the context, clear the context
-        cache.delete(contextCacheKey)
+        set({ $ctx: UNDEFINED })
 
         // return the data
         return data
@@ -186,16 +185,16 @@ export const infinite = (<Data, Error>(useSWRNext: SWRHook) =>
         const shouldRevalidate = args[1] !== false
 
         // It is possible that the key is still falsy.
-        if (!contextCacheKey) return
+        if (!infiniteKey) return
 
         if (shouldRevalidate) {
           if (!isUndefined(data)) {
             // We only revalidate the pages that are changed
             const originalData = dataRef.current
-            cache.set(contextCacheKey, [false, originalData])
+            set({ $ctx: [false, originalData] })
           } else {
             // Calling `mutate()`, we revalidate all pages
-            cache.set(contextCacheKey, [true])
+            set({ $ctx: [true] })
           }
         }
 
@@ -203,7 +202,7 @@ export const infinite = (<Data, Error>(useSWRNext: SWRHook) =>
       },
       // swr.mutate is always the same reference
       // eslint-disable-next-line react-hooks/exhaustive-deps
-      [contextCacheKey]
+      [infiniteKey]
     )
 
     // Function to load pages data from the cache based on the page size.
@@ -216,7 +215,7 @@ export const infinite = (<Data, Error>(useSWRNext: SWRHook) =>
         const [pageKey] = serialize(getKey(i, previousPageData))
 
         // Get the cached page data.
-        const pageData = pageKey ? cache.get(pageKey) : UNDEFINED
+        const pageData = pageKey ? cache.get(pageKey)?.data : UNDEFINED
 
         // Return the current data if we can't get it from the cache.
         if (isUndefined(pageData)) return dataRef.current
@@ -233,7 +232,7 @@ export const infinite = (<Data, Error>(useSWRNext: SWRHook) =>
     const setSize = useCallback(
       (arg: number | ((size: number) => number)) => {
         // It is possible that the key is still falsy.
-        if (!pageSizeCacheKey) return
+        if (!infiniteKey) return
 
         let size
         if (isFunction(arg)) {
@@ -243,14 +242,14 @@ export const infinite = (<Data, Error>(useSWRNext: SWRHook) =>
         }
         if (typeof size != 'number') return
 
-        cache.set(pageSizeCacheKey, size)
+        set({ $len: size })
         lastPageSizeRef.current = size
         rerender({})
         return mutate(resolvePagesFromCache(size))
       },
       // `cache` and `rerender` isn't allowed to change during the lifecycle
       // eslint-disable-next-line react-hooks/exhaustive-deps
-      [pageSizeCacheKey, resolvePageSize, mutate]
+      [infiniteKey, resolvePageSize, mutate]
     )
 
     // Use getter functions to avoid unnecessary re-renders caused by triggering
diff --git a/src/constants/revalidate-events.ts b/src/constants.ts
similarity index 100%
rename from src/constants/revalidate-events.ts
rename to src/constants.ts
diff --git a/src/types.ts b/src/types.ts
index 0b028541c..4c42b0040 100644
--- a/src/types.ts
+++ b/src/types.ts
@@ -1,4 +1,4 @@
-import * as revalidateEvents from './constants/revalidate-events'
+import * as revalidateEvents from './constants'
 
 export type FetcherResponse<Data = unknown> = Data | Promise<Data>
 export type BareFetcher<Data = unknown> = (
@@ -248,11 +248,11 @@ export type RevalidateCallback = <K extends RevalidateEvent>(
   type: K
 ) => RevalidateCallbackReturnType[K]
 
-export type StateUpdateCallback<Data = any, Error = any> = (
-  data?: Data,
-  error?: Error,
+export type StateUpdateCallback<Data = any, Error = any> = (state: {
+  data?: Data
+  error?: Error
   isValidating?: boolean
-) => void
+}) => void
 
 export interface Cache<Data = any> {
   get(key: Key): Data | null | undefined
diff --git a/src/use-swr.ts b/src/use-swr.ts
index b5f1e350b..045f97987 100644
--- a/src/use-swr.ts
+++ b/src/use-swr.ts
@@ -17,7 +17,9 @@ import { subscribeCallback } from './utils/subscribe-key'
 import { broadcastState } from './utils/broadcast-state'
 import { getTimestamp } from './utils/timestamp'
 import { internalMutate } from './utils/mutate'
-import * as revalidateEvents from './constants/revalidate-events'
+import * as revalidateEvents from './constants'
+import { createCacheHelper } from './utils/cache'
+
 import {
   State,
   Fetcher,
@@ -69,7 +71,7 @@ export const useSWRHandler = <Data = any, Error = any>(
   // all of them are derived from `_key`.
   // `fnArg` is the argument/arguments parsed from the key, which will be passed
   // to the fetcher.
-  const [key, fnArg, keyInfo] = serialize(_key)
+  const [key, fnArg] = serialize(_key)
 
   // If it's the initial render of this hook.
   const initialMountedRef = useRef(false)
@@ -84,17 +86,17 @@ export const useSWRHandler = <Data = any, Error = any>(
   const configRef = useRef(config)
   const getConfig = () => configRef.current
   const isActive = () => getConfig().isVisible() && getConfig().isOnline()
-  const patchFetchInfo = (info: { isValidating?: boolean; error?: any }) =>
-    cache.set(keyInfo, mergeObjects(cache.get(keyInfo), info))
+
+  const [get, set] = createCacheHelper<Data>(cache, key)
 
   // Get the current state that SWR should return.
-  const cached = cache.get(key)
+  const cached = get()
+  const cachedData = cached.data
   const fallback = isUndefined(fallbackData)
     ? config.fallback[key]
     : fallbackData
-  const data = isUndefined(cached) ? fallback : cached
-  const info = cache.get(keyInfo) || {}
-  const error = info.error
+  const data = isUndefined(cachedData) ? fallback : cachedData
+  const error = cached.error
 
   const isInitialMount = !initialMountedRef.current
 
@@ -122,7 +124,7 @@ export const useSWRHandler = <Data = any, Error = any>(
   // Resolve the current validating state.
   const resolveValidating = () => {
     if (!key || !fetcher) return false
-    if (info.isValidating) return true
+    if (cached.isValidating) return true
 
     // If it's not mounted yet and it should revalidate on mount, revalidate.
     return isInitialMount && shouldRevalidate()
@@ -182,7 +184,7 @@ export const useSWRHandler = <Data = any, Error = any>(
       // The new state object when request finishes.
       const newState: State<Data, Error> = { isValidating: false }
       const finishRequestAndUpdateState = () => {
-        patchFetchInfo({ isValidating: false })
+        set({ isValidating: false })
         // We can only set state if it's safe (still mounted with the same key).
         if (isCurrentKeyMounted()) {
           setState(newState)
@@ -190,25 +192,20 @@ export const useSWRHandler = <Data = any, Error = any>(
       }
 
       // Start fetching. Change the `isValidating` state, update the cache.
-      patchFetchInfo({
-        isValidating: true
-      })
+      set({ isValidating: true })
       setState({ isValidating: true })
 
       try {
         if (shouldStartNewRequest) {
           // Tell all other hooks to change the `isValidating` state.
-          broadcastState(
-            cache,
-            key,
-            stateRef.current.data,
-            stateRef.current.error,
-            true
-          )
+          broadcastState(cache, key, {
+            ...stateRef.current,
+            isValidating: true
+          })
 
           // If no cache being rendered currently (it shows a blank page),
           // we trigger the loading slow event.
-          if (config.loadingTimeout && !cache.get(key)) {
+          if (config.loadingTimeout && isUndefined(get().data)) {
             setTimeout(() => {
               if (loading && isCurrentKeyMounted()) {
                 getConfig().onLoadingSlow(key, config)
@@ -251,9 +248,7 @@ export const useSWRHandler = <Data = any, Error = any>(
         }
 
         // Clear error.
-        patchFetchInfo({
-          error: UNDEFINED
-        })
+        set({ error: UNDEFINED })
         newState.error = UNDEFINED
 
         // If there're other mutations(s), overlapped with the current revalidation:
@@ -301,8 +296,8 @@ export const useSWRHandler = <Data = any, Error = any>(
 
         // For global state, it's possible that the key has changed.
         // https://github.com/vercel/swr/pull/1058
-        if (!compare(cache.get(key), newData)) {
-          cache.set(key, newData)
+        if (!compare(get().data, newData)) {
+          set({ data: newData })
         }
 
         // Trigger the successful callback if it's the original request.
@@ -317,7 +312,7 @@ export const useSWRHandler = <Data = any, Error = any>(
         // Not paused, we continue handling the error. Otherwise discard it.
         if (!getConfig().isPaused()) {
           // Get a new error, don't use deep comparison for errors.
-          patchFetchInfo({ error: err })
+          set({ error: err })
           newState.error = err as Error
 
           // Error event and retry logic. Only for the actual request, not
@@ -353,13 +348,13 @@ export const useSWRHandler = <Data = any, Error = any>(
       // Here is the source of the request, need to tell all other hooks to
       // update their states.
       if (isCurrentKeyMounted() && shouldStartNewRequest) {
-        broadcastState(cache, key, newState.data, newState.error, false)
+        broadcastState(cache, key, { ...newState, isValidating: false })
       }
 
       return true
     },
-    // `setState` is immutable, and `eventsCallback`, `fnArg`, `keyInfo`,
-    // and `keyValidating` are depending on `key`, so we can exclude them from
+    // `setState` is immutable, and `eventsCallback`, `fnArg`, and
+    // `keyValidating` are depending on `key`, so we can exclude them from
     // the deps array.
     //
     // FIXME:
@@ -399,23 +394,19 @@ export const useSWRHandler = <Data = any, Error = any>(
 
     // Expose state updater to global event listeners. So we can update hook's
     // internal state from the outside.
-    const onStateUpdate: StateUpdateCallback<Data, Error> = (
-      updatedData,
-      updatedError,
-      updatedIsValidating
-    ) => {
+    const onStateUpdate: StateUpdateCallback<Data, Error> = (state = {}) => {
       setState(
         mergeObjects(
           {
-            error: updatedError,
-            isValidating: updatedIsValidating
+            error: state.error,
+            isValidating: state.isValidating
           },
           // Since `setState` only shallowly compares states, we do a deep
           // comparison here.
-          compare(stateRef.current.data, updatedData)
+          compare(stateRef.current.data, state.data)
             ? UNDEFINED
             : {
-                data: updatedData
+                data: state.data
               }
         )
       )
diff --git a/src/utils/broadcast-state.ts b/src/utils/broadcast-state.ts
index eccf8b141..b02c0f6b9 100644
--- a/src/utils/broadcast-state.ts
+++ b/src/utils/broadcast-state.ts
@@ -1,13 +1,11 @@
 import { Broadcaster } from '../types'
 import { SWRGlobalState, GlobalState } from './global-state'
-import * as revalidateEvents from '../constants/revalidate-events'
+import * as revalidateEvents from '../constants'
 
 export const broadcastState: Broadcaster = (
   cache,
   key,
-  data,
-  error,
-  isValidating,
+  state,
   revalidate,
   broadcast = true
 ) => {
@@ -20,7 +18,7 @@ export const broadcastState: Broadcaster = (
   // Cache was populated, update states of all hooks.
   if (broadcast && updaters) {
     for (let i = 0; i < updaters.length; ++i) {
-      updaters[i](data, error, isValidating)
+      updaters[i](state)
     }
   }
 
@@ -31,11 +29,11 @@ export const broadcastState: Broadcaster = (
     delete FETCH[key]
 
     if (revalidators && revalidators[0]) {
-      return revalidators[0](revalidateEvents.MUTATE_EVENT).then(() =>
-        cache.get(key)
+      return revalidators[0](revalidateEvents.MUTATE_EVENT).then(
+        () => cache.get(key).data
       )
     }
   }
 
-  return cache.get(key)
+  return cache.get(key).data
 }
diff --git a/src/utils/cache.ts b/src/utils/cache.ts
index 7ff30f4a8..b45ab5e5c 100644
--- a/src/utils/cache.ts
+++ b/src/utils/cache.ts
@@ -3,12 +3,13 @@ import { IS_SERVER } from './env'
 import { UNDEFINED, mergeObjects, noop } from './helper'
 import { internalMutate } from './mutate'
 import { GlobalState, SWRGlobalState } from './global-state'
-import * as revalidateEvents from '../constants/revalidate-events'
-import { RevalidateEvent } from '../types'
+import * as revalidateEvents from '../constants'
 
 import {
+  Key,
   Cache,
   ScopedMutator,
+  RevalidateEvent,
   RevalidateCallback,
   ProviderConfiguration
 } from '../types'
@@ -98,3 +99,20 @@ export const initCache = <Data = any>(
 
   return [provider, (SWRGlobalState.get(provider) as GlobalState)[4]]
 }
+
+export const createCacheHelper = <Data = any, ExtendedInfo = {}>(
+  cache: Cache,
+  key: Key
+) =>
+  [
+    // Getter
+    () => cache.get(key) || {},
+    // Setter
+    (
+      info: Partial<
+        { data: Data; error: any; isValidating: boolean } | ExtendedInfo
+      >
+    ) => {
+      cache.set(key, mergeObjects(cache.get(key), info))
+    }
+  ] as const
diff --git a/src/utils/mutate.ts b/src/utils/mutate.ts
index a42b27bed..9b224ea2c 100644
--- a/src/utils/mutate.ts
+++ b/src/utils/mutate.ts
@@ -1,8 +1,9 @@
 import { serialize } from './serialize'
-import { isFunction, isUndefined, mergeObjects, UNDEFINED } from './helper'
+import { isFunction, isUndefined } from './helper'
 import { SWRGlobalState, GlobalState } from './global-state'
 import { broadcastState } from './broadcast-state'
 import { getTimestamp } from './timestamp'
+import { createCacheHelper } from './cache'
 
 import { Key, Cache, MutatorCallback, MutatorOptions } from '../types'
 
@@ -25,28 +26,22 @@ export const internalMutate = async <Data>(
   let populateCache = isUndefined(options.populateCache)
     ? true
     : options.populateCache
+  let optimisticData = options.optimisticData
   const revalidate = options.revalidate !== false
   const rollbackOnError = options.rollbackOnError !== false
-  const customOptimisticData = options.optimisticData
 
   // Serilaize key
-  const [key, , keyInfo] = serialize(_key)
+  const [key] = serialize(_key)
   if (!key) return
 
+  const [get, set] = createCacheHelper<Data>(cache, key)
+
   const [, , MUTATION] = SWRGlobalState.get(cache) as GlobalState
 
   // If there is no new data provided, revalidate the key with current state.
   if (args.length < 3) {
     // Revalidate and broadcast state.
-    return broadcastState(
-      cache,
-      key,
-      cache.get(key),
-      UNDEFINED,
-      UNDEFINED,
-      revalidate,
-      true
-    )
+    return broadcastState(cache, key, get(), revalidate, true)
   }
 
   let data: any = _data
@@ -55,22 +50,23 @@ export const internalMutate = async <Data>(
   // Update global timestamps.
   const beforeMutationTs = getTimestamp()
   MUTATION[key] = [beforeMutationTs, 0]
-  const hasCustomOptimisticData = !isUndefined(customOptimisticData)
-  const rollbackData = cache.get(key)
+
+  const hasOptimisticData = !isUndefined(optimisticData)
+  const originalData = get().data
 
   // Do optimistic data update.
-  if (hasCustomOptimisticData) {
-    const optimisticData = isFunction(customOptimisticData)
-      ? customOptimisticData(rollbackData)
-      : customOptimisticData
-    cache.set(key, optimisticData)
-    broadcastState(cache, key, optimisticData)
+  if (hasOptimisticData) {
+    optimisticData = isFunction(optimisticData)
+      ? optimisticData(originalData)
+      : optimisticData
+    set({ data: optimisticData })
+    broadcastState(cache, key, { data: optimisticData })
   }
 
   if (isFunction(data)) {
     // `data` is a function, call it passing current cache value.
     try {
-      data = (data as MutatorCallback<Data>)(cache.get(key))
+      data = (data as MutatorCallback<Data>)(originalData)
     } catch (err) {
       // If it throws an error synchronously, we shouldn't update the cache.
       error = err
@@ -91,12 +87,12 @@ export const internalMutate = async <Data>(
     if (beforeMutationTs !== MUTATION[key][0]) {
       if (error) throw error
       return data
-    } else if (error && hasCustomOptimisticData && rollbackOnError) {
+    } else if (error && hasOptimisticData && rollbackOnError) {
       // Rollback. Always populate the cache in this case but without
       // transforming the data.
       populateCache = true
-      data = rollbackData
-      cache.set(key, rollbackData)
+      data = originalData
+      set({ data: originalData })
     }
   }
 
@@ -105,15 +101,15 @@ export const internalMutate = async <Data>(
     if (!error) {
       // Transform the result into data.
       if (isFunction(populateCache)) {
-        data = populateCache(data, rollbackData)
+        data = populateCache(data, originalData)
       }
 
       // Only update cached data if there's no error. Data can be `undefined` here.
-      cache.set(key, data)
+      set({ data })
     }
 
     // Always update or reset the error.
-    cache.set(keyInfo, mergeObjects(cache.get(keyInfo), { error }))
+    set({ error })
   }
 
   // Reset the timestamp to mark the mutation has ended.
@@ -123,9 +119,10 @@ export const internalMutate = async <Data>(
   const res = await broadcastState(
     cache,
     key,
-    data,
-    error,
-    UNDEFINED,
+    {
+      data,
+      error
+    },
     revalidate,
     !!populateCache
   )
diff --git a/src/utils/serialize.ts b/src/utils/serialize.ts
index b4233ac93..6eda57876 100644
--- a/src/utils/serialize.ts
+++ b/src/utils/serialize.ts
@@ -3,7 +3,7 @@ import { isFunction } from './helper'
 
 import { Key } from '../types'
 
-export const serialize = (key: Key): [string, Key, string] => {
+export const serialize = (key: Key): [string, Key] => {
   if (isFunction(key)) {
     try {
       key = key()
@@ -25,6 +25,5 @@ export const serialize = (key: Key): [string, Key, string] => {
       ? stableHash(key)
       : ''
 
-  const infoKey = key ? '$swr$' + key : ''
-  return [key, args, infoKey]
+  return [key, args]
 }
diff --git a/test/use-swr-cache.test.tsx b/test/use-swr-cache.test.tsx
index 405a47dfb..b3965eb40 100644
--- a/test/use-swr-cache.test.tsx
+++ b/test/use-swr-cache.test.tsx
@@ -32,12 +32,12 @@ describe('useSWR - cache provider', () => {
     renderWithConfig(<Page />, { provider: () => provider })
     await screen.findByText(fetcher(keys[0]))
 
-    expect(provider.get(keys[1])).toBe(undefined)
+    expect(provider.get(keys[1])?.data).toBe(undefined)
     fireEvent.click(screen.getByText(fetcher(keys[0])))
     await act(() => sleep(10))
 
-    expect(provider.get(keys[0])).toBe(fetcher(keys[0]))
-    expect(provider.get(keys[1])).toBe(fetcher(keys[1]))
+    expect(provider.get(keys[0])?.data).toBe(fetcher(keys[0]))
+    expect(provider.get(keys[1])?.data).toBe(fetcher(keys[1]))
   })
 
   it('should be able to read from the initial cache with updates', async () => {
@@ -52,7 +52,7 @@ describe('useSWR - cache provider', () => {
     }
 
     renderWithConfig(<Page />, {
-      provider: () => new Map([[key, 'cached value']])
+      provider: () => new Map([[key, { data: 'cached value' }]])
     })
     screen.getByText('cached value')
     await screen.findByText('updated value')
@@ -71,7 +71,7 @@ describe('useSWR - cache provider', () => {
     }
 
     renderWithConfig(<Page />, {
-      provider: () => new Map([[key, 'cached value']])
+      provider: () => new Map([[key, { data: 'cached value' }]])
     })
     screen.getByText('cached value')
     await act(() => mutate(key, 'mutated value', false))
@@ -91,14 +91,18 @@ describe('useSWR - cache provider', () => {
       return (
         <div>
           {data}:
-          <SWRConfig value={{ provider: () => new Map([[key, '2']]) }}>
+          <SWRConfig
+            value={{ provider: () => new Map([[key, { data: '2' }]]) }}
+          >
             <Foo />
           </SWRConfig>
         </div>
       )
     }
 
-    renderWithConfig(<Page />, { provider: () => new Map([[key, '1']]) })
+    renderWithConfig(<Page />, {
+      provider: () => new Map([[key, { data: '1' }]])
+    })
     screen.getByText('1:2')
   })
 
@@ -113,11 +117,15 @@ describe('useSWR - cache provider', () => {
     function Page() {
       return (
         <div>
-          <SWRConfig value={{ provider: () => new Map([[key, '1']]) }}>
+          <SWRConfig
+            value={{ provider: () => new Map([[key, { data: '1' }]]) }}
+          >
             <Foo />
           </SWRConfig>
           :
-          <SWRConfig value={{ provider: () => new Map([[key, '2']]) }}>
+          <SWRConfig
+            value={{ provider: () => new Map([[key, { data: '2' }]]) }}
+          >
             <Foo />
           </SWRConfig>
         </div>
@@ -142,7 +150,7 @@ describe('useSWR - cache provider', () => {
       return <>{String(data)}</>
     }
     const { unmount } = renderWithConfig(<Page />, {
-      provider: () => new Map([[key, 0]]),
+      provider: () => new Map([[key, { data: 0 }]]),
       initFocus() {
         focusFn()
         return unsubscribeFocusFn
@@ -216,14 +224,14 @@ describe('useSWR - cache provider', () => {
     }
 
     renderWithConfig(<Page />, {
-      provider: () => new Map([[key, 'cache']]),
+      provider: () => new Map([[key, { data: 'cache' }]]),
       fallback: { [key]: 'fallback' }
     })
     screen.getByText('cache') // no `undefined`, directly from cache
     await screen.findByText('data')
   })
 
-  it('should be able to extend the parent cache', async () => {
+  it.skip('should be able to extend the parent cache', async () => {
     let parentCache
 
     const key = createKey()
@@ -243,8 +251,10 @@ describe('useSWR - cache provider', () => {
           get: k => {
             // We append `-extended` to the value returned by the parent cache.
             const v = parentCache_.get(k)
-            if (typeof v === 'undefined') return v
-            return v + '-extended'
+            if (v && typeof v.data !== 'undefined') {
+              return { ...v, data: v.data + '-extended' }
+            }
+            return v
           },
           delete: k => parentCache_.delete(k)
         }
@@ -357,12 +367,12 @@ describe('useSWR - global cache', () => {
     renderWithGlobalCache(<Page />)
     await screen.findByText(fetcher(keys[0]))
 
-    expect(cache.get(keys[1])).toBe(undefined)
+    expect(cache.get(keys[1])?.data).toBe(undefined)
     fireEvent.click(screen.getByText(fetcher(keys[0])))
     await act(() => sleep(10))
 
-    expect(cache.get(keys[0])).toBe(fetcher(keys[0]))
-    expect(cache.get(keys[1])).toBe(fetcher(keys[1]))
+    expect(cache.get(keys[0])?.data).toBe(fetcher(keys[0]))
+    expect(cache.get(keys[1])?.data).toBe(fetcher(keys[1]))
   })
 
   it('should correctly mutate the cached value', async () => {
@@ -419,7 +429,7 @@ describe('useSWR - global cache', () => {
   it('should reusing the same cache instance after unmounting SWRConfig', async () => {
     let focusEventRegistered = false
 
-    const cacheSingleton = new Map([['key', 'value']])
+    const cacheSingleton = new Map([['key', { data: 'value' }]])
     function Page() {
       return (
         <SWRConfig
@@ -437,7 +447,7 @@ describe('useSWR - global cache', () => {
     }
     function Comp() {
       const { cache } = useSWRConfig()
-      return <>{String(cache.get('key'))}</>
+      return <>{String(cache.get('key')?.data)}</>
     }
 
     function Wrapper() {
@@ -462,7 +472,7 @@ describe('useSWR - global cache', () => {
   it('should correctly return the cache instance under strict mode', async () => {
     function Page() {
       // Intentionally do this.
-      const [cache] = useState(new Map([['key', 'value']]))
+      const [cache] = useState(new Map([['key', { data: 'value' }]]))
       return (
         <SWRConfig value={{ provider: () => cache }}>
           <Comp />
@@ -471,7 +481,7 @@ describe('useSWR - global cache', () => {
     }
     function Comp() {
       const { cache } = useSWRConfig()
-      return <>{String(cache.get('key'))}</>
+      return <>{String(cache.get('key')?.data)}</>
     }
 
     renderWithGlobalCache(
diff --git a/test/use-swr-infinite.test.tsx b/test/use-swr-infinite.test.tsx
index 66d9d4e5a..05bb3603b 100644
--- a/test/use-swr-infinite.test.tsx
+++ b/test/use-swr-infinite.test.tsx
@@ -693,6 +693,34 @@ describe('useSWRInfinite', () => {
     await screen.findByText('data:')
   })
 
+  it('should support getKey to return null', async () => {
+    function Page() {
+      const { data, setSize } = useSWRInfinite(
+        () => null,
+        () => 'data'
+      )
+
+      return (
+        <div
+          onClick={() => {
+            // load next page
+            setSize(size => size + 1)
+          }}
+        >
+          data:{data || ''}
+        </div>
+      )
+    }
+
+    renderWithConfig(<Page />)
+    screen.getByText('data:')
+    await screen.findByText('data:')
+
+    // load next page
+    fireEvent.click(screen.getByText('data:'))
+    await screen.findByText('data:')
+  })
+
   it('should mutate a cache with `unstable_serialize`', async () => {
     let count = 0
     const key = createKey()
@@ -776,7 +804,9 @@ describe('useSWRInfinite', () => {
     function App() {
       return (
         <SWRConfig
-          value={{ provider: () => new Map([[key, 'initial-cache']]) }}
+          value={{
+            provider: () => new Map([[key, { data: 'initial-cache' }]])
+          }}
         >
           <Page />
         </SWRConfig>
@@ -950,7 +980,7 @@ describe('useSWRInfinite', () => {
     }
 
     renderWithConfig(<Page />, {
-      provider: () => new Map([[key + '-1', 'cached value']])
+      provider: () => new Map([[key + '-1', { data: 'cached value' }]])
     })
 
     screen.getByText('data:')
@@ -973,7 +1003,7 @@ describe('useSWRInfinite', () => {
       )
     }
     renderWithConfig(<Page />, {
-      provider: () => new Map([[key + '-1', 'cached value']])
+      provider: () => new Map([[key + '-1', { data: 'cached value' }]])
     })
 
     screen.getByText('data:')
diff --git a/test/use-swr-local-mutation.test.tsx b/test/use-swr-local-mutation.test.tsx
index d3875e4ac..23cd28e70 100644
--- a/test/use-swr-local-mutation.test.tsx
+++ b/test/use-swr-local-mutation.test.tsx
@@ -272,7 +272,7 @@ describe('useSWR - local mutation', () => {
 
     // Prefill the cache with data
     renderWithConfig(<Page />, {
-      provider: () => new Map([[key, 'cached data']])
+      provider: () => new Map([[key, { data: 'cached data' }]])
     })
 
     const callback = jest.fn()
@@ -303,7 +303,7 @@ describe('useSWR - local mutation', () => {
     expect(increment).toHaveBeenLastCalledWith(undefined)
     expect(increment).toHaveLastReturnedWith(undefined)
 
-    cache.set(key, 42)
+    cache.set(key, { ...cache.get(key), data: 42 })
 
     await mutate(key, increment, false)
 
@@ -536,12 +536,12 @@ describe('useSWR - local mutation', () => {
     })
 
     screen.getByText(message)
-    const [keyData, , keyInfo] = serialize(key)
+    const [keyInfo] = serialize(key)
     let cacheError = cache.get(keyInfo)?.error
     expect(cacheError.message).toMatchInlineSnapshot(`"${message}"`)
 
     // if mutate throws an error synchronously, the cache shouldn't be updated
-    expect(cache.get(keyData)).toBe(value)
+    expect(cache.get(keyInfo)?.data).toBe(value)
 
     // if mutate succeed, error should be cleared
     await act(() => mutate(key, value, false))
@@ -807,7 +807,7 @@ describe('useSWR - local mutation', () => {
         createResponse('data', { delay: 30 })
       )
       const { cache } = useSWRConfig()
-      const [, , keyInfo] = serialize(key)
+      const [keyInfo] = serialize(key)
       const cacheIsValidating = cache.get(keyInfo)?.isValidating
       return (
         <>
diff --git a/test/use-swr-refresh.test.tsx b/test/use-swr-refresh.test.tsx
index 05d9996ac..d09bb6c8d 100644
--- a/test/use-swr-refresh.test.tsx
+++ b/test/use-swr-refresh.test.tsx
@@ -259,7 +259,7 @@ describe('useSWR - refresh', () => {
       version: '1.0'
     })
 
-    const cachedData = customCache.get(key)
+    const cachedData = customCache.get(key)?.data
     expect(cachedData.timestamp.toString()).toEqual('1')
     screen.getByText('1')
   })