@tanstack/start-plugin-core 1.131.10 → 1.132.0-alpha.1

package/src/plugin.ts

@@ -1,76 +1,125 @@
 import path from 'node:path'
-import { createNitro } from 'nitropack'
 import { trimPathRight } from '@tanstack/router-core'
 import { VIRTUAL_MODULES } from '@tanstack/start-server-core'
 import { TanStackServerFnPluginEnv } from '@tanstack/server-functions-plugin'
 import * as vite from 'vite'
 import { crawlFrameworkPkgs } from 'vitefu'
-import { createTanStackConfig } from './schema'
-import { nitroPlugin } from './nitro-plugin/plugin'
+import { join } from 'pathe'
 import { startManifestPlugin } from './start-manifest-plugin/plugin'
 import { startCompilerPlugin } from './start-compiler-plugin'
-import {
-  CLIENT_DIST_DIR,
-  SSR_ENTRY_FILE,
-  VITE_ENVIRONMENT_NAMES,
-} from './constants'
+import { ENTRY_POINTS, VITE_ENVIRONMENT_NAMES } from './constants'
 import { tanStackStartRouter } from './start-router-plugin/plugin'
 import { loadEnvPlugin } from './load-env-plugin/plugin'
 import { devServerPlugin } from './dev-server-plugin/plugin'
-import { resolveVirtualEntriesPlugin } from './resolve-virtual-entries-plugin/plugin'
-import type { createTanStackStartOptionsSchema } from './schema'
-import type { PluginOption, Rollup } from 'vite'
-import type { z } from 'zod'
+import { parseStartConfig } from './schema'
+import { resolveEntry } from './resolve-entries'
+import {
+  getClientOutputDirectory,
+  getServerOutputDirectory,
+} from './output-directory'
+import { postServerBuild } from './post-server-build'
+import type { ViteEnvironmentNames } from './constants'
+import type { TanStackStartInputConfig } from './schema'
+import type { PluginOption } from 'vite'
 import type { CompileStartFrameworkOptions } from './compilers'
 
-export type TanStackStartInputConfig = z.input<
-  ReturnType<typeof createTanStackStartOptionsSchema>
->
-
-const defaultConfig = createTanStackConfig()
-export function getTanStackStartOptions(opts?: TanStackStartInputConfig) {
-  return defaultConfig.parse(opts)
-}
-
-export type TanStackStartOutputConfig = ReturnType<
-  typeof getTanStackStartOptions
->
-
 export interface TanStackStartVitePluginCoreOptions {
   framework: CompileStartFrameworkOptions
-  getVirtualServerRootHandler: (ctx: {
-    routerFilepath: string
-    serverEntryFilepath: string
-  }) => string
-  getVirtualServerEntry: (ctx: { routerFilepath: string }) => string
-  getVirtualClientEntry: (ctx: { routerFilepath: string }) => string
+  defaultEntryPaths: {
+    client: string
+    server: string
+  }
   crawlPackages?: (opts: {
     name: string
     peerDependencies: Record<string, any>
     exports?: Record<string, any> | string
   }) => 'include' | 'exclude' | undefined
 }
-// this needs to live outside of the TanStackStartVitePluginCore since it will be invoked multiple times by vite
-let ssrBundle: Rollup.OutputBundle
 
 export function TanStackStartVitePluginCore(
-  opts: TanStackStartVitePluginCoreOptions,
-  startConfig: TanStackStartOutputConfig,
+  corePluginOpts: TanStackStartVitePluginCoreOptions,
+  startPluginOpts: TanStackStartInputConfig,
 ): Array<PluginOption> {
+  const startConfig = parseStartConfig(startPluginOpts)
+
+  const capturedBundle: Partial<
+    Record<ViteEnvironmentNames, vite.Rollup.OutputBundle>
+  > = {}
+
+  function getBundle(envName: ViteEnvironmentNames): vite.Rollup.OutputBundle {
+    const bundle = capturedBundle[envName]
+    if (!bundle) {
+      throw new Error(`No bundle captured for environment: ${envName}`)
+    }
+    return bundle
+  }
+
   return [
     tanStackStartRouter({
       ...startConfig.tsr,
-      target: opts.framework,
+      target: corePluginOpts.framework,
       autoCodeSplitting: true,
     }),
-    resolveVirtualEntriesPlugin(opts, startConfig),
     {
-      name: 'tanstack-start-core:config-client',
+      name: 'tanstack-start-core:config',
       async config(viteConfig, { command }) {
         const viteAppBase = trimPathRight(viteConfig.base || '/')
         globalThis.TSS_APP_BASE = viteAppBase
 
-        const nitroOutputPublicDir = await (async () => {
+        const root = viteConfig.root || process.cwd()
+        const resolvedSrcDirectory = join(root, startConfig.tsr.srcDirectory)
+
+        const routerFilePath = resolveEntry({
+          type: 'router entry',
+          configuredEntry: startConfig.router.entry,
+          defaultEntry: 'router',
+          root,
+          resolvedSrcDirectory,
+          required: true,
+        })
+        const clientEntryPath = resolveEntry({
+          type: 'client entry',
+          configuredEntry: startConfig.client.entry,
+          defaultEntry: 'client',
+          root,
+          resolvedSrcDirectory,
+          required: false,
+        })
+
+        const serverEntryPath = resolveEntry({
+          type: 'server entry',
+          configuredEntry: startConfig.server.entry,
+          defaultEntry: 'server',
+          root,
+          resolvedSrcDirectory,
+          required: false,
+        })
+
+        let clientAlias: string
+        if (clientEntryPath) {
+          clientAlias = vite.normalizePath(
+            path.join('/@fs', path.resolve(root, clientEntryPath)),
+          )
+        } else {
+          clientAlias = corePluginOpts.defaultEntryPaths.client
+        }
+        let serverAlias: string
+        if (serverEntryPath) {
+          serverAlias = vite.normalizePath(path.resolve(root, serverEntryPath))
+        } else {
+          serverAlias = corePluginOpts.defaultEntryPaths.server
+        }
+        const entryAliasConfiguration: Record<
+          (typeof ENTRY_POINTS)[keyof typeof ENTRY_POINTS],
+          string
+        > = {
+          [ENTRY_POINTS.router]: routerFilePath,
+          [ENTRY_POINTS.client]: clientAlias,
+          [ENTRY_POINTS.server]: serverAlias,
+        }
+
+        // TODO
+        /* const nitroOutputPublicDir = await (async () => {
           // Create a dummy nitro app to get the resolved public output path
           const dummyNitroApp = await createNitro({
             preset: startConfig.target,
@@ -81,10 +130,10 @@ export function TanStackStartVitePluginCore(
           await dummyNitroApp.close()
 
           return nitroOutputPublicDir
-        })()
+        })()*/
 
-        const startPackageName = `@tanstack/${opts.framework}-start`
-        const routerPackageName = `@tanstack/${opts.framework}-router`
+        const startPackageName = `@tanstack/${corePluginOpts.framework}-start`
+        const routerPackageName = `@tanstack/${corePluginOpts.framework}-router`
 
         const additionalOptimizeDeps = {
           include: new Set<string>(),
@@ -108,7 +157,7 @@ export function TanStackStartVitePluginCore(
             const peerDependencies = pkgJson['peerDependencies']
 
             if (peerDependencies) {
-              const internalResult = opts.crawlPackages?.({
+              const internalResult = corePluginOpts.crawlPackages?.({
                 name: pkgJson.name,
                 peerDependencies,
                 exports: pkgJson.exports,
@@ -131,61 +180,70 @@ export function TanStackStartVitePluginCore(
 
         return {
           base: viteAppBase,
+          // see https://vite.dev/config/shared-options.html#apptype
+          // this will prevent vite from injecting middlewares that we don't want
+          appType: viteConfig.appType ?? 'custom',
           environments: {
             [VITE_ENVIRONMENT_NAMES.client]: {
               consumer: 'client',
               build: {
-                manifest: true,
+                emptyOutDir:
+                  viteConfig.environments?.[VITE_ENVIRONMENT_NAMES.client]
+                    ?.build?.emptyOutDir ?? true,
                 rollupOptions: {
                   input: {
-                    main: getClientEntryPath(startConfig),
+                    main: ENTRY_POINTS.client,
                   },
-                  output: {
-                    dir: path.resolve(startConfig.root, CLIENT_DIST_DIR),
-                  },
-                  // TODO: this should be removed
-                  external: ['node:fs', 'node:path', 'node:os', 'node:crypto'],
                 },
+                outDir: getClientOutputDirectory(viteConfig),
               },
             },
             [VITE_ENVIRONMENT_NAMES.server]: {
               consumer: 'server',
               build: {
+                emptyOutDir:
+                  viteConfig.environments?.[VITE_ENVIRONMENT_NAMES.server]
+                    ?.build?.emptyOutDir ?? false,
                 ssr: true,
-                // we don't write to the file system as the below 'capture-output' plugin will
-                // capture the output and write it to the virtual file system
-                write: false,
-                copyPublicDir: false,
                 rollupOptions: {
-                  output: {
-                    entryFileNames: SSR_ENTRY_FILE,
-                  },
-                  plugins: [
-                    {
-                      name: 'capture-output',
-                      generateBundle(_options, bundle) {
-                        // TODO: can this hook be called more than once?
-                        ssrBundle = bundle
-                      },
-                    },
-                  ],
+                  input:
+                    viteConfig.environments?.[VITE_ENVIRONMENT_NAMES.server]
+                      ?.build?.rollupOptions?.input ?? ENTRY_POINTS.server,
                 },
+                outDir: getServerOutputDirectory(viteConfig),
                 commonjsOptions: {
                   include: [/node_modules/],
                 },
+                copyPublicDir:
+                  viteConfig.environments?.[VITE_ENVIRONMENT_NAMES.server]
+                    ?.build?.copyPublicDir ?? false,
+              },
+              optimizeDeps: {
+                exclude: [
+                  ...Object.values(VIRTUAL_MODULES),
+                  ...result.optimizeDeps.exclude.sort(),
+                  ...additionalOptimizeDeps.exclude,
+                  `@tanstack/${corePluginOpts.framework}-start/server-functions-server`,
+                ],
+                include: [
+                  ...additionalOptimizeDeps.include,
+                  ...result.optimizeDeps.include.sort(),
+                ],
               },
             },
           },
           resolve: {
             noExternal: [
               '@tanstack/start**',
-              `@tanstack/${opts.framework}-start**`,
+              `@tanstack/${corePluginOpts.framework}-start**`,
               ...Object.values(VIRTUAL_MODULES),
               startPackageName,
               ...result.ssr.noExternal.sort(),
             ],
-            external: [...result.ssr.external.sort()],
             dedupe: [startPackageName],
+            alias: {
+              ...entryAliasConfiguration,
+            },
           },
           optimizeDeps: {
             exclude: [
@@ -203,15 +261,42 @@ export function TanStackStartVitePluginCore(
             // This is not the same as injecting environment variables.
 
             ...defineReplaceEnv('TSS_SERVER_FN_BASE', startConfig.serverFns.base),
-            ...defineReplaceEnv('TSS_OUTPUT_PUBLIC_DIR', nitroOutputPublicDir),
+            ...defineReplaceEnv('TSS_OUTPUT_PUBLIC_DIR', getClientOutputDirectory(viteConfig)),
             ...defineReplaceEnv('TSS_APP_BASE', viteAppBase),
             ...(command === 'serve' ? defineReplaceEnv('TSS_SHELL', startConfig.spa?.enabled ? 'true' : 'false') : {}),
+            ...defineReplaceEnv('TSS_DEV_SERVER', command === 'serve' ? 'true' : 'false'),
+          },
+          builder: {
+            sharedPlugins: true,
+            async buildApp(builder) {
+              const client = builder.environments[VITE_ENVIRONMENT_NAMES.client]
+              const server = builder.environments[VITE_ENVIRONMENT_NAMES.server]
+
+              if (!client) {
+                throw new Error('Client environment not found')
+              }
+
+              if (!server) {
+                throw new Error('SSR environment not found')
+              }
+
+              if (!client.isBuilt) {
+                // Build the client bundle first
+                await builder.build(client)
+              }
+              if (!server.isBuilt) {
+                // Build the SSR bundle
+                await builder.build(server)
+              }
+              const serverBundle = getBundle(VITE_ENVIRONMENT_NAMES.server)
+              await postServerBuild({ builder, startConfig, serverBundle })
+            },
           },
         }
       },
     },
     // N.B. TanStackStartCompilerPlugin must be before the TanStackServerFnPluginEnv
-    startCompilerPlugin(opts.framework, {
+    startCompilerPlugin(corePluginOpts.framework, {
       client: { envName: VITE_ENVIRONMENT_NAMES.client },
       server: { envName: VITE_ENVIRONMENT_NAMES.server },
     }),
@@ -221,31 +306,39 @@ export function TanStackStartVitePluginCore(
       manifestVirtualImportId: VIRTUAL_MODULES.serverFnManifest,
       client: {
         getRuntimeCode: () =>
-          `import { createClientRpc } from '@tanstack/${opts.framework}-start/server-functions-client'`,
+          `import { createClientRpc } from '@tanstack/${corePluginOpts.framework}-start/server-functions-client'`,
         replacer: (d) =>
           `createClientRpc('${d.functionId}', '${startConfig.serverFns.base}')`,
         envName: VITE_ENVIRONMENT_NAMES.client,
       },
       server: {
         getRuntimeCode: () =>
-          `import { createServerRpc } from '@tanstack/${opts.framework}-start/server-functions-server'`,
+          `import { createServerRpc } from '@tanstack/${corePluginOpts.framework}-start/server-functions-server'`,
         replacer: (d) =>
           `createServerRpc('${d.functionId}', '${startConfig.serverFns.base}', ${d.fn})`,
         envName: VITE_ENVIRONMENT_NAMES.server,
       },
     }),
-    loadEnvPlugin(startConfig),
-    startManifestPlugin({ clientEntry: getClientEntryPath(startConfig) }),
-    devServerPlugin(),
-    nitroPlugin(startConfig, () => ssrBundle),
+    loadEnvPlugin(),
+    startManifestPlugin({
+      getClientBundle: () => getBundle(VITE_ENVIRONMENT_NAMES.client),
+    }),
+    devServerPlugin({ startConfig }),
     {
-      name: 'tanstack-start:core:capture-client-bundle',
+      name: 'tanstack-start:core:capture-bundle',
       applyToEnvironment(e) {
-        return e.name === VITE_ENVIRONMENT_NAMES.client
+        return (
+          e.name === VITE_ENVIRONMENT_NAMES.client ||
+          e.name === VITE_ENVIRONMENT_NAMES.server
+        )
       },
       enforce: 'post',
       generateBundle(_options, bundle) {
-        globalThis.TSS_CLIENT_BUNDLE = bundle
+        const environment = this.environment.name as ViteEnvironmentNames
+        if (!Object.values(VITE_ENVIRONMENT_NAMES).includes(environment)) {
+          throw new Error(`Unknown environment: ${environment}`)
+        }
+        capturedBundle[environment] = bundle
       },
     },
   ]
@@ -260,22 +353,3 @@ function defineReplaceEnv<TKey extends string, TValue extends string>(
     [`import.meta.env.${key}`]: JSON.stringify(value),
   } as { [P in `process.env.${TKey}` | `import.meta.env.${TKey}`]: TValue }
 }
-
-const getClientEntryPath = (startConfig: TanStackStartOutputConfig) => {
-  // when the user specifies a custom client entry path, we need to resolve it
-  // relative to the root of the project, keeping in mind that if not specified
-  // it will be /~start/default-client-entry which is a virtual path
-  // that is resolved by vite to the actual client entry path
-  const entry = startConfig.clientEntryPath.startsWith(
-    '/~start/default-client-entry',
-  )
-    ? startConfig.clientEntryPath
-    : vite.normalizePath(
-        path.join(
-          '/@fs',
-          path.resolve(startConfig.root, startConfig.clientEntryPath),
-        ),
-      )
-
-  return entry
-}

package/src/post-server-build.ts

@@ -0,0 +1,73 @@
+import { HEADERS } from '@tanstack/start-server-core'
+import { buildSitemap } from './build-sitemap'
+import { VITE_ENVIRONMENT_NAMES } from './constants'
+import { prerender } from './prerender'
+import type { TanStackStartOutputConfig } from './schema'
+import type { Rollup, ViteBuilder } from 'vite'
+
+export async function postServerBuild({
+  builder,
+  startConfig,
+  serverBundle,
+}: {
+  builder: ViteBuilder
+  startConfig: TanStackStartOutputConfig
+  serverBundle: Rollup.OutputBundle
+}) {
+  // 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 the user has explicitly set prerender.enabled, this should be respected
+  if (startConfig.prerender?.enabled !== false) {
+    startConfig.prerender = {
+      ...startConfig.prerender,
+      enabled:
+        startConfig.prerender?.enabled ??
+        startConfig.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 (startConfig.spa?.enabled) {
+    startConfig.prerender = {
+      ...startConfig.prerender,
+      enabled: true,
+    }
+
+    const maskUrl = new URL(startConfig.spa.maskPath, 'http://localhost')
+
+    startConfig.pages.push({
+      path: maskUrl.toString().replace('http://localhost', ''),
+      prerender: {
+        ...startConfig.spa.prerender,
+        headers: {
+          ...startConfig.spa.prerender.headers,
+          [HEADERS.TSS_SHELL]: 'true',
+        },
+      },
+      sitemap: {
+        exclude: true,
+      },
+    })
+  }
+
+  // Run the prerendering process
+  if (startConfig.prerender.enabled) {
+    await prerender({
+      startConfig,
+      builder,
+      serverBundle,
+    })
+  }
+
+  // Run the sitemap build process
+  if (startConfig.pages.length) {
+    buildSitemap({
+      startConfig,
+      publicDir:
+        builder.environments[VITE_ENVIRONMENT_NAMES.client]?.config.build
+          .outDir ?? builder.config.build.outDir,
+    })
+  }
+}