Open History to see the last commit
1import type { AnyRouter } from '../router'
2β
3export type SsrResponse =
4 | {
5 response: Response
6 serverSsrCleanup: 'none'
7 }
8 | {
9 response: Response
10 serverSsrCleanup: 'stream'
11 dispose: (reason?: unknown) => undefined
12 }
13β
14export type HandlerCallbackResult = Response | SsrResponse
15β
16export function isSsrResponse(value: unknown): value is SsrResponse {
17 if (
18 typeof value !== 'object' ||
19 value === null ||
20 !('response' in value) ||
21 !(value.response instanceof Response) ||
22 !('serverSsrCleanup' in value)
23 ) {
24 return false
25 }
26β
27 if (value.serverSsrCleanup === 'none') {
28 return true
29 }
30β
31 return (
32 value.serverSsrCleanup === 'stream' &&
33 'dispose' in value &&
34 typeof value.dispose === 'function'
35 )
36}
37β
38export function normalizeSsrResponse(
39 result: HandlerCallbackResult,
40): SsrResponse {
41 if (result instanceof Response) {
42 return { response: result, serverSsrCleanup: 'none' }
43 }
44 if (isSsrResponse(result)) {
45 return result
46 }
47β
48 throw new TypeError('Expected a Response from the SSR handler')
49}
50β
51function cancelResponseBody(response: Response, reason?: unknown): void {
52 const body = response.body
53 if (!body) {
54 return
55 }
56 void body.cancel(reason).catch(console.error)
57}
58β
59export function disposeSsrResponse(
60 result: HandlerCallbackResult,
61 reason?: unknown,
62): undefined {
63 const response = normalizeSsrResponse(result)
64 if (response.serverSsrCleanup === 'stream') {
65 response.dispose(reason)
66 } else {
67 cancelResponseBody(response.response, reason)
68 }
69}
70β
71/** The HTTP status that Router's server load selected for this render. */
72export function getSsrStatus(router: AnyRouter) {
73 return router._serverResult?.type === 'render'
74 ? router._serverResult.status
75 : 200
76}
77β
78export function createSsrStreamResponse(
79 router: AnyRouter,
80 response: Response,
81): Extract<SsrResponse, { serverSsrCleanup: 'stream' }> {
82 const body = response.body
83 if (!body) {
84 throw new Error('Invariant failed: SSR stream response requires a body')
85 }
86β
87 return {
88 response,
89 serverSsrCleanup: 'stream',
90 dispose(reason?: unknown): undefined {
91 // Sever router ownership before asking user/renderer stream machinery to
92 // cancel. A custom stream is allowed to ignore cancellation forever.
93 router.serverSsr?.cleanup()
94β
95 void body.cancel(reason).catch(() => {})
96 },
97 }
98}
99β
100export function bindSsrResponseToRequest(
101 router: AnyRouter | undefined,
102 result: HandlerCallbackResult,
103 signal: AbortSignal,
104): SsrResponse {
105 const ssrResponse = normalizeSsrResponse(result)
106 if (ssrResponse.serverSsrCleanup !== 'stream') {
107 if (signal.aborted) {
108 disposeSsrResponse(result, signal.reason)
109 }
110 return ssrResponse
111 }
112β
113 const abort = () => {
114 disposeSsrResponse(ssrResponse, signal.reason)
115 }
116 if (signal.aborted) {
117 abort()
118 return ssrResponse
119 }
120β
121 const serverSsr = router?.serverSsr
122 if (serverSsr?.hydrationScripts.requestSignal === signal) {
123 // The transform already observes this request. Its cleanup must also
124 // dispose the final response, including any middleware-owned body.
125 serverSsr.onCleanup(() => {
126 if (signal.aborted) {
127 abort()
128 }
129 })
130 return ssrResponse
131 }
132β
133 signal.addEventListener('abort', abort, { once: true })
134 if (!serverSsr) {
135 return ssrResponse
136 }
137β
138 serverSsr.onCleanup(() => {
139 signal.removeEventListener('abort', abort)
140 })
141 return ssrResponse
142}
143β
144export function replaceSsrResponse(
145 result: HandlerCallbackResult,
146 response: Response,
147 reason?: unknown,
148): Extract<SsrResponse, { serverSsrCleanup: 'none' }> {
149 disposeSsrResponse(result, reason)
150 return { response, serverSsrCleanup: 'none' }
151}
152β
153export function stripSsrResponseBody(
154 result: HandlerCallbackResult,
155 reason?: unknown,
156): Extract<SsrResponse, { serverSsrCleanup: 'none' }> {
157 const ssrResponse = normalizeSsrResponse(result)
158 disposeSsrResponse(ssrResponse, reason)
159 return {
160 response: new Response(null, ssrResponse.response),
161 serverSsrCleanup: 'none',
162 }
163}
164β
165export interface HandlerCallback<TRouter extends AnyRouter> {
166 (ctx: {
167 request: Request
168 router: TRouter
169 responseHeaders: Headers
170 }): HandlerCallbackResult | Promise<HandlerCallbackResult>
171}
172β
173export function defineHandlerCallback<TRouter extends AnyRouter>(
174 handler: HandlerCallback<TRouter>,
175): HandlerCallback<TRouter> {
176 return handler
177}