Unverified Commit 89ba33ac authored by Josh Story's avatar Josh Story Committed by GitHub

[dynamicIO] unify server and client prerender for non-ppr pathway (#71764)

same as prior update (#71749) but we refactor the non-ppr prerender
pathway. goal is to only 2 two renders max and still support cache
warming and lazy module init
parent acd89db7
import { InvariantError } from '../../shared/lib/invariant-error'
import { isPrerenderInterruptedError } from './dynamic-rendering'
/**
* This is a utility function to make scheduling sequential tasks that run back to back easier.
......@@ -18,6 +19,7 @@ export function prerenderAndAbortInSequentialTasks<R>(
setImmediate(() => {
try {
pendingResult = prerender()
pendingResult.catch(() => {})
} catch (err) {
reject(err)
}
......@@ -30,6 +32,322 @@ export function prerenderAndAbortInSequentialTasks<R>(
}
}
export function prerenderServerWithPhases(
signal: AbortSignal,
render: () => ReadableStream<Uint8Array>,
finalPhase: () => void
): Promise<ServerPrerenderStreamResult>
export function prerenderServerWithPhases(
signal: AbortSignal,
render: () => ReadableStream<Uint8Array>,
secondPhase: () => void,
finalPhase: () => void
): Promise<ServerPrerenderStreamResult>
export function prerenderServerWithPhases(
signal: AbortSignal,
render: () => ReadableStream<Uint8Array>,
secondPhase: () => void,
thirdPhase: () => void,
...remainingPhases: Array<() => void>
): Promise<ServerPrerenderStreamResult>
export function prerenderServerWithPhases(
signal: AbortSignal,
render: () => ReadableStream<Uint8Array>,
...remainingPhases: Array<() => void>
): Promise<ServerPrerenderStreamResult> {
if (process.env.NEXT_RUNTIME === 'edge') {
throw new InvariantError(
'`prerenderAndAbortInSequentialTasks` should not be called in edge runtime.'
)
} else {
return new Promise((resolve, reject) => {
let result: ServerPrerenderStreamResult
signal.addEventListener(
'abort',
() => {
if (isPrerenderInterruptedError(signal.reason)) {
result.markInterrupted()
} else {
result.markComplete()
}
},
{
once: true,
}
)
setImmediate(() => {
try {
result = new ServerPrerenderStreamResult(render())
} catch (err) {
reject(err)
}
})
function runFinalTask(this: () => void) {
try {
if (result) {
result.markComplete()
this()
}
resolve(result)
} catch (err) {
reject(err)
}
}
function runNextTask(this: () => void) {
try {
if (result) {
result.markPhase()
this()
}
} catch (err) {
reject(err)
}
}
let i = 0
for (; i < remainingPhases.length - 1; i++) {
const phase = remainingPhases[i]
setImmediate(runNextTask.bind(phase))
}
if (remainingPhases[i]) {
const finalPhase = remainingPhases[i]
setImmediate(runFinalTask.bind(finalPhase))
}
})
}
}
const PENDING = 0
const COMPLETE = 1
const INTERRUPTED = 2
const ERRORED = 3
export class ServerPrerenderStreamResult {
private currentChunks: Array<Uint8Array>
private chunksByPhase: Array<Array<Uint8Array>>
private trailingChunks: Array<Uint8Array>
private status: 0 | 1 | 2 | 3
private reason: null | unknown
constructor(stream: ReadableStream<Uint8Array>) {
this.status = PENDING
this.reason = null
this.trailingChunks = []
this.currentChunks = []
this.chunksByPhase = [this.currentChunks]
const reader = stream.getReader()
const progress = ({
done,
value,
}: ReadableStreamReadResult<Uint8Array>) => {
if (done) {
if (this.status === PENDING) {
this.status = COMPLETE
}
return
}
if (this.status === PENDING || this.status === INTERRUPTED) {
this.currentChunks.push(value)
} else {
this.trailingChunks.push(value)
}
reader.read().then(progress, error)
}
const error = (reason: unknown) => {
this.status = ERRORED
this.reason = reason
}
reader.read().then(progress, error)
}
markPhase() {
this.currentChunks = []
this.chunksByPhase.push(this.currentChunks)
}
markComplete() {
if (this.status === PENDING) {
this.status = COMPLETE
}
}
markInterrupted() {
this.status = INTERRUPTED
}
/**
* Returns a stream which only releases chunks when `releasePhase` is called. This stream will never "complete" because
* we rely upon the stream remaining open when prerendering to avoid triggering errors for incomplete chunks in the client.
*
* asPhasedStream is expected to be called once per result however it is safe to call multiple times as long as we have not
* transferred the underlying data. Generally this will only happen when streaming to a response
*/
asPhasedStream() {
switch (this.status) {
case COMPLETE:
case INTERRUPTED:
return new PhasedStream(this.chunksByPhase)
default:
throw new InvariantError(
`ServerPrerenderStreamResult cannot be consumed as a stream because it is not yet complete. status: ${this.status}`
)
}
}
/**
* Returns a stream which will release all chunks immediately. This stream will "complete" synchronously. It should be used outside
* of render use cases like loading client chunks ahead of SSR or writing the streamed content to disk.
*/
asStream() {
switch (this.status) {
case COMPLETE:
case INTERRUPTED:
const chunksByPhase = this.chunksByPhase
const trailingChunks = this.trailingChunks
return new ReadableStream({
start(controller) {
for (let i = 0; i < chunksByPhase.length; i++) {
const chunks = chunksByPhase[i]
for (let j = 0; j < chunks.length; j++) {
controller.enqueue(chunks[j])
}
}
for (let i = 0; i < trailingChunks.length; i++) {
controller.enqueue(trailingChunks[i])
}
controller.close()
},
})
default:
throw new InvariantError(
`ServerPrerenderStreamResult cannot be consumed as a stream because it is not yet complete. status: ${this.status}`
)
}
}
}
class PhasedStream<T> extends ReadableStream<T> {
private nextPhase: number
private chunksByPhase: Array<Array<T>>
private destination: ReadableStreamDefaultController<T>
constructor(chunksByPhase: Array<Array<T>>) {
if (chunksByPhase.length === 0) {
throw new InvariantError(
'PhasedStream expected at least one phase but none were found.'
)
}
let destination: ReadableStreamDefaultController<T>
super({
start(controller) {
destination = controller
},
})
// the start function above is called synchronously during construction so we will always have a destination
// We wait to assign it until after the super call because we cannot access `this` before calling super
this.destination = destination!
this.nextPhase = 0
this.chunksByPhase = chunksByPhase
this.releasePhase()
}
releasePhase() {
if (this.nextPhase < this.chunksByPhase.length) {
const chunks = this.chunksByPhase[this.nextPhase++]
for (let i = 0; i < chunks.length; i++) {
this.destination.enqueue(chunks[i])
}
} else {
throw new InvariantError(
'PhasedStream expected more phases to release but none were found.'
)
}
}
assertExhausted() {
if (this.nextPhase < this.chunksByPhase.length) {
throw new InvariantError(
'PhasedStream expected no more phases to release but some were found.'
)
}
}
}
export function prerenderClientWithPhases<T>(
render: () => Promise<T>,
finalPhase: () => void
): Promise<T>
export function prerenderClientWithPhases<T>(
render: () => Promise<T>,
secondPhase: () => void,
finalPhase: () => void
): Promise<T>
export function prerenderClientWithPhases<T>(
render: () => Promise<T>,
secondPhase: () => void,
thirdPhase: () => void,
...remainingPhases: Array<() => void>
): Promise<T>
export function prerenderClientWithPhases<T>(
render: () => Promise<T>,
...remainingPhases: Array<() => void>
): Promise<T> {
if (process.env.NEXT_RUNTIME === 'edge') {
throw new InvariantError(
'`prerenderAndAbortInSequentialTasks` should not be called in edge runtime.'
)
} else {
return new Promise((resolve, reject) => {
let pendingResult: Promise<T>
setImmediate(() => {
try {
pendingResult = render()
pendingResult.catch((err) => reject(err))
} catch (err) {
reject(err)
}
})
function runFinalTask(this: () => void) {
try {
this()
resolve(pendingResult)
} catch (err) {
reject(err)
}
}
function runNextTask(this: () => void) {
try {
this()
} catch (err) {
reject(err)
}
}
let i = 0
for (; i < remainingPhases.length - 1; i++) {
const phase = remainingPhases[i]
setImmediate(runNextTask.bind(phase))
}
if (remainingPhases[i]) {
const finalPhase = remainingPhases[i]
setImmediate(runFinalTask.bind(finalPhase))
}
})
}
}
// React's RSC prerender function will emit an incomplete flight stream when using `prerender`. If the connection
// closes then whatever hanging chunks exist will be errored. This is because prerender (an experimental feature)
// has not yet implemented a concept of resume. For now we will simulate a paused connection by wrapping the stream
......
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