@tanstack/start-plugin-core 1.132.0-alpha.5 → 1.132.0-alpha.7

package/dist/esm/start-compiler-plugin/serverFn.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"serverFn.js","sources":["../../../src/start-compiler-plugin/serverFn.ts"],"sourcesContent":["import * as t from '@babel/types'\nimport { codeFrameError, getRootCallExpression } from './utils'\nimport type * as babel from '@babel/core'\n\nimport type { CompileOptions } from './compilers'\n\nexport function handleCreateServerFnCallExpression(\n  path: babel.NodePath<t.CallExpression>,\n  opts: CompileOptions,\n) {\n  // Traverse the member expression and find the call expressions for\n  // the validator, handler, and middleware methods. Check to make sure they\n  // are children of the createServerFn call expression.\n\n  const calledOptions = path.node.arguments[0]\n    ? (path.get('arguments.0') as babel.NodePath<t.ObjectExpression>)\n    : null\n\n  const shouldValidateClient = !!calledOptions?.node.properties.find((prop) => {\n    return (\n      t.isObjectProperty(prop) &&\n      t.isIdentifier(prop.key) &&\n      prop.key.name === 'validateClient' &&\n      t.isBooleanLiteral(prop.value) &&\n      prop.value.value === true\n    )\n  })\n\n  const callExpressionPaths = {\n    middleware: null as babel.NodePath<t.CallExpression> | null,\n    validator: null as babel.NodePath<t.CallExpression> | null,\n    handler: null as babel.NodePath<t.CallExpression> | null,\n  }\n\n  const validMethods = Object.keys(callExpressionPaths)\n\n  const rootCallExpression = getRootCallExpression(path)\n\n  // if (debug)\n  //   console.info(\n  //     'Handling createServerFn call expression:',\n  //     rootCallExpression.toString(),\n  //   )\n\n  // Check if the call is assigned to a variable\n  if (!rootCallExpression.parentPath.isVariableDeclarator()) {\n    throw new Error('createServerFn must be assigned to a variable!')\n  }\n\n  // Get the identifier name of the variable\n  const variableDeclarator = rootCallExpression.parentPath.node\n  const existingVariableName = (variableDeclarator.id as t.Identifier).name\n\n  rootCallExpression.traverse({\n    MemberExpression(memberExpressionPath) {\n      if (t.isIdentifier(memberExpressionPath.node.property)) {\n        const name = memberExpressionPath.node.property\n          .name as keyof typeof callExpressionPaths\n\n        if (\n          validMethods.includes(name) &&\n          memberExpressionPath.parentPath.isCallExpression()\n        ) {\n          callExpressionPaths[name] = memberExpressionPath.parentPath\n        }\n      }\n    },\n  })\n\n  if (callExpressionPaths.validator) {\n    const innerInputExpression = callExpressionPaths.validator.node.arguments[0]\n\n    if (!innerInputExpression) {\n      throw new Error(\n        'createServerFn().validator() must be called with a validator!',\n      )\n    }\n\n    // If we're on the client, and we're not validating the client, remove the validator call expression\n    if (\n      opts.env === 'client' &&\n      !shouldValidateClient &&\n      t.isMemberExpression(callExpressionPaths.validator.node.callee)\n    ) {\n      callExpressionPaths.validator.replaceWith(\n        callExpressionPaths.validator.node.callee.object,\n      )\n    }\n  }\n\n  // First, we need to move the handler function to a nested function call\n  // that is applied to the arguments passed to the server function.\n\n  const handlerFnPath = callExpressionPaths.handler?.get(\n    'arguments.0',\n  ) as babel.NodePath<any>\n\n  if (!callExpressionPaths.handler || !handlerFnPath.node) {\n    throw codeFrameError(\n      opts.code,\n      path.node.callee.loc!,\n      `createServerFn must be called with a \"handler\" property!`,\n    )\n  }\n\n  const handlerFn = handlerFnPath.node\n\n  // So, the way we do this is we give the handler function a way\n  // to access the serverFn ctx on the server via function scope.\n  // The 'use server' extracted function will be called with the\n  // payload from the client, then use the scoped serverFn ctx\n  // to execute the handler function.\n  // This way, we can do things like data and middleware validation\n  // in the __execute function without having to AST transform the\n  // handler function too much itself.\n\n  // .handler((optsOut, ctx) => {\n  //   return ((optsIn) => {\n  //     'use server'\n  //     ctx.__execute(handlerFn, optsIn)\n  //   })(optsOut)\n  // })\n\n  // If the handler function is an identifier and we're on the client, we need to\n  // remove the bound function from the file.\n  // If we're on the server, you can leave it, since it will get referenced\n  // as a second argument.\n\n  if (t.isIdentifier(handlerFn)) {\n    if (opts.env === 'client') {\n      // Find the binding for the handler function\n      const binding = handlerFnPath.scope.getBinding(handlerFn.name)\n      // Remove it\n      if (binding) {\n        binding.path.remove()\n      }\n    }\n    // If the env is server, just leave it alone\n  }\n\n  handlerFnPath.replaceWith(\n    t.arrowFunctionExpression(\n      [t.identifier('opts'), t.identifier('signal')],\n      t.blockStatement(\n        // Everything in here is server-only, since the client\n        // will strip out anything in the 'use server' directive.\n        [\n          t.returnStatement(\n            t.callExpression(\n              t.identifier(`${existingVariableName}.__executeServer`),\n              [t.identifier('opts'), t.identifier('signal')],\n            ),\n          ),\n        ],\n        [t.directive(t.directiveLiteral('use server'))],\n      ),\n    ),\n  )\n\n  if (opts.env === 'server') {\n    callExpressionPaths.handler.node.arguments.push(handlerFn)\n  }\n}\n"],"names":[],"mappings":";;AAMO,SAAS,mCACd,MACA,MACA;AAKA,QAAM,gBAAgB,KAAK,KAAK,UAAU,CAAC,IACtC,KAAK,IAAI,aAAa,IACvB;AAEJ,QAAM,uBAAuB,CAAC,CAAC,eAAe,KAAK,WAAW,KAAK,CAAC,SAAS;AAC3E,WACE,EAAE,iBAAiB,IAAI,KACvB,EAAE,aAAa,KAAK,GAAG,KACvB,KAAK,IAAI,SAAS,oBAClB,EAAE,iBAAiB,KAAK,KAAK,KAC7B,KAAK,MAAM,UAAU;AAAA,EAEzB,CAAC;AAED,QAAM,sBAAsB;AAAA,IAC1B,YAAY;AAAA,IACZ,WAAW;AAAA,IACX,SAAS;AAAA,EAAA;AAGX,QAAM,eAAe,OAAO,KAAK,mBAAmB;AAEpD,QAAM,qBAAqB,sBAAsB,IAAI;AASrD,MAAI,CAAC,mBAAmB,WAAW,wBAAwB;AACzD,UAAM,IAAI,MAAM,gDAAgD;AAAA,EAClE;AAGA,QAAM,qBAAqB,mBAAmB,WAAW;AACzD,QAAM,uBAAwB,mBAAmB,GAAoB;AAErE,qBAAmB,SAAS;AAAA,IAC1B,iBAAiB,sBAAsB;AACrC,UAAI,EAAE,aAAa,qBAAqB,KAAK,QAAQ,GAAG;AACtD,cAAM,OAAO,qBAAqB,KAAK,SACpC;AAEH,YACE,aAAa,SAAS,IAAI,KAC1B,qBAAqB,WAAW,oBAChC;AACA,8BAAoB,IAAI,IAAI,qBAAqB;AAAA,QACnD;AAAA,MACF;AAAA,IACF;AAAA,EAAA,CACD;AAED,MAAI,oBAAoB,WAAW;AACjC,UAAM,uBAAuB,oBAAoB,UAAU,KAAK,UAAU,CAAC;AAE3E,QAAI,CAAC,sBAAsB;AACzB,YAAM,IAAI;AAAA,QACR;AAAA,MAAA;AAAA,IAEJ;AAGA,QACE,KAAK,QAAQ,YACb,CAAC,wBACD,EAAE,mBAAmB,oBAAoB,UAAU,KAAK,MAAM,GAC9D;AACA,0BAAoB,UAAU;AAAA,QAC5B,oBAAoB,UAAU,KAAK,OAAO;AAAA,MAAA;AAAA,IAE9C;AAAA,EACF;AAKA,QAAM,gBAAgB,oBAAoB,SAAS;AAAA,IACjD;AAAA,EAAA;AAGF,MAAI,CAAC,oBAAoB,WAAW,CAAC,cAAc,MAAM;AACvD,UAAM;AAAA,MACJ,KAAK;AAAA,MACL,KAAK,KAAK,OAAO;AAAA,MACjB;AAAA,IAAA;AAAA,EAEJ;AAEA,QAAM,YAAY,cAAc;AAuBhC,MAAI,EAAE,aAAa,SAAS,GAAG;AAC7B,QAAI,KAAK,QAAQ,UAAU;AAEzB,YAAM,UAAU,cAAc,MAAM,WAAW,UAAU,IAAI;AAE7D,UAAI,SAAS;AACX,gBAAQ,KAAK,OAAA;AAAA,MACf;AAAA,IACF;AAAA,EAEF;AAEA,gBAAc;AAAA,IACZ,EAAE;AAAA,MACA,CAAC,EAAE,WAAW,MAAM,GAAG,EAAE,WAAW,QAAQ,CAAC;AAAA,MAC7C,EAAE;AAAA;AAAA;AAAA,QAGA;AAAA,UACE,EAAE;AAAA,YACA,EAAE;AAAA,cACA,EAAE,WAAW,GAAG,oBAAoB,kBAAkB;AAAA,cACtD,CAAC,EAAE,WAAW,MAAM,GAAG,EAAE,WAAW,QAAQ,CAAC;AAAA,YAAA;AAAA,UAC/C;AAAA,QACF;AAAA,QAEF,CAAC,EAAE,UAAU,EAAE,iBAAiB,YAAY,CAAC,CAAC;AAAA,MAAA;AAAA,IAChD;AAAA,EACF;AAGF,MAAI,KAAK,QAAQ,UAAU;AACzB,wBAAoB,QAAQ,KAAK,UAAU,KAAK,SAAS;AAAA,EAC3D;AACF;"}

package/dist/esm/start-compiler-plugin/utils.d.ts

@@ -0,0 +1,13 @@
+import type * as t from '@babel/types';
+import type * as babel from '@babel/core';
+export declare function getRootCallExpression(path: babel.NodePath<t.CallExpression>): babel.NodePath<t.CallExpression>;
+export declare function codeFrameError(code: string, loc: {
+    start: {
+        line: number;
+        column: number;
+    };
+    end: {
+        line: number;
+        column: number;
+    };
+}, message: string): Error;

package/dist/esm/start-compiler-plugin/utils.js

@@ -0,0 +1,30 @@
+import { codeFrameColumns } from "@babel/code-frame";
+function getRootCallExpression(path) {
+  let rootCallExpression = path;
+  while (rootCallExpression.parentPath.isMemberExpression()) {
+    const parent = rootCallExpression.parentPath;
+    if (parent.parentPath.isCallExpression()) {
+      rootCallExpression = parent.parentPath;
+    }
+  }
+  return rootCallExpression;
+}
+function codeFrameError(code, loc, message) {
+  const frame = codeFrameColumns(
+    code,
+    {
+      start: loc.start,
+      end: loc.end
+    },
+    {
+      highlightCode: true,
+      message
+    }
+  );
+  return new Error(frame);
+}
+export {
+  codeFrameError,
+  getRootCallExpression
+};
+//# sourceMappingURL=utils.js.map

package/dist/esm/start-compiler-plugin/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","sources":["../../../src/start-compiler-plugin/utils.ts"],"sourcesContent":["import { codeFrameColumns } from '@babel/code-frame'\nimport type * as t from '@babel/types'\nimport type * as babel from '@babel/core'\n\nexport function getRootCallExpression(path: babel.NodePath<t.CallExpression>) {\n  // Find the highest callExpression parent\n  let rootCallExpression: babel.NodePath<t.CallExpression> = path\n\n  // Traverse up the chain of CallExpressions\n  while (rootCallExpression.parentPath.isMemberExpression()) {\n    const parent = rootCallExpression.parentPath\n    if (parent.parentPath.isCallExpression()) {\n      rootCallExpression = parent.parentPath\n    }\n  }\n\n  return rootCallExpression\n}\n\nexport function codeFrameError(\n  code: string,\n  loc: {\n    start: { line: number; column: number }\n    end: { line: number; column: number }\n  },\n  message: string,\n) {\n  const frame = codeFrameColumns(\n    code,\n    {\n      start: loc.start,\n      end: loc.end,\n    },\n    {\n      highlightCode: true,\n      message,\n    },\n  )\n\n  return new Error(frame)\n}\n"],"names":[],"mappings":";AAIO,SAAS,sBAAsB,MAAwC;AAE5E,MAAI,qBAAuD;AAG3D,SAAO,mBAAmB,WAAW,sBAAsB;AACzD,UAAM,SAAS,mBAAmB;AAClC,QAAI,OAAO,WAAW,oBAAoB;AACxC,2BAAqB,OAAO;AAAA,IAC9B;AAAA,EACF;AAEA,SAAO;AACT;AAEO,SAAS,eACd,MACA,KAIA,SACA;AACA,QAAM,QAAQ;AAAA,IACZ;AAAA,IACA;AAAA,MACE,OAAO,IAAI;AAAA,MACX,KAAK,IAAI;AAAA,IAAA;AAAA,IAEX;AAAA,MACE,eAAe;AAAA,MACf;AAAA,IAAA;AAAA,EACF;AAGF,SAAO,IAAI,MAAM,KAAK;AACxB;"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tanstack/start-plugin-core",
-  "version": "1.132.0-alpha.5",
+  "version": "1.132.0-alpha.7",
   "description": "Modern and scalable routing for React applications",
   "author": "Tanner Linsley",
   "license": "MIT",
@@ -62,7 +62,7 @@
     "@tanstack/router-plugin": "1.132.0-alpha.4",
     "@tanstack/router-utils": "1.132.0-alpha.1",
     "@tanstack/server-functions-plugin": "1.132.0-alpha.3",
-    "@tanstack/start-server-core": "1.132.0-alpha.5"
+    "@tanstack/start-server-core": "1.132.0-alpha.7"
   },
   "devDependencies": {
     "@types/babel__code-frame": "^7.0.6",

package/src/plugin.ts

@@ -56,7 +56,7 @@ export function TanStackStartVitePluginCore(
 
   return [
     tanStackStartRouter({
-      ...startConfig.tsr,
+      ...startConfig.router,
       target: corePluginOpts.framework,
       autoCodeSplitting: true,
     }),
@@ -67,7 +67,7 @@ export function TanStackStartVitePluginCore(
         globalThis.TSS_APP_BASE = viteAppBase
 
         const root = viteConfig.root || process.cwd()
-        const resolvedSrcDirectory = join(root, startConfig.tsr.srcDirectory)
+        const resolvedSrcDirectory = join(root, startConfig.srcDirectory)
 
         const routerFilePath = resolveEntry({
           type: 'router entry',

package/src/schema.ts

@@ -2,35 +2,28 @@ import path from 'node:path'
 import { z } from 'zod'
 import { configSchema, getConfig } from '@tanstack/router-generator'
 
-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'),
-  })
+const tsrConfig = configSchema.omit({ autoCodeSplitting: true }).partial()
 
 export function parseStartConfig(
   opts?: z.input<typeof tanstackStartOptionsSchema>,
 ) {
   const options = tanstackStartOptionsSchema.parse(opts)
 
-  const srcDirectory = options.tsr.srcDirectory
+  const srcDirectory = options.srcDirectory
 
   const routesDirectory =
-    options.tsr.routesDirectory ?? path.join(srcDirectory, 'routes')
+    options.router.routesDirectory ?? path.join(srcDirectory, 'routes')
 
   const generatedRouteTree =
-    options.tsr.generatedRouteTree ??
+    options.router.generatedRouteTree ??
     path.join(srcDirectory, 'routeTree.gen.ts')
 
   return {
     ...options,
-    tsr: {
-      ...options.tsr,
+    router: {
+      ...options.router,
       ...getConfig({
-        ...options.tsr,
+        ...options.router,
         routesDirectory,
         generatedRouteTree,
       }),
@@ -121,12 +114,13 @@ const pageSchema = pageBaseSchema.extend({
 
 const tanstackStartOptionsSchema = z
   .object({
-    tsr: tsrConfig.optional().default({}),
+    srcDirectory: z.string().optional().default('src'),
     router: z
       .object({
-        // TODO naming?
+        // TODO this will move to 'start' once we have `createStart`
         entry: z.string().optional(),
       })
+      .and(tsrConfig.optional().default({}))
       .optional()
       .default({}),
     client: z

package/src/start-compiler-plugin/compilers.ts

@@ -1,6 +1,5 @@
 import * as babel from '@babel/core'
 import * as t from '@babel/types'
-import { codeFrameColumns } from '@babel/code-frame'
 
 import {
   deadCodeElimination,
@@ -8,6 +7,14 @@ import {
 } from 'babel-dead-code-elimination'
 import { generateFromAst, parseAst } from '@tanstack/router-utils'
 import { transformFuncs } from './constants'
+import { handleCreateServerFileRouteCallExpressionFactory } from './serverFileRoute'
+import { handleCreateIsomorphicFnCallExpression } from './isomorphicFn'
+import { handleCreateMiddlewareCallExpression } from './middleware'
+import { handleCreateServerFnCallExpression } from './serverFn'
+import {
+  handleCreateClientOnlyFnCallExpression,
+  handleCreateServerOnlyFnCallExpression,
+} from './envOnly'
 import type { GeneratorResult, ParseAstOptions } from '@tanstack/router-utils'
 
 export type CompileStartFrameworkOptions = 'react' | 'solid'
@@ -50,14 +57,14 @@ const getIdentifiers = (
     handleCallExpression: handleCreateMiddlewareCallExpression,
     paths: [],
   },
-  serverOnly: {
-    name: 'serverOnly',
-    handleCallExpression: handleServerOnlyCallExpression,
+  createServerOnlyFn: {
+    name: 'createServerOnlyFn',
+    handleCallExpression: handleCreateServerOnlyFnCallExpression,
     paths: [],
   },
-  clientOnly: {
-    name: 'clientOnly',
-    handleCallExpression: handleClientOnlyCallExpression,
+  createClientOnlyFn: {
+    name: 'createClientOnlyFn',
+    handleCallExpression: handleCreateClientOnlyFnCallExpression,
     paths: [],
   },
   createIsomorphicFn: {
@@ -131,6 +138,8 @@ export function compileStartOutputFactory(
                   return identifiers[identifierKey].paths.push(path)
                 }
 
+                // handle namespace imports like "import * as TanStackStart from '@tanstack/react-start';"
+                // which are then called like "TanStackStart.createServerFn()"
                 if (t.isMemberExpression(path.node.callee)) {
                   if (
                     t.isIdentifier(path.node.callee.object) &&
@@ -176,67 +185,6 @@ export function compileStartOutputFactory(
   }
 }
 
-function handleCreateServerFileRouteCallExpressionFactory(
-  framework: CompileStartFrameworkOptions,
-  method:
-    | 'createServerFileRoute'
-    | 'createServerRoute'
-    | 'createServerRootRoute',
-) {
-  return function handleCreateServerFileRouteCallExpression(
-    path: babel.NodePath<t.CallExpression>,
-    opts: CompileOptions,
-  ) {
-    const PACKAGES = { start: `@tanstack/${framework}-start/server` }
-
-    let highestParent: babel.NodePath<any> = path
-
-    while (highestParent.parentPath && !highestParent.parentPath.isProgram()) {
-      highestParent = highestParent.parentPath
-    }
-
-    const programPath = highestParent.parentPath as babel.NodePath<t.Program>
-
-    // If we're on the client, remove the entire variable
-    if (opts.env === 'client') {
-      highestParent.remove()
-      return
-    }
-
-    let isCreateServerFileRouteImported = false as boolean
-
-    programPath.traverse({
-      ImportDeclaration(importPath) {
-        const importSource = importPath.node.source.value
-        if (importSource === PACKAGES.start) {
-          const specifiers = importPath.node.specifiers
-          isCreateServerFileRouteImported ||= specifiers.some((specifier) => {
-            return (
-              t.isImportSpecifier(specifier) &&
-              t.isIdentifier(specifier.imported) &&
-              specifier.imported.name === method
-            )
-          })
-        }
-      },
-    })
-
-    if (!isCreateServerFileRouteImported) {
-      const importDeclaration = t.importDeclaration(
-        [t.importSpecifier(t.identifier(method), t.identifier(method))],
-        t.stringLiteral(PACKAGES.start),
-      )
-      programPath.node.body.unshift(importDeclaration)
-    }
-  }
-}
-
-// build these once and reuse them
-export const handleServerOnlyCallExpression =
-  buildEnvOnlyCallExpressionHandler('server')
-export const handleClientOnlyCallExpression =
-  buildEnvOnlyCallExpressionHandler('client')
-
 export type CompileOptions = ParseAstOptions & {
   env: 'server' | 'client'
   dce?: boolean
@@ -251,397 +199,3 @@ export type IdentifierConfig = {
   ) => void
   paths: Array<babel.NodePath>
 }
-
-export function handleCreateServerFnCallExpression(
-  path: babel.NodePath<t.CallExpression>,
-  opts: CompileOptions,
-) {
-  // The function is the 'fn' property of the object passed to createServerFn
-
-  // const firstArg = path.node.arguments[0]
-  // if (t.isObjectExpression(firstArg)) {
-  //   // Was called with some options
-  // }
-
-  // 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 = Object.keys(callExpressionPaths)
-
-  const rootCallExpression = getRootCallExpression(path)
-
-  // if (debug)
-  //   console.info(
-  //     'Handling createServerFn call expression:',
-  //     rootCallExpression.toString(),
-  //   )
-
-  // Check if the call is assigned to a variable
-  if (!rootCallExpression.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 keyof typeof callExpressionPaths
-
-        if (
-          validMethods.includes(name) &&
-          memberExpressionPath.parentPath.isCallExpression()
-        ) {
-          callExpressionPaths[name] = memberExpressionPath.parentPath
-        }
-      }
-    },
-  })
-
-  if (callExpressionPaths.validator) {
-    const innerInputExpression = callExpressionPaths.validator.node.arguments[0]
-
-    if (!innerInputExpression) {
-      throw new Error(
-        'createServerFn().validator() 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,
-      )
-    }
-  }
-
-  // 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>
-
-  if (!callExpressionPaths.handler || !handlerFnPath.node) {
-    throw codeFrameError(
-      opts.code,
-      path.node.callee.loc!,
-      `createServerFn must be called with a "handler" property!`,
-    )
-  }
-
-  const handlerFn = handlerFnPath.node
-
-  // So, the way we do this is we give the handler function a way
-  // to access the serverFn ctx on the server via function scope.
-  // The 'use server' extracted function will be called with the
-  // payload from the client, then use the scoped serverFn ctx
-  // to execute the handler function.
-  // This way, we can do things like data and middleware validation
-  // in the __execute function without having to AST transform the
-  // handler function too much itself.
-
-  // .handler((optsOut, ctx) => {
-  //   return ((optsIn) => {
-  //     'use server'
-  //     ctx.__execute(handlerFn, optsIn)
-  //   })(optsOut)
-  // })
-
-  // If the handler function is an identifier and we're on the client, we need to
-  // remove the bound function from the file.
-  // If we're on the server, you can leave it, since it will get referenced
-  // as a second argument.
-
-  if (t.isIdentifier(handlerFn)) {
-    if (opts.env === 'client') {
-      // Find the binding for the handler function
-      const binding = handlerFnPath.scope.getBinding(handlerFn.name)
-      // Remove it
-      if (binding) {
-        binding.path.remove()
-      }
-    }
-    // If the env is server, just leave it alone
-  }
-
-  handlerFnPath.replaceWith(
-    t.arrowFunctionExpression(
-      [t.identifier('opts'), t.identifier('signal')],
-      t.blockStatement(
-        // Everything in here is server-only, since the client
-        // will strip out anything in the 'use server' directive.
-        [
-          t.returnStatement(
-            t.callExpression(
-              t.identifier(`${existingVariableName}.__executeServer`),
-              [t.identifier('opts'), t.identifier('signal')],
-            ),
-          ),
-        ],
-        [t.directive(t.directiveLiteral('use server'))],
-      ),
-    ),
-  )
-
-  if (opts.env === 'server') {
-    callExpressionPaths.handler.node.arguments.push(handlerFn)
-  }
-}
-
-export function handleCreateMiddlewareCallExpression(
-  path: babel.NodePath<t.CallExpression>,
-  opts: CompileOptions,
-) {
-  const rootCallExpression = getRootCallExpression(path)
-
-  // if (debug)
-  //   console.info(
-  //     'Handling createMiddleware call expression:',
-  //     rootCallExpression.toString(),
-  //   )
-
-  const callExpressionPaths = {
-    middleware: null as babel.NodePath<t.CallExpression> | null,
-    validator: 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
-
-        if (
-          validMethods.includes(name) &&
-          memberExpressionPath.parentPath.isCallExpression()
-        ) {
-          callExpressionPaths[name] = memberExpressionPath.parentPath
-        }
-      }
-    },
-  })
-
-  if (callExpressionPaths.validator) {
-    const innerInputExpression = callExpressionPaths.validator.node.arguments[0]
-
-    if (!innerInputExpression) {
-      throw new Error(
-        'createMiddleware().validator() 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,
-        )
-      }
-    }
-  }
-
-  const serverFnPath = callExpressionPaths.server?.get(
-    'arguments.0',
-  ) as babel.NodePath<any>
-
-  if (
-    callExpressionPaths.server &&
-    serverFnPath.node &&
-    opts.env === 'client'
-  ) {
-    // If we're on the client, remove the server call expression
-    if (t.isMemberExpression(callExpressionPaths.server.node.callee)) {
-      callExpressionPaths.server.replaceWith(
-        callExpressionPaths.server.node.callee.object,
-      )
-    }
-  }
-}
-
-function buildEnvOnlyCallExpressionHandler(env: 'client' | 'server') {
-  return function envOnlyCallExpressionHandler(
-    path: babel.NodePath<t.CallExpression>,
-    opts: CompileOptions,
-  ) {
-    // if (debug)
-    //   console.info(`Handling ${env}Only call expression:`, path.toString())
-
-    const isEnvMatch =
-      env === 'client' ? opts.env === 'client' : opts.env === 'server'
-
-    if (isEnvMatch) {
-      // extract the inner function from the call expression
-      const innerInputExpression = path.node.arguments[0]
-
-      if (!t.isExpression(innerInputExpression)) {
-        throw new Error(
-          `${env}Only() functions must be called with a function!`,
-        )
-      }
-
-      path.replaceWith(innerInputExpression)
-      return
-    }
-
-    // If we're on the wrong environment, replace the call expression
-    // with a function that always throws an error.
-    path.replaceWith(
-      t.arrowFunctionExpression(
-        [],
-        t.blockStatement([
-          t.throwStatement(
-            t.newExpression(t.identifier('Error'), [
-              t.stringLiteral(
-                `${env}Only() functions can only be called on the ${env}!`,
-              ),
-            ]),
-          ),
-        ]),
-      ),
-    )
-  }
-}
-
-export function handleCreateIsomorphicFnCallExpression(
-  path: babel.NodePath<t.CallExpression>,
-  opts: CompileOptions,
-) {
-  const rootCallExpression = getRootCallExpression(path)
-
-  // if (debug)
-  //   console.info(
-  //     'Handling createIsomorphicFn call expression:',
-  //     rootCallExpression.toString(),
-  //   )
-
-  const callExpressionPaths = {
-    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
-
-        if (
-          validMethods.includes(name) &&
-          memberExpressionPath.parentPath.isCallExpression()
-        ) {
-          callExpressionPaths[name] = memberExpressionPath.parentPath
-        }
-      }
-    },
-  })
-
-  if (
-    validMethods.every(
-      (method) =>
-        !callExpressionPaths[method as keyof typeof callExpressionPaths],
-    )
-  ) {
-    const variableId = rootCallExpression.parentPath.isVariableDeclarator()
-      ? rootCallExpression.parentPath.node.id
-      : null
-    console.warn(
-      'createIsomorphicFn called without a client or server implementation!',
-      'This will result in a no-op function.',
-      'Variable name:',
-      t.isIdentifier(variableId) ? variableId.name : 'unknown',
-    )
-  }
-
-  const envCallExpression = callExpressionPaths[opts.env]
-
-  if (!envCallExpression) {
-    // if we don't have an implementation for this environment, default to a no-op
-    rootCallExpression.replaceWith(
-      t.arrowFunctionExpression([], t.blockStatement([])),
-    )
-    return
-  }
-
-  const innerInputExpression = envCallExpression.node.arguments[0]
-
-  if (!t.isExpression(innerInputExpression)) {
-    throw new Error(
-      `createIsomorphicFn().${opts.env}(func) must be called with a function!`,
-    )
-  }
-
-  rootCallExpression.replaceWith(innerInputExpression)
-}
-
-export function getRootCallExpression(path: babel.NodePath<t.CallExpression>) {
-  // Find the highest callExpression parent
-  let rootCallExpression: babel.NodePath<t.CallExpression> = path
-
-  // Traverse up the chain of CallExpressions
-  while (rootCallExpression.parentPath.isMemberExpression()) {
-    const parent = rootCallExpression.parentPath
-    if (parent.parentPath.isCallExpression()) {
-      rootCallExpression = parent.parentPath
-    }
-  }
-
-  return rootCallExpression
-}
-
-function codeFrameError(
-  code: string,
-  loc: {
-    start: { line: number; column: number }
-    end: { line: number; column: number }
-  },
-  message: string,
-) {
-  const frame = codeFrameColumns(
-    code,
-    {
-      start: loc.start,
-      end: loc.end,
-    },
-    {
-      highlightCode: true,
-      message,
-    },
-  )
-
-  return new Error(frame)
-}

package/src/start-compiler-plugin/constants.ts

@@ -1,8 +1,8 @@
 export const transformFuncs = [
   'createServerFn',
   'createMiddleware',
-  'serverOnly',
-  'clientOnly',
+  'createServerOnlyFn',
+  'createClientOnlyFn',
   'createIsomorphicFn',
   'createServerRoute',
   'createServerFileRoute',