File size: 2,873 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 |
import type { WaitUntil } from '../../after/builtin-request-context'
import { PageSignatureError } from '../error'
import type { NextRequest } from './request'
const responseSymbol = Symbol('response')
const passThroughSymbol = Symbol('passThrough')
const waitUntilSymbol = Symbol('waitUntil')
class FetchEvent {
// TODO(after): get rid of the 'internal' variant and always use an external waitUntil
// (this means removing `FetchEventResult.waitUntil` which also requires a builder change)
readonly [waitUntilSymbol]:
| { kind: 'internal'; promises: Promise<any>[] }
| { kind: 'external'; function: WaitUntil };
[responseSymbol]?: Promise<Response>;
[passThroughSymbol] = false
constructor(_request: Request, waitUntil?: WaitUntil) {
this[waitUntilSymbol] = waitUntil
? { kind: 'external', function: waitUntil }
: { kind: 'internal', promises: [] }
}
// TODO: is this dead code? NextFetchEvent never lets this get called
respondWith(response: Response | Promise<Response>): void {
if (!this[responseSymbol]) {
this[responseSymbol] = Promise.resolve(response)
}
}
// TODO: is this dead code? passThroughSymbol is unused
passThroughOnException(): void {
this[passThroughSymbol] = true
}
waitUntil(promise: Promise<any>): void {
if (this[waitUntilSymbol].kind === 'external') {
// if we received an external waitUntil, we delegate to it
// TODO(after): this will make us not go through `getServerError(error, 'edge-server')` in `sandbox`
const waitUntil = this[waitUntilSymbol].function
return waitUntil(promise)
} else {
// if we didn't receive an external waitUntil, we make it work on our own
// (and expect the caller to do something with the promises)
this[waitUntilSymbol].promises.push(promise)
}
}
}
export function getWaitUntilPromiseFromEvent(
event: FetchEvent
): Promise<void> | undefined {
return event[waitUntilSymbol].kind === 'internal'
? Promise.all(event[waitUntilSymbol].promises).then(() => {})
: undefined
}
export class NextFetchEvent extends FetchEvent {
sourcePage: string
constructor(params: {
request: NextRequest
page: string
context: { waitUntil: WaitUntil } | undefined
}) {
super(params.request, params.context?.waitUntil)
this.sourcePage = params.page
}
/**
* @deprecated The `request` is now the first parameter and the API is now async.
*
* Read more: https://nextjs.org/docs/messages/middleware-new-signature
*/
get request() {
throw new PageSignatureError({
page: this.sourcePage,
})
}
/**
* @deprecated Using `respondWith` is no longer needed.
*
* Read more: https://nextjs.org/docs/messages/middleware-new-signature
*/
respondWith() {
throw new PageSignatureError({
page: this.sourcePage,
})
}
}
|