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

createStartHandler.ts

1,019 lines30.6 KB

1import { createServerHistory } from '@tanstack/history'
2import {
3 createCsrfMiddleware,
4 createNullProtoObject,
5 csrfSymbol,
6 flattenMiddlewares,
7 mergeHeaders,
8 safeObjectMerge,
9} from '@tanstack/start-client-core'
10import {
11 _getRenderedMatches,
12 executeRewriteInput,
13 isDangerousProtocol,
14 isPromise,
15 isRedirect,
16} from '@tanstack/router-core'
17import {
18 attachRouterServerSsrUtils,
19 bindSsrResponseToRequest,
20 disposeSsrResponse,
21 getNormalizedURL,
22 isSsrResponse,
23 normalizeSsrResponse,
24 replaceSsrResponse,
25 stripSsrResponseBody,
26 waitForRequest,
27} from '@tanstack/router-core/ssr/server'
28import {
29 getStartContext,
30 runWithStartContext,
31} from '@tanstack/start-storage-context'
32import { requestHandler } from './request-response'
33import { getStartManifest } from './router-manifest'
34import { handleServerAction } from './server-functions-handler'
35import { createEarlyHintsCollector } from './early-hints'
36import {
37 createCachedBaseManifestLoader,
38 createFinalManifestResolver,
39} from './finalManifest'
40​
41import { HEADERS } from './constants'
42import { ServerFunctionSerializationAdapter } from './serializer/ServerFunctionSerializationAdapter'
43import type {
44 AnyFunctionMiddleware,
45 AnyRequestMiddleware,
46 AnyStartInstanceOptions,
47 RouteMethod,
48 RouterEntry,
49 StartEntry,
50} from '@tanstack/start-client-core'
51import type { RequestHandler } from './request-handler'
52import type {
53 AnyRoute,
54 AnyRouter,
55 AnySerializationAdapter,
56 Register,
57} from '@tanstack/router-core'
58import type {
59 HandlerCallback,
60 HandlerCallbackResult,
61 SsrResponse,
62} from '@tanstack/router-core/ssr/server'
63import type { FinalManifestOptions } from './finalManifest'
64​
65type TODO = any
66​
67type AnyMiddlewareServerFn =
68 | AnyRequestMiddleware['options']['server']
69 | AnyFunctionMiddleware['options']['server']
70​
71export interface CreateStartHandlerOptions extends FinalManifestOptions {
72 handler: HandlerCallback<AnyRouter>
74​
75function getStartResponseHeaders(opts: { router: AnyRouter }) {
76 const headers = mergeHeaders(
77 {
78 'Content-Type': 'text/html; charset=utf-8',
79 },
80 ..._getRenderedMatches(opts.router.stores.matches.get()).map((match) => {
81 return match.headers
82 }),
83 )
84 return headers
86​
87interface PluginAdaptersEntry {
88 hasPluginAdapters: boolean
89 pluginSerializationAdapters: Array<AnySerializationAdapter>
91​
92interface Entries {
93 startEntry: StartEntry
94 routerEntry: RouterEntry
95 pluginAdapters: PluginAdaptersEntry
97​
98// Cached entries - promises stored immediately to prevent concurrent imports
99// that can cause race conditions during module initialization
100let entriesPromise: Promise<Entries> | undefined
101let hasWarnedMissingCsrfMiddleware = false
102const defaultCsrfMiddleware = createCsrfMiddleware({
103 filter: (ctx) => ctx.handlerType === 'serverFn',
104})
105const getCachedBaseManifest = createCachedBaseManifestLoader(() =>
106 getStartManifest(),
108const getProdBaseManifest: typeof getStartManifest = () =>
109 getCachedBaseManifest()
110const getBaseManifest =
111 process.env.TSS_DEV_SERVER === 'true' ? getStartManifest : getProdBaseManifest
112const createEarlyHintsForRequest: typeof createEarlyHintsCollector =
113 process.env.TSS_DEV_SERVER === 'true'
114 ? () => undefined
115 : createEarlyHintsCollector
116​
117async function loadEntries(): Promise<Entries> {
118 const [routerEntry, startEntry, pluginAdapters] = await Promise.all([
119 // @ts-ignore When building, we currently don't respect tsconfig.ts' `include` so we are not picking up the .d.ts from start-client-core
120 import('#tanstack-router-entry'),
121 // @ts-ignore When building, we currently don't respect tsconfig.ts' `include` so we are not picking up the .d.ts from start-client-core
122 import('#tanstack-start-entry'),
123 // @ts-ignore When building, we currently don't respect tsconfig.ts' `include` so we are not picking up the .d.ts from start-client-core
124 import('#tanstack-start-plugin-adapters'),
125 ])
126 return {
127 routerEntry: routerEntry as unknown as RouterEntry,
128 startEntry: startEntry as unknown as StartEntry,
129 pluginAdapters: pluginAdapters as unknown as PluginAdaptersEntry,
130 }
132​
133function getEntries() {
134 if (!entriesPromise) {
135 entriesPromise = loadEntries()
136 }
137 return entriesPromise
139​
140function hasCsrfMiddleware(
141 middlewares: Array<AnyRequestMiddleware | AnyFunctionMiddleware>,
142): boolean {
143 return middlewares.some((middleware) => csrfSymbol in middleware)
145​
146function warnMissingCsrfMiddlewareOnce() {
147 if (hasWarnedMissingCsrfMiddleware) return
148 hasWarnedMissingCsrfMiddleware = true
149​
150 console.warn(`TanStack Start server functions are not protected by the CSRF middleware.
151​
152Server functions are same-origin RPC endpoints and should be protected from cross-site requests.
153​
154Add the CSRF middleware in src/start.ts:
155​
156 const csrfMiddleware = createCsrfMiddleware({
157 filter: (ctx) => ctx.handlerType === 'serverFn',
158 })
159​
160 export const startInstance = createStart(() => ({
161 requestMiddleware: [csrfMiddleware],
162 }))
163​
164If you intentionally handle CSRF another way, disable this warning:
165​
166 tanstackStart({
167 serverFns: {
168 disableCsrfMiddlewareWarning: true,
169 },
170 })`)
172​
173// Pre-computed constants
174const ROUTER_BASEPATH = process.env.TSS_ROUTER_BASEPATH || '/'
175const SERVER_FN_BASE = process.env.TSS_SERVER_FN_BASE
176const IS_PRERENDERING = process.env.TSS_PRERENDERING === 'true'
177const IS_SHELL_ENV = process.env.TSS_SHELL === 'true'
178const IS_DEV = process.env.NODE_ENV === 'development'
179​
180// Reusable error messages
181const ERR_NO_RESPONSE = IS_DEV
182 ? `It looks like you forgot to return a response from your server route handler. If you want to defer to the app router, make sure to have a component set in this route.`
183 : 'Internal Server Error'
184​
185const ERR_NO_DEFER = IS_DEV
186 ? `You cannot defer to the app router if there is no component defined on this route.`
187 : 'Internal Server Error'
188​
189function throwRouteHandlerError(): never {
190 throw new Error(ERR_NO_RESPONSE)
192​
193function throwIfMayNotDefer(): never {
194 throw new Error(ERR_NO_DEFER)
196​
197function getResponseFromResult(result: TODO): TODO {
198 return isSsrResponse(result) || result instanceof Response
199 ? result
200 : result?.response
202​
203type StreamSsrResponse = Extract<SsrResponse, { serverSsrCleanup: 'stream' }>
204​
205type ResponseBody = NonNullable<Response['body']>
206type ResponseWithBody = Response & { readonly body: ResponseBody }
207​
208/** The context object threaded through one middleware pipeline. */
209interface PipelineContext {
210 request: Request
211 pathname: string
212 handlerType: 'serverFn' | 'router'
213 context: Record<string, unknown>
214 params?: Record<string, unknown>
215 response?: Response
216 // Middleware may add arbitrary own properties through `next(ctx)`.
217 [key: string]: unknown
219​
220interface MiddlewareResponseOwnership {
221 response: ResponseWithBody
222 sourceBody: ResponseBody
223 streamResponse?: StreamSsrResponse
225​
226// Entries are released with their response; the map is never cleared by hand.
227const responseBodySources = new WeakMap<Response, Response>()
228​
229function disposeResponseResult(result: TODO, reason: unknown): void {
230 const response = getResponseFromResult(result)
231 if (isSsrResponse(response) || response instanceof Response) {
232 disposeSsrResponse(response, reason)
233 }
235​
236/**
237 * Marks `response` as directly derived from the current `source`.
238 * Middleware must consume or cancel any other `clone()` or `tee()` branches.
239 */
240export function transferResponseBodyOwnership<TResponse extends Response>(
241 source: Response,
242 response: TResponse,
243): TResponse {
244 if (!source.body || !response.body) {
245 throw new Error('Response body ownership requires two response bodies')
246 }
247 responseBodySources.set(response, source)
248 return response
250​
251function hasResponseBody(value: unknown): value is ResponseWithBody {
252 return value instanceof Response && value.body !== null
254​
255function inheritsResponseOwnership(
256 ownership: MiddlewareResponseOwnership,
257 candidate: unknown,
258): candidate is ResponseWithBody {
259 return (
260 hasResponseBody(candidate) &&
261 (candidate.body === ownership.response.body ||
262 responseBodySources.get(candidate) === ownership.response)
263 )
265​
266function disposeResponseOwnership(
267 ownership: MiddlewareResponseOwnership,
268 reason: unknown,
269): void {
270 const { response, sourceBody, streamResponse } = ownership
271 streamResponse?.dispose(reason)
272 if (!streamResponse || response.body !== sourceBody) {
273 void response.body.cancel(reason).catch(() => {})
274 }
276​
277function getOwnedResponse(
278 ownership: MiddlewareResponseOwnership,
279): HandlerCallbackResult {
280 const { response, sourceBody, streamResponse } = ownership
281 if (!streamResponse) {
282 return response
283 }
284 if (streamResponse.response === response && response.body === sourceBody) {
285 return streamResponse
286 }
287 if (response.body === sourceBody) {
288 return { ...streamResponse, response }
289 }
290 return {
291 ...streamResponse,
292 response,
293 dispose(reason): undefined {
294 disposeResponseOwnership(ownership, reason)
295 },
296 }
298​
299function createLateResponseDisposer(signal: AbortSignal) {
300 return (result: TODO) => disposeResponseResult(result, signal.reason)
302​
303/**
304 * Compose middleware around a terminal response handler. With no middleware
305 * the terminal runs directly.
306 */
307async function executeMiddleware(
308 middlewares: Array<TODO>,
309 terminal: TODO,
310 ctx: PipelineContext,
311 signal: AbortSignal,
312 terminalNext?: TODO,
313): Promise<HandlerCallbackResult> {
314 let index = -1
315 let responseOwnership: MiddlewareResponseOwnership | undefined
316 // Once the pipeline returned, the HTTP runtime owns the response. A result
317 // that settles later (for example the loser of a `Promise.race`) must not
318 // replace or cancel it.
319 let settled = false
320 const disposeAbandonedResult = createLateResponseDisposer(signal)
321​
322 const setResponse = (response: TODO) => {
323 const ssrResponse = isSsrResponse(response) ? response : undefined
324 const streamResponse =
325 ssrResponse?.serverSsrCleanup === 'stream' ? ssrResponse : undefined
326 const exposed: Response | undefined = ssrResponse
327 ? ssrResponse.response
328 : response
329 const current = responseOwnership
330​
331 if (settled) {
332 if (exposed !== ctx.response) {
333 disposeResponseResult(response, 'late middleware response')
334 }
335 return
336 }
337 if (current && current.response === exposed) {
338 current.streamResponse ??= streamResponse
339 } else if (current && inheritsResponseOwnership(current, exposed)) {
340 current.response = exposed
341 current.streamResponse ??= streamResponse
342 } else {
343 if (current) {
344 disposeResponseOwnership(current, 'middleware response replaced')
345 }
346 if (hasResponseBody(exposed)) {
347 responseOwnership = {
348 response: exposed,
349 sourceBody: exposed.body,
350 streamResponse,
351 }
352 } else {
353 responseOwnership = undefined
354 }
355 }
356 ctx.response = exposed
357 }
358​
359 const reconcileCtxResponse = () => {
360 if (ctx.response !== responseOwnership?.response) {
361 setResponse(ctx.response)
362 }
363 }
364​
365 let nextPromise: Promise<TODO> | undefined
366​
367 function next(nextCtx?: TODO): Promise<TODO> {
368 const result = runNext(nextCtx)
369 nextPromise = result
370 return result
371 }
372​
373 async function runNext(nextCtx?: TODO): Promise<TODO> {
374 signal.throwIfAborted()
375​
376 // Merge context if provided using safeObjectMerge for prototype pollution prevention
377 if (nextCtx) {
378 if (nextCtx.context) {
379 ctx.context = safeObjectMerge(ctx.context, nextCtx.context)
380 }
381 // Copy own properties except context (Object.keys returns only own enumerable properties)
382 for (const key of Object.keys(nextCtx)) {
383 if (key === 'response') {
384 setResponse(nextCtx.response)
385 } else if (key !== 'context') {
386 ctx[key] = nextCtx[key]
387 }
388 }
389 }
390​
391 index++
392 const isTerminal = index === middlewares.length
393 const middleware =
394 index < middlewares.length
395 ? middlewares[index]
396 : isTerminal
397 ? terminal
398 : undefined
399 const middlewareNext = isTerminal && terminalNext ? terminalNext : next
400 if (!middleware) {
401 return ctx
402 }
403​
404 let result: TODO
405 try {
406 const pending = middleware({ ...ctx, next: middlewareNext })
407 // A directly returned next() promise already propagates request aborts.
408 if (nextPromise && pending === nextPromise) {
409 nextPromise = undefined
410 await pending
411 if (signal.aborted) {
412 throw signal.reason
413 }
414 return ctx
415 } else if (!isPromise(pending)) {
416 result = pending
417 signal.throwIfAborted()
418 } else {
419 result = await waitForRequest(
420 pending,
421 signal,
422 disposeAbandonedResult,
423 disposeAbandonedResult,
424 )
425 }
426 } catch (err) {
427 reconcileCtxResponse()
428 if (signal.aborted) {
429 if (result !== undefined) {
430 disposeAbandonedResult(result)
431 }
432 if (err !== signal.reason) {
433 disposeAbandonedResult(err)
434 }
435 throw signal.reason
436 }
437 if (err instanceof Response) {
438 setResponse(err)
439 return ctx
440 }
441 throw err
442 }
443​
444 if (isTerminal && terminalNext && !result) {
445 throwRouteHandlerError()
446 }
447​
448 reconcileCtxResponse()
449 if (result && result !== ctx) {
450 const response = getResponseFromResult(result)
451 if (response !== undefined && response !== ctx.response) {
452 setResponse(response)
453 }
454 if (
455 response !== result &&
456 result.context &&
457 result.context !== ctx.context
458 ) {
459 ctx.context = safeObjectMerge(ctx.context, result.context)
460 }
461 }
462​
463 return ctx
464 }
465​
466 try {
467 await runNext()
468 const response = ctx.response
469 if (!response) {
470 throwRouteHandlerError()
471 }
472 reconcileCtxResponse()
473 if (signal.aborted) {
474 throw signal.reason
475 }
476 settled = true
477 return responseOwnership ? getOwnedResponse(responseOwnership) : response
478 } catch (err) {
479 settled = true
480 if (responseOwnership) {
481 disposeResponseOwnership(
482 responseOwnership,
483 signal.aborted ? signal.reason : err,
484 )
485 }
486 throw err
487 }
489​
490/**
491 * Creates the TanStack Start request handler.
492 *
493 * @example Backwards-compatible usage (handler callback only):
494 * ```ts
495 * export default createStartHandler(defaultStreamHandler)
496 * ```
497 *
498 * @example With CDN URL rewriting:
499 * ```ts
500 * export default createStartHandler({
501 * handler: defaultStreamHandler,
502 * transformAssets: 'https://cdn.example.com',
503 * })
504 * ```
505 *
506 * @example With per-request URL rewriting:
507 * ```ts
508 * export default createStartHandler({
509 * handler: defaultStreamHandler,
510 * transformAssets: {
511 * transform: ({ url }) => {
512 * const cdnBase = getRequest().headers.get('x-cdn-base') || ''
513 * return { href: `${cdnBase}${url}` }
514 * },
515 * cache: false,
516 * },
517 * })
518 * ```
519 */
520export function createStartHandler<TRegister = Register>(
521 cbOrOptions: HandlerCallback<AnyRouter> | CreateStartHandlerOptions,
522): RequestHandler<TRegister> {
523 const handlerOptions: FinalManifestOptions =
524 typeof cbOrOptions === 'function' ? {} : cbOrOptions
525 const cb: HandlerCallback<AnyRouter> =
526 typeof cbOrOptions === 'function' ? cbOrOptions : cbOrOptions.handler
527 const finalManifestResolver = createFinalManifestResolver({
528 ...handlerOptions,
529 cacheCreateTransform: process.env.TSS_DEV_SERVER !== 'true',
530 })
531 const resolveManifestForRequest =
532 process.env.TSS_DEV_SERVER === 'true'
533 ? finalManifestResolver.resolveUncached
534 : finalManifestResolver.resolveCached
535​
536 if (process.env.TSS_DEV_SERVER !== 'true') {
537 finalManifestResolver.warmup({
538 getBaseManifest: () => getBaseManifest(undefined),
539 })
540 }
541​
542 const startRequestResolver: RequestHandler<Register> = async (
543 request,
544 requestOpts,
545 ) => {
546 const signal = request.signal
547 let router: AnyRouter | undefined
548 let routerPromise: Promise<AnyRouter> | undefined
549 let responseOwnsCleanup = false
550​
551 try {
552 signal.throwIfAborted()
553 // normalizing and sanitizing the pathname here for server, so we always deal with the same format during SSR.
554 // during normalization paths like '//posts' are flattened to '/posts'.
555 // in these cases we would prefer to redirect to the new path
556 const { url, handledProtocolRelativeURL } = getNormalizedURL(request.url)
557 const href = url.pathname + url.search + url.hash
558 const origin = url.origin
559​
560 if (handledProtocolRelativeURL) {
561 return Response.redirect(url, 308)
562 }
563​
564 const entries = await waitForRequest(getEntries(), signal)
565 const isServerFnRequest =
566 !!SERVER_FN_BASE && url.pathname.startsWith(SERVER_FN_BASE)
567 const startInstance = entries.startEntry.startInstance
568 let startOptions: AnyStartInstanceOptions
569 if (startInstance) {
570 const pendingStartOptions = startInstance.getOptions()
571 startOptions = isPromise(pendingStartOptions)
572 ? await waitForRequest(pendingStartOptions, signal)
573 : pendingStartOptions
574 signal.throwIfAborted()
575 } else {
576 startOptions = {} as AnyStartInstanceOptions
577 }
578​
579 const { hasPluginAdapters, pluginSerializationAdapters } =
580 entries.pluginAdapters
581​
582 const serializationAdapters = [
583 ...(startOptions.serializationAdapters || []),
584 ...(hasPluginAdapters ? pluginSerializationAdapters : []),
585 ServerFunctionSerializationAdapter,
586 ]
587​
588 const requestStartOptions = {
589 ...startOptions,
590 requestMiddleware: startInstance
591 ? startOptions.requestMiddleware
592 : isServerFnRequest
593 ? [defaultCsrfMiddleware]
594 : undefined,
595 serializationAdapters,
596 }
597​
598 // Flatten request middlewares once
599 const flattenedRequestMiddlewares = requestStartOptions.requestMiddleware
600 ? flattenMiddlewares(requestStartOptions.requestMiddleware)
601 : []
602​
603 // Create set for deduplication
604 const executedRequestMiddlewares = new Set<TODO>(
605 flattenedRequestMiddlewares,
606 )
607​
608 // Memoized router getter
609 const getRouter = (): Promise<AnyRouter> => {
610 routerPromise ??= (async () => {
611 signal.throwIfAborted()
612 const requestRouter = await waitForRequest(
613 entries.routerEntry.getRouter(),
614 signal,
615 )
616​
617 let isShell = IS_SHELL_ENV
618 if (IS_PRERENDERING && !isShell) {
619 isShell = request.headers.get(HEADERS.TSS_SHELL) === 'true'
620 }
621​
622 const history = createServerHistory(href)
623​
624 requestRouter.update({
625 history,
626 isShell,
627 isPrerendering: IS_PRERENDERING,
628 origin: requestRouter.options.origin ?? origin,
629 // Start-owned options that RouterConstructorOptions omits.
630 ...{
631 defaultSsr: requestStartOptions.defaultSsr,
632 serializationAdapters: [
633 ...requestStartOptions.serializationAdapters,
634 ...(requestRouter.options.serializationAdapters || []),
635 ],
636 },
637 basepath: ROUTER_BASEPATH,
638 })
639​
640 router = requestRouter
641 return requestRouter
642 })()
643​
644 return routerPromise
645 }
646​
647 const handlerType = isServerFnRequest
648 ? ('serverFn' as const)
649 : ('router' as const)
650 const startContext = {
651 getRouter,
652 startOptions: requestStartOptions,
653 request,
654 executedRequestMiddlewares,
655 handlerType,
656 }
657 let terminal: (ctx: PipelineContext) => unknown
658​
659 if (isServerFnRequest) {
660 if (
661 process.env.NODE_ENV !== 'production' &&
662 process.env.TSS_DISABLE_CSRF_MIDDLEWARE_WARNING !== 'true' &&
663 !hasCsrfMiddleware(flattenedRequestMiddlewares)
664 ) {
665 warnMissingCsrfMiddlewareOnce()
666 }
667​
668 const serverFnId = url.pathname
669 .slice(SERVER_FN_BASE.length)
670 .split('/')[0]
671​
672 if (!serverFnId) {
673 throw new Error('Invalid server action param for serverFnId')
674 }
675​
676 terminal = ({ context }) =>
677 runWithStartContext(
678 { ...startContext, contextAfterGlobalMiddlewares: context },
679 () =>
680 handleServerAction({
681 request,
682 context: requestOpts?.context,
683 serverFnId,
684 }),
685 )
686 } else {
687 const executeRouter = async (
688 serverContext: TODO,
689 matchedRoutes?: ReadonlyArray<AnyRoute>,
690 ): Promise<SsrResponse> => {
691 if (
692 !/(^|,)\s*(\*\/\*|text\/html)/.test(
693 request.headers.get('Accept') || '*/*',
694 )
695 ) {
696 return normalizeSsrResponse(
697 Response.json(
698 { error: 'Only HTML requests are supported here' },
699 { status: 406 },
700 ),
701 )
702 }
703​
704 const manifest = await waitForRequest(
705 resolveManifestForRequest({
706 request,
707 requestInlineCss: requestOpts?.inlineCss,
708 getBaseManifest: () => getBaseManifest(matchedRoutes),
709 }),
710 signal,
711 )
712​
713 const earlyHints = createEarlyHintsForRequest({
714 onEarlyHints: requestOpts?.onEarlyHints,
715 responseLinkHeader: requestOpts?.responseLinkHeader,
716 })
717​
718 earlyHints?.collectStatic({ manifest, matchedRoutes })
719​
720 const routerInstance = await getRouter()
721​
722 attachRouterServerSsrUtils({
723 router: routerInstance,
724 manifest,
725 getRequestAssets: () =>
726 getStartContext({ throwIfNotFound: false })?.requestAssets,
727 })
728​
729 // `additionalContext` is request-scoped and only read from router.options
730 // during load; avoid a full router.update() and redundant location parse.
731 routerInstance.options.additionalContext = { serverContext }
732 await routerInstance.load({ _signal: signal })
733 signal.throwIfAborted()
734​
735 if (routerInstance._serverResult?.type === 'redirect') {
736 return normalizeSsrResponse(routerInstance._serverResult.redirect)
737 }
738​
739 earlyHints?.collectDynamic(
740 _getRenderedMatches(routerInstance.stores.matches.get()),
741 )
742​
743 // Pass request-scoped assets to dehydrate for manifest injection
744 const ctx = getStartContext({ throwIfNotFound: false })
745 await routerInstance.serverSsr!.dehydrate({
746 requestAssets: ctx?.requestAssets,
747 signal,
748 })
749 signal.throwIfAborted()
750​
751 const responseHeaders = getStartResponseHeaders({
752 router: routerInstance,
753 })
754 earlyHints?.appendResponseHeaders(responseHeaders)
755 signal.throwIfAborted()
756 const disposeLate = createLateResponseDisposer(signal)
757 const response = await waitForRequest(
758 cb({
759 request,
760 router: routerInstance,
761 responseHeaders,
762 }),
763 signal,
764 disposeLate,
765 disposeLate,
766 )
767 return normalizeSsrResponse(response)
768 }
769​
770 terminal = ({ context }) =>
771 runWithStartContext(
772 { ...startContext, contextAfterGlobalMiddlewares: context },
773 () =>
774 handleServerRoutes({
775 getRouter,
776 request,
777 url,
778 executeRouter,
779 context,
780 executedRequestMiddlewares,
781 }),
782 )
783 }
784​
785 const middlewareResponse = await executeMiddleware(
786 flattenedRequestMiddlewares.map((d) => d.options.server),
787 terminal,
788 {
789 request,
790 pathname: url.pathname,
791 handlerType,
792 context: createNullProtoObject(requestOpts?.context),
793 },
794 signal,
795 )
796​
797 let result: SsrResponse
798 try {
799 result = await handleRedirectResponse(
800 middlewareResponse,
801 getRouter,
802 signal,
803 isServerFnRequest && request.headers.get('x-tsr-serverFn') === 'true',
804 )
805 if (request.method === 'HEAD') {
806 result = stripSsrResponseBody(result, 'HEAD body stripped')
807 }
808 } catch (error) {
809 disposeResponseResult(
810 middlewareResponse,
811 signal.aborted ? signal.reason : error,
812 )
813 throw error
814 }
815 bindSsrResponseToRequest(router, result, signal)
816 signal.throwIfAborted()
817 responseOwnsCleanup = result.serverSsrCleanup === 'stream'
818 return result.response
819 } finally {
820 if (router?.serverSsr && !responseOwnsCleanup) {
821 // Clean up router SSR state if it was set up but won't be cleaned up by the callback
822 // (e.g., in redirect cases or early returns before the callback is invoked).
823 // Transformed streaming response bodies clean up when consumed/cancelled.
824 router.serverSsr.cleanup()
825 }
826 // `routerPromise` stays memoized: a streamed Suspense boundary or a late
827 // server function may still ask for this request's router.
828 }
829 }
830​
831 return requestHandler(startRequestResolver)
833​
834const relativeRedirectProtocols = new Set<string>()
835​
836async function handleRedirectResponse(
837 response: HandlerCallbackResult,
838 getRouter: () => Promise<AnyRouter>,
839 signal: AbortSignal,
840 serializeRedirect: boolean,
841): Promise<SsrResponse> {
842 signal.throwIfAborted()
843 const ssrResponse = normalizeSsrResponse(response)
844 const redirect = ssrResponse.response
845 if (!isRedirect(redirect)) {
846 return ssrResponse
847 }
848​
849 const opts = redirect.options
850 const href = redirect.headers.get('Location') || opts.href
851 if (
852 !href &&
853 opts.to &&
854 typeof opts.to === 'string' &&
855 !opts.to.startsWith('/')
856 ) {
857 throw new Error(
858 `Server side redirects must use absolute paths via the 'href' or 'to' options. The redirect() method's "to" property accepts an internal path only. Use the "href" property to provide an external URL. Received: ${JSON.stringify(opts)}`,
859 )
860 }
861​
862 if (
863 !href &&
864 ['params', 'search', 'hash'].some(
865 (d) => typeof (opts as TODO)[d] === 'function',
866 )
867 ) {
868 throw new Error(
869 `Server side redirects must use static search, params, and hash values and do not support functional values. Received functional values for: ${Object.keys(
870 opts,
871 )
872 .filter((d) => typeof (opts as TODO)[d] === 'function')
873 .map((d) => `"${d}"`)
874 .join(', ')}`,
875 )
876 }
877​
878 signal.throwIfAborted()
879 // Unambiguous relative hrefs need no route resolution or protocol policy.
880 // Every scheme falls back to the router to honor its custom allowlist.
881 if (href && !isDangerousProtocol(href, relativeRedirectProtocols)) {
882 opts.href = href
883 redirect.headers.set('Location', href)
884 } else {
885 const router = await getRouter()
886 signal.throwIfAborted()
887 // Resolves `redirect` in place.
888 router.resolveRedirect(redirect)
889 }
890​
891 if (serializeRedirect) {
892 const redirectOptions = { ...(opts as TODO) }
893 delete redirectOptions.headers
894 const responseHeaders = new Headers(redirect.headers)
895 responseHeaders.set('content-type', 'application/json')
896 return replaceSsrResponse(
897 ssrResponse,
898 Response.json(
899 { ...redirectOptions, isSerializedRedirect: true },
900 { headers: responseHeaders },
901 ),
902 'redirect response replaced',
903 )
904 }
905​
906 return ssrResponse
908​
909async function handleServerRoutes({
910 getRouter,
911 request,
912 url,
913 executeRouter,
914 context,
915 executedRequestMiddlewares,
916}: {
917 getRouter: () => Promise<AnyRouter>
918 request: Request
919 url: URL
920 executeRouter: (
921 serverContext: any,
922 matchedRoutes?: ReadonlyArray<AnyRoute>,
923 ) => Promise<SsrResponse>
924 context: any
925 executedRequestMiddlewares: Set<AnyRequestMiddleware>
926}): Promise<SsrResponse> {
927 const router = await getRouter()
928 const rewrittenUrl = executeRewriteInput(router.rewrite, url)
929 const pathname = rewrittenUrl.pathname
930 // this will perform a fuzzy match, however for server routes we need an exact match
931 // if the route is not an exact match, executeRouter will handle rendering the app router
932 // the match will be cached internally, so no extra work is done during the app router render
933 const [matchedRoutes, rawParams, foundRoute] =
934 router.getMatchedRoutes(pathname)
935​
936 const isExactMatch = foundRoute && rawParams['**'] === undefined
937​
938 // Collect and dedupe route middlewares
939 const routeMiddlewares: Array<AnyMiddlewareServerFn> = []
940 let terminalHandler: TODO = (ctx: TODO) =>
941 executeRouter(ctx.context, matchedRoutes)
942 let terminalNext: TODO
943​
944 // Collect middleware from matched routes, filtering out those already executed
945 // in the request phase
946 for (const route of matchedRoutes) {
947 const serverMiddleware = route.options.server?.middleware as
948 | Array<AnyRequestMiddleware>
949 | undefined
950 if (serverMiddleware) {
951 const flattened = flattenMiddlewares(serverMiddleware)
952 for (const m of flattened) {
953 if (!executedRequestMiddlewares.has(m)) {
954 routeMiddlewares.push(m.options.server)
955 }
956 }
957 }
958 }
959​
960 // Add handler middleware if exact match
961 const server = foundRoute?.options.server
962 if (server?.handlers && isExactMatch) {
963 const handlers =
964 typeof server.handlers === 'function'
965 ? server.handlers({ createHandlers: (d: any) => d })
966 : server.handlers
967​
968 const requestMethod = request.method.toUpperCase() as RouteMethod
969 // Per RFC 9110 Β§9.3.2, HEAD must return the same header fields as GET.
970 // Priority for HEAD: explicit HEAD handler β†’ GET β†’ ANY (last resort).
971 const handler =
972 requestMethod === 'HEAD'
973 ? (handlers['HEAD'] ?? handlers['GET'] ?? handlers['ANY'])
974 : (handlers[requestMethod] ?? handlers['ANY'])
975 if (handler) {
976 const mayDefer = !!foundRoute.options.component
977​
978 if (typeof handler === 'function') {
979 if (!mayDefer) {
980 terminalHandler = handler
981 terminalNext = throwIfMayNotDefer
982 } else {
983 routeMiddlewares.push(handler)
984 }
985 } else {
986 if (handler.middleware?.length) {
987 const handlerMiddlewares = flattenMiddlewares(handler.middleware)
988 for (const m of handlerMiddlewares) {
989 routeMiddlewares.push(m.options.server)
990 }
991 }
992 if (handler.handler) {
993 if (!mayDefer) {
994 terminalHandler = handler.handler
995 terminalNext = throwIfMayNotDefer
996 } else {
997 routeMiddlewares.push(handler.handler)
998 }
999 }
1003​
1004 const response = await executeMiddleware(
1005 routeMiddlewares,
1006 terminalHandler,
1008 request,
1009 context,
1010 params: rawParams,
1011 pathname,
1012 handlerType: 'router',
1013 },
1014 request.signal,
1015 terminalNext,
1017​
1018 return normalizeSsrResponse(response)