@tanstack/start-plugin-core 1.142.4 → 1.142.6

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

@@ -1,9 +1,14 @@
 import * as t from '@babel/types'
-import { getRootCallExpression } from '../start-compiler-plugin/utils'
-import type * as babel from '@babel/core'
-
+import type { RewriteCandidate } from './types'
+
+/**
+ * Handles createMiddleware transformations.
+ *
+ * @param candidate - The rewrite candidate containing path and method chain
+ * @param opts - Options including the environment
+ */
 export function handleCreateMiddleware(
-  path: babel.NodePath<t.CallExpression>,
+  candidate: RewriteCandidate,
   opts: {
     env: 'client' | 'server'
   },
@@ -11,36 +16,11 @@ export function handleCreateMiddleware(
   if (opts.env === 'server') {
     throw new Error('handleCreateMiddleware should not be called on the server')
   }
-  const rootCallExpression = getRootCallExpression(path)
-
-  const callExpressionPaths = {
-    middleware: 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,
-  }
-
-  const validMethods = Object.keys(callExpressionPaths)
 
-  rootCallExpression.traverse({
-    MemberExpression(memberExpressionPath) {
-      if (t.isIdentifier(memberExpressionPath.node.property)) {
-        const name = memberExpressionPath.node.property
-          .name as keyof typeof callExpressionPaths
+  const { inputValidator, server } = candidate.methodChain
 
-        if (
-          validMethods.includes(name) &&
-          memberExpressionPath.parentPath.isCallExpression()
-        ) {
-          callExpressionPaths[name] = memberExpressionPath.parentPath
-        }
-      }
-    },
-  })
-
-  if (callExpressionPaths.inputValidator) {
-    const innerInputExpression =
-      callExpressionPaths.inputValidator.node.arguments[0]
+  if (inputValidator) {
+    const innerInputExpression = inputValidator.callPath.node.arguments[0]
 
     if (!innerInputExpression) {
       throw new Error(
@@ -49,23 +29,17 @@ export function handleCreateMiddleware(
     }
 
     // remove the validator call expression
-    if (t.isMemberExpression(callExpressionPaths.inputValidator.node.callee)) {
-      callExpressionPaths.inputValidator.replaceWith(
-        callExpressionPaths.inputValidator.node.callee.object,
+    if (t.isMemberExpression(inputValidator.callPath.node.callee)) {
+      inputValidator.callPath.replaceWith(
+        inputValidator.callPath.node.callee.object,
       )
     }
   }
 
-  const serverFnPath = callExpressionPaths.server?.get(
-    'arguments.0',
-  ) as babel.NodePath<any>
-
-  if (callExpressionPaths.server && serverFnPath.node) {
+  if (server) {
     // remove the server call expression
-    if (t.isMemberExpression(callExpressionPaths.server.node.callee)) {
-      callExpressionPaths.server.replaceWith(
-        callExpressionPaths.server.node.callee.object,
-      )
+    if (t.isMemberExpression(server.callPath.node.callee)) {
+      server.callPath.replaceWith(server.callPath.node.callee.object)
     }
   }
 }

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

@@ -1,12 +1,15 @@
 import * as t from '@babel/types'
-import {
-  codeFrameError,
-  getRootCallExpression,
-} from '../start-compiler-plugin/utils'
-import type * as babel from '@babel/core'
-
+import { codeFrameError } from '../start-compiler-plugin/utils'
+import type { RewriteCandidate } from './types'
+
+/**
+ * Handles createServerFn transformations.
+ *
+ * @param candidate - The rewrite candidate containing path and method chain
+ * @param opts - Options including the environment, code, directive, and provider file flag
+ */
 export function handleCreateServerFn(
-  path: babel.NodePath<t.CallExpression>,
+  candidate: RewriteCandidate,
   opts: {
     env: 'client' | 'server'
     code: string
@@ -18,56 +21,27 @@ export function handleCreateServerFn(
     isProviderFile: boolean
   },
 ) {
-  // 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 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 rootCallExpression = getRootCallExpression(path)
-
-  // if (debug)
-  //   console.info(
-  //     'Handling createServerFn call expression:',
-  //     rootCallExpression.toString(),
-  //   )
+  const { path, methodChain } = candidate
+  const { inputValidator, handler } = methodChain
 
   // Check if the call is assigned to a variable
-  if (!rootCallExpression.parentPath.isVariableDeclarator()) {
+  if (!path.parentPath.isVariableDeclarator()) {
     throw new Error('createServerFn must be assigned to a variable!')
   }
 
   // Get the identifier name of the variable
-  const variableDeclarator = rootCallExpression.parentPath.node
-  const existingVariableName = (variableDeclarator.id as t.Identifier).name
-
-  rootCallExpression.traverse({
-    MemberExpression(memberExpressionPath) {
-      if (t.isIdentifier(memberExpressionPath.node.property)) {
-        const name = memberExpressionPath.node.property.name as ValidMethods
-
-        if (
-          validMethods.includes(name) &&
-          memberExpressionPath.parentPath.isCallExpression()
-        ) {
-          callExpressionPaths[name] = memberExpressionPath.parentPath
-        }
-      }
-    },
-  })
+  const variableDeclarator = path.parentPath.node
+  if (!t.isIdentifier(variableDeclarator.id)) {
+    throw codeFrameError(
+      opts.code,
+      variableDeclarator.id.loc!,
+      'createServerFn must be assigned to a simple identifier, not a destructuring pattern',
+    )
+  }
+  const existingVariableName = variableDeclarator.id.name
 
-  if (callExpressionPaths.inputValidator) {
-    const innerInputExpression =
-      callExpressionPaths.inputValidator.node.arguments[0]
+  if (inputValidator) {
+    const innerInputExpression = inputValidator.callPath.node.arguments[0]
 
     if (!innerInputExpression) {
       throw new Error(
@@ -77,11 +51,9 @@ export function handleCreateServerFn(
 
     // 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,
+      if (t.isMemberExpression(inputValidator.callPath.node.callee)) {
+        inputValidator.callPath.replaceWith(
+          inputValidator.callPath.node.callee.object,
         )
       }
     }
@@ -90,11 +62,9 @@ export function handleCreateServerFn(
   // First, we need to move the handler function to a nested function call
   // that is applied to the arguments passed to the server function.
 
-  const handlerFnPath = callExpressionPaths.handler?.get(
-    'arguments.0',
-  ) as babel.NodePath<any>
+  const handlerFnPath = handler?.firstArgPath
 
-  if (!callExpressionPaths.handler || !handlerFnPath.node) {
+  if (!handler || !handlerFnPath?.node) {
     throw codeFrameError(
       opts.code,
       path.node.callee.loc!,
@@ -102,6 +72,15 @@ export function handleCreateServerFn(
     )
   }
 
+  // Validate the handler argument is an expression (not a SpreadElement, etc.)
+  if (!t.isExpression(handlerFnPath.node)) {
+    throw codeFrameError(
+      opts.code,
+      handlerFnPath.node.loc!,
+      `handler() must be called with an expression, not a ${handlerFnPath.node.type}`,
+    )
+  }
+
   const handlerFn = handlerFnPath.node
 
   // So, the way we do this is we give the handler function a way
@@ -161,6 +140,6 @@ export function handleCreateServerFn(
   // Caller files must NOT have the second argument because the implementation is already available in the extracted chunk
   // and including it would duplicate code
   if (opts.env === 'server' && opts.isProviderFile) {
-    callExpressionPaths.handler.node.arguments.push(handlerFn)
+    handler.callPath.node.arguments.push(handlerFn)
   }
 }

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

@@ -0,0 +1,42 @@
+import type * as babel from '@babel/core'
+import type * as t from '@babel/types'
+
+/**
+ * Info about a method call in the chain, including the call expression path
+ * and the path to its first argument (if any).
+ */
+export interface MethodCallInfo {
+  callPath: babel.NodePath<t.CallExpression>
+  /** Path to the first argument, or null if no arguments */
+  firstArgPath: babel.NodePath | null
+}
+
+/**
+ * Pre-collected method chain paths for a root call expression.
+ * This avoids needing to traverse the AST again in handlers.
+ */
+export interface MethodChainPaths {
+  middleware: MethodCallInfo | null
+  inputValidator: MethodCallInfo | null
+  handler: MethodCallInfo | null
+  server: MethodCallInfo | null
+  client: MethodCallInfo | null
+}
+
+export type MethodChainKey = keyof MethodChainPaths
+
+export const METHOD_CHAIN_KEYS: ReadonlyArray<MethodChainKey> = [
+  'middleware',
+  'inputValidator',
+  'handler',
+  'server',
+  'client',
+] as const
+
+/**
+ * Information about a candidate that needs to be rewritten.
+ */
+export interface RewriteCandidate {
+  path: babel.NodePath<t.CallExpression>
+  methodChain: MethodChainPaths
+}