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

Fix cache revalidation queued during streaming (#100448)

Next.js previously flushed revalidations after preparing the HTML stream
or running a Route Handler, before the response body finished streaming.
That flush dispatched queued tags and collected existing background
cache promises. Work added during streaming was omitted, so later cache
regeneration lacked `waitUntil` coverage and later tag invalidations
were never dispatched.

This extends the response-close approach proposed in #99772 beyond
dynamic HTML to Flight responses, Route Handlers, and streamed Server
Actions. `AfterContext` registers a `waitUntil` promise before the
handler returns and flushes newly queued work at close. Its snapshot
excludes earlier flushes and runs before `after()` callbacks start, so
their invalidations wait for callback completion. The change also
handles already-closed Node responses and Edge error paths that must
release close waiters. Server Action barriers retain their existing
ordering.

Fixes #99339
Fixes #99566
Closes #99772
parent fa3830c4
...@@ -1093,8 +1093,12 @@ export function createAppPageEntrypoint({ ...@@ -1093,8 +1093,12 @@ export function createAppPageEntrypoint({
}, },
waitUntil: ctx.waitUntil, waitUntil: ctx.waitUntil,
onClose: (cb) => { onClose: (callback) => {
res.on('close', cb) if (res.closed) {
callback()
} else {
res.once('close', callback)
}
}, },
onAfterTaskError: () => {}, onAfterTaskError: () => {},
......
...@@ -297,8 +297,12 @@ async function handleRequest( ...@@ -297,8 +297,12 @@ async function handleRequest(
cacheLifeProfiles: nextConfig.cacheLife, cacheLifeProfiles: nextConfig.cacheLife,
staticPageGenerationTimeout: nextConfig.staticPageGenerationTimeout, staticPageGenerationTimeout: nextConfig.staticPageGenerationTimeout,
waitUntil: ctx.waitUntil, waitUntil: ctx.waitUntil,
onClose: (cb) => { onClose: (callback) => {
res.on('close', cb) if (res.closed) {
callback()
} else {
res.once('close', callback)
}
}, },
onAfterTaskError: undefined, onAfterTaskError: undefined,
}, },
......
...@@ -404,6 +404,9 @@ async function requestHandler( ...@@ -404,6 +404,9 @@ async function requestHandler(
return renderResultToResponse(result) return renderResultToResponse(result)
} catch (err) { } catch (err) {
if (!closeController.isClosed) {
closeController.dispatchClose()
}
const silenceLog = false const silenceLog = false
await pageRouteModule.onRequestError( await pageRouteModule.onRequestError(
baseReq, baseReq,
......
...@@ -431,6 +431,25 @@ describe('AfterContext', () => { ...@@ -431,6 +431,25 @@ describe('AfterContext', () => {
expect(taskErrors).toEqual([]) expect(taskErrors).toEqual([])
}) })
it('runs callbacks registered after close in the after phase', async () => {
const completions: Promise<unknown>[] = []
const { onClose, triggerOnClose } = createOnClose()
const afterContext = new AfterContext({
waitUntil: (promise) => completions.push(promise),
onClose,
onTaskError: undefined,
})
const workStore = createMockWorkStore(afterContext)
const workUnitStore = createMockWorkUnitStore()
const run = createRun(afterContext, workStore, workUnitStore)
triggerOnClose()
const callback = jest.fn(() => workUnitStore.phase)
run(() => after(callback))
await Promise.all(completions)
expect(callback).toHaveBeenCalledTimes(1)
expect(callback.mock.results[0].value).toBe('after')
})
it('reports onClose failures', async () => { it('reports onClose failures', async () => {
const waitUntilPromises: Promise<unknown>[] = [] const waitUntilPromises: Promise<unknown>[] = []
const waitUntil = jest.fn((promise) => waitUntilPromises.push(promise)) const waitUntil = jest.fn((promise) => waitUntilPromises.push(promise))
...@@ -679,6 +698,201 @@ describe('AfterContext', () => { ...@@ -679,6 +698,201 @@ describe('AfterContext', () => {
expect(store2 === store1).toBe(true) expect(store2 === store1).toBe(true)
expect(taskErrors).toEqual([]) expect(taskErrors).toEqual([])
}) })
describe('revalidations on close', () => {
function setup(overrides: MockWorkStoreOverrides = {}) {
const completions: Promise<unknown>[] = []
const { onClose, triggerOnClose } = createOnClose()
const afterContext = new AfterContext({
waitUntil: (promise) => completions.push(promise),
onClose,
onTaskError: undefined,
})
const workStore = createMockWorkStore(afterContext, overrides)
return { afterContext, workStore, completions, triggerOnClose }
}
it('waits for late writes without waiting again for an earlier flush', async () => {
const { afterContext, workStore, completions, triggerOnClose } = setup()
const initial = createPromiseWithResolvers<void>()
const late = createPromiseWithResolvers<void>()
workStore.pendingRevalidateWrites = [initial.promise]
const initialFlush = afterContext.executeRevalidations(workStore)
expect(completions).toHaveLength(1)
workStore.pendingRevalidateWrites.push(late.promise)
let settled = false
completions[0].then(() => {
settled = true
})
try {
triggerOnClose()
await waitForCallbackQueue()
expect(settled).toBe(false)
late.resolve()
await completions[0]
expect(settled).toBe(true)
} finally {
initial.resolve()
late.resolve()
await initialFlush
}
})
it('waits for late writes when the initial flush is empty', async () => {
const { afterContext, workStore, completions, triggerOnClose } = setup()
expect(afterContext.executeRevalidations(workStore)).toBe(false)
expect(completions).toHaveLength(1)
const late = createPromiseWithResolvers<void>()
workStore.pendingRevalidateWrites = [late.promise]
let settled = false
completions[0].then(() => {
settled = true
})
try {
triggerOnClose()
await waitForCallbackQueue()
expect(settled).toBe(false)
} finally {
late.resolve()
await completions[0]
}
expect(settled).toBe(true)
})
it('waits for a new promise registered under a previously flushed key', async () => {
const { afterContext, workStore, completions, triggerOnClose } = setup()
afterContext.scheduleRevalidationsOnClose(workStore)
workStore.pendingRevalidates = { key: Promise.resolve() }
await afterContext.executeRevalidations(workStore)
const replacement = createPromiseWithResolvers<void>()
workStore.pendingRevalidates.key = replacement.promise
let settled = false
completions[0].then(() => {
settled = true
})
try {
triggerOnClose()
await waitForCallbackQueue()
expect(settled).toBe(false)
} finally {
replacement.resolve()
await completions[0]
}
})
it('does not repeat flushed tags with colons in tags and profiles', async () => {
const revalidateTag = jest.fn(() => Promise.resolve())
const profile = { stale: 0, revalidate: 60, expire: 3600 }
const { afterContext, workStore, completions, triggerOnClose } = setup({
incrementalCache: { revalidateTag },
cacheLifeProfiles: { default: profile, c: profile, 'b:c': profile },
})
workStore.pendingRevalidatedTags = [
{ tag: 'a:b', profile: 'c', revalidatedAt: 2 },
{ tag: 'a', profile: 'b:c', revalidatedAt: 1 },
]
afterContext.scheduleRevalidationsOnClose(workStore)
await afterContext.executeRevalidations(workStore)
expect(revalidateTag).toHaveBeenCalledTimes(2)
triggerOnClose()
await completions[0]
expect(revalidateTag).toHaveBeenCalledTimes(2)
})
it('flushes streamed tags at close and callback tags after the callback completes', async () => {
const { revalidateTag } = await import('../web/spec-extension/revalidate')
const updateTags = jest.fn(() => Promise.resolve())
const { afterContext, workStore, completions, triggerOnClose } = setup({
incrementalCache: { revalidateTag: updateTags },
})
const workUnitStore = {
type: 'request',
phase: 'action',
} as WorkUnitStore
const run = createRun(afterContext, workStore, workUnitStore)
const callbackCompletion = createPromiseWithResolvers<void>()
await run(() => {
revalidateTag('early', { expire: 0 })
after(async () => {
revalidateTag('callback', { expire: 0 })
await callbackCompletion.promise
})
return afterContext.executeRevalidations(workStore)
})
expect(updateTags.mock.calls).toEqual([[['early'], { expire: 0 }]])
run(() => revalidateTag('streamed', { expire: 0 }))
try {
expect(updateTags.mock.calls).toEqual([[['early'], { expire: 0 }]])
triggerOnClose()
await waitForCallbackQueue()
expect(updateTags.mock.calls).toEqual([
[['early'], { expire: 0 }],
[['streamed'], { expire: 0 }],
])
} finally {
callbackCompletion.resolve()
await Promise.all(completions)
}
expect(updateTags.mock.calls).toEqual([
[['early'], { expire: 0 }],
[['streamed'], { expire: 0 }],
[['callback'], { expire: 0 }],
])
})
it('does not register a close wait after close was already observed', () => {
const { afterContext, workStore, completions, triggerOnClose } = setup()
triggerOnClose()
afterContext.scheduleRevalidationsOnClose(workStore)
expect(completions).toHaveLength(0)
})
it('preserves the registration context when flushing at close', async () => {
let observedStore: WorkStore | undefined
const { afterContext, workStore, completions, triggerOnClose } = setup({
incrementalCache: {
revalidateTag: async () => {
observedStore = workAsyncStorage.getStore()
},
},
})
workAsyncStorage.run(workStore, () => {
afterContext.scheduleRevalidationsOnClose(workStore)
})
workStore.pendingRevalidatedTags = [{ tag: 'late', revalidatedAt: 1 }]
triggerOnClose()
await completions[0]
expect(observedStore === workStore).toBe(true)
})
it('leaves revalidation to the explicit flush when waitUntil is unavailable', async () => {
const { onClose, triggerOnClose } = createOnClose()
const afterContext = new AfterContext({
waitUntil: undefined,
onClose,
onTaskError: undefined,
})
const write = jest.fn(() => Promise.resolve())
const workStore = createMockWorkStore(afterContext, {
incrementalCache: { revalidateTag: write },
})
workStore.pendingRevalidatedTags = [{ tag: 'explicit', revalidatedAt: 1 }]
afterContext.scheduleRevalidationsOnClose(workStore)
triggerOnClose()
expect(write).not.toHaveBeenCalled()
const flushed = afterContext.executeRevalidations(workStore)
expect(flushed).not.toBe(false)
await flushed
expect(write).toHaveBeenCalledTimes(1)
})
})
}) })
function createOnClose() { function createOnClose() {
...@@ -701,8 +915,20 @@ function waitForCallbackQueue() { ...@@ -701,8 +915,20 @@ function waitForCallbackQueue() {
return new Promise((resolve) => setImmediate(() => setImmediate(resolve))) return new Promise((resolve) => setImmediate(() => setImmediate(resolve)))
} }
const createMockWorkStore = (afterContext: AfterContext): WorkStore => { type MockWorkStoreOverrides = {
const partialStore: Partial<WorkStore> = { incrementalCache?: Pick<
NonNullable<WorkStore['incrementalCache']>,
'revalidateTag'
>
cacheLifeProfiles?: WorkStore['cacheLifeProfiles']
}
const createMockWorkStore = (
afterContext: AfterContext,
overrides: MockWorkStoreOverrides = {}
): WorkStore => {
const partialStore: Partial<Omit<WorkStore, 'incrementalCache'>> &
MockWorkStoreOverrides = {
afterContext: afterContext, afterContext: afterContext,
forceStatic: false, forceStatic: false,
forceDynamic: false, forceDynamic: false,
...@@ -711,6 +937,7 @@ const createMockWorkStore = (afterContext: AfterContext): WorkStore => { ...@@ -711,6 +937,7 @@ const createMockWorkStore = (afterContext: AfterContext): WorkStore => {
pendingRevalidates: undefined, pendingRevalidates: undefined,
pendingRevalidateWrites: undefined, pendingRevalidateWrites: undefined,
incrementalCache: undefined, incrementalCache: undefined,
...overrides,
} }
return new Proxy(partialStore as WorkStore, { return new Proxy(partialStore as WorkStore, {
......
...@@ -3,8 +3,17 @@ import type { RequestLifecycleOpts } from '../base-server' ...@@ -3,8 +3,17 @@ import type { RequestLifecycleOpts } from '../base-server'
import type { AfterCallback, AfterTask } from './after' import type { AfterCallback, AfterTask } from './after'
import { InvariantError } from '../../shared/lib/invariant-error' import { InvariantError } from '../../shared/lib/invariant-error'
import { isThenable } from '../../shared/lib/is-thenable' import { isThenable } from '../../shared/lib/is-thenable'
import { workAsyncStorage } from '../app-render/work-async-storage.external' import {
import { withExecuteRevalidates } from '../revalidation-utils' workAsyncStorage,
type WorkStore,
} from '../app-render/work-async-storage.external'
import {
cloneRevalidationState,
diffRevalidationState,
executeRevalidates,
withExecuteRevalidates,
type RevalidationState,
} from '../revalidation-utils'
import { bindSnapshot } from '../app-render/async-local-storage' import { bindSnapshot } from '../app-render/async-local-storage'
import type { WorkUnitStore } from '../app-render/work-unit-async-storage.external' import type { WorkUnitStore } from '../app-render/work-unit-async-storage.external'
import { afterTaskAsyncStorage } from '../app-render/after-task-async-storage.external' import { afterTaskAsyncStorage } from '../app-render/after-task-async-storage.external'
...@@ -27,6 +36,8 @@ export class AfterContext { ...@@ -27,6 +36,8 @@ export class AfterContext {
private runCallbacksOnClosePromise: Promise<void> | undefined private runCallbacksOnClosePromise: Promise<void> | undefined
private callbackQueue: PromiseQueue private callbackQueue: PromiseQueue
private workUnitStores = new Set<WorkUnitStore>() private workUnitStores = new Set<WorkUnitStore>()
private executedRevalidations: RevalidationState | undefined = undefined
private revalidateOnClose: (() => void) | undefined = undefined
constructor({ waitUntil, onClose, onTaskError }: AfterContextOpts) { constructor({ waitUntil, onClose, onTaskError }: AfterContextOpts) {
this.waitUntil = waitUntil this.waitUntil = waitUntil
...@@ -45,6 +56,10 @@ export class AfterContext { ...@@ -45,6 +56,10 @@ export class AfterContext {
for (const workUnitStore of this.workUnitStores) { for (const workUnitStore of this.workUnitStores) {
workUnitStore.phase = 'after' workUnitStore.phase = 'after'
} }
const revalidate = this.revalidateOnClose
this.revalidateOnClose = undefined
revalidate?.()
}) })
} catch (err) { } catch (err) {
// If onClose is broken, report errors lazily, when after() is called. // If onClose is broken, report errors lazily, when after() is called.
...@@ -52,6 +67,52 @@ export class AfterContext { ...@@ -52,6 +67,52 @@ export class AfterContext {
} }
} }
public scheduleRevalidationsOnClose(workStore: WorkStore): void {
if (
!this.waitUntil ||
this.initialOnCloseError ||
this.isRequestClosed ||
this.revalidateOnClose
) {
return
}
// Register before the handler returns. The internal Edge adapter captures
// its waitUntil promises at that point.
this.waitUntil(
new Promise<void>((resolve, reject) => {
this.revalidateOnClose = bindSnapshot(() => {
try {
// Capture synchronously at close, before after() callbacks start.
// Their existing completion flush handles callback revalidations.
const current = cloneRevalidationState(workStore)
const previous = this.executedRevalidations
this.executedRevalidations = undefined
resolve(
executeRevalidates(
workStore,
previous ? diffRevalidationState(previous, current) : current
) || undefined
)
} catch (error) {
reject(error)
}
})
})
)
}
public executeRevalidations(workStore: WorkStore): false | Promise<void> {
const result = executeRevalidates(workStore)
this.scheduleRevalidationsOnClose(workStore)
if (this.revalidateOnClose) {
this.executedRevalidations = cloneRevalidationState(workStore)
}
return result
}
public after(task: AfterTask, workUnitStore: WorkUnitStore): void { public after(task: AfterTask, workUnitStore: WorkUnitStore): void {
if (this.initialOnCloseError) { if (this.initialOnCloseError) {
throw new InvariantError( throw new InvariantError(
...@@ -124,6 +185,8 @@ export class AfterContext { ...@@ -124,6 +185,8 @@ export class AfterContext {
// See: https://github.com/facebook/react/pull/34911 // See: https://github.com/facebook/react/pull/34911
async () => { async () => {
try { try {
// A callback registered after close missed the earlier phase change.
workUnitStore.phase = 'after'
await afterTaskAsyncStorage.run({ rootTaskSpawnPhase }, () => await afterTaskAsyncStorage.run({ rootTaskSpawnPhase }, () =>
callback() callback()
) )
......
...@@ -73,7 +73,6 @@ import { synchronizeMutableCookies } from '../async-storage/request-store' ...@@ -73,7 +73,6 @@ import { synchronizeMutableCookies } from '../async-storage/request-store'
import type { TemporaryReferenceSet } from 'react-server-dom-webpack/server' import type { TemporaryReferenceSet } from 'react-server-dom-webpack/server'
import { workUnitAsyncStorage } from '../app-render/work-unit-async-storage.external' import { workUnitAsyncStorage } from '../app-render/work-unit-async-storage.external'
import { InvariantError } from '../../shared/lib/invariant-error' import { InvariantError } from '../../shared/lib/invariant-error'
import { executeRevalidates } from '../revalidation-utils'
import { addRequestMeta, getRequestMeta } from '../request-meta' import { addRequestMeta, getRequestMeta } from '../request-meta'
import { setCacheBustingSearchParamWithHash } from '../../client/components/router-reducer/set-cache-busting-search-param' import { setCacheBustingSearchParamWithHash } from '../../client/components/router-reducer/set-cache-busting-search-param'
import { import {
...@@ -609,7 +608,8 @@ function getRevalidationWaitUntil( ...@@ -609,7 +608,8 @@ function getRevalidationWaitUntil(
return undefined return undefined
} }
const revalidatesPromise = executeRevalidates(workStore) const revalidatesPromise =
workStore.afterContext.executeRevalidations(workStore)
return revalidatesPromise === false ? undefined : revalidatesPromise return revalidatesPromise === false ? undefined : revalidatesPromise
} }
...@@ -1511,7 +1511,7 @@ async function executeActionAndPrepareForRender< ...@@ -1511,7 +1511,7 @@ async function executeActionAndPrepareForRender<
// If the action called revalidateTag/revalidatePath, then that might // If the action called revalidateTag/revalidatePath, then that might
// affect data used by the subsequent render, so we need to make sure all // affect data used by the subsequent render, so we need to make sure all
// revalidations are applied before that. // revalidations are applied before that.
await executeRevalidates(workStore) await workStore.afterContext.executeRevalidations(workStore)
} }
} }
} }
......
...@@ -283,7 +283,6 @@ import type { MetadataErrorType } from '../../lib/metadata/resolve-metadata' ...@@ -283,7 +283,6 @@ import type { MetadataErrorType } from '../../lib/metadata/resolve-metadata'
import isError, { getProperError } from '../../lib/is-error' import isError, { getProperError } from '../../lib/is-error'
import { createServerInsertedMetadata } from './metadata-insertion/create-server-inserted-metadata' import { createServerInsertedMetadata } from './metadata-insertion/create-server-inserted-metadata'
import type { ParsedRequestHeaders } from '../route-modules/app-page/parse-request-headers' import type { ParsedRequestHeaders } from '../route-modules/app-page/parse-request-headers'
import { executeRevalidates } from '../revalidation-utils'
import { trackPendingModules } from './module-loading/track-module-loading.external' import { trackPendingModules } from './module-loading/track-module-loading.external'
import { isReactLargeShellError } from './react-large-shell-error' import { isReactLargeShellError } from './react-large-shell-error'
import type { GlobalErrorComponent } from '../../client/components/builtin/global-error' import type { GlobalErrorComponent } from '../../client/components/builtin/global-error'
...@@ -2769,7 +2768,8 @@ async function prerenderAppPage({ ...@@ -2769,7 +2768,8 @@ async function prerenderAppPage({
} }
// If we have pending revalidates, wait until they are all resolved. // If we have pending revalidates, wait until they are all resolved.
const maybeRevalidatesPromise = executeRevalidates(workStore) const maybeRevalidatesPromise =
workStore.afterContext.executeRevalidations(workStore)
if (maybeRevalidatesPromise !== false) { if (maybeRevalidatesPromise !== false) {
const revalidatesPromise = maybeRevalidatesPromise.finally(() => { const revalidatesPromise = maybeRevalidatesPromise.finally(() => {
if (process.env.NEXT_PRIVATE_DEBUG_CACHE) { if (process.env.NEXT_PRIVATE_DEBUG_CACHE) {
...@@ -2922,6 +2922,9 @@ async function renderAppPage( ...@@ -2922,6 +2922,9 @@ async function renderAppPage(
// MARK: RSC request // MARK: RSC request
if (isRSCRequest) { if (isRSCRequest) {
// Register the close flush for Flight responses. These branches return
// before the HTML path executes pending revalidations.
workStore.afterContext.scheduleRevalidationsOnClose(workStore)
if (runtimePrefetchStage !== null) { if (runtimePrefetchStage !== null) {
// MARK: RSC runtimePrefetch // MARK: RSC runtimePrefetch
return generateRuntimePrefetchResult( return generateRuntimePrefetchResult(
...@@ -3087,7 +3090,8 @@ async function renderAppPage( ...@@ -3087,7 +3090,8 @@ async function renderAppPage(
} }
// If we have pending revalidates, wait until they are all resolved. // If we have pending revalidates, wait until they are all resolved.
const maybeRevalidatesPromise = executeRevalidates(workStore) const maybeRevalidatesPromise =
workStore.afterContext.executeRevalidations(workStore)
if (maybeRevalidatesPromise !== false) { if (maybeRevalidatesPromise !== false) {
const revalidatesPromise = maybeRevalidatesPromise.finally(() => { const revalidatesPromise = maybeRevalidatesPromise.finally(() => {
if (process.env.NEXT_PRIVATE_DEBUG_CACHE) { if (process.env.NEXT_PRIVATE_DEBUG_CACHE) {
......
...@@ -25,14 +25,14 @@ export async function withExecuteRevalidates<T>( ...@@ -25,14 +25,14 @@ export async function withExecuteRevalidates<T>(
} }
} }
type RevalidationState = Required< export type RevalidationState = Required<
Pick< Pick<
WorkStore, WorkStore,
'pendingRevalidatedTags' | 'pendingRevalidates' | 'pendingRevalidateWrites' 'pendingRevalidatedTags' | 'pendingRevalidates' | 'pendingRevalidateWrites'
> >
> >
function cloneRevalidationState(store: WorkStore): RevalidationState { export function cloneRevalidationState(store: WorkStore): RevalidationState {
return { return {
// revalidateTag updates revalidatedAt in place when the tag/profile already // revalidateTag updates revalidatedAt in place when the tag/profile already
// exists, so snapshot the items as well as the array. // exists, so snapshot the items as well as the array.
...@@ -46,28 +46,27 @@ function cloneRevalidationState(store: WorkStore): RevalidationState { ...@@ -46,28 +46,27 @@ function cloneRevalidationState(store: WorkStore): RevalidationState {
} }
} }
function diffRevalidationState( function getRevalidatedTagKey({
tag,
profile,
}: RevalidationState['pendingRevalidatedTags'][number]): string {
return JSON.stringify([tag, typeof profile, profile])
}
export function diffRevalidationState(
prev: RevalidationState, prev: RevalidationState,
curr: RevalidationState curr: RevalidationState
): RevalidationState { ): RevalidationState {
const prevTagsWithProfile = new Map( const prevTagsWithProfile = new Map(
prev.pendingRevalidatedTags.map((item) => { prev.pendingRevalidatedTags.map(
const profileKey = (item) => [getRevalidatedTagKey(item), item.revalidatedAt] as const
typeof item.profile === 'object' )
? JSON.stringify(item.profile)
: item.profile || ''
return [`${item.tag}:${profileKey}`, item.revalidatedAt] as const
})
) )
const prevRevalidateWrites = new Set(prev.pendingRevalidateWrites) const prevRevalidateWrites = new Set(prev.pendingRevalidateWrites)
return { return {
pendingRevalidatedTags: curr.pendingRevalidatedTags.filter((item) => { pendingRevalidatedTags: curr.pendingRevalidatedTags.filter((item) => {
const profileKey =
typeof item.profile === 'object'
? JSON.stringify(item.profile)
: item.profile || ''
const previousRevalidatedAt = prevTagsWithProfile.get( const previousRevalidatedAt = prevTagsWithProfile.get(
`${item.tag}:${profileKey}` getRevalidatedTagKey(item)
) )
return ( return (
previousRevalidatedAt === undefined || previousRevalidatedAt === undefined ||
...@@ -76,7 +75,7 @@ function diffRevalidationState( ...@@ -76,7 +75,7 @@ function diffRevalidationState(
}), }),
pendingRevalidates: Object.fromEntries( pendingRevalidates: Object.fromEntries(
Object.entries(curr.pendingRevalidates).filter( Object.entries(curr.pendingRevalidates).filter(
([key]) => !(key in prev.pendingRevalidates) ([key, promise]) => prev.pendingRevalidates[key] !== promise
) )
), ),
pendingRevalidateWrites: curr.pendingRevalidateWrites.filter( pendingRevalidateWrites: curr.pendingRevalidateWrites.filter(
......
...@@ -86,7 +86,6 @@ import { ...@@ -86,7 +86,6 @@ import {
} from '../../../client/components/http-access-fallback/http-access-fallback' } from '../../../client/components/http-access-fallback/http-access-fallback'
import { RedirectStatusCode } from '../../../client/components/redirect-status-code' import { RedirectStatusCode } from '../../../client/components/redirect-status-code'
import { INFINITE_CACHE } from '../../../lib/constants' import { INFINITE_CACHE } from '../../../lib/constants'
import { executeRevalidates } from '../../revalidation-utils'
import { trackPendingModules } from '../../app-render/module-loading/track-module-loading.external' import { trackPendingModules } from '../../app-render/module-loading/track-module-loading.external'
import { InvariantError } from '../../../shared/lib/invariant-error' import { InvariantError } from '../../../shared/lib/invariant-error'
import { LazyModule } from '../../lib/lazy-module' import { LazyModule } from '../../lib/lazy-module'
...@@ -395,7 +394,8 @@ export class AppRouteRouteModule extends RouteModule< ...@@ -395,7 +394,8 @@ export class AppRouteRouteModule extends RouteModule<
requestStore: RequestStore, requestStore: RequestStore,
context: AppRouteRouteHandlerContext context: AppRouteRouteHandlerContext
): void { ): void {
const maybeRevalidatesPromise = executeRevalidates(workStore) const maybeRevalidatesPromise =
workStore.afterContext.executeRevalidations(workStore)
if (maybeRevalidatesPromise !== false) { if (maybeRevalidatesPromise !== false) {
context.renderOpts.pendingWaitUntil = maybeRevalidatesPromise.finally( context.renderOpts.pendingWaitUntil = maybeRevalidatesPromise.finally(
......
...@@ -147,7 +147,13 @@ export class EdgeRouteModuleWrapper { ...@@ -147,7 +147,13 @@ export class EdgeRouteModuleWrapper {
} }
// Get the response from the handler. // Get the response from the handler.
let res = await this.routeModule.handle(request, context) let res: Response
try {
res = await this.routeModule.handle(request, context)
} catch (error) {
closeController.dispatchClose()
throw error
}
const waitUntilPromises = [internal_getCurrentFunctionWaitUntil()] const waitUntilPromises = [internal_getCurrentFunctionWaitUntil()]
if (context.renderOpts.pendingWaitUntil) { if (context.renderOpts.pendingWaitUntil) {
......
import { nextTestSetup } from 'e2e-utils' import { nextTestSetup } from 'e2e-utils'
import { hasErrorToast, retry, waitFor, waitForNoRedbox } from 'next-test-utils' import { hasErrorToast, retry, waitFor, waitForNoRedbox } from 'next-test-utils'
import stripAnsi from 'strip-ansi' import stripAnsi from 'strip-ansi'
import escapeStringRegexp from 'escape-string-regexp'
// TODO(deploy-test-completion): Re-enable this suite in deploy mode. // TODO(deploy-test-completion): Re-enable this suite in deploy mode.
// It likely asserts local CLI or runtime output that deploy tests do not expose. // It likely asserts local CLI or runtime output that deploy tests do not expose.
...@@ -103,7 +104,7 @@ describe('app-custom-cache-handler-errors - set throws', () => { ...@@ -103,7 +104,7 @@ describe('app-custom-cache-handler-errors - set throws', () => {
env: { CACHE_HANDLER_THROW_ON: 'set' }, env: { CACHE_HANDLER_THROW_ON: 'set' },
}) })
it('renders the page successfully', async () => { it('logs the cache write error without failing the render', async () => {
const outputIndex = next.cliOutput.length const outputIndex = next.cliOutput.length
const browser = await next.browser('/?input=x') const browser = await next.browser('/?input=x')
...@@ -112,22 +113,20 @@ describe('app-custom-cache-handler-errors - set throws', () => { ...@@ -112,22 +113,20 @@ describe('app-custom-cache-handler-errors - set throws', () => {
) )
if (isNextDev) { if (isNextDev) {
// A throwing set() is currently completely silent in dev: the cache
// handler is called and its rejection is swallowed without being logged
// or reported to the dev overlay.
await waitForNoRedbox(browser) await waitForNoRedbox(browser)
expect(await hasErrorToast(browser)).toBe(false) expect(await hasErrorToast(browser)).toBe(false)
expect(next.cliOutput.slice(outputIndex)).not.toContain(
'CustomCacheHandler.set failed'
)
} else {
await retry(async () => {
expect(stripAnsi(next.cliOutput.slice(outputIndex))).toContain(
'Error: CustomCacheHandler.set failed' +
'\n at Object.set (throwing-cache-handler.js:50:13)' +
'\n at <unknown> ('
)
})
} }
const errorBlock =
'Error: CustomCacheHandler.set failed' +
'\n at Object.set (throwing-cache-handler.js:50:13)'
await retry(async () => {
expect(stripAnsi(next.cliOutput.slice(outputIndex))).toContain(errorBlock)
})
const cliOutput = stripAnsi(next.cliOutput.slice(outputIndex))
expect(cliOutput).not.toContain('unhandledRejection')
expect(cliOutput).toIncludeRepeated(escapeStringRegexp(errorBlock), 1)
}) })
}) })
export { GET } from '../../nodejs/route-error/route'
export const runtime = 'edge'
export const dynamic = 'force-dynamic'
import { after, NextResponse } from 'next/server'
import { cliLog } from '../../../utils/log'
export const runtime = 'nodejs'
export const dynamic = 'force-dynamic'
export async function GET() {
after(() => {
cliLog({ source: '[route handler] /route-error' })
})
return NextResponse.next()
}
...@@ -60,6 +60,16 @@ describe.each(runtimes)('after() in %s runtime', (runtimeValue) => { ...@@ -60,6 +60,16 @@ describe.each(runtimes)('after() in %s runtime', (runtimeValue) => {
}) })
}) })
it('runs when route response validation fails', async () => {
const response = await next.fetch(pathPrefix + '/route-error')
expect(response.status).toBe(500)
await retry(() => {
expect(getLogs()).toContainEqual({
source: '[route handler] /route-error',
})
})
})
it('runs in server actions', async () => { it('runs in server actions', async () => {
const browser = await next.browser(pathPrefix + '/123/with-action') const browser = await next.browser(pathPrefix + '/123/with-action')
expect(getLogs()).toContainEqual({ expect(getLogs()).toContainEqual({
......
'use server'
import { revalidateTag } from 'next/cache'
export async function invalidateFromStream(key: string) {
return new ReadableStream<string>({
async start(controller) {
controller.enqueue('started')
await new Promise((resolve) => setTimeout(resolve, 500))
revalidateTag('streamed:' + key, { expire: 0 })
controller.enqueue('invalidated')
controller.close()
},
})
}
'use client'
import { useState } from 'react'
import { invalidateFromStream } from './action'
export function ActionButton({ cacheKey }: { cacheKey: string }) {
const [status, setStatus] = useState('idle')
async function run() {
const stream = await invalidateFromStream(cacheKey)
const reader = stream.getReader()
for (;;) {
if ((await reader.read()).done) {
break
}
}
setStatus('finished')
}
return (
<button id="action" onClick={run}>
{status}
</button>
)
}
import { Suspense } from 'react'
import { ActionButton } from './client'
async function Content({ params }: { params: Promise<{ key: string }> }) {
return <ActionButton cacheKey={(await params).key} />
}
export default function Page({ params }: { params: Promise<{ key: string }> }) {
return (
<Suspense fallback={<p>Loading</p>}>
<Content params={params} />
</Suspense>
)
}
import { randomUUID } from 'node:crypto'
import { cacheLife, cacheTag } from 'next/cache'
export async function getValue(key: string) {
'use cache: remote'
cacheLife({ stale: 0, revalidate: 3600, expire: 86400 })
cacheTag('streamed:' + key)
return randomUUID()
}
import type { ReactNode } from 'react'
export default function Root({ children }: { children: ReactNode }) {
return (
<html>
<body>{children}</body>
</html>
)
}
export default function Page() {
return <p>hello world</p>
}
import { revalidateTag } from 'next/cache'
export async function POST(request: Request) {
const parameters = new URL(request.url).searchParams
const key = parameters.get('key')!
const encoder = new TextEncoder()
let writeTimer: ReturnType<typeof setTimeout>
const body = new ReadableStream<Uint8Array>({
start(controller) {
controller.enqueue(encoder.encode('started\n'))
writeTimer = setTimeout(() => {
revalidateTag('streamed:' + key, { expire: 0 })
controller.enqueue(encoder.encode('invalidated\n'))
controller.close()
}, 200)
},
cancel() {
clearTimeout(writeTimer)
},
})
return new Response(body, {
headers: { 'content-type': 'text/event-stream' },
})
}
import { getValue } from '../../cache'
export async function GET(
_request: Request,
{ params }: { params: Promise<{ key: string }> }
) {
const { key } = await params
return Response.json(await getValue(key))
}
import type { NextConfig } from 'next'
const nextConfig: NextConfig = { cacheComponents: true }
export default nextConfig
import { randomUUID } from 'node:crypto'
import { nextTestSetup } from 'e2e-utils'
import { retry } from 'next-test-utils'
describe('streamed cache revalidation', () => {
const { next } = nextTestSetup({ files: __dirname })
async function readValue(key: string): Promise<string> {
const response = await next.fetch('/value/' + key)
expect(response.status).toBe(200)
return response.json()
}
async function prime(key: string) {
const value = await readValue(key)
expect(await readValue(key)).toBe(value)
return value
}
it('invalidates a cached value from a streamed action that skips rendering', async () => {
const key = randomUUID()
const value = await prime(key)
const browser = await next.browser('/action/' + key)
await browser.elementById('action').click()
await retry(async () =>
expect(await browser.elementById('action').text()).toBe('finished')
)
await retry(async () => expect(await readValue(key)).not.toBe(value))
})
it('applies a tag invalidation queued during response streaming', async () => {
const key = randomUUID()
const value = await prime(key)
const response = await next.fetch('/stream?key=' + key, { method: 'POST' })
expect(response.status).toBe(200)
expect(response.headers.get('content-type')).toBe('text/event-stream')
expect(await response.text()).toBe('started\ninvalidated\n')
await retry(async () => {
expect(await readValue(key)).not.toBe(value)
})
})
})
import { randomUUID } from 'node:crypto'
import { Suspense } from 'react'
import { cacheLife } from 'next/cache'
type Props = { params: Promise<{ key: string; id: string }> }
async function getValue(key: string) {
'use cache: remote'
// Keep the entry fresh through its five-second generation and initial
// cache-hit check.
cacheLife({ stale: 0, revalidate: 10, expire: 3600 })
// The verification request can resume an instance paused after the previous
// response. A single overdue timer could then finish regeneration before the
// cache read. This loop schedules new timers after resumption, so that read
// can still observe the stale value.
for (let step = 0; step < 10; step++) {
await new Promise((resolve) => setTimeout(resolve, 500))
}
return `${key}:${randomUUID()}`
}
async function Shell({ params }: Props) {
const { id } = await params
return <p>Request: {id}</p>
}
async function Value({ params }: Props) {
const { key } = await params
// The shell starts streaming before this read starts background regeneration.
await new Promise((resolve) => setTimeout(resolve, 250))
return <p id="value">{await getValue(key)}</p>
}
export default function Page({ params }: Props) {
return (
<main>
<Suspense fallback={<p>Loading request</p>}>
<Shell params={params} />
</Suspense>
<Suspense fallback={<p>Loading value</p>}>
<Value params={params} />
</Suspense>
</main>
)
}
import type { ReactNode } from 'react'
export default function Root({ children }: { children: ReactNode }) {
return (
<html>
<body>{children}</body>
</html>
)
}
// @ts-check
/**
* @typedef {import('next/cache').CacheEntry} CacheEntry
*/
/**
* @type {Map<string, Omit<CacheEntry, 'value'> & { value: Uint8Array }>}
*/
const entries = new Map()
/**
* @type {Map<string, Promise<void>>}
*/
const pendingWrites = new Map()
/**
* @type {import('next/cache').CacheHandler}
*/
const handler = {
async get(key) {
await pendingWrites.get(key)
const entry = entries.get(key)
if (!entry) {
return undefined
}
if (
performance.timeOrigin + performance.now() >
entry.timestamp + entry.expire * 1000
) {
entries.delete(key)
return undefined
}
return {
...entry,
value: new ReadableStream({
start(controller) {
controller.enqueue(entry.value)
controller.close()
},
}),
}
},
async set(key, pendingEntry) {
const write = pendingEntry.then(async (entry) => {
const value = new Uint8Array(
await new Response(entry.value).arrayBuffer()
)
entries.set(key, { ...entry, value })
})
pendingWrites.set(key, write)
try {
await write
} finally {
if (pendingWrites.get(key) === write) {
pendingWrites.delete(key)
}
}
},
async refreshTags() {},
async getExpiration() {
return 0
},
async updateTags() {},
}
module.exports = handler
import type { NextConfig } from 'next'
const nextConfig: NextConfig = {
cacheComponents: true,
// The local handler retains stale entries so next start also uses background
// regeneration. Deploy tests use Vercel's remote handler.
cacheHandlers: process.env.VERCEL
? undefined
: { remote: require.resolve('./cache-handler.cjs') },
}
export default nextConfig
import { randomUUID } from 'node:crypto'
import { nextTestSetup } from 'e2e-utils'
import { waitFor } from 'next-test-utils'
// Production resumes the cached HTML prelude before the delayed cache read.
// @force-gate !dev
describe('use cache streaming revalidation', () => {
const { next } = nextTestSetup({ files: __dirname })
it.each(['html', 'flight'] as const)(
'completes stale regeneration started during a streaming %s response',
async (protocol) => {
const key = randomUUID()
async function readValue() {
const startedAt = performance.now()
const path = `/${key}/${randomUUID()}`
let value: string
if (protocol === 'html') {
const html = await next.render$(path)
value = html('#value').text()
} else {
const response = await next.fetch(path, { headers: { RSC: '1' } })
expect(response.status).toBe(200)
expect(response.headers.get('content-type')).toContain(
'text/x-component'
)
const flight = await response.text()
value = flight.match(new RegExp(`${key}:[a-f0-9-]{36}`))?.[0] ?? ''
}
expect(value).not.toBe('')
return { value, duration: performance.now() - startedAt }
}
const { value: initialValue } = await readValue()
expect((await readValue()).value).toBe(initialValue)
// Let the ten-second revalidation interval pass without making requests.
await waitFor(11000)
const stale = await readValue()
// Both handlers retain stale entries until expire. This request must
// serve the old value without waiting for regeneration.
expect(stale.value).toBe(initialValue)
expect(stale.duration).toBeLessThan(5000)
// Requests during this interval could let an untracked regeneration run
// under another invocation.
await waitFor(8000)
const regenerated = await readValue()
expect(regenerated.value).not.toBe(initialValue)
// A cache miss would run the five-second generation during this request.
// Reject that case even if it produces a different value.
expect(regenerated.duration).toBeLessThan(5000)
}
)
})
import { randomUUID } from 'node:crypto'
import { Suspense } from 'react'
import { cacheLife, cacheTag } from 'next/cache'
import { getState, waitForGate } from '../../../../state.cjs'
type Props = { params: Promise<{ key: string; id: string }> }
async function getValue(key: string) {
'use cache: remote'
cacheLife({ stale: 0, revalidate: 1, expire: 3600 })
cacheTag(key)
getState().events.push('generation-started:' + key)
await waitForGate('generation:' + key)
getState().events.push('generation-finished:' + key)
return `${key}:${randomUUID()}`
}
async function Shell({ params }: Props) {
const { id } = await params
return <p>Request: {id}</p>
}
async function Value({ params }: Props) {
const { key } = await params
await waitForGate('read:' + key)
return <p id="value">{await getValue(key)}</p>
}
export default function Page({ params }: Props) {
return (
<>
<Suspense fallback={<p>Loading request</p>}>
<Shell params={params} />
</Suspense>
<Suspense fallback={<p>Loading value</p>}>
<Value params={params} />
</Suspense>
</>
)
}
import type { ReactNode } from 'react'
import { Suspense } from 'react'
export default function Root({ children }: { children: ReactNode }) {
return (
<html>
<body>
<Suspense fallback={<p>Loading</p>}>{children}</Suspense>
</body>
</html>
)
}
export default function Page() {
return <p>hello world</p>
}
const { getState } = require('./state.cjs')
module.exports = {
async get(key) {
const state = getState()
const entry = state.entries.get(key)
if (!entry) {
return undefined
}
return {
...entry,
timestamp: state.stale ? Date.now() - 2000 : entry.timestamp,
value: new ReadableStream({
start(controller) {
controller.enqueue(entry.value)
controller.close()
},
}),
}
},
async set(key, pendingEntry) {
const entry = await pendingEntry
const value = new Uint8Array(await new Response(entry.value).arrayBuffer())
getState().entries.set(key, { ...entry, value })
for (const tag of entry.tags) {
getState().events.push('written:' + tag)
}
},
async refreshTags() {},
async getExpiration() {
return 0
},
async updateTags() {},
}
import type { NextConfig } from 'next'
const nextConfig: NextConfig = {
cacheComponents: true,
cacheHandlers: { remote: require.resolve('./cache-handler.cjs') },
}
export default nextConfig
import next from 'next'
import { createServer } from 'node:http'
import { AsyncLocalStorage } from 'node:async_hooks'
import { getState, createGate, releaseGate } from './state.cjs'
const requestStorage = new AsyncLocalStorage()
globalThis[Symbol.for('@next/request-context')] = {
get: () => requestStorage.getStore(),
}
const port = Number(process.env.PORT)
const app = next({ dev: false, hostname: 'localhost', port })
await app.prepare()
const handler = app.getRequestHandler()
createServer(async (request, response) => {
const url = new URL(request.url, 'http://localhost')
const state = getState()
if (url.pathname === '/_test/control') {
let body = ''
for await (const chunk of request) {
body += chunk
}
const command = JSON.parse(body)
for (const name of command.create ?? []) {
createGate(name)
}
for (const name of command.release ?? []) {
releaseGate(name)
}
if (command.stale !== undefined) {
state.stale = command.stale
}
response.end('ok')
return
}
if (url.pathname === '/_test/state') {
response.setHeader('content-type', 'application/json')
response.end(
JSON.stringify({ events: state.events, requests: state.requests })
)
return
}
const lifecycle = {
url: request.url,
pending: 0,
finished: false,
handled: false,
}
state.requests.push(lifecycle)
response.once('finish', () => {
lifecycle.finished = true
})
try {
await requestStorage.run(
{
waitUntil(promise) {
lifecycle.pending++
promise.then(
() => lifecycle.pending--,
(error) => {
lifecycle.pending--
console.error(error)
}
)
},
},
() => handler(request, response)
)
} catch (error) {
console.error(error)
response.destroy(error)
} finally {
lifecycle.handled = true
}
}).listen(port, () => {
console.log('- Local: http://localhost:' + port)
console.log('Revalidation server ready')
})
const stateSymbol = Symbol.for('streaming-revalidation-close')
function getState() {
return (globalThis[stateSymbol] ??= {
events: [],
gates: new Map(),
requests: [],
entries: new Map(),
stale: false,
})
}
function createGate(name) {
let resolve
const promise = new Promise((done) => {
resolve = done
})
getState().gates.set(name, { promise, resolve })
}
function waitForGate(name) {
return getState().gates.get(name)?.promise ?? Promise.resolve()
}
function releaseGate(name) {
getState().gates.get(name)?.resolve()
getState().gates.delete(name)
}
module.exports = { getState, createGate, waitForGate, releaseGate }
import { randomUUID } from 'node:crypto'
import { nextTestSetup } from 'e2e-utils'
import { retry } from 'next-test-utils'
// The custom server exposes the platform's pending promises and gates cache
// I/O. Deploy coverage uses the separate streaming revalidation e2e fixtures.
// @force-gate !deploy
describe('streaming revalidation at response close', () => {
const { next } = nextTestSetup({
files: __dirname,
startCommand: 'node server.mjs',
serverReadyPattern: /Revalidation server ready/,
forcedPort: 'random',
})
async function control(command: {
create?: string[]
release?: string[]
stale?: boolean
}) {
await next.fetch('/_test/control', {
method: 'POST',
body: JSON.stringify(command),
})
}
async function readState(): Promise<{
events: string[]
requests: {
url: string
pending: number
finished: boolean
handled: boolean
}[]
}> {
return (await next.fetch('/_test/state')).json()
}
it('keeps regeneration started after the HTML shell alive after the response ends', async () => {
const key = randomUUID()
const warmPath = `/cache/${key}/warm`
const initialValue = (await next.render$(warmPath))('#value').text()
expect(initialValue).toContain(key)
await retry(async () => {
const state = await readState()
expect(state.events).toContain('written:' + key)
expect(
state.requests.find((request) => request.url === warmPath)?.pending
).toBe(0)
})
// Block the cache read until the shell streams. Block regeneration
// separately so it can remain pending after the response ends.
await control({ stale: true, create: ['read:' + key, 'generation:' + key] })
try {
const path = `/cache/${key}/stale`
const response = await next.fetch(path)
const reader = response.body!.getReader()
const decoder = new TextDecoder()
let html = ''
while (!html.includes('Request:')) {
const chunk = await reader.read()
expect(chunk.done).toBe(false)
html += decoder.decode(chunk.value)
}
await control({ release: ['read:' + key] })
for (;;) {
const chunk = await reader.read()
if (chunk.done) {
break
}
html += decoder.decode(chunk.value)
}
expect(html).toContain(initialValue)
await retry(async () => {
expect(
(await readState()).requests.find((request) => request.url === path)
?.handled
).toBe(true)
})
const state = await readState()
// The warmup generation finished. The stale request started a second
// generation, which is still blocked.
expect(
state.events.filter((event) => event === 'generation-started:' + key)
).toHaveLength(2)
expect(
state.events.filter((event) => event === 'generation-finished:' + key)
).toHaveLength(1)
const request = state.requests.find((request) => request.url === path)!
expect(request.finished).toBe(true)
// The response and handler have finished, but waitUntil must still track
// the blocked regeneration.
expect(request.pending).toBeGreaterThan(0)
} finally {
await control({
stale: false,
release: ['read:' + key, 'generation:' + key],
})
await retry(async () => {
expect(
(await readState()).events.filter(
(event) => event === 'written:' + key
)
).toHaveLength(2)
})
}
})
})
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