Unverified Commit f4a68604 authored by Hendrik Liebau's avatar Hendrik Liebau Committed by GitHub

Preserve error boundaries in on-demand partial prerenders (#99051)

An on-demand prerender failure still throws when its recovery output
requires a resume. This hides the route's error boundary behind a
generic error response, even when healthy parts of the page could
continue rendering.

Failures now retain their original error and serialized postponed state.
Self-hosted servers append a separate continuation for each document
request. Adapter deployments use the existing platform transport to
resume with the actual request.

In `next start`, a failed partial prerender follows the same prerender
and resume flow as a successful PPR cache miss. Failed preludes are not
persisted, so later independent requests retry prerendering before
resuming. Concurrent requests can share the pending prerender, and each
document request owns its resume.

The response retains status 500 and non-cacheable headers. Failed output
is not persisted as a successful ISR entry. Build failures and recovery
without a usable Flight result continue to throw.

The tests cover errors inside and outside Suspense, request-specific
dynamic content, navigation after failed prefetches, same-URL recovery,
successful-page retention, and original-error reporting.
parent c54cc098
......@@ -2988,14 +2988,8 @@ async function prerenderAppPage({
}
}
// Keep the original failure for builds and incomplete prerender results.
//
// TODO: Preserve postponed state in on-demand failures and resume their
// recovery output during response delivery.
if (
renderError !== undefined &&
(renderOpts.isBuildTimePrerendering || metadata.postponed !== undefined)
) {
// Build failures still throw, even if recovery produced a usable response.
if (renderError !== undefined && renderOpts.isBuildTimePrerendering) {
throw renderError.thrownValue
}
......@@ -3028,8 +3022,8 @@ async function prerenderAppPage({
const streamString = await streamToString(response.stream)
// A completed failure is never resumed. Copy only the delivery metadata so
// the response cache does not retain the resume data cache assigned below.
// Copy only the delivery metadata. Partial recovery includes its resume data
// cache in the serialized postponed state, so it needs no live cache below.
if (renderError !== undefined) {
return {
error: getProperError(renderError.thrownValue),
......@@ -3040,6 +3034,7 @@ async function prerenderAppPage({
headers: metadata.headers,
flightData: metadata.flightData,
fetchMetrics: metadata.fetchMetrics,
postponed: metadata.postponed,
},
}),
}
......@@ -10108,13 +10103,11 @@ async function prerenderToStream(
metadata.statusCode = res.statusCode
}
// TODO: Recover partial Flight results on demand and resume the unfinished
// components. Keep throwing for builds and unknown Flight state.
if (
cacheComponents &&
!isHTTPAccessFallback &&
!isRedirect &&
(isBuildTimePrerendering || reactServerPrerenderResultIsDynamic !== false)
(isBuildTimePrerendering || reactServerPrerenderResultIsDynamic === null)
) {
throw reactServerErrorsByDigest.get((err as any)?.digest) ?? err
}
......@@ -10402,7 +10395,10 @@ async function prerenderToStream(
originalFlightPrerenderResult.consume()
errorServerResult.consume()
return {
error: undefined,
error:
isHTTPAccessFallback || isRedirect
? undefined
: { thrownValue: err },
digestErrorsMap: reactServerErrorsByDigest,
ssrErrors: allCapturedErrors,
stream: await continueDynamicPrerender(errorHtmlStream, {
......
......@@ -79,7 +79,10 @@ export type AppPageRenderResultMetadata = {
export type PrerenderFailure = {
readonly error: Error
readonly result: RenderResult<
Pick<AppPageRenderResultMetadata, 'headers' | 'flightData' | 'fetchMetrics'>
Pick<
AppPageRenderResultMetadata,
'headers' | 'flightData' | 'fetchMetrics' | 'postponed'
>
>
}
......
......@@ -3,6 +3,7 @@ import { headers } from 'next/headers'
import { cacheLife, unstable_noStore } from 'next/cache'
import { SsrError } from '../../ssr-error'
import { getOrigin } from '../../origin'
import { getData } from '../../test-data'
export function generateStaticParams() {
return [{ slug: 'prerendered' }]
......@@ -29,20 +30,6 @@ function NoStoreContent() {
return <p id="content">No-store content</p>
}
async function getData(key: string) {
'use cache'
// The HTTP boundary keeps the data tag out of the page's ISR entry.
const response = await fetch(
`${getOrigin()}/test-data?key=${encodeURIComponent(key)}`,
{ cache: 'no-store' }
)
if (!response.ok) {
throw new Error(`Failed to read test data: ${response.status}`)
}
return response.text()
}
export default async function Page({
params,
}: {
......
'use client'
export default function ErrorBoundary() {
return <p>Partial prerender error boundary</p>
}
import { Suspense, type ReactNode } from 'react'
import { connection } from 'next/server'
import { headers } from 'next/headers'
async function RequestContent() {
await connection()
const language = (await headers()).get('accept-language')
return <p id="request-content">{language}</p>
}
export default function Layout({ children }: { children: ReactNode }) {
return (
<>
<p>Static layout</p>
<Suspense fallback={<p>Waiting for request</p>}>
<RequestContent />
</Suspense>
{children}
</>
)
}
export default function NotFound() {
return <p>Partial prerender not-found boundary</p>
}
import { Suspense } from 'react'
import { notFound } from 'next/navigation'
import { getData, getTransientData } from '../../../test-data'
export function generateStaticParams() {
return [{ slug: 'prerendered' }]
}
async function Content({ slug, pathname }: { slug: string; pathname: string }) {
if (slug.startsWith('transient-')) {
const value = await getTransientData(pathname)
return <p id="content">{value}</p>
}
if (slug.startsWith('recovery-')) {
const value = await getData(slug)
if (value === 'error') {
throw new Error('Partial prerender application data is unavailable')
}
return <p id="content">{value}</p>
}
if (slug.startsWith('reported-')) {
throw new Error(`Reported partial prerender error: ${slug}`)
}
if (slug.endsWith('missing')) {
notFound()
}
throw new Error('Partial prerender application error')
}
export default async function Page({
params,
}: {
params: Promise<{ slug: string }>
}) {
const { slug } = await params
if (slug === 'prerendered' || slug === 'healthy') {
return <p>Healthy page</p>
}
const withSuspense = slug.startsWith('suspense-')
const content = (
<Content
slug={withSuspense ? slug.slice('suspense-'.length) : slug}
pathname={`/partial/${slug}`}
/>
)
return withSuspense ? (
<Suspense fallback={<p>Page loading</p>}>{content}</Suspense>
) : (
content
)
}
import { LinkAccordion } from '../../link-accordion'
export default function Page() {
return (
<>
<LinkAccordion href="/partial/suspense-error">
Open error inside Suspense
</LinkAccordion>
<LinkAccordion href="/partial/error">Open error</LinkAccordion>
</>
)
}
import { cacheLife, cacheTag, revalidateTag } from 'next/cache'
import { connection } from 'next/server'
import { getOrigin } from '../../origin'
async function getData(key: string) {
'use cache: remote'
......@@ -53,3 +54,48 @@ export async function DELETE(request: Request) {
revalidateTag(key, { expire: 0 })
return new Response(null, { status: 204 })
}
export async function PATCH(request: Request) {
const key = new URL(request.url).searchParams.get('key')
if (!key) {
return new Response('Missing key', { status: 400 })
}
const readyKey = `ready-${key}`
if ((await getData(readyKey)) === null) {
// Publish a readiness marker before returning the failing value. Concurrent
// failing reads write the same marker without invalidating it.
const url = `${getOrigin()}/test-data?key=${encodeURIComponent(readyKey)}`
const timeoutSignal = AbortSignal.timeout(30_000)
const fetchData = (init?: RequestInit) =>
fetch(url, {
...init,
cache: 'no-store',
signal: AbortSignal.any([timeoutSignal]),
})
while (true) {
const fill = await fetchData({ method: 'POST', body: 'ready' })
await fill.text()
const read = await fetchData()
const currentValue = await read.text()
if (fill.ok && read.ok && currentValue === 'ready') {
break
}
}
return new Response('error')
}
// Later reads wait for the original error report before succeeding. The
// response can stream while the data source waits for recovery.
const timeoutSignal = AbortSignal.timeout(30_000)
while (true) {
const report = await fetch(
`${getOrigin()}/test-data?key=${encodeURIComponent(`report-${key}`)}`,
{ cache: 'no-store', signal: AbortSignal.any([timeoutSignal]) }
)
await report.text()
if (report.ok) {
break
}
}
return new Response('ready')
}
......@@ -6,7 +6,9 @@ export const onRequestError: Instrumentation.onRequestError = async (
request,
context
) => {
if (!request.path.startsWith('/reported-')) {
if (
!/^\/(?:partial\/(?:suspense-)?)?(?:reported|transient)-/.test(request.path)
) {
return
}
......
import { getOrigin } from './origin'
export async function getData(key: string) {
'use cache'
// The HTTP boundary keeps the data tag out of the page's ISR entry.
const response = await fetch(
`${getOrigin()}/test-data?key=${encodeURIComponent(key)}`,
{ cache: 'no-store' }
)
if (!response.ok) {
throw new Error(`Failed to read test data: ${response.status}`)
}
return response.text()
}
export async function getTransientData(pathname: string) {
'use cache'
const response = await fetch(
`${getOrigin()}/test-data?key=${encodeURIComponent(pathname)}`,
{ method: 'PATCH', cache: 'no-store' }
)
if (!response.ok) {
throw new Error(`Failed to read transient data: ${response.status}`)
}
if ((await response.text()) === 'error') {
// The data source has prepared the next read to succeed. The failed cache
// entry must be omitted from the resume data cache so this reader runs
// again.
throw new Error(`Transient prerender error: ${pathname}`)
}
return 'Recovered during resume'
}
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment