|
|
--- |
|
|
title: after |
|
|
description: API Reference for the after function. |
|
|
--- |
|
|
|
|
|
`after` allows you to schedule work to be executed after a response (or prerender) is finished. This is useful for tasks and other side effects that should not block the response, such as logging and analytics. |
|
|
|
|
|
It can be used in [Server Components](/docs/app/getting-started/server-and-client-components) (including [`generateMetadata`](https://nextjs.org/docs/app/api-reference/functions/generate-metadata)), [Server Actions](/docs/app/getting-started/updating-data), [Route Handlers](/docs/app/api-reference/file-conventions/route), and [Middleware](/docs/app/api-reference/file-conventions/middleware). |
|
|
|
|
|
The function accepts a callback that will be executed after the response (or prerender) is finished: |
|
|
|
|
|
```tsx filename="app/layout.tsx" switcher |
|
|
import { after } from 'next/server' |
|
|
// Custom logging function |
|
|
import { log } from '@/app/utils' |
|
|
|
|
|
export default function Layout({ children }: { children: React.ReactNode }) { |
|
|
after(() => { |
|
|
// Execute after the layout is rendered and sent to the user |
|
|
log() |
|
|
}) |
|
|
return <>{children}</> |
|
|
} |
|
|
``` |
|
|
|
|
|
```jsx filename="app/layout.jsx" switcher |
|
|
import { after } from 'next/server' |
|
|
// Custom logging function |
|
|
import { log } from '@/app/utils' |
|
|
|
|
|
export default function Layout({ children }) { |
|
|
after(() => { |
|
|
// Execute after the layout is rendered and sent to the user |
|
|
log() |
|
|
}) |
|
|
return <>{children}</> |
|
|
} |
|
|
``` |
|
|
|
|
|
> **Good to know:** `after` is not a [Dynamic API](/docs/app/getting-started/partial-prerendering |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
- A callback function which will be executed after the response (or prerender) is finished. |
|
|
|
|
|
|
|
|
|
|
|
`after` will run for the platform's default or configured max duration of your route. If your platform supports it, you can configure the timeout limit using the [`maxDuration`](/docs/app/api-reference/file-conventions/route-segment-config#maxduration) route segment config. |
|
|
|
|
|
## Good to know |
|
|
|
|
|
- `after` will be executed even if the response didn't complete successfully. Including when an error is thrown or when `notFound` or `redirect` is called. |
|
|
- You can use React `cache` to deduplicate functions called inside `after`. |
|
|
- `after` can be nested inside other `after` calls, for example, you can create utility functions that wrap `after` calls to add additional functionality. |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
You can use request APIs such as [`cookies`](/docs/app/api-reference/functions/cookies) and [`headers`](/docs/app/api-reference/functions/headers) inside `after` in [Server Actions](/docs/app/getting-started/updating-data) and [Route Handlers](/docs/app/api-reference/file-conventions/route). This is useful for logging activity after a mutation. For example: |
|
|
|
|
|
```ts filename="app/api/route.ts" highlight={2,7-9} switcher |
|
|
import { after } from 'next/server' |
|
|
import { cookies, headers } from 'next/headers' |
|
|
import { logUserAction } from '@/app/utils' |
|
|
|
|
|
export async function POST(request: Request) { |
|
|
// Perform mutation |
|
|
// ... |
|
|
|
|
|
// Log user activity for analytics |
|
|
after(async () => { |
|
|
const userAgent = (await headers().get('user-agent')) || 'unknown' |
|
|
const sessionCookie = |
|
|
(await cookies().get('session-id'))?.value || 'anonymous' |
|
|
|
|
|
logUserAction({ sessionCookie, userAgent }) |
|
|
}) |
|
|
|
|
|
return new Response(JSON.stringify({ status: 'success' }), { |
|
|
status: 200, |
|
|
headers: { 'Content-Type': 'application/json' }, |
|
|
}) |
|
|
} |
|
|
``` |
|
|
|
|
|
```js filename="app/api/route.js" highlight={2,7-9} switcher |
|
|
import { after } from 'next/server' |
|
|
import { cookies, headers } from 'next/headers' |
|
|
import { logUserAction } from '@/app/utils' |
|
|
|
|
|
export async function POST(request) { |
|
|
// Perform mutation |
|
|
// ... |
|
|
|
|
|
// Log user activity for analytics |
|
|
after(async () => { |
|
|
const userAgent = (await headers().get('user-agent')) || 'unknown' |
|
|
const sessionCookie = |
|
|
(await cookies().get('session-id'))?.value || 'anonymous' |
|
|
|
|
|
logUserAction({ sessionCookie, userAgent }) |
|
|
}) |
|
|
|
|
|
return new Response(JSON.stringify({ status: 'success' }), { |
|
|
status: 200, |
|
|
headers: { 'Content-Type': 'application/json' }, |
|
|
}) |
|
|
} |
|
|
``` |
|
|
|
|
|
However, you cannot use these request APIs inside `after` in [Server Components](/docs/app/getting-started/server-and-client-components). This is because Next.js needs to know which part of the tree access the request APIs to support [Partial Prerendering](/docs/app/getting-started/partial-prerendering), but `after` runs after React's rendering lifecycle. |
|
|
|
|
|
## Platform Support |
|
|
|
|
|
| Deployment Option | Supported | |
|
|
| ------------------------------------------------------------------- | ----------------- | |
|
|
| [Node.js server](/docs/app/getting-started/deploying#nodejs-server) | Yes | |
|
|
| [Docker container](/docs/app/getting-started/deploying#docker) | Yes | |
|
|
| [Static export](/docs/app/getting-started/deploying#static-export) | No | |
|
|
| [Adapters](/docs/app/getting-started/deploying#adapters) | Platform-specific | |
|
|
|
|
|
Learn how to [configure `after`](/docs/app/guides/self-hosting#after) when self-hosting Next.js. |
|
|
|
|
|
<details id="after-serverless"> |
|
|
<summary>Reference: supporting `after` for serverless platforms</summary> |
|
|
|
|
|
Using `after` in a serverless context requires waiting for asynchronous tasks to finish after the response has been sent. In Next.js and Vercel, this is achieved using a primitive called `waitUntil(promise)`, which extends the lifetime of a serverless invocation until all promises passed to [`waitUntil`](https://vercel.com/docs/functions/functions-api-reference#waituntil) have settled. |
|
|
|
|
|
If you want your users to be able to run `after`, you will have to provide your implementation of `waitUntil` that behaves in an analogous way. |
|
|
|
|
|
When `after` is called, Next.js will access `waitUntil` like this: |
|
|
|
|
|
```jsx |
|
|
const RequestContext = globalThis[Symbol.for('@next/request-context')] |
|
|
const contextValue = RequestContext?.get() |
|
|
const waitUntil = contextValue?.waitUntil |
|
|
``` |
|
|
|
|
|
Which means that `globalThis[Symbol.for('@next/request-context')]` is expected to contain an object like this: |
|
|
|
|
|
```tsx |
|
|
type NextRequestContext = { |
|
|
get(): NextRequestContextValue | undefined |
|
|
} |
|
|
|
|
|
type NextRequestContextValue = { |
|
|
waitUntil?: (promise: Promise<any>) => void |
|
|
} |
|
|
``` |
|
|
|
|
|
Here is an example of the implementation. |
|
|
|
|
|
```tsx |
|
|
import { AsyncLocalStorage } from 'node:async_hooks' |
|
|
|
|
|
const RequestContextStorage = new AsyncLocalStorage<NextRequestContextValue>() |
|
|
|
|
|
// Define and inject the accessor that next.js will use |
|
|
const RequestContext: NextRequestContext = { |
|
|
get() { |
|
|
return RequestContextStorage.getStore() |
|
|
}, |
|
|
} |
|
|
globalThis[Symbol.for('@next/request-context')] = RequestContext |
|
|
|
|
|
const handler = (req, res) => { |
|
|
const contextValue = { waitUntil: YOUR_WAITUNTIL } |
|
|
// Provide the value |
|
|
return RequestContextStorage.run(contextValue, () => nextJsHandler(req, res)) |
|
|
} |
|
|
``` |
|
|
|
|
|
</details> |
|
|
|
|
|
## Version History |
|
|
|
|
|
| Version History | Description | |
|
|
| --------------- | ---------------------------- | |
|
|
| `v15.1.0` | `after` became stable. | |
|
|
| `v15.0.0-rc` | `unstable_after` introduced. | |
|
|
|
