Skip to content
Source
Sign inSign up
TanStack/router
Open History to see the last commit

renderRouterToStream.tsx

182 lines5.4 KB

1import * as Solid from 'solid-js/web'
2import { isbot } from 'isbot'
3import {
4 createSsrStreamResponse,
5 transformReadableStreamWithRouter,
6} from '@tanstack/router-core/ssr/server'
7import { makeSsrSerovalPlugin } from '@tanstack/router-core'
8import type { JSXElement } from 'solid-js'
9import type { ReadableStream } from 'node:stream/web'
10import type { AnyRouter } from '@tanstack/router-core'
11​
12const noop = () => {}
13​
14// Bot responses wait for the server renderer before streaming. If the request
15// disconnects during that wait, unblock so the pipe can abort and clean up.
16async function waitForReadyOrAbort(
17 ready: Promise<unknown>,
18 signal: AbortSignal,
19) {
20 let cleanup = noop
21 try {
22 await Promise.race([
23 ready,
24 new Promise<void>((resolve) => {
25 const onAbort = () => resolve()
26 cleanup = () => signal.removeEventListener('abort', onAbort)
27 signal.addEventListener('abort', onAbort, { once: true })
28 if (signal.aborted) resolve()
29 }),
30 ])
31 } finally {
32 cleanup()
33 }
35​
36export const renderRouterToStream = async ({
37 request,
38 router,
39 responseHeaders,
40 children,
41}: {
42 request: Request
43 router: AnyRouter
44 responseHeaders: Headers
45 children: () => JSXElement
46}) => {
47 const { writable, readable } = new TransformStream()
48​
49 const docType = Solid.ssr('<!DOCTYPE html>')
50​
51 const serializationAdapters =
52 (router.options as any)?.serializationAdapters ||
53 (router.options.ssr as any)?.serializationAdapters
54 const serovalPlugins = serializationAdapters?.map((adapter: any) => {
55 const plugin = makeSsrSerovalPlugin(adapter, { didRun: false })
56 return plugin
57 })
58​
59 const stream = Solid.renderToStream(
60 () => (
61 <>
62 {docType}
63 {children()}
64 </>
65 ),
66 {
67 nonce: router.options.ssr?.nonce,
68 plugins: serovalPlugins,
69 } as any,
70 )
71​
72 // Solid's `pipeTo(w)` takes a single arg (no signal overload) and locks
73 // `w` via `w.getWriter()`. To still own the lifecycle we hand Solid a
74 // proxy WritableStream that forwards into an inner writer we control on
75 // the real TransformStream writable. Aborting the inner writer errors
76 // the underlying readable (which our router transform reads from),
77 // surfacing the cancel through the response pipeline.
78 //
79 // RESIDUAL RISK: solid-js@1.x does NOT expose a disposal hook on
80 // `renderToStream`, and its internal write loop swallows writer
81 // rejections (`writer.write(...).catch(() => {})` in
82 // solid-js/web/dist/server.js). So aborting the inner writer stops
83 // outbound bytes but does not terminate Solid's render continuation
84 // if a Suspense/resource never resolves β€” those pending promise
85 // continuations remain scheduled and can retain children/context/
86 // request references via captured closures until natural completion
87 // or process exit. The request-scoped router graph itself is released
88 // by ServerSsr.cleanup() through the router stream lifecycle, so the leak
89 // is bounded to whatever the user's Suspense/resource closures capture.
90 // A hard upstream-abort guarantee would require a disposal API in solid-js.
91 const innerWriter = writable.getWriter()
92 let writerDone = false
93 const releaseWriter = () => {
94 try {
95 innerWriter.releaseLock()
96 } catch {
97 // already released / errored
98 }
99 }
100 const abortSolidPipe = (reason?: unknown) => {
101 if (writerDone) return
102 writerDone = true
103 void innerWriter
104 .abort(reason)
105 .catch(() => {})
106 .finally(releaseWriter)
107 }
108​
109 const onRequestAbort = () => {
110 abortSolidPipe(request.signal.reason)
111 }
112​
113 // Wire request abort before the bot all-ready wait. Otherwise a disconnect
114 // during `await stream` can leave this callback pending forever.
115 if (request.signal.aborted) {
116 onRequestAbort()
117 } else {
118 request.signal.addEventListener('abort', onRequestAbort, { once: true })
119 router.serverSsr?.onCleanup(() => {
120 request.signal.removeEventListener('abort', onRequestAbort)
121 })
122 }
123​
124 if (isbot(request.headers.get('User-Agent'))) {
125 await waitForReadyOrAbort(
126 Promise.resolve(stream as unknown),
127 request.signal,
128 )
129 }
130​
131 const solidWritable = new WritableStream({
132 write(chunk) {
133 return innerWriter.write(chunk)
134 },
135 close() {
136 writerDone = true
137 return innerWriter.close().finally(releaseWriter)
138 },
139 abort(reason) {
140 writerDone = true
141 return innerWriter.abort(reason).finally(releaseWriter)
142 },
143 })
144​
145 if (!request.signal.aborted) {
146 try {
147 void Promise.resolve(stream.pipeTo(solidWritable) as unknown).catch(
148 (err: any) => {
149 if (
150 writerDone ||
151 err?.name === 'AbortError' ||
152 err?.code === 'ABORT_ERR'
153 )
154 return
155 console.error('Error in Solid render stream:', err)
156 abortSolidPipe(err)
157 },
158 )
159 } catch (err: any) {
160 if (err?.name !== 'AbortError' && err?.code !== 'ABORT_ERR') {
161 console.error('Error in Solid render stream:', err)
162 }
163 abortSolidPipe(err)
164 }
165 }
166​
167 const responseStream = transformReadableStreamWithRouter(
168 router,
169 readable as unknown as ReadableStream,
170 { signal: request.signal, onAbort: abortSolidPipe },
171 )
172 return createSsrStreamResponse(
173 router,
174 new Response(responseStream as any, {
175 status:
176 router._serverResult?.type === 'render'
177 ? router._serverResult.status
178 : 200,
179 headers: responseHeaders,
180 }),
181 )