File size: 5,400 Bytes
1e92f2d |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 |
import PromiseQueue from 'next/dist/compiled/p-queue'
import type { RequestLifecycleOpts } from '../base-server'
import type { AfterCallback, AfterTask } from './after'
import { InvariantError } from '../../shared/lib/invariant-error'
import { isThenable } from '../../shared/lib/is-thenable'
import { workAsyncStorage } from '../app-render/work-async-storage.external'
import { withExecuteRevalidates } from '../revalidation-utils'
import { bindSnapshot } from '../app-render/async-local-storage'
import {
workUnitAsyncStorage,
type WorkUnitStore,
} from '../app-render/work-unit-async-storage.external'
import { afterTaskAsyncStorage } from '../app-render/after-task-async-storage.external'
export type AfterContextOpts = {
waitUntil: RequestLifecycleOpts['waitUntil'] | undefined
onClose: RequestLifecycleOpts['onClose']
onTaskError: RequestLifecycleOpts['onAfterTaskError'] | undefined
}
export class AfterContext {
private waitUntil: RequestLifecycleOpts['waitUntil'] | undefined
private onClose: RequestLifecycleOpts['onClose']
private onTaskError: RequestLifecycleOpts['onAfterTaskError'] | undefined
private runCallbacksOnClosePromise: Promise<void> | undefined
private callbackQueue: PromiseQueue
private workUnitStores = new Set<WorkUnitStore>()
constructor({ waitUntil, onClose, onTaskError }: AfterContextOpts) {
this.waitUntil = waitUntil
this.onClose = onClose
this.onTaskError = onTaskError
this.callbackQueue = new PromiseQueue()
this.callbackQueue.pause()
}
public after(task: AfterTask): void {
if (isThenable(task)) {
if (!this.waitUntil) {
errorWaitUntilNotAvailable()
}
this.waitUntil(
task.catch((error) => this.reportTaskError('promise', error))
)
} else if (typeof task === 'function') {
// TODO(after): implement tracing
this.addCallback(task)
} else {
throw new Error('`after()`: Argument must be a promise or a function')
}
}
private addCallback(callback: AfterCallback) {
// if something is wrong, throw synchronously, bubbling up to the `after` callsite.
if (!this.waitUntil) {
errorWaitUntilNotAvailable()
}
const workUnitStore = workUnitAsyncStorage.getStore()
if (workUnitStore) {
this.workUnitStores.add(workUnitStore)
}
const afterTaskStore = afterTaskAsyncStorage.getStore()
// This is used for checking if request APIs can be called inside `after`.
// Note that we need to check the phase in which the *topmost* `after` was called (which should be "action"),
// not the current phase (which might be "after" if we're in a nested after).
// Otherwise, we might allow `after(() => headers())`, but not `after(() => after(() => headers()))`.
const rootTaskSpawnPhase = afterTaskStore
? afterTaskStore.rootTaskSpawnPhase // nested after
: workUnitStore?.phase // topmost after
// this should only happen once.
if (!this.runCallbacksOnClosePromise) {
this.runCallbacksOnClosePromise = this.runCallbacksOnClose()
this.waitUntil(this.runCallbacksOnClosePromise)
}
// Bind the callback to the current execution context (i.e. preserve all currently available ALS-es).
// We do this because we want all of these to be equivalent in every regard except timing:
// after(() => x())
// after(x())
// await x()
const wrappedCallback = bindSnapshot(async () => {
try {
await afterTaskAsyncStorage.run({ rootTaskSpawnPhase }, () =>
callback()
)
} catch (error) {
this.reportTaskError('function', error)
}
})
this.callbackQueue.add(wrappedCallback)
}
private async runCallbacksOnClose() {
await new Promise<void>((resolve) => this.onClose!(resolve))
return this.runCallbacks()
}
private async runCallbacks(): Promise<void> {
if (this.callbackQueue.size === 0) return
for (const workUnitStore of this.workUnitStores) {
workUnitStore.phase = 'after'
}
const workStore = workAsyncStorage.getStore()
if (!workStore) {
throw new InvariantError('Missing workStore in AfterContext.runCallbacks')
}
return withExecuteRevalidates(workStore, () => {
this.callbackQueue.start()
return this.callbackQueue.onIdle()
})
}
private reportTaskError(taskKind: 'promise' | 'function', error: unknown) {
// TODO(after): this is fine for now, but will need better intergration with our error reporting.
// TODO(after): should we log this if we have a onTaskError callback?
console.error(
taskKind === 'promise'
? `A promise passed to \`after()\` rejected:`
: `An error occurred in a function passed to \`after()\`:`,
error
)
if (this.onTaskError) {
// this is very defensive, but we really don't want anything to blow up in an error handler
try {
this.onTaskError?.(error)
} catch (handlerError) {
console.error(
new InvariantError(
'`onTaskError` threw while handling an error thrown from an `after` task',
{
cause: handlerError,
}
)
)
}
}
}
}
function errorWaitUntilNotAvailable(): never {
throw new Error(
'`after()` will not work correctly, because `waitUntil` is not available in the current environment.'
)
}
|