fix: make sitemap accessible via public assets (#4235)

SeanCassiere · web-flow · commit 496fac3efc18 · 2025-05-23T14:44:40.000+12:00
diff --git a/packages/start-plugin-core/src/build-sitemap.ts b/packages/start-plugin-core/src/build-sitemap.ts
@@ -1,6 +1,7 @@
 import { writeFileSync } from 'node:fs'
 import path from 'node:path'
 import { create } from 'xmlbuilder2'
+import { createLogger } from './utils'
 import type { TanStackStartOutputConfig } from './plugin'
 import type { XMLBuilder } from 'xmlbuilder2/lib/interfaces'
 
@@ -121,13 +122,15 @@ function jsonToXml(sitemapData: SitemapData): string {
   return sitemap.end({ prettyPrint: true })
 }
 
-export async function buildSitemap({
+export function buildSitemap({
   options,
   publicDir,
 }: {
   options: TanStackStartOutputConfig
   publicDir: string
 }) {
+  const logger = createLogger('sitemap')
+
   let sitemapOptions = options.sitemap
 
   if (!sitemapOptions && options.pages.length) {
@@ -142,7 +145,7 @@ export async function buildSitemap({
 
   if (!host) {
     if (!options.sitemap) {
-      console.info(
+      logger.info(
         'Hint: Pages found, but no sitemap host has been set. To enable sitemap generation, set the `sitemap.host` option.',
       )
       return
@@ -159,11 +162,11 @@ export async function buildSitemap({
   const { pages } = options
 
   if (!pages.length) {
-    console.log('No pages were found to build the sitemap. Skipping...')
+    logger.info('No pages were found to build the sitemap. Skipping...')
     return
   }
 
-  console.log('Building Sitemap...')
+  logger.info('Building Sitemap...')
 
   // Build the sitemap data
   const sitemapData = buildSitemapJson(pages, host)
@@ -174,11 +177,11 @@ export async function buildSitemap({
 
   try {
     // Write XML sitemap
-    console.log(`Writing sitemap XML at ${xmlOutputPath}`)
+    logger.info(`Writing sitemap XML at ${xmlOutputPath}`)
     writeFileSync(xmlOutputPath, jsonToXml(sitemapData))
 
     // Write pages data for runtime use
-    console.log(`Writing pages data at ${pagesOutputPath}`)
+    logger.info(`Writing pages data at ${pagesOutputPath}`)
     writeFileSync(
       pagesOutputPath,
       JSON.stringify(
@@ -192,7 +195,7 @@ export async function buildSitemap({
       ),
     )
   } catch (e) {
-    console.error(`Unable to write sitemap files`, e)
+    logger.error(`Unable to write sitemap files`, e)
   }
 }
 
diff --git a/packages/start-plugin-core/src/nitro/build-nitro.ts b/packages/start-plugin-core/src/nitro/build-nitro.ts
diff --git a/packages/start-plugin-core/src/nitro/nitro-plugin.ts b/packages/start-plugin-core/src/nitro/nitro-plugin.ts
@@ -1,15 +1,20 @@
 import path from 'node:path'
 import { rmSync } from 'node:fs'
-import { build, createNitro } from 'nitropack'
+import * as fsp from 'node:fs/promises'
+import { build, copyPublicAssets, createNitro, prepare } from 'nitropack'
 import { dirname, resolve } from 'pathe'
 import { clientDistDir, ssrEntryFile } from '../plugin'
 import { prerender } from '../prerender'
 import { VITE_ENVIRONMENT_NAMES } from '../constants'
 import { buildSitemap } from '../build-sitemap'
 import { devServerPlugin } from './dev-server-plugin'
-import { buildNitroEnvironment } from './build-nitro'
-import type { EnvironmentOptions, PluginOption, Rollup } from 'vite'
-import type { NitroConfig } from 'nitropack'
+import type {
+  EnvironmentOptions,
+  PluginOption,
+  Rollup,
+  ViteBuilder,
+} from 'vite'
+import type { Nitro, NitroConfig } from 'nitropack'
 import type { TanStackStartOutputConfig } from '../plugin'
 
 export function nitroPlugin(
@@ -88,59 +93,7 @@ export function nitroPlugin(
 
               const nitro = await createNitro(nitroConfig)
 
-              await buildNitroEnvironment(nitro, () => build(nitro))
-
-              // If the user has not set a prerender option, we need to set it to true
-              // if the pages array is not empty and has sub options requiring for prerendering
-              if (options.prerender?.enabled !== false) {
-                options.prerender = {
-                  ...options.prerender,
-                  enabled: options.pages.some((d) =>
-                    typeof d === 'string' ? false : !!d.prerender?.enabled,
-                  ),
-                }
-              }
-
-              // Setup the options for prerendering the SPA shell (i.e `src/routes/__root.tsx`)
-              if (options.spa?.enabled) {
-                options.prerender = {
-                  ...options.prerender,
-                  enabled: true,
-                }
-
-                const maskUrl = new URL(
-                  options.spa.maskPath,
-                  'http://localhost',
-                )
-
-                maskUrl.searchParams.set('__TSS_SHELL', 'true')
-
-                options.pages.push({
-                  path: maskUrl.toString().replace('http://localhost', ''),
-                  prerender: options.spa.prerender,
-                  sitemap: {
-                    exclude: true,
-                  },
-                })
-              }
-
-              // Start prerendering!!!
-              if (options.prerender.enabled) {
-                await prerender({
-                  options,
-                  nitro,
-                  builder,
-                })
-              }
-
-              if (options.pages.length) {
-                await buildSitemap({
-                  options,
-                  publicDir: nitro.options.output.publicDir,
-                })
-              }
-
-              console.log(`\n✅ Client and server bundles successfully built.`)
+              await buildNitroApp(builder, nitro, options)
             },
           },
         }
@@ -149,6 +102,93 @@ export function nitroPlugin(
   ]
 }
 
+/**
+ * Correctly co-ordinates the nitro app build process to make sure that the
+ * app is built, while also correctly handling the prerendering and sitemap
+ * generation and including their outputs in the final build.
+ */
+async function buildNitroApp(
+  builder: ViteBuilder,
+  nitro: Nitro,
+  options: TanStackStartOutputConfig,
+) {
+  // Cleans the public and server directories for a fresh build
+  // i.e the `.output/public` and `.output/server` directories
+  await prepare(nitro)
+
+  // Creates the `.output/public` directory and copies the public assets
+  await copyPublicAssets(nitro)
+
+  // If the user has not set a prerender option, we need to set it to true
+  // if the pages array is not empty and has sub options requiring for prerendering
+  if (options.prerender?.enabled !== false) {
+    options.prerender = {
+      ...options.prerender,
+      enabled: options.pages.some((d) =>
+        typeof d === 'string' ? false : !!d.prerender?.enabled,
+      ),
+    }
+  }
+
+  // Setup the options for prerendering the SPA shell (i.e `src/routes/__root.tsx`)
+  if (options.spa?.enabled) {
+    options.prerender = {
+      ...options.prerender,
+      enabled: true,
+    }
+
+    const maskUrl = new URL(options.spa.maskPath, 'http://localhost')
+
+    maskUrl.searchParams.set('__TSS_SHELL', 'true')
+
+    options.pages.push({
+      path: maskUrl.toString().replace('http://localhost', ''),
+      prerender: options.spa.prerender,
+      sitemap: {
+        exclude: true,
+      },
+    })
+  }
+
+  // Run the prerendering process
+  if (options.prerender.enabled) {
+    await prerender({
+      options,
+      nitro,
+      builder,
+    })
+  }
+
+  // Run the sitemap build process
+  if (options.pages.length) {
+    buildSitemap({
+      options,
+      publicDir: nitro.options.output.publicDir,
+    })
+  }
+
+  // Build the nitro app
+  await build(nitro)
+
+  // Cleanup the vite public directory
+  // As a part of the build process, a `.vite/` directory
+  // is copied over from `.tanstack-start/build/client-dist/`
+  // to the nitro `publicDir` (e.g. `.output/public/`).
+  // This directory (and its contents including the vite client manifest)
+  // should not be included in the final build, so we remove it.
+  const nitroPublicDir = nitro.options.output.publicDir
+  const viteDir = path.resolve(nitroPublicDir, '.vite')
+  if (await fsp.stat(viteDir).catch(() => false)) {
+    await fsp.rm(viteDir, { recursive: true, force: true })
+  }
+
+  // Close the nitro instance
+  await nitro.close()
+  nitro.logger.success(
+    'Client and Server bundles for TanStack Start have been successfully built.',
+  )
+}
+
 function virtualBundlePlugin(ssrBundle: Rollup.OutputBundle): Rollup.Plugin {
   type VirtualModule = { code: string; map: string | null }
   const _modules = new Map<string, VirtualModule>()
diff --git a/packages/start-plugin-core/src/prerender.ts b/packages/start-plugin-core/src/prerender.ts
@@ -5,8 +5,8 @@ import { getRollupConfig } from 'nitropack/rollup'
 import { build as buildNitro, createNitro } from 'nitropack'
 import { joinURL, withBase, withoutBase } from 'ufo'
 import { Queue } from './queue'
-import { buildNitroEnvironment } from './nitro/build-nitro'
 import { VITE_ENVIRONMENT_NAMES } from './constants'
+import { createLogger } from './utils'
 import type { ViteBuilder } from 'vite'
 import type { $Fetch, Nitro } from 'nitropack'
 import type { TanStackStartOutputConfig } from './plugin'
@@ -21,7 +21,8 @@ export async function prerender({
   nitro: Nitro
   builder: ViteBuilder
 }) {
-  console.info('Prendering pages...')
+  const logger = createLogger('prerender')
+  logger.info('Prendering pages...')
 
   // If prerender is enabled but no pages are provided, default to prerendering the root page
   if (options.prerender?.enabled && !options.pages.length) {
@@ -72,7 +73,7 @@ export async function prerender({
     },
   }
 
-  await buildNitroEnvironment(nodeNitro, () => buildNitro(nodeNitro))
+  await buildNitro(nodeNitro)
 
   // Import renderer entry
   const serverFilename =
@@ -93,14 +94,14 @@ export async function prerender({
     // Crawl all pages
     const pages = await prerenderPages()
 
-    console.info(`Prerendered ${pages.length} pages:`)
+    logger.info(`Prerendered ${pages.length} pages:`)
     pages.forEach((page) => {
-      console.info(`- ${page}`)
+      logger.info(`- ${page}`)
     })
 
     // TODO: Write the prerendered pages to the output directory
   } catch (error) {
-    console.error(error)
+    logger.error(error)
   } finally {
     // Ensure server is always closed
     // server.process.kill()
@@ -126,7 +127,7 @@ export async function prerender({
     const seen = new Set<string>()
     const retriesByPath = new Map<string, number>()
     const concurrency = options.prerender?.concurrency ?? os.cpus().length
-    console.info(`Concurrency: ${concurrency}`)
+    logger.info(`Concurrency: ${concurrency}`)
     const queue = new Queue({ concurrency })
 
     options.pages.forEach((page) => addCrawlPageTask(page))
@@ -160,7 +161,7 @@ export async function prerender({
 
       // Add the task
       queue.add(async () => {
-        console.info(`Crawling: ${page.path}`)
+        logger.info(`Crawling: ${page.path}`)
         const retries = retriesByPath.get(page.path) || 0
         try {
           // Fetch the route
@@ -228,7 +229,7 @@ export async function prerender({
           }
         } catch (error) {
           if (retries < (prerenderOptions.retryCount ?? 0)) {
-            console.warn(`Encountered error, retrying: ${page.path} in 500ms`)
+            logger.warn(`Encountered error, retrying: ${page.path} in 500ms`)
             await new Promise((resolve) =>
               setTimeout(resolve, prerenderOptions.retryDelay),
             )
diff --git a/packages/start-plugin-core/src/utils.ts b/packages/start-plugin-core/src/utils.ts
@@ -1,3 +1,14 @@
 export function resolveViteId(id: string) {
   return `\0${id}`
 }
+
+export function createLogger(prefix: string) {
+  const label = `[${prefix}]`
+  return {
+    log: (...args: any) => console.log(label, ...args),
+    debug: (...args: any) => console.debug(label, ...args),
+    info: (...args: any) => console.info(label, ...args),
+    warn: (...args: any) => console.warn(label, ...args),
+    error: (...args: any) => console.error(label, ...args),
+  }
+}
