Cache

Q: Quais são as quatro camadas de cache no Next.js e como elas diferem?

Memoização de Requisição: por renderização, desduplica chamadas de fetch idênticas dentro de um único passe de renderização do servidor Cache de Dados: persiste entre requisições e implantações, chaveado pela URL e opções do fetch Cache de Rota Completa: armazena HTML pré-renderizado e payload RSC para rotas estáticas no tempo de build Cache do Roteador: cache em memória do lado do cliente para segmentos de rota pré-buscados durante a navegação

Q: Como você desduplica consultas de banco de dados que ignoram a memoização automática de fetch?

Envolva a função com React.cache() para desduplicação por requisição

Q: Qual é o comportamento padrão de cache para fetch no Next.js 15+?

O padrão é cache: "auto", não force-cache como no Next.js 14 O framework decide o comportamento de cache com base no contexto (funções dinâmicas, configuração de rota) Seja explícito definindo cache ou next.revalidate em cada fetch

Q: Como você opta uma rota para fora de todas as camadas de cache?

force-dynamic pula o Cache de Rota Completa force-no-store pula o Cache de Dados para todos os fetches na rota

Q: Quando você deve usar unstable_cache em vez de React.cache()?

React.cache() fornece apenas desduplicação por requisição; os dados não persistem entre requisições unstable_cache fornece semântica de Cache de Dados (persiste entre requisições, suporta tags e revalidação) Use unstable_cache para chamadas de banco de dados ou ORM que precisam de cache entre requisições

Entenda as quatro camadas de cache no Next.js -- memoização de requisição, cache de dados, cache de rota completa e cache do roteador.

Receita

Cartão de receita de referência rápida -- pronto para copiar e colar.

// Camada 1: Memoização de Requisição (automática para fetch, manual para outras)
// O mesmo URL de fetch é desduplicado dentro de um único passe de renderização
const data = await fetch("https://api.example.com/user/1"); // chamado em 3 componentes, apenas 1 requisição
 
// Memoização manual para chamadas não-fetch
import { cache } from "react";
export const getUser = cache(async (id: string) => {
  return db.user.findUnique({ where: { id } });
});
 
// Camada 2: Cache de Dados (persiste entre requisições)
await fetch(url, { next: { revalidate: 3600 } }); // cacheado por 1 hora
await fetch(url, { cache: "no-store" });           // pula o cache de dados
await fetch(url, { next: { tags: ["users"] } });   // tag para invalidação
 
// Camada 3: Cache de Rota Completa (páginas estáticas no tempo de build)
// Automático para rotas sem dados dinâmicos
 
// Camada 4: Cache do Roteador (lado do cliente, em memória)
// Automático para pré-busca de <Link> e navegação de voltar/avançar

Quando usar isso: Você precisa entender por que seus dados estão desatualizados, por que uma página não está atualizando ou como otimizar o desempenho aproveitando a camada de cache correta.

Exemplo de Trabalho

// lib/data.ts -- demonstrando todas as camadas de cache
import { cache } from "react";
import { db } from "@/lib/db";
 
// ---- Camada 1: Memoização de Requisição ----
// Esta função pode ser chamada de múltiplos Server Components
// no mesmo passe de renderização -- apenas uma consulta ao DB é executada
export const getCurrentUser = cache(async () => {
  const session = await getSession();
  if (!session) return null;
  return db.user.findUnique({ where: { id: session.userId } });
});
 
// ---- Camada 2: Cache de Dados ----
export async function getProducts() {
  const res = await fetch("https://api.example.com/products", {
    next: { revalidate: 600, tags: ["products"] },
  });
  return res.json() as Promise<Product[]>;
}
 
// Sem cache -- sempre atualizado
export async function getCartItems(userId: string) {
  const res = await fetch(`https://api.example.com/cart/${userId}`, {
    cache: "no-store",
  });
  return res.json() as Promise<CartItem[]>;
}

// app/layout.tsx -- getCurrentUser chamado aqui...
import { getCurrentUser } from "@/lib/data";
 
export default async function RootLayout({
  children,
}: {
  children: React.ReactNode;
}) {
  const user = await getCurrentUser(); // Requisição 1 (chamada real ao DB)
 
  return (
    <html lang="en">
      <body>
        <nav>
          <span>{user?.name ?? "Guest"}</span>
        </nav>
        {children}
      </body>
    </html>
  );
}

// app/dashboard/page.tsx -- ...e também chamado aqui (desduplicado)
import { getCurrentUser } from "@/lib/data";
 
export default async function DashboardPage() {
  const user = await getCurrentUser(); // Requisição 2 (memoizada -- sem chamada ao DB)
 
  return <h1>Welcome back, {user?.name}</h1>;
}

O que isso demonstra:

React.cache desduplicando uma chamada de banco de dados entre dois Server Components na mesma renderização
next.revalidate colocando resultados de fetch no Cache de Dados
cache: "no-store" ignorando o Cache de Dados para dados específicos do usuário
O layout e a página chamando getCurrentUser() sem disparar duas consultas

Mergulho Profundo

Como Funciona

Memoização de Requisição executa durante uma única renderização do servidor. Quando fetch é chamado com a mesma URL e opções, o React retorna o resultado memoizado. Para chamadas não-fetch (banco de dados, ORM), envolva a função com React.cache(). A memoização é limpa após a conclusão da renderização.
Cache de Dados persiste dados buscados entre requisições e implantações no servidor. Ele é chaveado pela URL e opções do fetch. Respeita next.revalidate para expiração baseada em tempo e next.tags para invalidação sob demanda via revalidateTag().
Cache de Rota Completa armazena o HTML completo e o payload RSC para rotas renderizadas estaticamente no tempo de build. Quando um usuário solicita uma página estática, a versão em cache é servida instantaneamente. Rotas dinâmicas (aquelas que usam cookies(), headers(), searchParams, ou cache: "no-store") são excluídas.
Cache do Roteador é um cache em memória, do lado do cliente, que armazena segmentos de rota pré-buscados. Quando o usuário navega com <Link>, a próxima página pode já estar em cache. O cache do roteador tem diferentes tempos de vida: 30 segundos para páginas dinâmicas, 5 minutos para páginas estáticas (estes são os padrões e configuráveis no Next.js 15+).

Variações

Optando por sair de todos os caches para uma rota:

// app/real-time/page.tsx
export const dynamic = "force-dynamic"; // pula o Cache de Rota Completa
export const fetchCache = "force-no-store"; // pula o Cache de Dados para todos os fetches

Usando unstable_cache para dados não-fetch:

import { unstable_cache } from "next/cache";
 
const getCachedPosts = unstable_cache(
  async () => db.post.findMany(),
  ["all-posts"],        // partes da chave do cache
  {
    tags: ["posts"],
    revalidate: 3600,
  }
);

Controlando o comportamento do Cache do Roteador:

// next.config.ts
import type { NextConfig } from "next";
 
const config: NextConfig = {
  experimental: {
    staleTimes: {
      dynamic: 0,   // não cachear páginas dinâmicas no cliente
      static: 300,  // cachear páginas estáticas por 5 minutos
    },
  },
};
 
export default config;

Notas TypeScript

// React.cache preserva a assinatura da função
import { cache } from "react";
 
const getUser = cache(
  async (id: string): Promise<User | null> => {
    return db.user.findUnique({ where: { id } });
  }
);
// getUser: (id: string) => Promise<User | null>
 
// Tipos de configuração de segmento
export const dynamic: "auto" | "force-dynamic" | "force-static" | "error" = "auto";
export const revalidate: number | false = 60;
export const fetchCache: "auto" | "default-cache" | "only-cache" |
  "force-cache" | "force-no-store" | "default-no-store" | "only-no-store" = "auto";

Armadilhas

Confundir memoização de requisição com Cache de Dados -- A memoização de requisição é por renderização e efêmera; o Cache de Dados persiste entre requisições. Correção: Use React.cache() para desduplicação por requisição e next.revalidate / next.tags para cache persistente.
Cache do Roteador servindo páginas desatualizadas -- Após uma mutação, o Cache do Roteador do lado do cliente pode ainda servir a página antiga durante a navegação de voltar/avançar. Correção: Chame router.refresh() no Client Component após uma Server Action, ou configure staleTimes para reduzir a duração do cache do lado do cliente.
cache: "force-cache" não é sempre o padrão -- No Next.js 15+, o padrão é cache: "auto", que pode variar dependendo do contexto (funções dinâmicas, configuração de rota). Correção: Seja explícito sobre o comportamento de cache definindo cache ou next.revalidate em cada fetch.
Colisões de chave unstable_cache -- Se duas chamadas unstable_cache compartilham as mesmas partes de chave, mas retornam formas de dados diferentes, você obtém cache corrompido. Correção: Use arrays de chaves únicos e descritivos.
Middleware e Edge Runtime não compartilham caches -- O Cache de Dados é por região de implantação. Middleware executando na edge pode não ver o mesmo cache que uma função de servidor Node.js. Correção: Esteja ciente dos limites de cache em implantações multirregionais.

Alternativas

Alternativa	Usar Quando	Não Usar Quando
`React.cache()`	Você precisa de desduplicação por requisição para chamadas não-fetch	Você precisa que os dados persistam entre requisições
`unstable_cache`	Você precisa de semântica de Cache de Dados para chamadas de banco de dados ou ORM	`fetch` simples com `next.revalidate` funciona
Redis ou Memcached	Você precisa de um cache compartilhado entre múltiplas instâncias de servidor	O cache integrado do Next.js é suficiente
SWR `stale-while-revalidate`	Você quer cache do lado do cliente com revalidação automática	O cache do lado do servidor cobre suas necessidades
`cache: "no-store"` em todos os lugares	Os dados devem estar sempre atualizados (dashboards em tempo real)	Você pode tolerar dados desatualizados para melhor desempenho

FAQs

Quais são as quatro camadas de cache no Next.js e como elas diferem?

Memoização de Requisição: por renderização, desduplica chamadas de fetch idênticas dentro de um único passe de renderização do servidor
Cache de Dados: persiste entre requisições e implantações, chaveado pela URL e opções do fetch
Cache de Rota Completa: armazena HTML pré-renderizado e payload RSC para rotas estáticas no tempo de build
Cache do Roteador: cache em memória do lado do cliente para segmentos de rota pré-buscados durante a navegação

Como você desduplica consultas de banco de dados que ignoram a memoização automática de fetch?

import { cache } from "react";
import { db } from "@/lib/db";
 
export const getUser = cache(async (id: string) => {
  return db.user.findUnique({ where: { id } });
});

Envolva a função com React.cache() para desduplicação por requisição

Qual é o comportamento padrão de cache para `fetch` no Next.js 15+?

O padrão é cache: "auto", não force-cache como no Next.js 14
O framework decide o comportamento de cache com base no contexto (funções dinâmicas, configuração de rota)
Seja explícito definindo cache ou next.revalidate em cada fetch

Por quanto tempo o Cache do Roteador mantém as páginas no lado do cliente?

30 segundos para páginas dinâmicas
5 minutos para páginas estáticas
Estes são os padrões no Next.js 15+ e podem ser configurados via staleTimes em next.config.ts

Como você opta uma rota para fora de todas as camadas de cache?

export const dynamic = "force-dynamic";
export const fetchCache = "force-no-store";

force-dynamic pula o Cache de Rota Completa
force-no-store pula o Cache de Dados para todos os fetches na rota

O que causa o Cache do Roteador a servir dados desatualizados após uma mutação?

O Cache do Roteador do lado do cliente não invalida automaticamente após Server Actions
A navegação de voltar/avançar pode mostrar a página antiga
Chame router.refresh() no Client Component ou reduza staleTimes na configuração

O que acontece se duas chamadas `unstable_cache` compartilham as mesmas partes de chave, mas retornam dados diferentes?

Você obtém cache corrompido -- a forma de dados errada é retornada
Sempre use arrays de chaves únicos e descritivos para cada chamada unstable_cache
Esta é uma fonte comum de bugs difíceis de depurar em produção

Como `React.cache()` preserva os tipos TypeScript?

import { cache } from "react";
 
const getUser = cache(
  async (id: string): Promise<User | null> => {
    return db.user.findUnique({ where: { id } });
  }
);
// getUser: (id: string) => Promise<User | null>

A função envolvida retém exatamente a mesma assinatura e tipo de retorno

O Middleware compartilha o mesmo Cache de Dados que as funções de servidor Node.js?

Não. O Cache de Dados é por região de implantação
Middleware executando na edge pode não ver o mesmo cache que uma função de servidor Node.js
Esteja ciente dos limites de cache em implantações multirregionais

Quando você deve usar `unstable_cache` em vez de `React.cache()`?

React.cache() fornece apenas desduplicação por requisição; os dados não persistem entre requisições
unstable_cache fornece semântica de Cache de Dados (persiste entre requisições, suporta tags e revalidação)
Use unstable_cache para chamadas de banco de dados ou ORM que precisam de cache entre requisições

Como você configura o tempo de vida do Cache do Roteador para páginas dinâmicas?

// next.config.ts
const config: NextConfig = {
  experimental: {
    staleTimes: {
      dynamic: 0,   // não cachear páginas dinâmicas no cliente
      static: 300,  // cachear páginas estáticas por 5 minutos
    },
  },
};

Qual é o tipo para a exportação de configuração de segmento `fetchCache`?

export const fetchCache:
  | "auto"
  | "default-cache"
  | "only-cache"
  | "force-cache"
  | "force-no-store"
  | "default-no-store"
  | "only-no-store" = "auto";

Relacionados

Fetching -- Configurando opções de cache em chamadas fetch
Revalidation -- Invalidando dados em cache
Static vs Dynamic -- Como o cache determina o modo de renderização
Streaming -- Streaming de conteúdo em cache e dinâmico

Receita

Cartão de receita de referência rápida -- pronto para copiar e colar.

// Camada 1: Memoização de Requisição (automática para fetch, manual para outras)
// O mesmo URL de fetch é desduplicado dentro de um único passe de renderização
const data = await fetch("https://api.example.com/user/1"); // chamado em 3 componentes, apenas 1 requisição
 
// Memoização manual para chamadas não-fetch
import { cache } from "react";
export const getUser = cache(async (id: string) => {
  return db.user.findUnique({ where: { id } });
});
 
// Camada 2: Cache de Dados (persiste entre requisições)
await fetch(url, { next: { revalidate: 3600 } }); // cacheado por 1 hora
await fetch(url, { cache: "no-store" });           // pula o cache de dados
await fetch(url, { next: { tags: ["users"] } });   // tag para invalidação
 
// Camada 3: Cache de Rota Completa (páginas estáticas no tempo de build)
// Automático para rotas sem dados dinâmicos
 
// Camada 4: Cache do Roteador (lado do cliente, em memória)
// Automático para pré-busca de <Link> e navegação de voltar/avançar

Quando usar isso: Você precisa entender por que seus dados estão desatualizados, por que uma página não está atualizando ou como otimizar o desempenho aproveitando a camada de cache correta.

Exemplo de Trabalho

// lib/data.ts -- demonstrando todas as camadas de cache
import { cache } from "react";
import { db } from "@/lib/db";
 
// ---- Camada 1: Memoização de Requisição ----
// Esta função pode ser chamada de múltiplos Server Components
// no mesmo passe de renderização -- apenas uma consulta ao DB é executada
export const getCurrentUser = cache(async () => {
  const session = await getSession();
  if (!session) return null;
  return db.user.findUnique({ where: { id: session.userId } });
});
 
// ---- Camada 2: Cache de Dados ----
export async function getProducts() {
  const res = await fetch("https://api.example.com/products", {
    next: { revalidate: 600, tags: ["products"] },
  });
  return res.json() as Promise<Product[]>;
}
 
// Sem cache -- sempre atualizado
export async function getCartItems(userId: string) {
  const res = await fetch(`https://api.example.com/cart/${userId}`, {
    cache: "no-store",
  });
  return res.json() as Promise<CartItem[]>;
}

// app/layout.tsx -- getCurrentUser chamado aqui...
import { getCurrentUser } from "@/lib/data";
 
export default async function RootLayout({
  children,
}: {
  children: React.ReactNode;
}) {
  const user = await getCurrentUser(); // Requisição 1 (chamada real ao DB)
 
  return (
    <html lang="en">
      <body>
        <nav>
          <span>{user?.name ?? "Guest"}</span>
        </nav>
        {children}
      </body>
    </html>
  );
}

// app/dashboard/page.tsx -- ...e também chamado aqui (desduplicado)
import { getCurrentUser } from "@/lib/data";
 
export default async function DashboardPage() {
  const user = await getCurrentUser(); // Requisição 2 (memoizada -- sem chamada ao DB)
 
  return <h1>Welcome back, {user?.name}</h1>;
}

O que isso demonstra:

React.cache desduplicando uma chamada de banco de dados entre dois Server Components na mesma renderização
next.revalidate colocando resultados de fetch no Cache de Dados
cache: "no-store" ignorando o Cache de Dados para dados específicos do usuário
O layout e a página chamando getCurrentUser() sem disparar duas consultas

Mergulho Profundo

Como Funciona

Memoização de Requisição executa durante uma única renderização do servidor. Quando fetch é chamado com a mesma URL e opções, o React retorna o resultado memoizado. Para chamadas não-fetch (banco de dados, ORM), envolva a função com React.cache(). A memoização é limpa após a conclusão da renderização.
Cache de Dados persiste dados buscados entre requisições e implantações no servidor. Ele é chaveado pela URL e opções do fetch. Respeita next.revalidate para expiração baseada em tempo e next.tags para invalidação sob demanda via revalidateTag().
Cache de Rota Completa armazena o HTML completo e o payload RSC para rotas renderizadas estaticamente no tempo de build. Quando um usuário solicita uma página estática, a versão em cache é servida instantaneamente. Rotas dinâmicas (aquelas que usam cookies(), headers(), searchParams, ou cache: "no-store") são excluídas.
Cache do Roteador é um cache em memória, do lado do cliente, que armazena segmentos de rota pré-buscados. Quando o usuário navega com <Link>, a próxima página pode já estar em cache. O cache do roteador tem diferentes tempos de vida: 30 segundos para páginas dinâmicas, 5 minutos para páginas estáticas (estes são os padrões e configuráveis no Next.js 15+).

Variações

Optando por sair de todos os caches para uma rota:

// app/real-time/page.tsx
export const dynamic = "force-dynamic"; // pula o Cache de Rota Completa
export const fetchCache = "force-no-store"; // pula o Cache de Dados para todos os fetches

Usando unstable_cache para dados não-fetch:

import { unstable_cache } from "next/cache";
 
const getCachedPosts = unstable_cache(
  async () => db.post.findMany(),
  ["all-posts"],        // partes da chave do cache
  {
    tags: ["posts"],
    revalidate: 3600,
  }
);

Controlando o comportamento do Cache do Roteador:

// next.config.ts
import type { NextConfig } from "next";
 
const config: NextConfig = {
  experimental: {
    staleTimes: {
      dynamic: 0,   // não cachear páginas dinâmicas no cliente
      static: 300,  // cachear páginas estáticas por 5 minutos
    },
  },
};
 
export default config;

Notas TypeScript

// React.cache preserva a assinatura da função
import { cache } from "react";
 
const getUser = cache(
  async (id: string): Promise<User | null> => {
    return db.user.findUnique({ where: { id } });
  }
);
// getUser: (id: string) => Promise<User | null>
 
// Tipos de configuração de segmento
export const dynamic: "auto" | "force-dynamic" | "force-static" | "error" = "auto";
export const revalidate: number | false = 60;
export const fetchCache: "auto" | "default-cache" | "only-cache" |
  "force-cache" | "force-no-store" | "default-no-store" | "only-no-store" = "auto";

Armadilhas

Confundir memoização de requisição com Cache de Dados -- A memoização de requisição é por renderização e efêmera; o Cache de Dados persiste entre requisições. Correção: Use React.cache() para desduplicação por requisição e next.revalidate / next.tags para cache persistente.
Cache do Roteador servindo páginas desatualizadas -- Após uma mutação, o Cache do Roteador do lado do cliente pode ainda servir a página antiga durante a navegação de voltar/avançar. Correção: Chame router.refresh() no Client Component após uma Server Action, ou configure staleTimes para reduzir a duração do cache do lado do cliente.
cache: "force-cache" não é sempre o padrão -- No Next.js 15+, o padrão é cache: "auto", que pode variar dependendo do contexto (funções dinâmicas, configuração de rota). Correção: Seja explícito sobre o comportamento de cache definindo cache ou next.revalidate em cada fetch.
Colisões de chave unstable_cache -- Se duas chamadas unstable_cache compartilham as mesmas partes de chave, mas retornam formas de dados diferentes, você obtém cache corrompido. Correção: Use arrays de chaves únicos e descritivos.
Middleware e Edge Runtime não compartilham caches -- O Cache de Dados é por região de implantação. Middleware executando na edge pode não ver o mesmo cache que uma função de servidor Node.js. Correção: Esteja ciente dos limites de cache em implantações multirregionais.

Alternativas

Alternativa	Usar Quando	Não Usar Quando
`React.cache()`	Você precisa de desduplicação por requisição para chamadas não-fetch	Você precisa que os dados persistam entre requisições
`unstable_cache`	Você precisa de semântica de Cache de Dados para chamadas de banco de dados ou ORM	`fetch` simples com `next.revalidate` funciona
Redis ou Memcached	Você precisa de um cache compartilhado entre múltiplas instâncias de servidor	O cache integrado do Next.js é suficiente
SWR `stale-while-revalidate`	Você quer cache do lado do cliente com revalidação automática	O cache do lado do servidor cobre suas necessidades
`cache: "no-store"` em todos os lugares	Os dados devem estar sempre atualizados (dashboards em tempo real)	Você pode tolerar dados desatualizados para melhor desempenho

FAQs

Quais são as quatro camadas de cache no Next.js e como elas diferem?

Memoização de Requisição: por renderização, desduplica chamadas de fetch idênticas dentro de um único passe de renderização do servidor
Cache de Dados: persiste entre requisições e implantações, chaveado pela URL e opções do fetch
Cache de Rota Completa: armazena HTML pré-renderizado e payload RSC para rotas estáticas no tempo de build
Cache do Roteador: cache em memória do lado do cliente para segmentos de rota pré-buscados durante a navegação

Como você desduplica consultas de banco de dados que ignoram a memoização automática de fetch?

import { cache } from "react";
import { db } from "@/lib/db";
 
export const getUser = cache(async (id: string) => {
  return db.user.findUnique({ where: { id } });
});

Envolva a função com React.cache() para desduplicação por requisição

Qual é o comportamento padrão de cache para `fetch` no Next.js 15+?

O padrão é cache: "auto", não force-cache como no Next.js 14
O framework decide o comportamento de cache com base no contexto (funções dinâmicas, configuração de rota)
Seja explícito definindo cache ou next.revalidate em cada fetch

Por quanto tempo o Cache do Roteador mantém as páginas no lado do cliente?

30 segundos para páginas dinâmicas
5 minutos para páginas estáticas
Estes são os padrões no Next.js 15+ e podem ser configurados via staleTimes em next.config.ts

Como você opta uma rota para fora de todas as camadas de cache?

export const dynamic = "force-dynamic";
export const fetchCache = "force-no-store";

force-dynamic pula o Cache de Rota Completa
force-no-store pula o Cache de Dados para todos os fetches na rota

O que causa o Cache do Roteador a servir dados desatualizados após uma mutação?

O Cache do Roteador do lado do cliente não invalida automaticamente após Server Actions
A navegação de voltar/avançar pode mostrar a página antiga
Chame router.refresh() no Client Component ou reduza staleTimes na configuração

O que acontece se duas chamadas `unstable_cache` compartilham as mesmas partes de chave, mas retornam dados diferentes?

Você obtém cache corrompido -- a forma de dados errada é retornada
Sempre use arrays de chaves únicos e descritivos para cada chamada unstable_cache
Esta é uma fonte comum de bugs difíceis de depurar em produção

Como `React.cache()` preserva os tipos TypeScript?

import { cache } from "react";
 
const getUser = cache(
  async (id: string): Promise<User | null> => {
    return db.user.findUnique({ where: { id } });
  }
);
// getUser: (id: string) => Promise<User | null>

A função envolvida retém exatamente a mesma assinatura e tipo de retorno

O Middleware compartilha o mesmo Cache de Dados que as funções de servidor Node.js?

Não. O Cache de Dados é por região de implantação
Middleware executando na edge pode não ver o mesmo cache que uma função de servidor Node.js
Esteja ciente dos limites de cache em implantações multirregionais

Quando você deve usar `unstable_cache` em vez de `React.cache()`?

React.cache() fornece apenas desduplicação por requisição; os dados não persistem entre requisições
unstable_cache fornece semântica de Cache de Dados (persiste entre requisições, suporta tags e revalidação)
Use unstable_cache para chamadas de banco de dados ou ORM que precisam de cache entre requisições

Como você configura o tempo de vida do Cache do Roteador para páginas dinâmicas?

// next.config.ts
const config: NextConfig = {
  experimental: {
    staleTimes: {
      dynamic: 0,   // não cachear páginas dinâmicas no cliente
      static: 300,  // cachear páginas estáticas por 5 minutos
    },
  },
};

Qual é o tipo para a exportação de configuração de segmento `fetchCache`?

export const fetchCache:
  | "auto"
  | "default-cache"
  | "only-cache"
  | "force-cache"
  | "force-no-store"
  | "default-no-store"
  | "only-no-store" = "auto";

Relacionados

Fetching -- Configurando opções de cache em chamadas fetch
Revalidation -- Invalidando dados em cache
Static vs Dynamic -- Como o cache determina o modo de renderização
Streaming -- Streaming de conteúdo em cache e dinâmico

Cache

Buscar na documentação

Cache