Unverified Commit 9c53486a authored by Tim Neutkens's avatar Tim Neutkens Committed by GitHub

Node.js streams: Add forkpoint for generateStagedDynamicFlightRenderResult (#92509)

## What?

Building on top of the changes in #92252. This PR implements similar
fork points for generateStagedDynamicFlightRenderResult
parent b42b5c6a
...@@ -924,7 +924,7 @@ async function generateDynamicFlightRenderResult( ...@@ -924,7 +924,7 @@ async function generateDynamicFlightRenderResult(
* staged rendering to separate static (RDC-backed) from runtime/dynamic * staged rendering to separate static (RDC-backed) from runtime/dynamic
* content. * content.
*/ */
async function generateStagedDynamicFlightRenderResult( async function generateStagedDynamicFlightRenderResultWeb(
req: BaseNextRequest, req: BaseNextRequest,
ctx: AppRenderContext, ctx: AppRenderContext,
requestStore: RequestStore requestStore: RequestStore
...@@ -1078,6 +1078,168 @@ async function generateStagedDynamicFlightRenderResult( ...@@ -1078,6 +1078,168 @@ async function generateStagedDynamicFlightRenderResult(
}) })
} }
/**
* Production-only staged dynamic flight render for cache components (Node.js
* streams). Uses staged rendering to separate static (RDC-backed) from
* runtime/dynamic content.
*/
async function generateStagedDynamicFlightRenderResultNode(
req: BaseNextRequest,
ctx: AppRenderContext,
requestStore: RequestStore
): Promise<RenderResult> {
const { componentMod, workStore, renderOpts } = ctx
const { routeModule } = componentMod
const { loaderTree } = routeModule.userland
const { onInstrumentationRequestError, experimental } = renderOpts
function onFlightDataRenderError(err: DigestedError, silenceLog: boolean) {
return onInstrumentationRequestError?.(
err,
req,
createErrorContext(ctx, 'react-server-components-payload'),
silenceLog
)
}
const onError = createReactServerErrorHandler(
false,
false,
workStore.reactServerErrorsByDigest,
onFlightDataRenderError
)
const selectStaleTime = createSelectStaleTime(experimental)
const staleTimeIterable = new StaleTimeIterable()
// TODO(cached-navs): this assumes that we checked during build that there's no sync IO.
// but it can happen e.g. after a revalidation or conditionally for a param that wasn't prerendered.
// we should change this to track sync IO, log an error and advance to dynamic.
const shouldTrackSyncIO = false
const stageController = new StagedRenderingController(
null, // no aborting
null, // no abandoning
shouldTrackSyncIO
)
// Initialize stale time tracking on the request store.
requestStore.stale = INFINITE_CACHE
requestStore.stagedRendering = stageController
requestStore.varyParamsAccumulator = createResponseVaryParamsAccumulator()
requestStore.asyncApiPromises = createAsyncApiPromises(
stageController,
requestStore.cookies,
requestStore.mutableCookies,
requestStore.headers
)
trackStaleTime(
requestStore as { stale: number },
staleTimeIterable,
selectStaleTime
)
// Deferred promise for the static stage byte length. Flight serializes the
// resolved value into the stream so the client knows where the static
// prefix ends.
let resolveStaticStageByteLength: (count: number) => void
const staticStageByteLengthPromise = new Promise<number>((resolve) => {
resolveStaticStageByteLength = resolve
})
// Check if this route has opted into runtime prefetching via
// unstable_instant. If so, we piggyback on the dynamic render to fill caches
// and then spawn a final runtime prerender whose result stream is embedded in
// the RSC payload. This is gated on the explicit opt-in because it adds extra
// server processing, increases the response payload size, and the runtime
// prefetch output should have been validated first.
const hasRuntimePrefetch =
await anySegmentHasRuntimePrefetchEnabled(loaderTree)
let runtimePrefetchStream: ReadableStream<Uint8Array> | undefined
if (hasRuntimePrefetch) {
// Create a mutable cache that gets filled during the dynamic render.
const prerenderResumeDataCache = createPrerenderResumeDataCache()
requestStore.prerenderResumeDataCache = prerenderResumeDataCache
const cacheSignal = new CacheSignal()
trackPendingModules(cacheSignal)
requestStore.cacheSignal = cacheSignal
// Create a deferred stream for the runtime prefetch result. Its readable
// side goes into the RSC payload (Flight serializes it lazily). The
// writable side receives the runtime prerender result once the dynamic
// render has filled all caches.
const runtimePrefetchTransform = new TransformStream<Uint8Array>()
runtimePrefetchStream = runtimePrefetchTransform.readable
// Wait for the dynamic render to fill caches, then run the final runtime
// prerender (fire-and-forget — does not block the response).
void cacheSignal
.cacheReady()
.then(() =>
spawnRuntimePrefetchWithFilledCaches(
runtimePrefetchTransform.writable,
ctx,
prerenderResumeDataCache,
requestStore,
onError
)
)
}
const rscPayload = await workUnitAsyncStorage.run(
requestStore,
generateDynamicRSCPayload,
ctx,
{ staleTimeIterable, staticStageByteLengthPromise, runtimePrefetchStream }
)
const { clientModules } = getClientReferenceManifest()
const flightStream = await runInSequentialTasks(
() => {
stageController.advanceStage(RenderStage.Static)
const sourceStream = workUnitAsyncStorage.run(
requestStore,
renderToNodeFlightStream,
ctx.componentMod,
rscPayload,
clientModules,
{ onError, filterStackFrame }
) as Readable
const replayable = new ReplayableNodeStream(sourceStream)
const dynamicStream = replayable.createReplayStream()
const staticStream = replayable.createReplayStream()
countStaticStageBytesNode(staticStream, stageController).then(
resolveStaticStageByteLength
)
return dynamicStream
},
() => {
// This is a separate task that doesn't advance a stage. It forces
// draining the microtask queue so that the stale time iterable and vary
// params accumulators are closed before we advance to the dynamic stage.
void finishStaleTimeTracking(staleTimeIterable)
if (requestStore.varyParamsAccumulator) {
void finishAccumulatingVaryParams(requestStore.varyParamsAccumulator)
}
},
() => {
stageController.advanceStage(RenderStage.Dynamic)
}
)
return new FlightRenderResult(flightStream, {
fetchMetrics: workStore.fetchMetrics,
})
}
/** /**
* Runs a final runtime prerender using the provided (already filled) cache and * Runs a final runtime prerender using the provided (already filled) cache and
* pipes its output into the provided writable stream. The caller is responsible * pipes its output into the provided writable stream. The caller is responsible
...@@ -2756,8 +2918,10 @@ async function renderToHTMLOrFlightImpl( ...@@ -2756,8 +2918,10 @@ async function renderToHTMLOrFlightImpl(
}) })
} }
// MARK: RSC request
if (isRSCRequest) { if (isRSCRequest) {
if (isRuntimePrefetchRequest) { if (isRuntimePrefetchRequest) {
// MARK: RSC runtimePrefetch
return generateRuntimePrefetchResult(req, ctx, requestStore) return generateRuntimePrefetchResult(req, ctx, requestStore)
} else { } else {
if ( if (
...@@ -2765,6 +2929,7 @@ async function renderToHTMLOrFlightImpl( ...@@ -2765,6 +2929,7 @@ async function renderToHTMLOrFlightImpl(
process.env.NEXT_RUNTIME !== 'edge' && process.env.NEXT_RUNTIME !== 'edge' &&
cacheComponents cacheComponents
) { ) {
// MARK: RSC devCacheComponents
return generateDynamicFlightRenderResultWithStagesInDev( return generateDynamicFlightRenderResultWithStagesInDev(
req, req,
ctx, ctx,
...@@ -2773,8 +2938,22 @@ async function renderToHTMLOrFlightImpl( ...@@ -2773,8 +2938,22 @@ async function renderToHTMLOrFlightImpl(
fallbackParams fallbackParams
) )
} else if (cacheComponents && cachedNavigations) { } else if (cacheComponents && cachedNavigations) {
return generateStagedDynamicFlightRenderResult(req, ctx, requestStore) // MARK: RSC cacheComponents
if (process.env.__NEXT_USE_NODE_STREAMS) {
return generateStagedDynamicFlightRenderResultNode(
req,
ctx,
requestStore
)
} else {
return generateStagedDynamicFlightRenderResultWeb(
req,
ctx,
requestStore
)
}
} else { } else {
// MARK: RSC dynamic
return generateDynamicFlightRenderResult(req, ctx, requestStore) return generateDynamicFlightRenderResult(req, ctx, requestStore)
} }
} }
......
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