text stringlengths 49 1.09k | source stringclasses 119
values | id stringlengths 14 15 |
|---|---|---|
This cookies instance is read-only. To set cookies, you need to return a new Response using the Set-Cookie header.
app/api/route.ts import { cookies } from 'next/headers'
export async function GET(request: Request) {
const cookieStore = cookies()
const token = cookieStore.get('token')
return new Response('Hel... | https://nextjs.org/docs/app/building-your-application/routing/router-handlers | bca5fbe12397-6 |
const token = request.cookies.get('token')
}
Headers
You can read headers with headers from next/headers. This server function can be called directly in a Route Handler, or nested inside of another function.
This headers instance is read-only. To set headers, you need to return a new Response with new headers.
app/api/... | https://nextjs.org/docs/app/building-your-application/routing/router-handlers | bca5fbe12397-7 |
app/api/route.ts import { type NextRequest } from 'next/server'
export async function GET(request: NextRequest) {
const requestHeaders = new Headers(request.headers)
}
Redirects
app/api/route.ts import { redirect } from 'next/navigation'
export async function GET(request: Request) {
redirect('https://nextjs.org... | https://nextjs.org/docs/app/building-your-application/routing/router-handlers | bca5fbe12397-8 |
const slug = params.slug // 'a', 'b', or 'c'
}
RouteExample URLparamsapp/items/[slug]/route.js/items/a{ slug: 'a' }app/items/[slug]/route.js/items/b{ slug: 'b' }app/items/[slug]/route.js/items/c{ slug: 'c' }
Streaming
Streaming is commonly used in combination with Large Language Models (LLMs), such an OpenAI, for AI-ge... | https://nextjs.org/docs/app/building-your-application/routing/router-handlers | bca5fbe12397-9 |
export const runtime = 'edge'
export async function POST(req: Request) {
const { prompt } = await req.json()
const response = await openai.createCompletion({
model: 'text-davinci-003',
stream: true,
temperature: 0.6,
prompt: 'What is Next.js?',
})
const stream = OpenAIStream(response)
retu... | https://nextjs.org/docs/app/building-your-application/routing/router-handlers | bca5fbe12397-10 |
const { value, done } = await iterator.next()
if (done) {
controller.close()
} else {
controller.enqueue(value)
}
},
})
}
function sleep(time: number) {
return new Promise((resolve) => {
setTimeout(resolve, time)
})
}
const encoder = new TextEncoder()
async functi... | https://nextjs.org/docs/app/building-your-application/routing/router-handlers | bca5fbe12397-11 |
return new Response(stream)
}
Request Body
You can read the Request body using the standard Web API methods:
app/items/route.ts import { NextResponse } from 'next/server'
export async function POST(request: Request) {
const res = await request.json()
return NextResponse.json({ res })
}
Request Body FormData
You c... | https://nextjs.org/docs/app/building-your-application/routing/router-handlers | bca5fbe12397-12 |
CORS
You can set CORS headers on a Response using the standard Web API methods:
app/api/route.ts export async function GET(request: Request) {
return new Response('Hello, Next.js!', {
status: 200,
headers: {
'Access-Control-Allow-Origin': '*',
'Access-Control-Allow-Methods': 'GET, POST, PUT, DELET... | https://nextjs.org/docs/app/building-your-application/routing/router-handlers | bca5fbe12397-13 |
export const runtime = 'edge' // 'nodejs' is the default
Non-UI Responses
You can use Route Handlers to return non-UI content. Note that sitemap.xml, robots.txt, app icons, and open graph images all have built-in support.
app/rss.xml/route.ts export async function GET() {
return new Response(`<?xml version="1.0" enco... | https://nextjs.org/docs/app/building-your-application/routing/router-handlers | bca5fbe12397-14 |
app/items/route.ts export const dynamic = 'auto'
export const dynamicParams = true
export const revalidate = false
export const fetchCache = 'auto'
export const runtime = 'nodejs'
export const preferredRegion = 'auto'
See the API reference for more details. | https://nextjs.org/docs/app/building-your-application/routing/router-handlers | bca5fbe12397-15 |
InternationalizationNext.js enables you to configure the routing and rendering of content to support multiple languages. Making your site adaptive to different locales includes translated content (localization) and internationalized routes.
Terminology
Locale: An identifier for a set of language and formatting preferen... | https://nextjs.org/docs/app/building-your-application/routing/internationalization | 84f11a9b4025-0 |
middleware.js import { match } from '@formatjs/intl-localematcher'
import Negotiator from 'negotiator'
let headers = { 'accept-language': 'en-US,en;q=0.5' }
let languages = new Negotiator({ headers }).languages()
let locales = ['en-US', 'nl-NL', 'nl']
let defaultLocale = 'en-US'
match(languages, locales, defaultLoc... | https://nextjs.org/docs/app/building-your-application/routing/internationalization | 84f11a9b4025-1 |
function getLocale(request) { ... }
export function middleware(request) {
// Check if there is any supported locale in the pathname
const pathname = request.nextUrl.pathname
const pathnameIsMissingLocale = locales.every(
(locale) => !pathname.startsWith(`/${locale}/`) && pathname !== `/${locale}`
)
//... | https://nextjs.org/docs/app/building-your-application/routing/internationalization | 84f11a9b4025-2 |
// Skip all internal paths (_next)
'/((?!_next).*)',
// Optional: only run on root (/) URL
// '/'
],
}
Finally, ensure all special files inside app/ are nested under app/[lang]. This enables the Next.js router to dynamically handle different locales in the route, and forward the lang parameter to every la... | https://nextjs.org/docs/app/building-your-application/routing/internationalization | 84f11a9b4025-3 |
Localization
Changing displayed content based on the user’s preferred locale, or localization, is not something specific to Next.js. The patterns described below would work the same with any web application.
Let’s assume we want to support both English and Dutch content inside our application. We might maintain two dif... | https://nextjs.org/docs/app/building-your-application/routing/internationalization | 84f11a9b4025-4 |
app/[lang]/dictionaries.js import 'server-only'
const dictionaries = {
en: () => import('./dictionaries/en.json').then((module) => module.default),
nl: () => import('./dictionaries/nl.json').then((module) => module.default),
}
export const getDictionary = async (locale) => dictionaries[locale]()
Given the curre... | https://nextjs.org/docs/app/building-your-application/routing/internationalization | 84f11a9b4025-5 |
return <button>{dict.products.cart}</button> // Add to Cart
}
Because all layouts and pages in the app/ directory default to Server Components, we do not need to worry about the size of the translation files affecting our client-side JavaScript bundle size. This code will only run on the server, and only the resulting ... | https://nextjs.org/docs/app/building-your-application/routing/internationalization | 84f11a9b4025-6 |
</html>
)
}
Examples
Minimal i18n routing and translations
next-intl | https://nextjs.org/docs/app/building-your-application/routing/internationalization | 84f11a9b4025-7 |
Loading UI and StreamingThe special file loading.js helps you create meaningful Loading UI with React Suspense. With this convention, you can show an instant loading state from the server while the content of a route segment loads. The new content is automatically swapped in once rendering is complete.
Instant Loading ... | https://nextjs.org/docs/app/building-your-application/routing/loading-ui-and-streaming | 89c74743c9ee-0 |
return <LoadingSkeleton />
}
In the same folder, loading.js will be nested inside layout.js. It will automatically wrap the page.js file and any children below in a <Suspense> boundary.
Good to know:
Navigation is immediate, even with server-centric routing.
Navigation is interruptible, meaning changing routes does not... | https://nextjs.org/docs/app/building-your-application/routing/loading-ui-and-streaming | 89c74743c9ee-1 |
What is Streaming?
To learn how Streaming works in React and Next.js, it's helpful to understand Server-Side Rendering (SSR) and its limitations.
With SSR, there's a series of steps that need to be completed before a user can see and interact with a page:
First, all data for a given page is fetched on the server.
The s... | https://nextjs.org/docs/app/building-your-application/routing/loading-ui-and-streaming | 89c74743c9ee-2 |
SSR with React and Next.js helps improve the perceived loading performance by showing a non-interactive page to the user as soon as possible.
However, it can still be slow as all data fetching on server needs to be completed before the page can be shown to the user.
Streaming allows you to break down the page's HTML in... | https://nextjs.org/docs/app/building-your-application/routing/loading-ui-and-streaming | 89c74743c9ee-3 |
Streaming is particularly beneficial when you want to prevent long data requests from blocking the page from rendering as it can reduce the Time To First Byte (TTFB) and First Contentful Paint (FCP). It also helps improve Time to Interactive (TTI), especially on slower devices.
Example
<Suspense> works by wrapping a co... | https://nextjs.org/docs/app/building-your-application/routing/loading-ui-and-streaming | 89c74743c9ee-4 |
<Suspense fallback={<p>Loading weather...</p>}>
<Weather />
</Suspense>
</section>
)
}
By using Suspense, you get the benefits of:
Streaming Server Rendering - Progressively rendering HTML from the server to the client.
Selective Hydration - React prioritizes what components to make interactive firs... | https://nextjs.org/docs/app/building-your-application/routing/loading-ui-and-streaming | 89c74743c9ee-5 |
Defining Routes
We recommend reading the Routing Fundamentals page before continuing.
This page will guide you through how to define and organize routes in your Next.js application.
Creating Routes
Next.js uses a file-system based router where folders are used to define routes.
Each folder represents a route segment th... | https://nextjs.org/docs/app/building-your-application/routing/defining-routes | d19ca5281f3a-0 |
Creating UI
Special file conventions are used to create UI for each route segment. The most common are pages to show UI unique to a route, and layouts to show UI that is shared across multiple routes.
For example, to create your first page, add a page.js file inside the app directory and export a React component:
app/p... | https://nextjs.org/docs/app/building-your-application/routing/defining-routes | d19ca5281f3a-1 |
Linking and NavigatingThe Next.js router uses server-centric routing with client-side navigation. It supports instant loading states and concurrent rendering. This means navigation maintains client-side state, avoids expensive re-renders, is interruptible, and doesn't cause race conditions.
There are two ways to naviga... | https://nextjs.org/docs/app/building-your-application/routing/linking-and-navigating | 2a30fc3db42e-0 |
return <Link href="/dashboard">Dashboard</Link>
}
There are optional props you can pass to <Link>. See the API reference for more information.
Examples
Linking to Dynamic Segments
When linking to dynamic segments, you can use template literals and interpolation to generate a list of links. For example, to generate a li... | https://nextjs.org/docs/app/building-your-application/routing/linking-and-navigating | 2a30fc3db42e-1 |
))}
</ul>
)
}
Checking Active Links
You can use usePathname() to determine if a link is active. For example, to add a class to the active link, you can check if the current pathname matches the href of the link:
app/ui/Navigation.js 'use client'
import { usePathname } from 'next/navigation'
import Link from 'ne... | https://nextjs.org/docs/app/building-your-application/routing/linking-and-navigating | 2a30fc3db42e-2 |
>
{link.name}
</Link>
)
})}
</>
)
}
Scrolling to an id
The default behavior of <Link> is to scroll to the top of the route segment that has changed. When there is an id defined in href, it will scroll to the specific id, similarly to a normal <a> tag.
useRouter() Hook
The useRo... | https://nextjs.org/docs/app/building-your-application/routing/linking-and-navigating | 2a30fc3db42e-3 |
Dashboard
</button>
)
}
The useRouter provides methods such as push(), refresh(), and more. See the API reference for more information.
Recommendation: Use the <Link> component to navigate between routes unless you have a specific requirement for using useRouter.
How Navigation Works
A route transition is initiat... | https://nextjs.org/docs/app/building-your-application/routing/linking-and-navigating | 2a30fc3db42e-4 |
If created, loading UI is shown from the server while the payload is being fetched.
The router uses the cached or fresh payload to render the new segments on the client.
Client-side Caching of Rendered Server Components
Good to know: This client-side cache is different from the server-side Next.js HTTP cache.
The new r... | https://nextjs.org/docs/app/building-your-application/routing/linking-and-navigating | 2a30fc3db42e-5 |
Invalidating the Cache
Server Actions can be used to revalidate data on-demand by path (revalidatePath) or by cache tag (revalidateTag).
Prefetching
Prefetching is a way to preload a route in the background before it's visited. The rendered result of prefetched routes is added to the router's client-side cache. This ma... | https://nextjs.org/docs/app/building-your-application/routing/linking-and-navigating | 2a30fc3db42e-6 |
If the route is dynamic, the payload from the first shared layout down until the first loading.js file is prefetched. This reduces the cost of prefetching the whole route dynamically and allows instant loading states for dynamic routes.
Good to know:
Prefetching is only enabled in production.
Prefetching can be disable... | https://nextjs.org/docs/app/building-your-application/routing/linking-and-navigating | 2a30fc3db42e-7 |
Navigating from /dashboard/team-red/* to /dashboard/team-red/* will be a soft navigation.
Navigating from /dashboard/team-red/* to /dashboard/team-blue/* will be a hard navigation.
Hard Navigation
On navigation, the cache is invalidated and the server refetches data and re-renders the changed segments.
Back/Forward Nav... | https://nextjs.org/docs/app/building-your-application/routing/linking-and-navigating | 2a30fc3db42e-8 |
Pages and Layouts
We recommend reading the Routing Fundamentals and Defining Routes pages before continuing.
The App Router inside Next.js 13 introduced new file conventions to easily create pages, shared layouts, and templates. This page will guide you through how to use these special files in your Next.js application... | https://nextjs.org/docs/app/building-your-application/routing/pages-and-layouts | cfe7de3b4dec-0 |
export default function Page() {
return <h1>Hello, Dashboard Page!</h1>
}
Good to know:
A page is always the leaf of the route subtree.
.js, .jsx, or .tsx file extensions can be used for Pages.
A page.js file is required to make a route segment publicly accessible.
Pages are Server Components by default but can be se... | https://nextjs.org/docs/app/building-your-application/routing/pages-and-layouts | cfe7de3b4dec-1 |
app/dashboard/layout.tsx export default function DashboardLayout({
children, // will be a page or nested layout
}: {
children: React.ReactNode
}) {
return (
<section>
{/* Include shared UI here e.g. a header or sidebar */}
<nav></nav>
{children}
</section>
)
}
Good to know:
The top-m... | https://nextjs.org/docs/app/building-your-application/routing/pages-and-layouts | cfe7de3b4dec-2 |
You can use Route Groups to opt specific route segments in and out of shared layouts.
Layouts are Server Components by default but can be set to a Client Component.
Layouts can fetch data. View the Data Fetching section for more information.
Passing data between a parent layout and its children is not possible. However... | https://nextjs.org/docs/app/building-your-application/routing/pages-and-layouts | cfe7de3b4dec-3 |
Root Layout (Required)
The root layout is defined at the top level of the app directory and applies to all routes. This layout enables you to modify the initial HTML returned from the server.
app/layout.tsx export default function RootLayout({
children,
}: {
children: React.ReactNode
}) {
return (
<html lang=... | https://nextjs.org/docs/app/building-your-application/routing/pages-and-layouts | cfe7de3b4dec-4 |
The root layout is a Server Component by default and can not be set to a Client Component.
Migrating from the pages directory: The root layout replaces the _app.js and _document.js files. View the migration guide.
Nesting Layouts
Layouts defined inside a folder (e.g. app/dashboard/layout.js) apply to specific route seg... | https://nextjs.org/docs/app/building-your-application/routing/pages-and-layouts | cfe7de3b4dec-5 |
Only the root layout can contain <html> and <body> tags.
If you were to combine the two layouts above, the root layout (app/layout.js) would wrap the dashboard layout (app/dashboard/layout.js), which would wrap route segments inside app/dashboard/*.
The two layouts would be nested as such:
You can use Route Groups to o... | https://nextjs.org/docs/app/building-your-application/routing/pages-and-layouts | cfe7de3b4dec-6 |
Enter/exit animations using CSS or animation libraries.
Features that rely on useEffect (e.g logging page views) and useState (e.g a per-page feedback form).
To change the default framework behavior. For example, Suspense Boundaries inside layouts only show the fallback the first time the Layout is loaded and not when ... | https://nextjs.org/docs/app/building-your-application/routing/pages-and-layouts | cfe7de3b4dec-7 |
Output <Layout>
{/* Note that the template is given a unique key. */}
<Template key={routeParam}>{children}</Template>
</Layout>
Modifying <head>
In the app directory, you can modify the <head> HTML elements such as title and meta using the built-in SEO support.
Metadata can be defined by exporting a metadata objec... | https://nextjs.org/docs/app/building-your-application/routing/pages-and-layouts | cfe7de3b4dec-8 |
Learn more about available metadata options in the API reference. | https://nextjs.org/docs/app/building-your-application/routing/pages-and-layouts | cfe7de3b4dec-9 |
Middleware
Middleware allows you to run code before a request is completed. Then, based on the incoming request, you can modify the response by rewriting, redirecting, modifying the request or response headers, or responding directly.
Middleware runs before cached content and routes are matched. See Matching Paths for ... | https://nextjs.org/docs/app/building-your-application/routing/middleware | d714de5ad9e8-0 |
// See "Matching Paths" below to learn more
export const config = {
matcher: '/about/:path*',
}
Matching Paths
Middleware will be invoked for every route in your project. The following is the execution order:
headers from next.config.js
redirects from next.config.js
Middleware (rewrites, redirects, etc.)
beforeFiles ... | https://nextjs.org/docs/app/building-your-application/routing/middleware | d714de5ad9e8-1 |
middleware.js export const config = {
matcher: '/about/:path*',
}
You can match a single path or multiple paths with an array syntax:
middleware.js export const config = {
matcher: ['/about/:path*', '/dashboard/:path*'],
}
The matcher config allows full regex so matching like negative lookaheads or character matchi... | https://nextjs.org/docs/app/building-your-application/routing/middleware | d714de5ad9e8-2 |
],
}
Good to know: The matcher values need to be constants so they can be statically analyzed at build-time. Dynamic values such as variables will be ignored.
Configured matchers:
MUST start with /
Can include named parameters: /about/:path matches /about/a and /about/b but not /about/a/c
Can have modifiers on named pa... | https://nextjs.org/docs/app/building-your-application/routing/middleware | d714de5ad9e8-3 |
Conditional Statements
middleware.ts import { NextResponse } from 'next/server'
import type { NextRequest } from 'next/server'
export function middleware(request: NextRequest) {
if (request.nextUrl.pathname.startsWith('/about')) {
return NextResponse.rewrite(new URL('/about-2', request.url))
}
if (request... | https://nextjs.org/docs/app/building-your-application/routing/middleware | d714de5ad9e8-4 |
rewrite to a route (Page or Route Handler) that produces a response
return a NextResponse directly. See Producing a Response
Using Cookies
Cookies are regular headers. On a Request, they are stored in the Cookie header. On a Response they are in the Set-Cookie header. Next.js provides a convenient way to access and man... | https://nextjs.org/docs/app/building-your-application/routing/middleware | d714de5ad9e8-5 |
// Getting cookies from the request using the `RequestCookies` API
let cookie = request.cookies.get('nextjs')
console.log(cookie) // => { name: 'nextjs', value: 'fast', Path: '/' }
const allCookies = request.cookies.getAll()
console.log(allCookies) // => [{ name: 'nextjs', value: 'fast' }]
request.cookies.h... | https://nextjs.org/docs/app/building-your-application/routing/middleware | d714de5ad9e8-6 |
path: '/',
})
cookie = response.cookies.get('vercel')
console.log(cookie) // => { name: 'vercel', value: 'fast', Path: '/' }
// The outgoing response will have a `Set-Cookie:vercel=fast;path=/test` header.
return response
}
Setting Headers
You can set request and response headers using the NextResponse API ... | https://nextjs.org/docs/app/building-your-application/routing/middleware | d714de5ad9e8-7 |
requestHeaders.set('x-hello-from-middleware1', 'hello')
// You can also set request headers in NextResponse.rewrite
const response = NextResponse.next({
request: {
// New request headers
headers: requestHeaders,
},
})
// Set a new response header `x-hello-from-middleware2`
response.hea... | https://nextjs.org/docs/app/building-your-application/routing/middleware | d714de5ad9e8-8 |
import { isAuthenticated } from '@lib/auth'
// Limit the middleware to paths starting with `/api/`
export const config = {
matcher: '/api/:function*',
}
export function middleware(request: NextRequest) {
// Call our authentication function to check the request
if (!isAuthenticated(request)) {
// Respond w... | https://nextjs.org/docs/app/building-your-application/routing/middleware | d714de5ad9e8-9 |
skipTrailingSlashRedirect allows disabling Next.js default redirects for adding or removing trailing slashes allowing custom handling inside middleware which can allow maintaining the trailing slash for some paths but not others allowing easier incremental migrations.
next.config.js module.exports = {
skipTrailingSla... | https://nextjs.org/docs/app/building-your-application/routing/middleware | d714de5ad9e8-10 |
return NextResponse.redirect(req.nextUrl)
}
}
skipMiddlewareUrlNormalize allows disabling the URL normalizing Next.js does to make handling direct visits and client-transitions the same. There are some advanced cases where you need full control using the original URL which this unlocks.
next.config.js module.exports ... | https://nextjs.org/docs/app/building-your-application/routing/middleware | d714de5ad9e8-11 |
// without the flag this would be normalized to /hello
}
Version History
VersionChangesv13.1.0Advanced Middleware flags addedv13.0.0Middleware can modify request headers, response headers, and send responsesv12.2.0Middleware is stable, please see the upgrade guidev12.0.9Enforce absolute URLs in Edge Runtime (PR)v12.0.0... | https://nextjs.org/docs/app/building-your-application/routing/middleware | d714de5ad9e8-12 |
Intercepting RoutesIntercepting routes allows you to load a route within the current layout while keeping the context for the current page. This routing paradigm can be useful when you want to "intercept" a certain route to show a different route.
For example, when clicking on a photo from within a feed, a modal overla... | https://nextjs.org/docs/app/building-your-application/routing/intercepting-routes | 205742354301-0 |
(.) to match segments on the same level
(..) to match segments one level above
(..)(..) to match segments two levels above
(...) to match segments from the root app directory
For example, you can intercept the photo segment from within the feed segment by creating a (..)photo directory.
Note that the (..) convention is... | https://nextjs.org/docs/app/building-your-application/routing/intercepting-routes | 205742354301-1 |
Reopen the modal on forwards navigation
In the above example, the path to the photo segment can use the (..) matcher since @modal is a slot and not a segment. This means that the photo route is only one segment level higher, despite being two file-system levels higher.
Other examples could include opening a login modal... | https://nextjs.org/docs/app/building-your-application/routing/intercepting-routes | 205742354301-2 |
Dynamic RoutesWhen you don't know the exact segment names ahead of time and want to create routes from dynamic data, you can use Dynamic Segments that are filled in at request time or prerendered at build time.
Convention
A Dynamic Segment can be created by wrapping a folder's name in square brackets: [folderName]. For... | https://nextjs.org/docs/app/building-your-application/routing/dynamic-routes | f91f50f8d40a-0 |
return <div>My Post: {params.slug}</div>
}
RouteExample URLparamsapp/blog/[slug]/page.js/blog/a{ slug: 'a' }app/blog/[slug]/page.js/blog/b{ slug: 'b' }app/blog/[slug]/page.js/blog/c{ slug: 'c' }
See the generateStaticParams() page to learn how to generate the params for the segment.
Good to know: Dynamic Segments are e... | https://nextjs.org/docs/app/building-your-application/routing/dynamic-routes | f91f50f8d40a-1 |
return posts.map((post) => ({
slug: post.slug,
}))
}
The primary benefit of the generateStaticParams function is its smart retrieval of data. If content is fetched within the generateStaticParams function using a fetch request, the requests are automatically deduplicated. This means a fetch request with the same ... | https://nextjs.org/docs/app/building-your-application/routing/dynamic-routes | f91f50f8d40a-2 |
RouteExample URLparamsapp/shop/[...slug]/page.js/shop/a{ slug: ['a'] }app/shop/[...slug]/page.js/shop/a/b{ slug: ['a', 'b'] }app/shop/[...slug]/page.js/shop/a/b/c{ slug: ['a', 'b', 'c'] }
Optional Catch-all Segments
Catch-all Segments can be made optional by including the parameter in double square brackets: [[...folde... | https://nextjs.org/docs/app/building-your-application/routing/dynamic-routes | f91f50f8d40a-3 |
RouteExample URLparamsapp/shop/[[...slug]]/page.js/shop{}app/shop/[[...slug]]/page.js/shop/a{ slug: ['a'] }app/shop/[[...slug]]/page.js/shop/a/b{ slug: ['a', 'b'] }app/shop/[[...slug]]/page.js/shop/a/b/c{ slug: ['a', 'b', 'c'] }
TypeScript
When using TypeScript, you can add types for params depending on your configured... | https://nextjs.org/docs/app/building-your-application/routing/dynamic-routes | f91f50f8d40a-4 |
Good to know: This may be done automatically by the TypeScript plugin in the future. | https://nextjs.org/docs/app/building-your-application/routing/dynamic-routes | f91f50f8d40a-5 |
Parallel RoutesParallel Routing allows you to simultaneously or conditionally render one or more pages in the same layout. For highly dynamic sections of an app, such as dashboards and feeds on social sites, Parallel Routing can be used to implement complex routing patterns.
For example, you can simultaneously render t... | https://nextjs.org/docs/app/building-your-application/routing/parallel-routes | dcbde6e320fb-0 |
For example, the following file structure defines two explicit slots: @analytics and @team.
The folder structure above means that the component in app/layout.js now accepts the @analytics and @team slots props, and can render them in parallel alongside the children prop:
app/layout.tsx export default function Layout(pr... | https://nextjs.org/docs/app/building-your-application/routing/parallel-routes | dcbde6e320fb-1 |
Unmatched Routes
By default, the content rendered within a slot will match the current URL.
In the case of an unmatched slot, the content that Next.js renders differs based on the routing technique and folder structure.
default.js
You can define a default.js file to render as a fallback when Next.js cannot recover a sl... | https://nextjs.org/docs/app/building-your-application/routing/parallel-routes | dcbde6e320fb-2 |
Soft Navigation
On a soft navigation - Next.js will render the slot's previously active state, even if it doesn't match the current URL.
Hard Navigation
On a hard navigation - a navigation that requires a full page reload - Next.js will first try to render the unmatched slot's default.js file. If that's not available, ... | https://nextjs.org/docs/app/building-your-application/routing/parallel-routes | dcbde6e320fb-3 |
}) {
const loginSegments = useSelectedLayoutSegment('authModal')
// ...
}
When a user navigates to @authModal/login, or /login in the URL bar, loginSegments will be equal to the string "login".
Examples
Modals
Parallel Routing can be used to render modals.
The @authModal slot renders a <Modal> component that can be... | https://nextjs.org/docs/app/building-your-application/routing/parallel-routes | dcbde6e320fb-4 |
return (
<Modal>
<h1>Login</h1>
{/* ... */}
</Modal>
)
}
To ensure that the contents of the modal don't get rendered when it's not active, you can create a default.js file that returns null.
app/@authModal/default.tsx export default function Default() {
return null
}
Dismissing a modal
If a moda... | https://nextjs.org/docs/app/building-your-application/routing/parallel-routes | dcbde6e320fb-5 |
const router = useRouter()
return (
<Modal>
<span onClick={() => router.back()}>Close modal</span>
<h1>Login</h1>
...
</Modal>
)
}
More information on modals is covered in the Intercepting Routes section.
If you want to navigate elsewhere and dismiss a modal, you can also use a catch-all r... | https://nextjs.org/docs/app/building-your-application/routing/parallel-routes | dcbde6e320fb-6 |
dashboard,
login,
}: {
dashboard: React.ReactNode
login: React.ReactNode
}) {
const isLoggedIn = getUser()
return isLoggedIn ? dashboard : login
} | https://nextjs.org/docs/app/building-your-application/routing/parallel-routes | dcbde6e320fb-7 |
Project Organization and File ColocationApart from routing folder and file conventions, Next.js is unopinionated about how you organize and colocate your project files.
This page shares default behavior and features you can use to organize your project.
Safe colocation by default
Project organization features
Project o... | https://nextjs.org/docs/app/building-your-application/routing/colocation | 0a8e13fe6b82-0 |
Good to know:
This is different from the pages directory, where any file in pages is considered a route.
While you can colocate your project files in app you don't have to. If you prefer, you can keep them outside the app directory.
Project organization features
Next.js provides several features to help you organize yo... | https://nextjs.org/docs/app/building-your-application/routing/colocation | 0a8e13fe6b82-1 |
Sorting and grouping files in code editors.
Avoiding potential naming conflicts with future Next.js file conventions.
Good to know
While not a framework convention, you might also consider marking files outside private folders as "private" using the same underscore pattern.
You can create URL segments that start with a... | https://nextjs.org/docs/app/building-your-application/routing/colocation | 0a8e13fe6b82-2 |
Enabling nested layouts in the same route segment level:
Creating multiple nested layouts in the same segment, including multiple root layouts
Adding a layout to a subset of routes in a common segment
src Directory
Next.js supports storing application code (including app) inside an optional src directory. This separate... | https://nextjs.org/docs/app/building-your-application/routing/colocation | 0a8e13fe6b82-3 |
The following section lists a very high-level overview of common strategies. The simplest takeaway is to choose a strategy that works for you and your team and be consistent across the project.
Good to know: In our examples below, we're using components and lib folders as generalized placeholders, their naming has no s... | https://nextjs.org/docs/app/building-your-application/routing/colocation | 0a8e13fe6b82-4 |
Route GroupsIn the app directory, nested folders are normally mapped to URL paths. However, you can mark a folder as a Route Group to prevent the folder from being included in the route's URL path.
This allows you to organize your route segments and project files into logical groups without affecting the URL path struc... | https://nextjs.org/docs/app/building-your-application/routing/route-groups | b9cadd55c338-0 |
Even though routes inside (marketing) and (shop) share the same URL hierarchy, you can create a different layout for each group by adding a layout.js file inside their folders.
Opting specific segments into a layout
To opt specific routes into a layout, create a new route group (e.g. (shop)) and move the routes that sh... | https://nextjs.org/docs/app/building-your-application/routing/route-groups | b9cadd55c338-1 |
Good to know:
The naming of route groups has no special significance other than for organization. They do not affect the URL path.
Routes that include a route group should not resolve to the same URL path as other routes. For example, since route groups don't affect URL structure, (marketing)/about/page.js and (shop)/a... | https://nextjs.org/docs/app/building-your-application/routing/route-groups | b9cadd55c338-2 |
Static and Dynamic RenderingIn Next.js, a route can be statically or dynamically rendered.
In a static route, components are rendered on the server at build time. The result of the work is cached and reused on subsequent requests.
In a dynamic route, components are rendered on the server at request time.
Static Renderi... | https://nextjs.org/docs/app/building-your-application/rendering/static-and-dynamic-rendering | 41cfb77f0402-0 |
To learn more about caching data fetching requests, see the Caching and Revalidating page.
Dynamic Rendering
During static rendering, if a dynamic function or a dynamic fetch() request (no caching) is discovered, Next.js will switch to dynamically rendering the whole route at request time. Any cached data requests can ... | https://nextjs.org/docs/app/building-your-application/rendering/static-and-dynamic-rendering | 41cfb77f0402-1 |
Good to know: In the future, Next.js will introduce hybrid server-side rendering where layouts and pages in a route can be independently statically or dynamically rendered, instead of the whole route.
Dynamic Functions
Dynamic functions rely on information that can only be known at request time such as a user's cookies... | https://nextjs.org/docs/app/building-your-application/rendering/static-and-dynamic-rendering | 41cfb77f0402-2 |
Dynamic Data Fetching
Dynamic data fetches are fetch() requests that specifically opt out of caching behavior by setting the cache option to 'no-store' or revalidate to 0.
The caching options for all fetch requests in a layout or page can also be set using the segment config object.
To learn more about Dynamic Data Fet... | https://nextjs.org/docs/app/building-your-application/rendering/static-and-dynamic-rendering | 41cfb77f0402-3 |
Edge and Node.js Runtimes
In the context of Next.js, "runtime" refers to the set of libraries, APIs, and general functionality available to your code during execution.
Next.js has two server runtimes where you can render parts of your application code:
Node.js Runtime
Edge Runtime
Each runtime has its own set of APIs. ... | https://nextjs.org/docs/app/building-your-application/rendering/edge-and-nodejs-runtimes | e595fbf5bdeb-0 |
NodeServerlessEdgeCold Boot/~250msInstantHTTP StreamingYesYesYesIOAllAllfetchScalability/HighHighestSecurityNormalHighHighLatencyNormalLowLowestnpm PackagesAllAllA smaller subset
Edge Runtime
In Next.js, the lightweight Edge Runtime is a subset of available Node.js APIs.
The Edge Runtime is ideal if you need to deliver... | https://nextjs.org/docs/app/building-your-application/rendering/edge-and-nodejs-runtimes | e595fbf5bdeb-1 |
Deploying your Next.js application to a Node.js server will require managing, scaling, and configuring your infrastructure. Alternatively, you can consider deploying your Next.js application to a serverless platform like Vercel, which will handle this for you.
Serverless Node.js
Serverless is ideal if you need a scalab... | https://nextjs.org/docs/app/building-your-application/rendering/edge-and-nodejs-runtimes | e595fbf5bdeb-2 |
Examples
Segment Runtime Option
You can specify a runtime for individual route segments in your Next.js application. To do so, declare a variable called runtime and export it. The variable must be a string, and must have a value of either 'nodejs' or 'edge' runtime.The following example demonstrates a page route segmen... | https://nextjs.org/docs/app/building-your-application/rendering/edge-and-nodejs-runtimes | e595fbf5bdeb-3 |
Server ActionsServer Actions are an alpha feature in Next.js, built on top of React Actions. They enable server-side data mutations, reduced client-side JavaScript, and progressively enhanced forms. They can be defined inside Server Components and/or called from Client Components:
With Server Components:
app/add-to-car... | https://nextjs.org/docs/app/building-your-application/data-fetching/server-actions | cc4a940c4965-0 |
app/actions.js 'use server'
export async function addItem(data) {
const cartId = cookies().get('cartId')?.value
await saveToDb({ cartId, data })
}
app/add-to-cart.js 'use client'
import { addItem } from './actions.js'
// Server Action being called inside a Client Component
export default function AddToCart({ ... | https://nextjs.org/docs/app/building-your-application/data-fetching/server-actions | cc4a940c4965-1 |
Next.js integrates React Actions into the Next.js router, bundler, and caching system, including adding data mutation APIs like revalidateTag and revalidatePath.
Convention
You can enable Server Actions in your Next.js project by enabling the experimental serverActions flag.
next.config.js module.exports = {
experime... | https://nextjs.org/docs/app/building-your-application/data-fetching/server-actions | cc4a940c4965-2 |
app/server-component.js export default function ServerComponent() {
async function myAction() {
'use server'
// ...
}
}
With Client Components
If you're using a Server Action inside a Client Component, create your action in a separate file with the "use server" directive at the top of the file. Then, import... | https://nextjs.org/docs/app/building-your-application/data-fetching/server-actions | cc4a940c4965-3 |
</form>
)
}
Good to know: When using a top-level "use server" directive, all exports below will be considered Server Actions. You can have multiple Server Actions in a single file.
Invocation
You can invoke Server Actions using the following methods:
Using action: React's action prop allows invoking a Server Action o... | https://nextjs.org/docs/app/building-your-application/data-fetching/server-actions | cc4a940c4965-4 |
app/add-to-cart.js import { cookies } from 'next/headers'
export default function AddToCart({ productId }) {
async function addItem(data) {
'use server'
const cartId = cookies().get('cartId')?.value
await saveToDb({ cartId, data })
}
return (
<form action={addItem}>
<button type="submi... | https://nextjs.org/docs/app/building-your-application/data-fetching/server-actions | cc4a940c4965-5 |
async function handleSubmit() {
'use server'
// ...
}
async function submitImage() {
'use server'
// ...
}
return (
<form action={handleSubmit}>
<input type="text" name="name" />
<input type="image" formAction={submitImage} />
<button type="submit">Submit</button>
<... | https://nextjs.org/docs/app/building-your-application/data-fetching/server-actions | cc4a940c4965-6 |
Good to know: Using startTransition disables the out-of-the-box Progressive Enhancement.
app/components/example-client-component.js 'use client'
import { useTransition } from 'react'
import { addItem } from '../actions'
function ExampleClientComponent({ id }) {
let [isPending, startTransition] = useTransition()
... | https://nextjs.org/docs/app/building-your-application/data-fetching/server-actions | cc4a940c4965-7 |
app/posts/[id]/page.tsx import kv from '@vercel/kv'
import LikeButton from './like-button'
export default function Page({ params }: { params: { id: string } }) {
async function increment() {
'use server'
await kv.incr(`post:id:${params.id}`)
}
return <LikeButton increment={increment} />
}
app/post/[id... | https://nextjs.org/docs/app/building-your-application/data-fetching/server-actions | cc4a940c4965-8 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.