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

prerender.ts

296 lines8.4 KB

1import { promises as fsp } from 'node:fs'
2import os from 'node:os'
3import path from 'pathe'
4import { joinURL, withBase, withoutBase } from 'ufo'
5import { VITE_ENVIRONMENT_NAMES } from './constants'
6import { createLogger } from './utils'
7import { Queue } from './queue'
8import type { PreviewServer, ResolvedConfig, ViteBuilder } from 'vite'
9import type { Page, TanStackStartOutputConfig } from './schema'
10​
11export async function prerender({
12 startConfig,
13 builder,
14}: {
15 startConfig: TanStackStartOutputConfig
16 builder: ViteBuilder
17}) {
18 const logger = createLogger('prerender')
19 logger.info('Prerendering pages...')
20​
21 // If prerender is enabled
22 if (startConfig.prerender?.enabled) {
23 // default to root page if no pages are defined
24 let pages = startConfig.pages.length ? startConfig.pages : [{ path: '/' }]
25​
26 if (startConfig.prerender.autoStaticPathsDiscovery ?? true) {
27 // merge discovered static pages with user-defined pages
28 const pagesMap = new Map(pages.map((item) => [item.path, item]))
29 const discoveredPages = globalThis.TSS_PRERENDABLE_PATHS || []
30​
31 for (const page of discoveredPages) {
32 if (!pagesMap.has(page.path)) {
33 pagesMap.set(page.path, page)
34 }
35 }
36​
37 pages = Array.from(pagesMap.values())
38 }
39​
40 startConfig.pages = pages
41 }
42​
43 const serverEnv = builder.environments[VITE_ENVIRONMENT_NAMES.server]
44​
45 if (!serverEnv) {
46 throw new Error(
47 `Vite's "${VITE_ENVIRONMENT_NAMES.server}" environment not found`,
48 )
49 }
50​
51 const clientEnv = builder.environments[VITE_ENVIRONMENT_NAMES.client]
52 if (!clientEnv) {
53 throw new Error(
54 `Vite's "${VITE_ENVIRONMENT_NAMES.client}" environment not found`,
55 )
56 }
57​
58 const outputDir = clientEnv.config.build.outDir
59​
60 process.env.TSS_PRERENDERING = 'true'
61​
62 // Start Vite preview server instead of importing module
63 const previewServer = await startPreviewServer(serverEnv.config)
64 const baseUrl = getResolvedUrl(previewServer)
65​
66 const isRedirectResponse = (res: Response) => {
67 return res.status >= 300 && res.status < 400 && res.headers.get('location')
68 }
69 async function localFetch(
70 path: string,
71 options?: RequestInit,
72 maxRedirects: number = 5,
73 ): Promise<Response> {
74 const url = new URL(path, baseUrl)
75 const request = new Request(url, options)
76 const response = await fetch(request)
77​
78 if (isRedirectResponse(response) && maxRedirects > 0) {
79 const location = response.headers.get('location')!
80 if (location.startsWith('http://localhost') || location.startsWith('/')) {
81 const newUrl = location.replace('http://localhost', '')
82 return localFetch(newUrl, options, maxRedirects - 1)
83 } else {
84 logger.warn(`Skipping redirect to external location: ${location}`)
85 }
86 }
87​
88 return response
89 }
90​
91 try {
92 // Crawl all pages
93 const pages = await prerenderPages({ outputDir })
94​
95 logger.info(`Prerendered ${pages.length} pages:`)
96 pages.forEach((page) => {
97 logger.info(`- ${page}`)
98 })
99 } catch (error) {
100 logger.error(error)
101 } finally {
102 await previewServer.close()
103 }
104​
105 function extractLinks(html: string): Array<string> {
106 const linkRegex = /<a[^>]+href=["']([^"']+)["'][^>]*>/g
107 const links: Array<string> = []
108 let match
109​
110 while ((match = linkRegex.exec(html)) !== null) {
111 const href = match[1]
112 if (href && (href.startsWith('/') || href.startsWith('./'))) {
113 links.push(href)
114 }
115 }
116​
117 return links
118 }
119​
120 async function prerenderPages({ outputDir }: { outputDir: string }) {
121 const seen = new Set<string>()
122 const prerendered = new Set<string>()
123 const retriesByPath = new Map<string, number>()
124 const concurrency = startConfig.prerender?.concurrency ?? os.cpus().length
125 logger.info(`Concurrency: ${concurrency}`)
126 const queue = new Queue({ concurrency })
127 const routerBasePath = joinURL('/', startConfig.router.basepath ?? '')
128​
129 startConfig.pages.forEach((page) => addCrawlPageTask(page))
130​
131 await queue.start()
132​
133 return Array.from(prerendered)
134​
135 function addCrawlPageTask(page: Page) {
136 // Was the page already seen?
137 if (seen.has(page.path)) return
138​
139 // Add the page to the seen set
140 seen.add(page.path)
141​
142 if (page.fromCrawl) {
143 startConfig.pages.push(page)
144 }
145​
146 // If not enabled, skip
147 if (!(page.prerender?.enabled ?? true)) return
148​
149 // If there is a filter link, check if the page should be prerendered
150 if (startConfig.prerender?.filter && !startConfig.prerender.filter(page))
151 return
152​
153 // Resolve the merged default and page-specific prerender options
154 const prerenderOptions = {
155 ...startConfig.prerender,
156 ...page.prerender,
157 }
158​
159 // Add the task
160 queue.add(async () => {
161 logger.info(`Crawling: ${page.path}`)
162 const retries = retriesByPath.get(page.path) || 0
163 try {
164 // Fetch the route
165​
166 const res = await localFetch(
167 withBase(page.path, routerBasePath),
168 {
169 headers: {
170 ...(prerenderOptions.headers ?? {}),
171 },
172 },
173 prerenderOptions.maxRedirects,
174 )
175​
176 if (!res.ok) {
177 if (isRedirectResponse(res)) {
178 logger.warn(`Max redirects reached for ${page.path}`)
179 }
180 throw new Error(`Failed to fetch ${page.path}: ${res.statusText}`, {
181 cause: res,
182 })
183 }
184​
185 const cleanPagePath = (
186 prerenderOptions.outputPath || page.path
187 ).split(/[?#]/)[0]!
188​
189 // Guess route type and populate fileName
190 const contentType = res.headers.get('content-type') || ''
191 const isImplicitHTML =
192 !cleanPagePath.endsWith('.html') && contentType.includes('html')
193​
194 const routeWithIndex = cleanPagePath.endsWith('/')
195 ? cleanPagePath + 'index'
196 : cleanPagePath
197​
198 const isSpaShell =
199 startConfig.spa?.prerender.outputPath === cleanPagePath
200​
201 let htmlPath: string
202 if (isSpaShell) {
203 // For SPA shell, ignore autoSubfolderIndex option
204 htmlPath = cleanPagePath + '.html'
205 } else {
206 if (
207 cleanPagePath.endsWith('/') ||
208 (prerenderOptions.autoSubfolderIndex ?? true)
209 ) {
210 htmlPath = joinURL(cleanPagePath, 'index.html')
211 } else {
212 htmlPath = cleanPagePath + '.html'
213 }
214 }
215​
216 const filename = withoutBase(
217 isImplicitHTML ? htmlPath : routeWithIndex,
218 routerBasePath,
219 )
220​
221 const html = await res.text()
222​
223 const filepath = path.join(outputDir, filename)
224​
225 await fsp.mkdir(path.dirname(filepath), {
226 recursive: true,
227 })
228​
229 await fsp.writeFile(filepath, html)
230​
231 prerendered.add(page.path)
232​
233 const newPage = await prerenderOptions.onSuccess?.({ page, html })
234​
235 if (newPage) {
236 Object.assign(page, newPage)
237 }
238​
239 // Find new links
240 if (prerenderOptions.crawlLinks ?? true) {
241 const links = extractLinks(html)
242 for (const link of links) {
243 addCrawlPageTask({ path: link, fromCrawl: true })
244 }
245 }
246 } catch (error) {
247 if (retries < (prerenderOptions.retryCount ?? 0)) {
248 logger.warn(`Encountered error, retrying: ${page.path} in 500ms`)
249 await new Promise((resolve) =>
250 setTimeout(resolve, prerenderOptions.retryDelay),
251 )
252 retriesByPath.set(page.path, retries + 1)
253 addCrawlPageTask(page)
254 } else {
255 if (prerenderOptions.failOnError ?? true) {
256 throw error
257 }
258 }
259 }
260 })
261 }
262 }
264​
265async function startPreviewServer(
266 viteConfig: ResolvedConfig,
267): Promise<PreviewServer> {
268 const vite = await import('vite')
269​
270 try {
271 return await vite.preview({
272 configFile: viteConfig.configFile,
273 preview: {
274 port: 0,
275 open: false,
276 },
277 })
278 } catch (error) {
279 throw new Error(
280 'Failed to start the Vite preview server for prerendering',
281 {
282 cause: error,
283 },
284 )
285 }
287​
288function getResolvedUrl(previewServer: PreviewServer): URL {
289 const baseUrl = previewServer.resolvedUrls?.local[0]
290​
291 if (!baseUrl) {
292 throw new Error('No resolved URL is available from the Vite preview server')
293 }
294​
295 return new URL(baseUrl)