Confusing explantion of Nextjs caching and rendering.

[DevDynasty0]

I am really confused about nextjs caching and rendering behavior after reading the recent doc of nextjs. The explanation of caching and rendering in different sections of docs conflict with each other.

For example:

1. fetch api reference states nextjs fetch request response no longer cached by default. doc reference
   
   But in data fetching and caching docs states, "The response from fetch will be automatically cached." doc reference

2. Fetching data on the server with an ORM or database states "The response from the database is not cached by default but could be with additional configuration. If you are not using any Dynamic APIs anywhere else in this route, it will be prerendered during next build to a static page. The data can then be updated using Incremental Static Regeneration. doc reference
   
   Question 1: if database response i not cached then how it can be prerendered?
   
   But Caching data with an ORM or Database states "You can use the unstable_cache API to cache the response to allow pages to be prerendered when running next build." doc reference
   
   Question 2: If fetching data with an ORM or database route is prerendered if I don't use a Dynamic APIs then why i do need unstable_store to make the route prerendered?
   
   Again nextjs lean chapter 10 states "And in Next.js, if you call a dynamic function in a route (like querying your database), the entire route becomes dynamic." doc reference

[icyJoseph]

You can expect quite a bit of material to catch up to the new standard, on the coming weeks.

So for question 1, you need to allow some time for the docs to align behind the new behavior of Next 15, which is not caching by default.

As for question 2. Often when you work with databases, their APIs do not use the fetch API, but other means to query the data, and because of that, they are not cached by Next.js.

That has nothing to do with pre-rendering. Pre-rendering just needs to collect the data, during build time.

If a route/page is statically pre-rendered, and has no means to incrementally refresh itself (ISR), or it is not generated on demand, fully dynamic, then you'd need to rebuild your app, every time you'd want to show new/updated data.

[DevDynasty0]

Thank you for your reply. I understand how caching and rendering work in Next.js 15; however, I found that the documentation explains these behaviors differently across various sections, which has led to some confusion.

I did those two questions to mark the incorrect statements in the doc.

In the first phase of the second point I mentioned from the doc, it should be clarified that if we query the database directly or use an ORM, this route will also render dynamically. It does not matter if we are using Dynamic APIs or not. Am I correct?

[icyJoseph]

it should be clarified that if we query the database directly or use an ORM, this route will also render dynamically. I

Not really. As far as I understand, it will just be an statically exported page. It'll be generated at build time, with either:

• ○ (Static) prerendered as static content
• ● (SSG) prerendered as static HTML (uses getStaticProps)

And that's it. To have new data, you'd need to rebuild or have had the revalidate option setup (ISR). To make it dynamic you'd need to opt-in to dynamic behaviour. The unstable_cache is so that, you can reduce the number of queries you fire to your DB.

And yeah, sadly, some content, and documentation are still in the Next 14 -> 15 phase it looks like.

• https://nextjs.org/docs/app/building-your-application/data-fetching/fetching

If you are not using any Dynamic APIs anywhere else in this route, it will be prerendered during next build to a static page. The data can then be updated using Incremental Static Regeneration.

import { db, posts } from '@/lib/db'
 
export default async function Page() {
  let allPosts = await db.select().from(posts)
  return (
    <ul>
      {allPosts.map((post) => (
        <li key={post.id}>{post.title}</li>
      ))}
    </ul>
  )
}

[DevDynasty0]

• https://nextjs.org/docs/app/building-your-application/data-fetching/fetching

If you are not using any Dynamic APIs anywhere else in this route, it will be prerendered during next build to a static page. The data can then be updated using Incremental Static Regeneration.

import { db, posts } from '@/lib/db'
 
export default async function Page() {
  let allPosts = await db.select().from(posts)
  return (
    <ul>
      {allPosts.map((post) => (
        <li key={post.id}>{post.title}</li>
      ))}
    </ul>
  )
}

https://nextjs.org/docs/app/building-your-application/data-fetching/fetching#fetching-data-on-the-server-with-an-orm-or-database
Here also mentioned that
This component will fetch and display a list of blog posts. The response from the database is not cached by default but could be with additional configuration.
And as unstable_cache not used in that example the response is not cache.

Now according to:
https://nextjs.org/docs/app/building-your-application/rendering/server-components#switching-to-dynamic-rendering

During rendering, if a Dynamic API or uncached data request is discovered, Next.js will switch to dynamically rendering the whole route

https://nextjs.org/learn/dashboard-app/partial-prerendering#static-vs-dynamic-routes

And in Next.js, if you call a dynamic function in a route (like querying your database), the entire route becomes dynamic." doc reference

As I am new to Next.js, my understanding might be incorrect.