@tanstack/start-plugin-core 1.132.0-alpha.8 → 1.132.0

package/src/{start-compiler-plugin/serverFn.ts → create-server-fn-plugin/handleCreateServerFn.ts}

@@ -1,39 +1,32 @@
 import * as t from '@babel/types'
-import { codeFrameError, getRootCallExpression } from './utils'
+import {
+  codeFrameError,
+  getRootCallExpression,
+} from '../start-compiler-plugin/utils'
 import type * as babel from '@babel/core'
 
-import type { CompileOptions } from './compilers'
-
-export function handleCreateServerFnCallExpression(
+export function handleCreateServerFn(
   path: babel.NodePath<t.CallExpression>,
-  opts: CompileOptions,
+  opts: {
+    env: 'client' | 'server'
+    code: string
+  },
 ) {
   // Traverse the member expression and find the call expressions for
   // the validator, handler, and middleware methods. Check to make sure they
   // are children of the createServerFn call expression.
 
-  const calledOptions = path.node.arguments[0]
-    ? (path.get('arguments.0') as babel.NodePath<t.ObjectExpression>)
-    : null
-
-  const shouldValidateClient = !!calledOptions?.node.properties.find((prop) => {
-    return (
-      t.isObjectProperty(prop) &&
-      t.isIdentifier(prop.key) &&
-      prop.key.name === 'validateClient' &&
-      t.isBooleanLiteral(prop.value) &&
-      prop.value.value === true
-    )
-  })
-
-  const callExpressionPaths = {
-    middleware: null as babel.NodePath<t.CallExpression> | null,
-    validator: null as babel.NodePath<t.CallExpression> | null,
-    handler: null as babel.NodePath<t.CallExpression> | null,
+  const validMethods = ['middleware', 'inputValidator', 'handler'] as const
+  type ValidMethods = (typeof validMethods)[number]
+  const callExpressionPaths: Record<
+    ValidMethods,
+    babel.NodePath<t.CallExpression> | null
+  > = {
+    middleware: null,
+    inputValidator: null,
+    handler: null,
   }
 
-  const validMethods = Object.keys(callExpressionPaths)
-
   const rootCallExpression = getRootCallExpression(path)
 
   // if (debug)
@@ -54,8 +47,7 @@ export function handleCreateServerFnCallExpression(
   rootCallExpression.traverse({
     MemberExpression(memberExpressionPath) {
       if (t.isIdentifier(memberExpressionPath.node.property)) {
-        const name = memberExpressionPath.node.property
-          .name as keyof typeof callExpressionPaths
+        const name = memberExpressionPath.node.property.name as ValidMethods
 
         if (
           validMethods.includes(name) &&
@@ -67,24 +59,25 @@ export function handleCreateServerFnCallExpression(
     },
   })
 
-  if (callExpressionPaths.validator) {
-    const innerInputExpression = callExpressionPaths.validator.node.arguments[0]
+  if (callExpressionPaths.inputValidator) {
+    const innerInputExpression =
+      callExpressionPaths.inputValidator.node.arguments[0]
 
     if (!innerInputExpression) {
       throw new Error(
-        'createServerFn().validator() must be called with a validator!',
+        'createServerFn().inputValidator() must be called with a validator!',
       )
     }
 
-    // If we're on the client, and we're not validating the client, remove the validator call expression
-    if (
-      opts.env === 'client' &&
-      !shouldValidateClient &&
-      t.isMemberExpression(callExpressionPaths.validator.node.callee)
-    ) {
-      callExpressionPaths.validator.replaceWith(
-        callExpressionPaths.validator.node.callee.object,
-      )
+    // If we're on the client, remove the validator call expression
+    if (opts.env === 'client') {
+      if (
+        t.isMemberExpression(callExpressionPaths.inputValidator.node.callee)
+      ) {
+        callExpressionPaths.inputValidator.replaceWith(
+          callExpressionPaths.inputValidator.node.callee.object,
+        )
+      }
     }
   }
 

package/src/create-server-fn-plugin/plugin.ts

@@ -0,0 +1,153 @@
+import { VITE_ENVIRONMENT_NAMES } from '../constants'
+import { ServerFnCompiler } from './compiler'
+import type { CompileStartFrameworkOptions } from '../start-compiler-plugin/compilers'
+import type { ViteEnvironmentNames } from '../constants'
+import type { PluginOption } from 'vite'
+
+function cleanId(id: string): string {
+  return id.split('?')[0]!
+}
+
+export function createServerFnPlugin(
+  framework: CompileStartFrameworkOptions,
+): PluginOption {
+  const SERVER_FN_LOOKUP = 'server-fn-module-lookup'
+
+  const compilers: Partial<Record<ViteEnvironmentNames, ServerFnCompiler>> = {}
+  return [
+    {
+      name: 'tanstack-start-core:capture-server-fn-module-lookup',
+      // we only need this plugin in dev mode
+      apply: 'serve',
+      applyToEnvironment(env) {
+        return [
+          VITE_ENVIRONMENT_NAMES.client,
+          VITE_ENVIRONMENT_NAMES.server,
+        ].includes(env.name as ViteEnvironmentNames)
+      },
+      transform: {
+        filter: {
+          id: new RegExp(`${SERVER_FN_LOOKUP}$`),
+        },
+        handler(code, id) {
+          const compiler =
+            compilers[this.environment.name as ViteEnvironmentNames]
+          compiler?.ingestModule({ code, id: cleanId(id) })
+        },
+      },
+    },
+    {
+      name: 'tanstack-start-core::server-fn',
+      enforce: 'pre',
+
+      applyToEnvironment(env) {
+        return [
+          VITE_ENVIRONMENT_NAMES.client,
+          VITE_ENVIRONMENT_NAMES.server,
+        ].includes(env.name as ViteEnvironmentNames)
+      },
+      transform: {
+        filter: {
+          id: {
+            exclude: new RegExp(`${SERVER_FN_LOOKUP}$`),
+          },
+          code: {
+            // only scan files that mention `.handler(` | `.server(` | `.client(`
+            include: [/\.handler\(/, /\.server\(/, /\.client\(/],
+          },
+        },
+        async handler(code, id) {
+          let compiler =
+            compilers[this.environment.name as ViteEnvironmentNames]
+          if (!compiler) {
+            const env =
+              this.environment.name === VITE_ENVIRONMENT_NAMES.client
+                ? 'client'
+                : this.environment.name === VITE_ENVIRONMENT_NAMES.server
+                  ? 'server'
+                  : (() => {
+                      throw new Error(
+                        `Environment ${this.environment.name} not configured`,
+                      )
+                    })()
+
+            compiler = new ServerFnCompiler({
+              env,
+              lookupConfigurations: [
+                {
+                  libName: `@tanstack/${framework}-start`,
+                  rootExport: 'createMiddleware',
+                },
+
+                {
+                  libName: `@tanstack/${framework}-start`,
+                  rootExport: 'createServerFn',
+                },
+                {
+                  libName: `@tanstack/${framework}-start`,
+                  rootExport: 'createStart',
+                },
+              ],
+              loadModule: async (id: string) => {
+                if (this.environment.mode === 'build') {
+                  const loaded = await this.load({ id })
+                  if (!loaded.code) {
+                    throw new Error(`could not load module ${id}`)
+                  }
+                  compiler!.ingestModule({ code: loaded.code, id })
+                } else if (this.environment.mode === 'dev') {
+                  /**
+                   * in dev, vite does not return code from `ctx.load()`
+                   * so instead, we need to take a different approach
+                   * we must force vite to load the module and run it through the vite plugin pipeline
+                   * we can do this by using the `fetchModule` method
+                   * the `captureServerFnModuleLookupPlugin` captures the module code via its transform hook and invokes analyzeModuleAST
+                   */
+                  await this.environment.fetchModule(
+                    id + '?' + SERVER_FN_LOOKUP,
+                  )
+                } else {
+                  throw new Error(
+                    `could not load module ${id}: unknown environment mode ${this.environment.mode}`,
+                  )
+                }
+              },
+              resolveId: async (source: string, importer?: string) => {
+                const r = await this.resolve(source, importer)
+                if (r) {
+                  if (!r.external) {
+                    return cleanId(r.id)
+                  }
+                }
+                return null
+              },
+            })
+            compilers[this.environment.name as ViteEnvironmentNames] = compiler
+          }
+
+          id = cleanId(id)
+          const result = await compiler.compile({ id, code })
+          return result
+        },
+      },
+
+      hotUpdate(ctx) {
+        const compiler =
+          compilers[this.environment.name as ViteEnvironmentNames]
+
+        ctx.modules.forEach((m) => {
+          if (m.id) {
+            const deleted = compiler?.invalidateModule(m.id)
+            if (deleted) {
+              m.importers.forEach((importer) => {
+                if (importer.id) {
+                  compiler?.invalidateModule(importer.id)
+                }
+              })
+            }
+          }
+        })
+      },
+    },
+  ]
+}

package/src/dev-server-plugin/plugin.ts

@@ -8,9 +8,9 @@ import type { Connect, DevEnvironment, PluginOption } from 'vite'
 import type { TanStackStartOutputConfig } from '../schema'
 
 export function devServerPlugin({
-  startConfig,
+  getConfig,
 }: {
-  startConfig: TanStackStartOutputConfig
+  getConfig: () => { startConfig: TanStackStartOutputConfig }
 }): PluginOption {
   let isTest = false
 
@@ -48,6 +48,7 @@ export function devServerPlugin({
               `Server environment ${VITE_ENVIRONMENT_NAMES.server} not found`,
             )
           }
+          const { startConfig } = getConfig()
           const installMiddleware = startConfig.vite?.installDevServerMiddleware
           if (installMiddleware === false) {
             return
@@ -98,7 +99,9 @@ export function devServerPlugin({
               return sendNodeResponse(res, webRes)
             } catch (e) {
               console.error(e)
-              viteDevServer.ssrFixStacktrace(e as Error)
+              try {
+                viteDevServer.ssrFixStacktrace(e as Error)
+              } catch (_e) {}
 
               if (
                 webReq.headers.get('content-type')?.includes('application/json')

package/src/plugin.ts

@@ -18,8 +18,12 @@ import {
   getServerOutputDirectory,
 } from './output-directory'
 import { postServerBuild } from './post-server-build'
+import { createServerFnPlugin } from './create-server-fn-plugin/plugin'
 import type { ViteEnvironmentNames } from './constants'
-import type { TanStackStartInputConfig } from './schema'
+import type {
+  TanStackStartInputConfig,
+  TanStackStartOutputConfig,
+} from './schema'
 import type { PluginOption } from 'vite'
 import type { CompileStartFrameworkOptions } from './start-compiler-plugin/compilers'
 
@@ -28,19 +32,46 @@ export interface TanStackStartVitePluginCoreOptions {
   defaultEntryPaths: {
     client: string
     server: string
+    start: string
   }
-  crawlPackages?: (opts: {
-    name: string
-    peerDependencies: Record<string, any>
-    exports?: Record<string, any> | string
-  }) => 'include' | 'exclude' | undefined
 }
 
+export interface ResolvedStartConfig {
+  root: string
+  startFilePath: string | undefined
+  routerFilePath: string
+  srcDirectory: string
+}
+
+export type GetConfigFn = () => {
+  startConfig: TanStackStartOutputConfig
+  resolvedStartConfig: ResolvedStartConfig
+}
 export function TanStackStartVitePluginCore(
   corePluginOpts: TanStackStartVitePluginCoreOptions,
   startPluginOpts: TanStackStartInputConfig,
 ): Array<PluginOption> {
-  const startConfig = parseStartConfig(startPluginOpts)
+  const resolvedStartConfig: ResolvedStartConfig = {
+    root: '',
+    startFilePath: undefined,
+    routerFilePath: '',
+    srcDirectory: '',
+  }
+
+  let startConfig: TanStackStartOutputConfig | null
+  const getConfig: GetConfigFn = () => {
+    if (!resolvedStartConfig.root) {
+      throw new Error(`Cannot get config before root is resolved`)
+    }
+    if (!startConfig) {
+      startConfig = parseStartConfig(
+        startPluginOpts,
+        corePluginOpts,
+        resolvedStartConfig.root,
+      )
+    }
+    return { startConfig, resolvedStartConfig }
+  }
 
   const capturedBundle: Partial<
     Record<ViteEnvironmentNames, vite.Rollup.OutputBundle>
@@ -55,33 +86,42 @@ export function TanStackStartVitePluginCore(
   }
 
   return [
-    tanStackStartRouter({
-      ...startConfig.router,
-      target: corePluginOpts.framework,
-      autoCodeSplitting: true,
-    }),
     {
       name: 'tanstack-start-core:config',
+      enforce: 'pre',
       async config(viteConfig, { command }) {
         const viteAppBase = trimPathRight(viteConfig.base || '/')
         globalThis.TSS_APP_BASE = viteAppBase
 
         const root = viteConfig.root || process.cwd()
+        resolvedStartConfig.root = root
+
+        const { startConfig } = getConfig()
         const resolvedSrcDirectory = join(root, startConfig.srcDirectory)
+        resolvedStartConfig.srcDirectory = resolvedSrcDirectory
+
+        const startFilePath = resolveEntry({
+          type: 'start entry',
+          configuredEntry: startConfig.start.entry,
+          defaultEntry: 'start',
+          resolvedSrcDirectory,
+          required: false,
+        })
+        resolvedStartConfig.startFilePath = startFilePath
 
         const routerFilePath = resolveEntry({
           type: 'router entry',
           configuredEntry: startConfig.router.entry,
           defaultEntry: 'router',
-          root,
           resolvedSrcDirectory,
           required: true,
         })
+        resolvedStartConfig.routerFilePath = routerFilePath
+
         const clientEntryPath = resolveEntry({
           type: 'client entry',
           configuredEntry: startConfig.client.entry,
           defaultEntry: 'client',
-          root,
           resolvedSrcDirectory,
           required: false,
         })
@@ -90,7 +130,6 @@ export function TanStackStartVitePluginCore(
           type: 'server entry',
           configuredEntry: startConfig.server.entry,
           defaultEntry: 'server',
-          root,
           resolvedSrcDirectory,
           required: false,
         })
@@ -103,42 +142,33 @@ export function TanStackStartVitePluginCore(
         } else {
           clientAlias = corePluginOpts.defaultEntryPaths.client
         }
+
         let serverAlias: string
         if (serverEntryPath) {
           serverAlias = vite.normalizePath(path.resolve(root, serverEntryPath))
         } else {
           serverAlias = corePluginOpts.defaultEntryPaths.server
         }
+
+        let startAlias: string
+        if (startFilePath) {
+          startAlias = vite.normalizePath(path.resolve(root, startFilePath))
+        } else {
+          startAlias = corePluginOpts.defaultEntryPaths.start
+        }
+
         const entryAliasConfiguration: Record<
           (typeof ENTRY_POINTS)[keyof typeof ENTRY_POINTS],
           string
         > = {
+          [ENTRY_POINTS.start]: startAlias,
           [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,
-            compatibilityDate: '2024-12-01',
-          })
-
-          const nitroOutputPublicDir = dummyNitroApp.options.output.publicDir
-          await dummyNitroApp.close()
-
-          return nitroOutputPublicDir
-        })()*/
-
-        const startPackageName = `@tanstack/${corePluginOpts.framework}-start`
-        const routerPackageName = `@tanstack/${corePluginOpts.framework}-router`
-
-        const additionalOptimizeDeps = {
-          include: new Set<string>(),
-          exclude: new Set<string>(),
-        }
+        const startPackageName =
+          `@tanstack/${corePluginOpts.framework}-start` as const
 
         // crawl packages that have start in "peerDependencies"
         // see https://github.com/svitejs/vitefu/blob/d8d82fa121e3b2215ba437107093c77bde51b63b/src/index.js#L95-L101
@@ -146,34 +176,16 @@ export function TanStackStartVitePluginCore(
         // this is currently uncached; could be implemented similarly as vite handles lock file changes
         // see https://github.com/vitejs/vite/blob/557f797d29422027e8c451ca50dd84bf8c41b5f0/packages/vite/src/node/optimizer/index.ts#L1282
 
-        const result = await crawlFrameworkPkgs({
+        const crawlFrameworkPkgsResult = await crawlFrameworkPkgs({
           root: process.cwd(),
           isBuild: command === 'build',
           isFrameworkPkgByJson(pkgJson) {
-            if ([routerPackageName, startPackageName].includes(pkgJson.name)) {
-              return false
-            }
-
             const peerDependencies = pkgJson['peerDependencies']
 
             if (peerDependencies) {
-              const internalResult = corePluginOpts.crawlPackages?.({
-                name: pkgJson.name,
-                peerDependencies,
-                exports: pkgJson.exports,
-              })
-              if (internalResult) {
-                if (internalResult === 'exclude') {
-                  additionalOptimizeDeps.exclude.add(pkgJson.name)
-                } else {
-                  additionalOptimizeDeps.include.add(pkgJson.name)
-                }
-              }
-              return (
-                startPackageName in peerDependencies ||
-                routerPackageName in peerDependencies
-              )
+              return startPackageName in peerDependencies
             }
+
             return false
           },
         })
@@ -197,6 +209,7 @@ export function TanStackStartVitePluginCore(
             },
             [VITE_ENVIRONMENT_NAMES.server]: {
               consumer: 'server',
+
               build: {
                 ssr: true,
                 rollupOptions: {
@@ -212,42 +225,20 @@ export function TanStackStartVitePluginCore(
                   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`,
-                ],
-                include: [
-                  ...additionalOptimizeDeps.include,
-                  ...result.optimizeDeps.include.sort(),
-                ],
-              },
             },
           },
+
           resolve: {
             noExternal: [
+              // ENTRY_POINTS.start,
               '@tanstack/start**',
               `@tanstack/${corePluginOpts.framework}-start**`,
-              ...Object.values(VIRTUAL_MODULES),
-              startPackageName,
-              ...result.ssr.noExternal.sort(),
+              ...crawlFrameworkPkgsResult.ssr.noExternal.sort(),
             ],
-            dedupe: [startPackageName],
             alias: {
               ...entryAliasConfiguration,
             },
           },
-          optimizeDeps: {
-            exclude: [
-              ...Object.values(VIRTUAL_MODULES),
-              startPackageName,
-              ...result.optimizeDeps.exclude.sort(),
-              ...additionalOptimizeDeps.exclude,
-            ],
-            include: [...additionalOptimizeDeps.include],
-          },
           /* prettier-ignore */
           define: {
             // define is an esbuild function that replaces the any instances of given keys with the given values
@@ -289,11 +280,11 @@ export function TanStackStartVitePluginCore(
         }
       },
     },
+    tanStackStartRouter(startPluginOpts, getConfig, corePluginOpts),
     // N.B. TanStackStartCompilerPlugin must be before the TanStackServerFnPluginEnv
-    startCompilerPlugin(corePluginOpts.framework, {
-      client: { envName: VITE_ENVIRONMENT_NAMES.client },
-      server: { envName: VITE_ENVIRONMENT_NAMES.server },
-    }),
+    startCompilerPlugin(corePluginOpts.framework),
+    createServerFnPlugin(corePluginOpts.framework),
+
     TanStackServerFnPluginEnv({
       // This is the ID that will be available to look up and import
       // our server function manifest and resolve its module
@@ -315,7 +306,7 @@ export function TanStackStartVitePluginCore(
     startManifestPlugin({
       getClientBundle: () => getBundle(VITE_ENVIRONMENT_NAMES.client),
     }),
-    devServerPlugin({ startConfig }),
+    devServerPlugin({ getConfig }),
     {
       name: 'tanstack-start:core:capture-bundle',
       applyToEnvironment(e) {

package/src/resolve-entries.ts

@@ -24,7 +24,6 @@ export function resolveEntry<
   configuredEntry?: string
   defaultEntry: string
   resolvedSrcDirectory: string
-  root: string
   required: TRequired
 }): TReturn {
   let resolveOptions: ResolveModuleOptions
@@ -38,7 +37,7 @@ export function resolveEntry<
   } else {
     resolveOptions = {
       baseName: opts.configuredEntry,
-      from: opts.root,
+      from: opts.resolvedSrcDirectory,
     }
   }
 

package/src/schema.ts

@@ -1,32 +1,44 @@
 import path from 'node:path'
 import { z } from 'zod'
-import { configSchema, getConfig } from '@tanstack/router-generator'
+import { configSchema, getConfig } from '@tanstack/router-plugin'
+import type { TanStackStartVitePluginCoreOptions } from './plugin'
 
-const tsrConfig = configSchema.omit({ autoCodeSplitting: true }).partial()
+const tsrConfig = configSchema
+  .omit({ autoCodeSplitting: true, target: true, verboseFileRoutes: true })
+  .partial()
 
 export function parseStartConfig(
-  opts?: z.input<typeof tanstackStartOptionsSchema>,
+  opts: z.input<typeof tanstackStartOptionsSchema>,
+  corePluginOpts: TanStackStartVitePluginCoreOptions,
+  root: string,
 ) {
   const options = tanstackStartOptionsSchema.parse(opts)
 
   const srcDirectory = options.srcDirectory
 
-  const routesDirectory =
-    options.router.routesDirectory ?? path.join(srcDirectory, 'routes')
+  const routesDirectory = path.resolve(
+    srcDirectory,
+    options.router.routesDirectory ?? 'routes',
+  )
 
-  const generatedRouteTree =
-    options.router.generatedRouteTree ??
-    path.join(srcDirectory, 'routeTree.gen.ts')
+  const generatedRouteTree = path.resolve(
+    srcDirectory,
+    options.router.generatedRouteTree ?? 'routeTree.gen.ts',
+  )
 
   return {
     ...options,
     router: {
       ...options.router,
-      ...getConfig({
-        ...options.router,
-        routesDirectory,
-        generatedRouteTree,
-      }),
+      ...getConfig(
+        {
+          ...options.router,
+          routesDirectory,
+          generatedRouteTree,
+        },
+        root,
+      ),
+      target: corePluginOpts.framework,
     },
   }
 }
@@ -115,9 +127,14 @@ const pageSchema = pageBaseSchema.extend({
 const tanstackStartOptionsSchema = z
   .object({
     srcDirectory: z.string().optional().default('src'),
+    start: z
+      .object({
+        entry: z.string().optional(),
+      })
+      .optional()
+      .default({}),
     router: z
       .object({
-        // TODO this will move to 'start' once we have `createStart`
         entry: z.string().optional(),
       })
       .and(tsrConfig.optional().default({}))