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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tanstack/start-plugin-core",
-  "version": "1.132.0-alpha.9",
+  "version": "1.132.0",
   "description": "Modern and scalable routing for React applications",
   "author": "Tanner Linsley",
   "license": "MIT",
@@ -42,7 +42,7 @@
     "src"
   ],
   "engines": {
-    "node": ">=12"
+    "node": ">=22.12.0"
   },
   "dependencies": {
     "@babel/code-frame": "7.26.2",
@@ -57,12 +57,12 @@
     "vitefu": "^1.1.1",
     "xmlbuilder2": "^3.1.1",
     "zod": "^3.24.2",
-    "@tanstack/router-core": "1.132.0-alpha.8",
-    "@tanstack/router-generator": "1.132.0-alpha.9",
-    "@tanstack/router-plugin": "1.132.0-alpha.9",
-    "@tanstack/router-utils": "1.132.0-alpha.9",
-    "@tanstack/server-functions-plugin": "1.132.0-alpha.9",
-    "@tanstack/start-server-core": "1.132.0-alpha.9"
+    "@tanstack/router-core": "1.132.0",
+    "@tanstack/router-plugin": "1.132.0",
+    "@tanstack/router-generator": "1.132.0",
+    "@tanstack/server-functions-plugin": "1.132.0",
+    "@tanstack/router-utils": "1.132.0",
+    "@tanstack/start-server-core": "1.132.0"
   },
   "devDependencies": {
     "@types/babel__code-frame": "^7.0.6",

package/src/constants.ts

@@ -14,6 +14,7 @@ export type ViteEnvironmentNames =
 export const ENTRY_POINTS = {
   client: 'virtual:tanstack-start-client-entry',
   server: 'virtual:tanstack-start-server-request-entry',
-  // the router entry point must always be provided by the user
-  router: '#tanstack-start-router-entry',
+  // the start entry point must always be provided by the user
+  start: '#tanstack-start-entry',
+  router: '#tanstack-router-entry',
 } as const

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

@@ -7,6 +7,7 @@ import {
   findReferencedIdentifiers,
 } from 'babel-dead-code-elimination'
 import { handleCreateServerFn } from './handleCreateServerFn'
+import { handleCreateMiddleware } from './handleCreateMiddleware'
 
 type Binding =
   | {
@@ -26,8 +27,16 @@ type ExportEntry =
   | { tag: 'Default'; name: string }
   | { tag: 'Namespace'; name: string; targetId: string } // for `export * as ns from './x'`
 
-type Kind = 'None' | 'Root' | 'Builder' | 'ServerFn'
+type Kind = 'None' | `Root` | `Builder` | LookupKind
 
+type LookupKind = 'ServerFn' | 'Middleware'
+
+const validLookupKinds: Array<LookupKind> = ['ServerFn', 'Middleware']
+const candidateCallIdentifier = ['handler', 'server', 'client']
+export type LookupConfig = {
+  libName: string
+  rootExport: string
+}
 interface ModuleInfo {
   id: string
   code: string
@@ -38,43 +47,55 @@ interface ModuleInfo {
 
 export class ServerFnCompiler {
   private moduleCache = new Map<string, ModuleInfo>()
-  private resolvedLibId!: string
   private initialized = false
   constructor(
     private options: {
       env: 'client' | 'server'
-      libName: string
-      rootExport: string
+      lookupConfigurations: Array<LookupConfig>
       loadModule: (id: string) => Promise<void>
       resolveId: (id: string, importer?: string) => Promise<string | null>
     },
   ) {}
 
   private async init(id: string) {
-    const libId = await this.options.resolveId(this.options.libName, id)
-    if (!libId) {
-      throw new Error(`could not resolve "${this.options.libName}"`)
-    }
-    // insert root binding
-    const rootModule = {
-      ast: null as any,
-      bindings: new Map(),
-      exports: new Map(),
-      code: '',
-      id: libId,
-    }
-    rootModule.exports.set(this.options.rootExport, {
-      tag: 'Normal',
-      name: this.options.rootExport,
-    })
-    rootModule.bindings.set(this.options.rootExport, {
-      type: 'var',
-      init: t.identifier(this.options.rootExport),
-      resolvedKind: 'Root',
-    })
-    this.moduleCache.set(libId, rootModule)
+    await Promise.all(
+      this.options.lookupConfigurations.map(async (config) => {
+        const libId = await this.options.resolveId(config.libName, id)
+        if (!libId) {
+          throw new Error(`could not resolve "${config.libName}"`)
+        }
+        let rootModule = this.moduleCache.get(libId)
+        if (!rootModule) {
+          // insert root binding
+          rootModule = {
+            ast: null as any,
+            bindings: new Map(),
+            exports: new Map(),
+            code: '',
+            id: libId,
+          }
+          this.moduleCache.set(libId, rootModule)
+        }
+
+        rootModule.exports.set(config.rootExport, {
+          tag: 'Normal',
+          name: config.rootExport,
+        })
+        rootModule.exports.set('*', {
+          tag: 'Namespace',
+          name: config.rootExport,
+          targetId: libId,
+        })
+        rootModule.bindings.set(config.rootExport, {
+          type: 'var',
+          init: t.identifier(config.rootExport),
+          resolvedKind: `Root` satisfies Kind,
+        })
+        this.moduleCache.set(libId, rootModule)
+      }),
+    )
+
     this.initialized = true
-    this.resolvedLibId = libId
   }
 
   public ingestModule({ code, id }: { code: string; id: string }) {
@@ -172,30 +193,37 @@ export class ServerFnCompiler {
       await this.init(id)
     }
     const { bindings, ast } = this.ingestModule({ code, id })
-    const candidates = this.collectHandlerCandidates(bindings)
+    const candidates = this.collectCandidates(bindings)
     if (candidates.length === 0) {
-      // this hook will only be invoked if there is `.handler(` in the code,
+      // this hook will only be invoked if there is `.handler(` | `.server(` | `.client(` in the code,
       // so not discovering a handler candidate is rather unlikely, but maybe possible?
       return null
     }
 
     // let's find out which of the candidates are actually server functions
-    const toRewrite: Array<t.CallExpression> = []
+    const toRewrite: Array<{
+      callExpression: t.CallExpression
+      kind: LookupKind
+    }> = []
     for (const handler of candidates) {
       const kind = await this.resolveExprKind(handler, id)
-      if (kind === 'ServerFn') {
-        toRewrite.push(handler)
+      if (validLookupKinds.includes(kind as LookupKind)) {
+        toRewrite.push({ callExpression: handler, kind: kind as LookupKind })
       }
     }
     if (toRewrite.length === 0) {
       return null
     }
-    const pathsToRewrite: Array<babel.NodePath<t.CallExpression>> = []
+
+    const pathsToRewrite: Array<{
+      nodePath: babel.NodePath<t.CallExpression>
+      kind: LookupKind
+    }> = []
     babel.traverse(ast, {
       CallExpression(path) {
-        const found = toRewrite.findIndex((h) => path.node === h)
+        const found = toRewrite.findIndex((h) => path.node === h.callExpression)
         if (found !== -1) {
-          pathsToRewrite.push(path)
+          pathsToRewrite.push({ nodePath: path, kind: toRewrite[found]!.kind })
           // delete from toRewrite
           toRewrite.splice(found, 1)
         }
@@ -210,9 +238,13 @@ export class ServerFnCompiler {
 
     const refIdents = findReferencedIdentifiers(ast)
 
-    pathsToRewrite.map((p) =>
-      handleCreateServerFn(p, { env: this.options.env, code }),
-    )
+    pathsToRewrite.map((p) => {
+      if (p.kind === 'ServerFn') {
+        handleCreateServerFn(p.nodePath, { env: this.options.env, code })
+      } else {
+        handleCreateMiddleware(p.nodePath, { env: this.options.env })
+      }
+    })
 
     deadCodeElimination(ast, refIdents)
 
@@ -223,13 +255,13 @@ export class ServerFnCompiler {
     })
   }
 
-  // collects all `.handler(...)` CallExpressions at top-level
-  private collectHandlerCandidates(bindings: Map<string, Binding>) {
+  // collects all candidate CallExpressions at top-level
+  private collectCandidates(bindings: Map<string, Binding>) {
     const candidates: Array<t.CallExpression> = []
 
     for (const binding of bindings.values()) {
       if (binding.type === 'var') {
-        const handler = isHandlerCall(binding.init)
+        const handler = isCandidateCallExpression(binding.init)
         if (handler) {
           candidates.push(handler)
         }
@@ -280,12 +312,6 @@ export class ServerFnCompiler {
         return 'None'
       }
 
-      if (binding.importedName === '*') {
-        throw new Error(
-          `should never get here, namespace imports are handled in resolveCalleeKind`,
-        )
-      }
-
       const importedModule = await this.getModuleInfo(target)
 
       const moduleExport = importedModule.exports.get(binding.importedName)
@@ -338,11 +364,15 @@ export class ServerFnCompiler {
         fileId,
         visited,
       )
-      if (calleeKind === 'Root' || calleeKind === 'Builder') {
-        return 'Builder'
-      }
-      if (calleeKind === 'ServerFn') {
-        return 'ServerFn'
+      if (calleeKind !== 'None') {
+        if (calleeKind === `Root` || calleeKind === `Builder`) {
+          return `Builder`
+        }
+        for (const kind of validLookupKinds) {
+          if (calleeKind === kind) {
+            return kind
+          }
+        }
       }
     } else if (t.isMemberExpression(expr) && t.isIdentifier(expr.property)) {
       result = await this.resolveCalleeKind(expr.object, fileId, visited)
@@ -383,6 +413,16 @@ export class ServerFnCompiler {
           return 'ServerFn'
         }
         return 'None'
+      } else if (
+        prop === 'client' ||
+        prop === 'server' ||
+        prop === 'createMiddleware'
+      ) {
+        const base = await this.resolveExprKind(callee.object, fileId, visited)
+        if (base === 'Root' || base === 'Builder' || base === 'Middleware') {
+          return 'Middleware'
+        }
+        return 'None'
       }
       // Check if the object is a namespace import
       if (t.isIdentifier(callee.object)) {
@@ -413,6 +453,8 @@ export class ServerFnCompiler {
                 )
               }
             }
+          } else {
+            return 'None'
           }
         }
       }
@@ -439,16 +481,16 @@ export class ServerFnCompiler {
   }
 }
 
-function isHandlerCall(
+function isCandidateCallExpression(
   node: t.Node | null | undefined,
 ): undefined | t.CallExpression {
   if (!t.isCallExpression(node)) return undefined
 
   const callee = node.callee
-  if (
-    !t.isMemberExpression(callee) ||
-    !t.isIdentifier(callee.property, { name: 'handler' })
-  ) {
+  if (!t.isMemberExpression(callee) || !t.isIdentifier(callee.property)) {
+    return undefined
+  }
+  if (!candidateCallIdentifier.includes(callee.property.name)) {
     return undefined
   }
 

package/src/{start-compiler-plugin/middleware.ts → create-server-fn-plugin/handleCreateMiddleware.ts}

@@ -1,12 +1,12 @@
 import * as t from '@babel/types'
-import { getRootCallExpression } from './utils'
+import { getRootCallExpression } from '../start-compiler-plugin/utils'
 import type * as babel from '@babel/core'
 
-import type { CompileOptions } from './compilers'
-
-export function handleCreateMiddlewareCallExpression(
+export function handleCreateMiddleware(
   path: babel.NodePath<t.CallExpression>,
-  opts: CompileOptions,
+  opts: {
+    env: 'client' | 'server'
+  },
 ) {
   const rootCallExpression = getRootCallExpression(path)
 
@@ -18,7 +18,7 @@ export function handleCreateMiddlewareCallExpression(
 
   const callExpressionPaths = {
     middleware: null as babel.NodePath<t.CallExpression> | null,
-    validator: null as babel.NodePath<t.CallExpression> | null,
+    inputValidator: null as babel.NodePath<t.CallExpression> | null,
     client: null as babel.NodePath<t.CallExpression> | null,
     server: null as babel.NodePath<t.CallExpression> | null,
   }
@@ -41,20 +41,23 @@ export function handleCreateMiddlewareCallExpression(
     },
   })
 
-  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(
-        'createMiddleware().validator() must be called with a validator!',
+        'createMiddleware().inputValidator() must be called with a validator!',
       )
     }
 
     // If we're on the client, remove the validator call expression
     if (opts.env === 'client') {
-      if (t.isMemberExpression(callExpressionPaths.validator.node.callee)) {
-        callExpressionPaths.validator.replaceWith(
-          callExpressionPaths.validator.node.callee.object,
+      if (
+        t.isMemberExpression(callExpressionPaths.inputValidator.node.callee)
+      ) {
+        callExpressionPaths.inputValidator.replaceWith(
+          callExpressionPaths.inputValidator.node.callee.object,
         )
       }
     }

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

@@ -16,14 +16,14 @@ export function handleCreateServerFn(
   // the validator, handler, and middleware methods. Check to make sure they
   // are children of the createServerFn call expression.
 
-  const validMethods = ['middleware', 'validator', 'handler'] as const
+  const validMethods = ['middleware', 'inputValidator', 'handler'] as const
   type ValidMethods = (typeof validMethods)[number]
   const callExpressionPaths: Record<
     ValidMethods,
     babel.NodePath<t.CallExpression> | null
   > = {
     middleware: null,
-    validator: null,
+    inputValidator: null,
     handler: null,
   }
 
@@ -59,20 +59,23 @@ export function handleCreateServerFn(
     },
   })
 
-  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, remove the validator call expression
     if (opts.env === 'client') {
-      if (t.isMemberExpression(callExpressionPaths.validator.node.callee)) {
-        callExpressionPaths.validator.replaceWith(
-          callExpressionPaths.validator.node.callee.object,
+      if (
+        t.isMemberExpression(callExpressionPaths.inputValidator.node.callee)
+      ) {
+        callExpressionPaths.inputValidator.replaceWith(
+          callExpressionPaths.inputValidator.node.callee.object,
         )
       }
     }

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

@@ -1,8 +1,8 @@
 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'
-import type { CompileStartFrameworkOptions } from '../start-compiler-plugin/compilers'
 
 function cleanId(id: string): string {
   return id.split('?')[0]!
@@ -11,9 +11,6 @@ function cleanId(id: string): string {
 export function createServerFnPlugin(
   framework: CompileStartFrameworkOptions,
 ): PluginOption {
-  const libName = `@tanstack/${framework}-start`
-  const rootExport = 'createServerFn'
-
   const SERVER_FN_LOOKUP = 'server-fn-module-lookup'
 
   const compilers: Partial<Record<ViteEnvironmentNames, ServerFnCompiler>> = {}
@@ -55,8 +52,8 @@ export function createServerFnPlugin(
             exclude: new RegExp(`${SERVER_FN_LOOKUP}$`),
           },
           code: {
-            // only scan files that mention `.handler(`
-            include: [/\.handler\(/],
+            // only scan files that mention `.handler(` | `.server(` | `.client(`
+            include: [/\.handler\(/, /\.server\(/, /\.client\(/],
           },
         },
         async handler(code, id) {
@@ -76,8 +73,21 @@ export function createServerFnPlugin(
 
             compiler = new ServerFnCompiler({
               env,
-              libName,
-              rootExport,
+              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 })
@@ -104,7 +114,12 @@ export function createServerFnPlugin(
               },
               resolveId: async (source: string, importer?: string) => {
                 const r = await this.resolve(source, importer)
-                return r ? cleanId(r.id) : null
+                if (r) {
+                  if (!r.external) {
+                    return cleanId(r.id)
+                  }
+                }
+                return null
               },
             })
             compilers[this.environment.name as ViteEnvironmentNames] = compiler

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')