Request memoization: is fetch Always Memoized or Only with force-cache in Next.js 15?

[Jancaster1234]

Summary

I’m looking for clarification on whether fetch requests are always memoized or if memoization only occurs when explicitly using force-cache in Next.js 15.

In this blog: https://nextjs.org/docs/app/building-your-application/data-fetching/fetching#reusing-data-across-multiple-functions
It states:
"If you are using fetch, requests can be memoized by adding cache: 'force-cache'. This means you can safely call the same URL with the same options, and only one request will be made."

In other blog: https://nextjs.org/docs/app/building-your-application/caching#request-memoization
An example suggests that fetch is automatically memoized, regardless of the cache setting:

async function getItem() {
// The fetch function is automatically memoized and the result
// is cached
const res = await fetch('https://.../item/1')
return res.json()
}

// This function is called twice, but only executed the first time
const item = await getItem() // cache MISS

// The second call could be anywhere in your route
const item = await getItem() // cache HIT

Additional information

No response

Example

No response

[icyJoseph]

Yeah, some documentation is not fully up-to-date, I think, but let's go off the Next 15 release notes:

With Next.js 15, we're changing the caching default for GET Route Handlers and the Client Router Cache from cached by default to uncached by default. If you want to retain the previous behavior, you can continue to opt-into caching.

[frantisek-heca]

React.cache() ?

[mlev]

The docs suggest React.cache() as an alternative - but only when fetch is not suitable.

For cases where fetch is not suitable (e.g. some database clients, CMS clients, or GraphQL clients), you can use the React cache function to memoize functions.

I'm using fetch and even if I roll my own React.cache() approach the underlying fetch requests will still get handled by the Next.js patched fetcher. So I'd just like some clarification on how it's meant to be working.

Would you agree that the 2 documents linked by the OP (and myself) are not consistent?

[mlev]

Digging a little deeper it seems the documentation isn't quite right a in a few places around this feature. e.g. from the Next docs:

Request memoization is a React feature, not a Next.js feature. It's included here to show how it interacts with the other caching mechanisms.

While this may have been the intention - it was removed from React:
facebook/react#28896

And instead Next.js maintains its own implementation here:
https://github.com/vercel/next.js/blob/canary/packages/next/src/server/lib/dedupe-fetch.ts

And this is used when patching fetch - the dedupe version is passed in as the "original". As far as I can tell there is no specific conditional around memoization for 'force-cache' param.

[frantisek-heca]

hmm... what's the problem now?
that React.cache() does not solve the memoization?
or that fetch is being overriden by nextjs? (what's the problem?)

the inconsistency in docs is something that i consider as a "sure thing", i would recommend everyone to stop trusting any advices on the net (and spreading any advices too), but to test everything localy and finding your own truth. there are so many variables that do influence this topic (nextjs versions, dev vs prod vs hmr, static vs dynamic pages...).

i am not happy with this situation myself at all, i ended by searching the source code, because i was pissed by the docs incosinstencies or the un-possibility by anyone (nextjs stuff) to express the huge state-machine that is behind the caching logic.

[mlev]

The problem is still the same as the original question in the discussion - that the expected behaviour re: request memoization is not clear based on the official documentation.

You can see that I've already searched the source code to see what's going on. But what the code does now and what it's meant to do are separate things. i.e. if request memoization is not intended to work without specifying "force-cache" then I will happily build my own solution. But if it is meant to work then there's no point rebuilding it because the built-in patched fetch will do it for me and I'd rather not add an unnecessary layer to the already complicated caching logic.

[maxaqquepucho]

I am creating an application and I have the same doubt. Based on my tests (which may not be entirely accurate since I don't have the expertise to be certain), it seems that you don't need to send the "force-cache" parameter. When I make several requests from the client without this parameter, the network inspector shows that each request is cached and returns a 304 response.

This leads me to believe that request memoization is working. I hope someone can help clarify whether I'm correct.