@tanstack/start-plugin-core 1.131.7 → 1.132.0-alpha.0

package/src/{nitro-plugin/prerender.ts → prerender.ts}

@@ -1,33 +1,29 @@
-import { promises as fsp } from 'node:fs'
+import { existsSync, promises as fsp, rmSync } from 'node:fs'
 import { pathToFileURL } from 'node:url'
 import os from 'node:os'
-import path from 'node:path'
-import { getRollupConfig } from 'nitropack/rollup'
-import { build as buildNitro, createNitro } from 'nitropack'
+import path from 'pathe'
 import { joinURL, withBase, withoutBase } from 'ufo'
-import { VITE_ENVIRONMENT_NAMES } from '../constants'
-import { createLogger } from '../utils'
+import { VITE_ENVIRONMENT_NAMES } from './constants'
+import { createLogger } from './utils'
 import { Queue } from './queue'
-import type { ViteBuilder } from 'vite'
-import type { $Fetch, Nitro } from 'nitropack'
-import type { TanStackStartOutputConfig } from '../plugin'
-import type { Page } from '../schema'
+import type { Rollup, ViteBuilder } from 'vite'
+import type { Page, TanStackStartOutputConfig } from './schema'
 
 export async function prerender({
-  options,
-  nitro,
+  startConfig,
   builder,
+  serverBundle,
 }: {
-  options: TanStackStartOutputConfig
-  nitro: Nitro
+  startConfig: TanStackStartOutputConfig
   builder: ViteBuilder
+  serverBundle: Rollup.OutputBundle
 }) {
   const logger = createLogger('prerender')
   logger.info('Prerendering pages...')
 
   // If prerender is enabled but no pages are provided, default to prerendering the root page
-  if (options.prerender?.enabled && !options.pages.length) {
-    options.pages = [
+  if (startConfig.prerender?.enabled && !startConfig.pages.length) {
+    startConfig.pages = [
       {
         path: '/',
       },
@@ -42,76 +38,52 @@ export async function prerender({
     )
   }
 
-  const prerenderOutputDir = path.resolve(
-    options.root,
-    '.tanstack',
-    'start',
-    'build',
-    'prerenderer',
-  )
-
-  const nodeNitro = await createNitro({
-    ...nitro.options._config,
-    preset: 'nitro-prerender',
-    logLevel: 0,
-    output: {
-      dir: prerenderOutputDir,
-      serverDir: path.resolve(prerenderOutputDir, 'server'),
-      publicDir: path.resolve(prerenderOutputDir, 'public'),
-    },
-  })
-
-  const nodeNitroRollupOptions = getRollupConfig(nodeNitro)
-
-  const build = serverEnv.config.build
-
-  build.outDir = prerenderOutputDir
-
-  build.rollupOptions = {
-    ...build.rollupOptions,
-    ...nodeNitroRollupOptions,
-    output: {
-      ...build.rollupOptions.output,
-      ...nodeNitroRollupOptions.output,
-      sourcemap: undefined,
-    },
+  const clientEnv = builder.environments[VITE_ENVIRONMENT_NAMES.client]
+  if (!clientEnv) {
+    throw new Error(
+      `Vite's "${VITE_ENVIRONMENT_NAMES.client}" environment not found`,
+    )
   }
 
-  await buildNitro(nodeNitro)
+  const outputDir = clientEnv.config.build.outDir
 
-  // Import renderer entry
-  const serverFilename =
-    typeof nodeNitroRollupOptions.output.entryFileNames === 'string'
-      ? nodeNitroRollupOptions.output.entryFileNames
-      : 'index.mjs'
+  const entryFile = findEntryFileInBundle(serverBundle)
+  let fullEntryFilePath = path.join(serverEnv.config.build.outDir, entryFile)
+  process.env.TSS_PRERENDERING = 'true'
 
-  const serverEntrypoint = pathToFileURL(
-    path.resolve(path.join(nodeNitro.options.output.serverDir, serverFilename)),
-  ).toString()
+  if (!existsSync(fullEntryFilePath)) {
+    // if the file does not exist, we need to write the bundle to a temporary directory
+    // this can happen e.g. with nitro that postprocesses the bundle and thus does not write SSR build to disk
+    const bundleOutputDir = path.resolve(
+      serverEnv.config.root,
+      '.tanstack',
+      'start',
+      'prerender',
+    )
+    rmSync(bundleOutputDir, { recursive: true, force: true })
+    await writeBundleToDisk({ bundle: serverBundle, outDir: bundleOutputDir })
+    fullEntryFilePath = path.join(bundleOutputDir, entryFile)
+  }
 
-  process.env.TSS_PRERENDERING = 'true'
+  const { default: serverEntrypoint } = await import(
+    pathToFileURL(fullEntryFilePath).toString()
+  )
 
-  const { closePrerenderer, localFetch } = (await import(serverEntrypoint)) as {
-    closePrerenderer: () => void
-    localFetch: $Fetch
+  function localFetch(path: string, options?: RequestInit): Promise<Response> {
+    const url = new URL(`http://localhost${path}`)
+    return serverEntrypoint.fetch(new Request(url, options))
   }
 
   try {
     // Crawl all pages
-    const pages = await prerenderPages()
+    const pages = await prerenderPages({ outputDir })
 
     logger.info(`Prerendered ${pages.length} pages:`)
     pages.forEach((page) => {
       logger.info(`- ${page}`)
     })
-
-    // TODO: Write the prerendered pages to the output directory
   } catch (error) {
     logger.error(error)
-  } finally {
-    // Ensure server is always closed
-    // server.process.kill()
-    closePrerenderer()
   }
 
   function extractLinks(html: string): Array<string> {
@@ -129,14 +101,14 @@ export async function prerender({
     return links
   }
 
-  async function prerenderPages() {
+  async function prerenderPages({ outputDir }: { outputDir: string }) {
     const seen = new Set<string>()
     const retriesByPath = new Map<string, number>()
-    const concurrency = options.prerender?.concurrency ?? os.cpus().length
+    const concurrency = startConfig.prerender?.concurrency ?? os.cpus().length
     logger.info(`Concurrency: ${concurrency}`)
     const queue = new Queue({ concurrency })
 
-    options.pages.forEach((page) => addCrawlPageTask(page))
+    startConfig.pages.forEach((page) => addCrawlPageTask(page))
 
     await queue.start()
 
@@ -150,18 +122,19 @@ export async function prerender({
       seen.add(page.path)
 
       if (page.fromCrawl) {
-        options.pages.push(page)
+        startConfig.pages.push(page)
       }
 
       // If not enabled, skip
       if (!(page.prerender?.enabled ?? true)) return
 
       // If there is a filter link, check if the page should be prerendered
-      if (options.prerender?.filter && !options.prerender.filter(page)) return
+      if (startConfig.prerender?.filter && !startConfig.prerender.filter(page))
+        return
 
       // Resolve the merged default and page-specific prerender options
       const prerenderOptions = {
-        ...options.prerender,
+        ...startConfig.prerender,
         ...page.prerender,
       }
 
@@ -173,15 +146,11 @@ export async function prerender({
           // Fetch the route
           const encodedRoute = encodeURI(page.path)
 
-          const res = await localFetch<Response>(
-            withBase(encodedRoute, nodeNitro.options.baseURL),
-            {
-              headers: {
-                ...prerenderOptions.headers,
-                'x-nitro-prerender': encodedRoute,
-              },
+          const res = await localFetch(withBase(encodedRoute, TSS_APP_BASE), {
+            headers: {
+              ...prerenderOptions.headers,
             },
-          )
+          })
 
           if (!res.ok) {
             throw new Error(`Failed to fetch ${page.path}: ${res.statusText}`, {
@@ -210,12 +179,12 @@ export async function prerender({
 
           const filename = withoutBase(
             isImplicitHTML ? htmlPath : routeWithIndex,
-            nitro.options.baseURL,
+            TSS_APP_BASE,
           )
 
           const html = await res.text()
 
-          const filepath = path.join(nitro.options.output.publicDir, filename)
+          const filepath = path.join(outputDir, filename)
 
           await fsp.mkdir(path.dirname(filepath), {
             recursive: true,
@@ -245,10 +214,48 @@ export async function prerender({
             retriesByPath.set(page.path, retries + 1)
             addCrawlPageTask(page)
           } else {
-            throw error
+            if (prerenderOptions.failOnError ?? true) {
+              throw error
+            }
           }
         }
       })
     }
   }
 }
+
+function findEntryFileInBundle(bundle: Rollup.OutputBundle): string {
+  let entryFile: string | undefined
+
+  for (const [_name, file] of Object.entries(bundle)) {
+    if (file.type === 'chunk') {
+      if (file.isEntry) {
+        if (entryFile !== undefined) {
+          throw new Error(
+            `Multiple entry points found. Only one entry point is allowed.`,
+          )
+        }
+        entryFile = file.fileName
+      }
+    }
+  }
+  if (entryFile === undefined) {
+    throw new Error(`No entry point found in the bundle.`)
+  }
+  return entryFile
+}
+
+export async function writeBundleToDisk({
+  bundle,
+  outDir,
+}: {
+  bundle: Rollup.OutputBundle
+  outDir: string
+}) {
+  for (const [fileName, asset] of Object.entries(bundle)) {
+    const fullPath = path.join(outDir, fileName)
+    const content = asset.type === 'asset' ? asset.source : asset.code
+    await fsp.mkdir(path.dirname(fullPath), { recursive: true })
+    await fsp.writeFile(fullPath, content)
+  }
+}

package/src/resolve-entries.ts

@@ -0,0 +1,52 @@
+import { resolveModulePath } from 'exsolve'
+
+interface ResolveModuleOptions {
+  baseName: string
+  from: string
+}
+function resolveModule(opts: ResolveModuleOptions): string | undefined {
+  let baseName = opts.baseName
+  if (!baseName.startsWith('./')) {
+    baseName = `./${baseName}`
+  }
+  return resolveModulePath(baseName, {
+    from: opts.from,
+    extensions: ['.ts', '.js', '.mts', '.mjs', '.tsx', '.jsx'],
+    try: true,
+  })
+}
+
+export function resolveEntry<
+  TRequired extends boolean,
+  TReturn = TRequired extends true ? string : string | undefined,
+>(opts: {
+  type: string
+  configuredEntry?: string
+  defaultEntry: string
+  resolvedSrcDirectory: string
+  root: string
+  required: TRequired
+}): TReturn {
+  let resolveOptions: ResolveModuleOptions
+
+  // if entry was not configured, use default relative to srcDirectory
+  if (!opts.configuredEntry) {
+    resolveOptions = {
+      baseName: opts.defaultEntry,
+      from: opts.resolvedSrcDirectory,
+    }
+  } else {
+    resolveOptions = {
+      baseName: opts.configuredEntry,
+      from: opts.root,
+    }
+  }
+
+  const resolvedEntry = resolveModule(resolveOptions)
+  if (opts.required && !resolvedEntry) {
+    throw new Error(
+      `Could not resolve entry for ${opts.type}: ${resolveOptions.baseName} in ${resolveOptions.from}`,
+    )
+  }
+  return resolvedEntry as TReturn
+}

package/src/schema.ts

@@ -1,142 +1,43 @@
 import path from 'node:path'
-import { existsSync } from 'node:fs'
 import { z } from 'zod'
 import { configSchema, getConfig } from '@tanstack/router-generator'
-import type { NitroConfig } from 'nitropack'
 
 const tsrConfig = configSchema
   .omit({ autoCodeSplitting: true })
   .partial()
   .extend({
+    // this is relative to vite root
+    // TODO why is this nested under tsr?
     srcDirectory: z.string().optional().default('src'),
   })
 
-export function createTanStackConfig<
-  TFrameworkPlugin extends Record<string, unknown>,
->(frameworkPlugin?: TFrameworkPlugin) {
-  const schema = createTanStackStartOptionsSchema(frameworkPlugin)
-
-  return {
-    schema,
-    parse: (opts?: z.input<typeof schema>) => {
-      const options = schema.parse(opts)
-
-      const srcDirectory = options.tsr.srcDirectory
-
-      const routesDirectory =
-        options.tsr.routesDirectory ?? path.join(srcDirectory, 'routes')
-
-      const generatedRouteTree =
-        options.tsr.generatedRouteTree ??
-        path.join(srcDirectory, 'routeTree.gen.ts')
-
-      const clientEntryPath = (() => {
-        if (options.client.entry) {
-          return path.join(srcDirectory, options.client.entry)
-        }
-
-        if (existsSync(path.join(srcDirectory, 'client.tsx'))) {
-          return path.join(srcDirectory, 'client.tsx')
-        }
-
-        return '/~start/default-client-entry'
-      })()
-
-      const serverEntryPath = (() => {
-        if (options.server.entry) {
-          return path.join(srcDirectory, options.server.entry)
-        }
-
-        if (existsSync(path.join(srcDirectory, 'server.tsx'))) {
-          return path.join(srcDirectory, 'server.tsx')
-        }
+export function parseStartConfig(
+  opts?: z.input<typeof tanstackStartOptionsSchema>,
+) {
+  const options = tanstackStartOptionsSchema.parse(opts)
 
-        if (existsSync(path.join(srcDirectory, 'server.ts'))) {
-          return path.join(srcDirectory, 'server.ts')
-        }
+  const srcDirectory = options.tsr.srcDirectory
 
-        if (existsSync(path.join(srcDirectory, 'server.js'))) {
-          return path.join(srcDirectory, 'server.js')
-        }
+  const routesDirectory =
+    options.tsr.routesDirectory ?? path.join(srcDirectory, 'routes')
 
-        return '/~start/default-server-entry'
-      })()
+  const generatedRouteTree =
+    options.tsr.generatedRouteTree ??
+    path.join(srcDirectory, 'routeTree.gen.ts')
 
-      return {
-        ...options,
-        tsr: {
-          ...options.tsr,
-          ...getConfig({
-            ...options.tsr,
-            routesDirectory,
-            generatedRouteTree,
-          }),
-        },
-        clientEntryPath,
-        serverEntryPath,
-      }
+  return {
+    ...options,
+    tsr: {
+      ...options.tsr,
+      ...getConfig({
+        ...options.tsr,
+        routesDirectory,
+        generatedRouteTree,
+      }),
     },
   }
 }
 
-export function createTanStackStartOptionsSchema(
-  frameworkPlugin: Record<string, unknown> = {},
-) {
-  return z
-    .object({
-      root: z.string().optional().default(process.cwd()),
-      target: z.custom<NitroConfig['preset']>().optional(),
-      ...frameworkPlugin,
-      tsr: tsrConfig.optional().default({}),
-      client: z
-        .object({
-          entry: z.string().optional(),
-          base: z.string().optional().default('/_build'),
-        })
-        .optional()
-        .default({}),
-      server: z
-        .object({
-          entry: z.string().optional(),
-        })
-        .optional()
-        .default({}),
-      serverFns: z
-        .object({
-          base: z.string().optional().default('/_serverFn'),
-        })
-        .optional()
-        .default({}),
-      public: z
-        .object({
-          dir: z.string().optional().default('public'),
-          base: z.string().optional().default('/'),
-        })
-        .optional()
-        .default({}),
-      pages: z.array(pageSchema).optional().default([]),
-      sitemap: z
-        .object({
-          enabled: z.boolean().optional().default(true),
-          host: z.string().optional(),
-          outputPath: z.string().optional().default('sitemap.xml'),
-        })
-        .optional(),
-      prerender: z
-        .object({
-          enabled: z.boolean().optional(),
-          concurrency: z.number().optional(),
-          filter: z.function().args(pageSchema).returns(z.any()).optional(),
-          failOnError: z.boolean().optional(),
-        })
-        .and(pagePrerenderOptionsSchema.optional())
-        .optional(),
-      spa: spaSchema.optional(),
-    })
-    .optional()
-    .default({})
-}
-
 const pageSitemapOptionsSchema = z.object({
   exclude: z.boolean().optional(),
   priority: z.number().min(0).max(1).optional(),
@@ -214,8 +115,74 @@ const spaSchema = z.object({
     })),
 })
 
-export const pageSchema = pageBaseSchema.extend({
+const pageSchema = pageBaseSchema.extend({
   prerender: pagePrerenderOptionsSchema.optional(),
 })
 
+const tanstackStartOptionsSchema = z
+  .object({
+    tsr: tsrConfig.optional().default({}),
+    router: z
+      .object({
+        // TODO naming?
+        entry: z.string().optional(),
+      })
+      .optional()
+      .default({}),
+    client: z
+      .object({
+        entry: z.string().optional(),
+        base: z.string().optional().default('/_build'),
+      })
+      .optional()
+      .default({}),
+    server: z
+      .object({
+        entry: z.string().optional(),
+      })
+      .optional()
+      .default({}),
+    serverFns: z
+      .object({
+        base: z.string().optional().default('/_serverFn'),
+      })
+      .optional()
+      .default({}),
+    public: z
+      .object({
+        dir: z.string().optional().default('public'),
+        base: z.string().optional().default('/'),
+      })
+      .optional()
+      .default({}),
+    pages: z.array(pageSchema).optional().default([]),
+    sitemap: z
+      .object({
+        enabled: z.boolean().optional().default(true),
+        host: z.string().optional(),
+        outputPath: z.string().optional().default('sitemap.xml'),
+      })
+      .optional(),
+    prerender: z
+      .object({
+        enabled: z.boolean().optional(),
+        concurrency: z.number().optional(),
+        filter: z.function().args(pageSchema).returns(z.any()).optional(),
+        failOnError: z.boolean().optional(),
+      })
+      .and(pagePrerenderOptionsSchema.optional())
+      .optional(),
+    spa: spaSchema.optional(),
+    vite: z
+      .object({ installDevServerMiddleware: z.boolean().optional() })
+      .optional(),
+  })
+  .optional()
+  .default({})
+
 export type Page = z.infer<typeof pageSchema>
+
+export type TanStackStartInputConfig = z.input<
+  typeof tanstackStartOptionsSchema
+>
+export type TanStackStartOutputConfig = ReturnType<typeof parseStartConfig>

package/src/start-manifest-plugin/plugin.ts

@@ -3,7 +3,8 @@ import { rootRouteId } from '@tanstack/router-core'
 import { VIRTUAL_MODULES } from '@tanstack/start-server-core'
 import { tsrSplit } from '@tanstack/router-plugin'
 import { resolveViteId } from '../utils'
-import type { PluginOption, ResolvedConfig, Rollup } from 'vite'
+import { ENTRY_POINTS } from '../constants'
+import type { PluginOption, Rollup } from 'vite'
 import type { RouterManagedTag } from '@tanstack/router-core'
 
 export const getCSSRecursively = (
@@ -40,17 +41,11 @@ export const getCSSRecursively = (
 
 const resolvedModuleId = resolveViteId(VIRTUAL_MODULES.startManifest)
 export function startManifestPlugin(opts: {
-  clientEntry: string
+  getClientBundle: () => Rollup.OutputBundle
 }): PluginOption {
-  let config: ResolvedConfig
-
   return {
     name: 'tanstack-start:start-manifest-plugin',
     enforce: 'pre',
-
-    configResolved(resolvedConfig) {
-      config = resolvedConfig
-    },
     resolveId: {
       filter: { id: new RegExp(VIRTUAL_MODULES.startManifest) },
       handler(id) {
@@ -76,10 +71,10 @@ export function startManifestPlugin(opts: {
           const APP_BASE = globalThis.TSS_APP_BASE
 
           // If we're in development, return a dummy manifest
-          if (config.command === 'serve') {
+          if (this.environment.config.command === 'serve') {
             return `export const tsrStartManifest = () => ({
             routes: {},
-            clientEntry: '${joinURL(APP_BASE, opts.clientEntry)}',
+            clientEntry: '${joinURL(APP_BASE, '@id', ENTRY_POINTS.client)}',
           })`
           }
 
@@ -88,10 +83,9 @@ export function startManifestPlugin(opts: {
           const routeTreeRoutes = globalThis.TSS_ROUTES_MANIFEST.routes
 
           // This is where hydration will start, from when the SSR'd page reaches the browser.
-          // By default, this'd be the virtual entry of `/~start/default-client-entry.tsx`, unless a custom entry is provided.
           let entryFile: Rollup.OutputChunk | undefined
 
-          const clientBundle = globalThis.TSS_CLIENT_BUNDLE
+          const clientBundle = opts.getClientBundle()
           const chunksByFileName = new Map<string, Rollup.OutputChunk>()
 
           const routeChunks: Record<
@@ -222,12 +216,12 @@ export function startManifestPlugin(opts: {
 
           recurseRoute(routeTreeRoutes[rootRouteId]!)
 
-          const routesManifest = {
+          const startManifest = {
             routes: routeTreeRoutes,
             clientEntry: joinURL(APP_BASE, entryFile.fileName),
           }
 
-          return `export const tsrStartManifest = () => (${JSON.stringify(routesManifest)})`
+          return `export const tsrStartManifest = () => (${JSON.stringify(startManifest)})`
         }
 
         return undefined