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

package/dist/esm/start-router-plugin/plugin.js.map

@@ -1 +1 @@
-{"version":3,"file":"plugin.js","sources":["../../../src/start-router-plugin/plugin.ts"],"sourcesContent":["/*\nwhat is this plugin doing, especially compared to one already existing in the @tanstack/router-plugin package?\n\nit configures:\n1. the generator to generate both the render-route-tree as well as the server-route-tree\n2. the code-splitter plugin, so it could possibly be enabled per environment (e.g. disable on the server)\n3. the auto import plugin for both environments\n4. the route tree client plugin, which removes the server part from the generated route tree\n5. the virtual route tree plugin, which provides the route tree to the server\n*/\n\nimport {\n  tanStackRouterCodeSplitter,\n  tanstackRouterAutoImport,\n  tanstackRouterGenerator,\n} from '@tanstack/router-plugin/vite'\nimport { VITE_ENVIRONMENT_NAMES } from '../constants'\nimport { routeTreeClientPlugin } from './route-tree-client-plugin'\nimport { virtualRouteTreePlugin } from './virtual-route-tree-plugin'\nimport { routesManifestPlugin } from './generator-plugins/routes-manifest-plugin'\nimport { serverRoutesPlugin } from './generator-plugins/server-routes-plugin'\nimport type { PluginOption } from 'vite'\nimport type { Config } from '@tanstack/router-plugin'\n\nexport function tanStackStartRouter(config: Config): Array<PluginOption> {\n  return [\n    tanstackRouterGenerator({\n      ...config,\n      plugins: [serverRoutesPlugin(), routesManifestPlugin()],\n      plugin: {\n        vite: { environmentName: VITE_ENVIRONMENT_NAMES.client },\n      },\n    }),\n    tanStackRouterCodeSplitter({\n      ...config,\n      codeSplittingOptions: {\n        ...config.codeSplittingOptions,\n        deleteNodes: ['ssr'],\n        addHmr: true,\n      },\n      plugin: {\n        vite: { environmentName: VITE_ENVIRONMENT_NAMES.client },\n      },\n    }),\n    tanStackRouterCodeSplitter({\n      ...config,\n      codeSplittingOptions: {\n        ...config.codeSplittingOptions,\n        addHmr: false,\n      },\n      plugin: {\n        vite: { environmentName: VITE_ENVIRONMENT_NAMES.server },\n      },\n    }),\n    tanstackRouterAutoImport(config),\n    routeTreeClientPlugin(config),\n    virtualRouteTreePlugin(config),\n  ]\n}\n"],"names":[],"mappings":";;;;;;AAwBO,SAAS,oBAAoB,QAAqC;AACvE,SAAO;AAAA,IACL,wBAAwB;AAAA,MACtB,GAAG;AAAA,MACH,SAAS,CAAC,sBAAsB,sBAAsB;AAAA,MACtD,QAAQ;AAAA,QACN,MAAM,EAAE,iBAAiB,uBAAuB,OAAA;AAAA,MAAO;AAAA,IACzD,CACD;AAAA,IACD,2BAA2B;AAAA,MACzB,GAAG;AAAA,MACH,sBAAsB;AAAA,QACpB,GAAG,OAAO;AAAA,QACV,aAAa,CAAC,KAAK;AAAA,QACnB,QAAQ;AAAA,MAAA;AAAA,MAEV,QAAQ;AAAA,QACN,MAAM,EAAE,iBAAiB,uBAAuB,OAAA;AAAA,MAAO;AAAA,IACzD,CACD;AAAA,IACD,2BAA2B;AAAA,MACzB,GAAG;AAAA,MACH,sBAAsB;AAAA,QACpB,GAAG,OAAO;AAAA,QACV,QAAQ;AAAA,MAAA;AAAA,MAEV,QAAQ;AAAA,QACN,MAAM,EAAE,iBAAiB,uBAAuB,OAAA;AAAA,MAAO;AAAA,IACzD,CACD;AAAA,IACD,yBAAyB,MAAM;AAAA,IAC/B,sBAAsB,MAAM;AAAA,IAC5B,uBAAuB,MAAM;AAAA,EAAA;AAEjC;"}
+{"version":3,"file":"plugin.js","sources":["../../../src/start-router-plugin/plugin.ts"],"sourcesContent":["import {\n  tanStackRouterCodeSplitter,\n  tanstackRouterAutoImport,\n  tanstackRouterGenerator,\n} from '@tanstack/router-plugin/vite'\nimport { normalizePath } from 'vite'\nimport path from 'pathe'\nimport { VITE_ENVIRONMENT_NAMES } from '../constants'\nimport { routesManifestPlugin } from './generator-plugins/routes-manifest-plugin'\nimport { pruneServerOnlySubtrees } from './pruneServerOnlySubtrees'\nimport { SERVER_PROP } from './constants'\nimport type {\n  Generator,\n  GeneratorPlugin,\n  RouteNode,\n} from '@tanstack/router-generator'\nimport type { DevEnvironment, Plugin, PluginOption } from 'vite'\nimport type { TanStackStartInputConfig } from '../schema'\nimport type { GetConfigFn, TanStackStartVitePluginCoreOptions } from '../plugin'\n\nfunction isServerOnlyNode(node: RouteNode | undefined) {\n  if (!node?.createFileRouteProps) {\n    return false\n  }\n  return (\n    node.createFileRouteProps.has(SERVER_PROP) &&\n    node.createFileRouteProps.size === 1\n  )\n}\n\nfunction moduleDeclaration({\n  startFilePath,\n  routerFilePath,\n  corePluginOpts,\n  generatedRouteTreePath,\n}: {\n  startFilePath: string | undefined\n  routerFilePath: string\n  corePluginOpts: TanStackStartVitePluginCoreOptions\n  generatedRouteTreePath: string\n}): string {\n  function getImportPath(absolutePath: string) {\n    let relativePath = path.relative(\n      path.dirname(generatedRouteTreePath),\n      absolutePath,\n    )\n\n    if (!relativePath.startsWith('.')) {\n      relativePath = './' + relativePath\n    }\n\n    // convert to POSIX-style for ESM imports (important on Windows)\n    relativePath = relativePath.split(path.sep).join('/')\n    return relativePath\n  }\n\n  const result: Array<string> = [\n    `import type { getRouter } from '${getImportPath(routerFilePath)}'`,\n  ]\n  if (startFilePath) {\n    result.push(\n      `import type { startInstance } from '${getImportPath(startFilePath)}'`,\n    )\n  }\n  // make sure we import something from start to get the server route declaration merge\n  else {\n    result.push(\n      `import type { createStart } from '@tanstack/${corePluginOpts.framework}-start'`,\n    )\n  }\n  result.push(\n    `declare module '@tanstack/${corePluginOpts.framework}-start' {\n  interface Register {\n    router: Awaited<ReturnType<typeof getRouter>>`,\n  )\n  if (startFilePath) {\n    result.push(\n      `    config: Awaited<ReturnType<typeof startInstance.getOptions>>`,\n    )\n  }\n  result.push(`  }\n}`)\n\n  return result.join('\\n')\n}\n\nexport function tanStackStartRouter(\n  startPluginOpts: TanStackStartInputConfig,\n  getConfig: GetConfigFn,\n  corePluginOpts: TanStackStartVitePluginCoreOptions,\n): Array<PluginOption> {\n  const getGeneratedRouteTreePath = () => {\n    const { startConfig } = getConfig()\n    return path.resolve(startConfig.router.generatedRouteTree)\n  }\n\n  let clientEnvironment: DevEnvironment | null = null\n  function invalidate() {\n    if (!clientEnvironment) {\n      return\n    }\n\n    const mod = clientEnvironment.moduleGraph.getModuleById(\n      getGeneratedRouteTreePath(),\n    )\n    if (mod) {\n      clientEnvironment.moduleGraph.invalidateModule(mod)\n    }\n    clientEnvironment.hot.send({ type: 'full-reload', path: '*' })\n  }\n\n  let generatorInstance: Generator | null = null\n\n  const clientTreeGeneratorPlugin: GeneratorPlugin = {\n    name: 'start-client-tree-plugin',\n    init({ generator }) {\n      generatorInstance = generator\n    },\n    afterTransform({ node, prevNode }) {\n      if (isServerOnlyNode(node) !== isServerOnlyNode(prevNode)) {\n        invalidate()\n      }\n    },\n  }\n\n  let routeTreeFileFooter: Array<string> | null = null\n\n  function getRouteTreeFileFooter() {\n    if (routeTreeFileFooter) {\n      return routeTreeFileFooter\n    }\n    const { startConfig, resolvedStartConfig } = getConfig()\n    const ogRouteTreeFileFooter = startConfig.router.routeTreeFileFooter\n    if (ogRouteTreeFileFooter) {\n      if (Array.isArray(ogRouteTreeFileFooter)) {\n        routeTreeFileFooter = ogRouteTreeFileFooter\n      } else {\n        routeTreeFileFooter = ogRouteTreeFileFooter()\n      }\n    }\n    routeTreeFileFooter = [\n      moduleDeclaration({\n        generatedRouteTreePath: getGeneratedRouteTreePath(),\n        corePluginOpts,\n        startFilePath: resolvedStartConfig.startFilePath,\n        routerFilePath: resolvedStartConfig.routerFilePath,\n      }),\n      ...(routeTreeFileFooter ?? []),\n    ]\n    return routeTreeFileFooter\n  }\n\n  let resolvedGeneratedRouteTreePath: string | null = null\n  const clientTreePlugin: Plugin = {\n    name: 'tanstack-start:route-tree-client-plugin',\n    enforce: 'pre',\n    applyToEnvironment: (env) => env.name === VITE_ENVIRONMENT_NAMES.client,\n    configureServer(server) {\n      clientEnvironment = server.environments[VITE_ENVIRONMENT_NAMES.client]\n    },\n    config() {\n      type LoadObjectHook = Extract<\n        typeof clientTreePlugin.load,\n        { filter?: unknown }\n      >\n      resolvedGeneratedRouteTreePath = normalizePath(\n        getGeneratedRouteTreePath(),\n      )\n      ;(clientTreePlugin.load as LoadObjectHook).filter = {\n        id: { include: new RegExp(resolvedGeneratedRouteTreePath) },\n      }\n    },\n\n    load: {\n      filter: {\n        // this will be set in the config hook above since it relies on `config` hook being called first\n      },\n      async handler() {\n        if (!generatorInstance) {\n          throw new Error('Generator instance not initialized')\n        }\n        const crawlingResult = await generatorInstance.getCrawlingResult()\n        if (!crawlingResult) {\n          throw new Error('Crawling result not available')\n        }\n        const prunedAcc = pruneServerOnlySubtrees(crawlingResult)\n        const acc = {\n          ...crawlingResult.acc,\n          ...prunedAcc,\n        }\n        const buildResult = generatorInstance.buildRouteTree({\n          ...crawlingResult,\n          acc,\n          config: {\n            // importRoutesUsingAbsolutePaths: true,\n            // addExtensions: true,\n            disableTypes: true,\n            enableRouteTreeFormatting: false,\n            routeTreeFileHeader: [],\n            routeTreeFileFooter: [],\n          },\n        })\n        return { code: buildResult.routeTreeContent, map: null }\n      },\n    },\n  }\n  return [\n    clientTreePlugin,\n    tanstackRouterGenerator(() => {\n      const routerConfig = getConfig().startConfig.router\n      return {\n        ...routerConfig,\n        target: corePluginOpts.framework,\n        routeTreeFileFooter: getRouteTreeFileFooter,\n        plugins: [clientTreeGeneratorPlugin, routesManifestPlugin()],\n      }\n    }),\n    tanStackRouterCodeSplitter(() => {\n      const routerConfig = getConfig().startConfig.router\n      return {\n        ...routerConfig,\n        codeSplittingOptions: {\n          ...routerConfig.codeSplittingOptions,\n          deleteNodes: ['ssr', 'server'],\n          addHmr: true,\n        },\n        plugin: {\n          vite: { environmentName: VITE_ENVIRONMENT_NAMES.client },\n        },\n      }\n    }),\n    tanStackRouterCodeSplitter(() => {\n      const routerConfig = getConfig().startConfig.router\n      return {\n        ...routerConfig,\n        codeSplittingOptions: {\n          ...routerConfig.codeSplittingOptions,\n          addHmr: false,\n        },\n        plugin: {\n          vite: { environmentName: VITE_ENVIRONMENT_NAMES.server },\n        },\n      }\n    }),\n    tanstackRouterAutoImport(startPluginOpts?.router),\n  ]\n}\n"],"names":[],"mappings":"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"}

package/dist/esm/start-router-plugin/pruneServerOnlySubtrees.d.ts

@@ -0,0 +1,8 @@
+import { HandleNodeAccumulator, RouteNode } from '@tanstack/router-generator';
+export declare function pruneServerOnlySubtrees({ rootRouteNode, acc, }: {
+    rootRouteNode: RouteNode;
+    acc: HandleNodeAccumulator;
+}): {
+    routeTree: RouteNode[];
+    routeNodes: RouteNode[];
+};

package/dist/esm/start-router-plugin/pruneServerOnlySubtrees.js

@@ -0,0 +1,34 @@
+import { SERVER_PROP } from "./constants.js";
+function pruneServerOnlySubtrees({
+  rootRouteNode,
+  acc
+}) {
+  const routeNodes = [];
+  const routeTree = prune({ ...rootRouteNode, children: acc.routeTree }, routeNodes)?.children || [];
+  routeNodes.pop();
+  return {
+    routeTree,
+    routeNodes
+  };
+}
+function prune(node, collectedRouteNodes) {
+  const newChildren = [];
+  let allChildrenServerOnly = true;
+  for (const child of node.children || []) {
+    const newChild = prune(child, collectedRouteNodes);
+    if (newChild) {
+      newChildren.push(newChild);
+      allChildrenServerOnly = false;
+    }
+  }
+  const allServerOnly = node.createFileRouteProps?.has(SERVER_PROP) && node.createFileRouteProps.size === 1 && allChildrenServerOnly;
+  if (allServerOnly) {
+    return null;
+  }
+  collectedRouteNodes.push(node);
+  return { ...node, children: newChildren };
+}
+export {
+  pruneServerOnlySubtrees
+};
+//# sourceMappingURL=pruneServerOnlySubtrees.js.map

package/dist/esm/start-router-plugin/pruneServerOnlySubtrees.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pruneServerOnlySubtrees.js","sources":["../../../src/start-router-plugin/pruneServerOnlySubtrees.ts"],"sourcesContent":["import { SERVER_PROP } from './constants'\nimport type {\n  HandleNodeAccumulator,\n  RouteNode,\n} from '@tanstack/router-generator'\n\nexport function pruneServerOnlySubtrees({\n  rootRouteNode,\n  acc,\n}: {\n  rootRouteNode: RouteNode\n  acc: HandleNodeAccumulator\n}) {\n  const routeNodes: Array<RouteNode> = []\n  const routeTree =\n    prune({ ...rootRouteNode, children: acc.routeTree }, routeNodes)\n      ?.children || []\n  // remove root node from routeNodes\n  routeNodes.pop()\n  return {\n    routeTree,\n    routeNodes,\n  }\n}\nfunction prune(\n  node: RouteNode,\n  collectedRouteNodes: Array<RouteNode>,\n): RouteNode | null {\n  const newChildren: Array<RouteNode> = []\n  let allChildrenServerOnly = true\n\n  for (const child of node.children || []) {\n    const newChild = prune(child, collectedRouteNodes)\n    if (newChild) {\n      newChildren.push(newChild)\n      // at least one child survived pruning\n      allChildrenServerOnly = false\n    }\n  }\n\n  const allServerOnly =\n    node.createFileRouteProps?.has(SERVER_PROP) &&\n    node.createFileRouteProps.size === 1 &&\n    allChildrenServerOnly\n  // prune this subtree\n  if (allServerOnly) {\n    return null\n  }\n  collectedRouteNodes.push(node)\n  return { ...node, children: newChildren }\n}\n"],"names":[],"mappings":";AAMO,SAAS,wBAAwB;AAAA,EACtC;AAAA,EACA;AACF,GAGG;AACD,QAAM,aAA+B,CAAA;AACrC,QAAM,YACJ,MAAM,EAAE,GAAG,eAAe,UAAU,IAAI,UAAA,GAAa,UAAU,GAC3D,YAAY,CAAA;AAElB,aAAW,IAAA;AACX,SAAO;AAAA,IACL;AAAA,IACA;AAAA,EAAA;AAEJ;AACA,SAAS,MACP,MACA,qBACkB;AAClB,QAAM,cAAgC,CAAA;AACtC,MAAI,wBAAwB;AAE5B,aAAW,SAAS,KAAK,YAAY,CAAA,GAAI;AACvC,UAAM,WAAW,MAAM,OAAO,mBAAmB;AACjD,QAAI,UAAU;AACZ,kBAAY,KAAK,QAAQ;AAEzB,8BAAwB;AAAA,IAC1B;AAAA,EACF;AAEA,QAAM,gBACJ,KAAK,sBAAsB,IAAI,WAAW,KAC1C,KAAK,qBAAqB,SAAS,KACnC;AAEF,MAAI,eAAe;AACjB,WAAO;AAAA,EACT;AACA,sBAAoB,KAAK,IAAI;AAC7B,SAAO,EAAE,GAAG,MAAM,UAAU,YAAA;AAC9B;"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tanstack/start-plugin-core",
-  "version": "1.132.0-alpha.8",
+  "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.8",
-    "@tanstack/router-utils": "1.132.0-alpha.1",
-    "@tanstack/router-plugin": "1.132.0-alpha.8",
-    "@tanstack/server-functions-plugin": "1.132.0-alpha.3",
-    "@tanstack/start-server-core": "1.132.0-alpha.8"
+    "@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

@@ -0,0 +1,498 @@
+/* eslint-disable import/no-commonjs */
+import * as t from '@babel/types'
+import { generateFromAst, parseAst } from '@tanstack/router-utils'
+import babel from '@babel/core'
+import {
+  deadCodeElimination,
+  findReferencedIdentifiers,
+} from 'babel-dead-code-elimination'
+import { handleCreateServerFn } from './handleCreateServerFn'
+import { handleCreateMiddleware } from './handleCreateMiddleware'
+
+type Binding =
+  | {
+      type: 'import'
+      source: string
+      importedName: string
+      resolvedKind?: Kind
+    }
+  | {
+      type: 'var'
+      init: t.Expression | null
+      resolvedKind?: Kind
+    }
+
+type ExportEntry =
+  | { tag: 'Normal'; name: string }
+  | { tag: 'Default'; name: string }
+  | { tag: 'Namespace'; name: string; targetId: string } // for `export * as ns from './x'`
+
+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
+  ast: ReturnType<typeof parseAst>
+  bindings: Map<string, Binding>
+  exports: Map<string, ExportEntry>
+}
+
+export class ServerFnCompiler {
+  private moduleCache = new Map<string, ModuleInfo>()
+  private initialized = false
+  constructor(
+    private options: {
+      env: 'client' | 'server'
+      lookupConfigurations: Array<LookupConfig>
+      loadModule: (id: string) => Promise<void>
+      resolveId: (id: string, importer?: string) => Promise<string | null>
+    },
+  ) {}
+
+  private async init(id: string) {
+    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
+  }
+
+  public ingestModule({ code, id }: { code: string; id: string }) {
+    const ast = parseAst({ code })
+
+    const bindings = new Map<string, Binding>()
+    const exports = new Map<string, ExportEntry>()
+
+    // we are only interested in top-level bindings, hence we don't traverse the AST
+    // instead we only iterate over the program body
+    for (const node of ast.program.body) {
+      if (t.isImportDeclaration(node)) {
+        const source = node.source.value
+        for (const s of node.specifiers) {
+          if (t.isImportSpecifier(s)) {
+            const importedName = t.isIdentifier(s.imported)
+              ? s.imported.name
+              : s.imported.value
+            bindings.set(s.local.name, { type: 'import', source, importedName })
+          } else if (t.isImportDefaultSpecifier(s)) {
+            bindings.set(s.local.name, {
+              type: 'import',
+              source,
+              importedName: 'default',
+            })
+          } else if (t.isImportNamespaceSpecifier(s)) {
+            bindings.set(s.local.name, {
+              type: 'import',
+              source,
+              importedName: '*',
+            })
+          }
+        }
+      } else if (t.isVariableDeclaration(node)) {
+        for (const decl of node.declarations) {
+          if (t.isIdentifier(decl.id)) {
+            bindings.set(decl.id.name, {
+              type: 'var',
+              init: decl.init ?? null,
+            })
+          }
+        }
+      } else if (t.isExportNamedDeclaration(node)) {
+        // export const foo = ...
+        if (node.declaration) {
+          if (t.isVariableDeclaration(node.declaration)) {
+            for (const d of node.declaration.declarations) {
+              if (t.isIdentifier(d.id)) {
+                exports.set(d.id.name, { tag: 'Normal', name: d.id.name })
+                bindings.set(d.id.name, { type: 'var', init: d.init ?? null })
+              }
+            }
+          }
+        }
+        for (const sp of node.specifiers) {
+          if (t.isExportNamespaceSpecifier(sp)) {
+            exports.set(sp.exported.name, {
+              tag: 'Namespace',
+              name: sp.exported.name,
+              targetId: node.source?.value || '',
+            })
+          }
+          // export { local as exported }
+          else if (t.isExportSpecifier(sp)) {
+            const local = sp.local.name
+            const exported = t.isIdentifier(sp.exported)
+              ? sp.exported.name
+              : sp.exported.value
+            exports.set(exported, { tag: 'Normal', name: local })
+          }
+        }
+      } else if (t.isExportDefaultDeclaration(node)) {
+        const d = node.declaration
+        if (t.isIdentifier(d)) {
+          exports.set('default', { tag: 'Default', name: d.name })
+        } else {
+          const synth = '__default_export__'
+          bindings.set(synth, { type: 'var', init: d as t.Expression })
+          exports.set('default', { tag: 'Default', name: synth })
+        }
+      }
+    }
+
+    const info: ModuleInfo = { code, id, ast, bindings, exports }
+    this.moduleCache.set(id, info)
+    return info
+  }
+
+  public invalidateModule(id: string) {
+    return this.moduleCache.delete(id)
+  }
+
+  public async compile({ code, id }: { code: string; id: string }) {
+    if (!this.initialized) {
+      await this.init(id)
+    }
+    const { bindings, ast } = this.ingestModule({ code, id })
+    const candidates = this.collectCandidates(bindings)
+    if (candidates.length === 0) {
+      // 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<{
+      callExpression: t.CallExpression
+      kind: LookupKind
+    }> = []
+    for (const handler of candidates) {
+      const kind = await this.resolveExprKind(handler, id)
+      if (validLookupKinds.includes(kind as LookupKind)) {
+        toRewrite.push({ callExpression: handler, kind: kind as LookupKind })
+      }
+    }
+    if (toRewrite.length === 0) {
+      return null
+    }
+
+    const pathsToRewrite: Array<{
+      nodePath: babel.NodePath<t.CallExpression>
+      kind: LookupKind
+    }> = []
+    babel.traverse(ast, {
+      CallExpression(path) {
+        const found = toRewrite.findIndex((h) => path.node === h.callExpression)
+        if (found !== -1) {
+          pathsToRewrite.push({ nodePath: path, kind: toRewrite[found]!.kind })
+          // delete from toRewrite
+          toRewrite.splice(found, 1)
+        }
+      },
+    })
+
+    if (toRewrite.length > 0) {
+      throw new Error(
+        `Internal error: could not find all paths to rewrite. please file an issue`,
+      )
+    }
+
+    const refIdents = findReferencedIdentifiers(ast)
+
+    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)
+
+    return generateFromAst(ast, {
+      sourceMaps: true,
+      sourceFileName: id,
+      filename: id,
+    })
+  }
+
+  // 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 = isCandidateCallExpression(binding.init)
+        if (handler) {
+          candidates.push(handler)
+        }
+      }
+    }
+    return candidates
+  }
+
+  private async resolveIdentifierKind(
+    ident: string,
+    id: string,
+    visited = new Set<string>(),
+  ): Promise<Kind> {
+    const info = await this.getModuleInfo(id)
+
+    const binding = info.bindings.get(ident)
+    if (!binding) {
+      return 'None'
+    }
+    if (binding.resolvedKind) {
+      return binding.resolvedKind
+    }
+
+    // TODO improve cycle detection? should we throw here instead of returning 'None'?
+    // prevent cycles
+    const vKey = `${id}:${ident}`
+    if (visited.has(vKey)) {
+      return 'None'
+    }
+    visited.add(vKey)
+
+    const resolvedKind = await this.resolveBindingKind(binding, id, visited)
+    binding.resolvedKind = resolvedKind
+    return resolvedKind
+  }
+
+  private async resolveBindingKind(
+    binding: Binding,
+    fileId: string,
+    visited = new Set<string>(),
+  ): Promise<Kind> {
+    if (binding.resolvedKind) {
+      return binding.resolvedKind
+    }
+    if (binding.type === 'import') {
+      const target = await this.options.resolveId(binding.source, fileId)
+      if (!target) {
+        return 'None'
+      }
+
+      const importedModule = await this.getModuleInfo(target)
+
+      const moduleExport = importedModule.exports.get(binding.importedName)
+      if (!moduleExport) {
+        return 'None'
+      }
+      const importedBinding = importedModule.bindings.get(moduleExport.name)
+      if (!importedBinding) {
+        return 'None'
+      }
+      if (importedBinding.resolvedKind) {
+        return importedBinding.resolvedKind
+      }
+
+      const resolvedKind = await this.resolveBindingKind(
+        importedBinding,
+        importedModule.id,
+        visited,
+      )
+      importedBinding.resolvedKind = resolvedKind
+      return resolvedKind
+    }
+
+    const resolvedKind = await this.resolveExprKind(
+      binding.init,
+      fileId,
+      visited,
+    )
+    binding.resolvedKind = resolvedKind
+    return resolvedKind
+  }
+
+  private async resolveExprKind(
+    expr: t.Expression | null,
+    fileId: string,
+    visited = new Set<string>(),
+  ): Promise<Kind> {
+    if (!expr) {
+      return 'None'
+    }
+
+    let result: Kind = 'None'
+
+    if (t.isCallExpression(expr)) {
+      if (!t.isExpression(expr.callee)) {
+        return 'None'
+      }
+      const calleeKind = await this.resolveCalleeKind(
+        expr.callee,
+        fileId,
+        visited,
+      )
+      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)
+    }
+
+    if (result === 'None' && t.isIdentifier(expr)) {
+      result = await this.resolveIdentifierKind(expr.name, fileId, visited)
+    }
+
+    if (result === 'None' && t.isTSAsExpression(expr)) {
+      result = await this.resolveExprKind(expr.expression, fileId, visited)
+    }
+    if (result === 'None' && t.isTSNonNullExpression(expr)) {
+      result = await this.resolveExprKind(expr.expression, fileId, visited)
+    }
+    if (result === 'None' && t.isParenthesizedExpression(expr)) {
+      result = await this.resolveExprKind(expr.expression, fileId, visited)
+    }
+
+    return result
+  }
+
+  private async resolveCalleeKind(
+    callee: t.Expression,
+    fileId: string,
+    visited = new Set<string>(),
+  ): Promise<Kind> {
+    if (t.isIdentifier(callee)) {
+      return this.resolveIdentifierKind(callee.name, fileId, visited)
+    }
+
+    if (t.isMemberExpression(callee) && t.isIdentifier(callee.property)) {
+      const prop = callee.property.name
+
+      if (prop === 'handler') {
+        const base = await this.resolveExprKind(callee.object, fileId, visited)
+        if (base === 'Root' || base === 'Builder') {
+          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)) {
+        const info = await this.getModuleInfo(fileId)
+        const binding = info.bindings.get(callee.object.name)
+        if (
+          binding &&
+          binding.type === 'import' &&
+          binding.importedName === '*'
+        ) {
+          // resolve the property from the target module
+          const targetModuleId = await this.options.resolveId(
+            binding.source,
+            fileId,
+          )
+          if (targetModuleId) {
+            const targetModule = await this.getModuleInfo(targetModuleId)
+            const exportEntry = targetModule.exports.get(callee.property.name)
+            if (exportEntry) {
+              const exportedBinding = targetModule.bindings.get(
+                exportEntry.name,
+              )
+              if (exportedBinding) {
+                return await this.resolveBindingKind(
+                  exportedBinding,
+                  targetModule.id,
+                  visited,
+                )
+              }
+            }
+          } else {
+            return 'None'
+          }
+        }
+      }
+      return this.resolveExprKind(callee.object, fileId, visited)
+    }
+
+    // handle nested expressions
+    return this.resolveExprKind(callee, fileId, visited)
+  }
+
+  private async getModuleInfo(id: string) {
+    let cached = this.moduleCache.get(id)
+    if (cached) {
+      return cached
+    }
+
+    await this.options.loadModule(id)
+
+    cached = this.moduleCache.get(id)
+    if (!cached) {
+      throw new Error(`could not load module info for ${id}`)
+    }
+    return cached
+  }
+}
+
+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)) {
+    return undefined
+  }
+  if (!candidateCallIdentifier.includes(callee.property.name)) {
+    return undefined
+  }
+
+  return node
+}

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,
         )
       }
     }