@tanstack/start-plugin-core 1.143.3 → 1.143.5

package/dist/esm/create-server-fn-plugin/types.d.ts

@@ -1,30 +0,0 @@
-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;
-/**
- * Information about a candidate that needs to be rewritten.
- */
-export interface RewriteCandidate {
-    path: babel.NodePath<t.CallExpression>;
-    methodChain: MethodChainPaths;
-}

package/dist/esm/create-server-fn-plugin/utils.d.ts

@@ -1,10 +0,0 @@
-export declare function codeFrameError(code: string, loc: {
-    start: {
-        line: number;
-        column: number;
-    };
-    end: {
-        line: number;
-        column: number;
-    };
-}, message: string): Error;

package/dist/esm/create-server-fn-plugin/utils.js

@@ -1,19 +0,0 @@
-import { codeFrameColumns } from "@babel/code-frame";
-function codeFrameError(code, loc, message) {
-  const frame = codeFrameColumns(
-    code,
-    {
-      start: loc.start,
-      end: loc.end
-    },
-    {
-      highlightCode: true,
-      message
-    }
-  );
-  return new Error(frame);
-}
-export {
-  codeFrameError
-};
-//# sourceMappingURL=utils.js.map

package/dist/esm/create-server-fn-plugin/utils.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"utils.js","sources":["../../../src/create-server-fn-plugin/utils.ts"],"sourcesContent":["import { codeFrameColumns } from '@babel/code-frame'\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":";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/src/create-server-fn-plugin/handleCreateIsomorphicFn.ts

@@ -1,46 +0,0 @@
-import * as t from '@babel/types'
-import type { RewriteCandidate } from './types'
-
-export function handleCreateIsomorphicFn(
-  candidate: RewriteCandidate,
-  opts: { env: 'client' | 'server' },
-) {
-  const { path, methodChain } = candidate
-
-  // Get the environment-specific call (.client() or .server())
-  const envCallInfo =
-    opts.env === 'client' ? methodChain.client : methodChain.server
-
-  // Check if we have any implementation at all
-  if (!methodChain.client && !methodChain.server) {
-    // No implementations provided - warn and replace with no-op
-    const variableId = path.parentPath.isVariableDeclarator()
-      ? path.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',
-    )
-    path.replaceWith(t.arrowFunctionExpression([], t.blockStatement([])))
-    return
-  }
-
-  if (!envCallInfo) {
-    // No implementation for this environment - replace with no-op
-    path.replaceWith(t.arrowFunctionExpression([], t.blockStatement([])))
-    return
-  }
-
-  // Extract the function argument from the environment-specific call
-  const innerFn = envCallInfo.firstArgPath?.node
-
-  if (!t.isExpression(innerFn)) {
-    throw new Error(
-      `createIsomorphicFn().${opts.env}(func) must be called with a function!`,
-    )
-  }
-
-  path.replaceWith(innerFn)
-}

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

@@ -1,45 +0,0 @@
-import * as t from '@babel/types'
-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(
-  candidate: RewriteCandidate,
-  opts: {
-    env: 'client' | 'server'
-  },
-) {
-  if (opts.env === 'server') {
-    throw new Error('handleCreateMiddleware should not be called on the server')
-  }
-
-  const { inputValidator, server } = candidate.methodChain
-
-  if (inputValidator) {
-    const innerInputExpression = inputValidator.callPath.node.arguments[0]
-
-    if (!innerInputExpression) {
-      throw new Error(
-        'createMiddleware().inputValidator() must be called with a validator!',
-      )
-    }
-
-    // remove the validator call expression
-    if (t.isMemberExpression(inputValidator.callPath.node.callee)) {
-      inputValidator.callPath.replaceWith(
-        inputValidator.callPath.node.callee.object,
-      )
-    }
-  }
-
-  if (server) {
-    // remove the server call expression
-    if (t.isMemberExpression(server.callPath.node.callee)) {
-      server.callPath.replaceWith(server.callPath.node.callee.object)
-    }
-  }
-}

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

@@ -1,145 +0,0 @@
-import * as t from '@babel/types'
-import { codeFrameError } from './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(
-  candidate: RewriteCandidate,
-  opts: {
-    env: 'client' | 'server'
-    code: string
-    directive: string
-    /**
-     * Whether this file is a provider file (extracted server function file).
-     * Only provider files should have the handler implementation as a second argument.
-     */
-    isProviderFile: boolean
-  },
-) {
-  const { path, methodChain } = candidate
-  const { inputValidator, handler } = methodChain
-
-  // Check if the call is assigned to a variable
-  if (!path.parentPath.isVariableDeclarator()) {
-    throw new Error('createServerFn must be assigned to a variable!')
-  }
-
-  // Get the identifier name of the variable
-  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 (inputValidator) {
-    const innerInputExpression = inputValidator.callPath.node.arguments[0]
-
-    if (!innerInputExpression) {
-      throw new Error(
-        '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(inputValidator.callPath.node.callee)) {
-        inputValidator.callPath.replaceWith(
-          inputValidator.callPath.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 = handler?.firstArgPath
-
-  if (!handler || !handlerFnPath?.node) {
-    throw codeFrameError(
-      opts.code,
-      path.node.callee.loc!,
-      `createServerFn must be called with a "handler" property!`,
-    )
-  }
-
-  // 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
-  // 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(opts.directive))],
-      ),
-    ),
-  )
-
-  // Add the serverFn as a second argument on the server side,
-  // but ONLY for provider files (extracted server function files).
-  // 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) {
-    handler.callPath.node.arguments.push(handlerFn)
-  }
-}

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

@@ -1,45 +0,0 @@
-import * as t from '@babel/types'
-import type { RewriteCandidate } from './types'
-import type { LookupKind } from './compiler'
-
-function capitalize(str: string) {
-  if (!str) return ''
-  return str.charAt(0).toUpperCase() + str.slice(1).toLowerCase()
-}
-
-export function handleEnvOnlyFn(
-  candidate: RewriteCandidate,
-  opts: { env: 'client' | 'server'; kind: LookupKind },
-) {
-  const { path } = candidate
-  const targetEnv = opts.kind === 'ClientOnlyFn' ? 'client' : 'server'
-
-  if (opts.env === targetEnv) {
-    // Matching environment - extract the inner function
-    const innerFn = path.node.arguments[0]
-
-    if (!t.isExpression(innerFn)) {
-      throw new Error(
-        `create${capitalize(targetEnv)}OnlyFn() must be called with a function!`,
-      )
-    }
-
-    path.replaceWith(innerFn)
-  } else {
-    // Wrong environment - replace with a function that throws an error
-    path.replaceWith(
-      t.arrowFunctionExpression(
-        [],
-        t.blockStatement([
-          t.throwStatement(
-            t.newExpression(t.identifier('Error'), [
-              t.stringLiteral(
-                `create${capitalize(targetEnv)}OnlyFn() functions can only be called on the ${targetEnv}!`,
-              ),
-            ]),
-          ),
-        ]),
-      ),
-    )
-  }
-}

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

@@ -1,234 +0,0 @@
-import { TRANSFORM_ID_REGEX } from '../constants'
-import {
-  KindDetectionPatterns,
-  LookupKindsPerEnv,
-  ServerFnCompiler,
-  detectKindsInCode,
-} from './compiler'
-import type { CompileStartFrameworkOptions } from '../types'
-import type { LookupConfig, LookupKind } from './compiler'
-import type { PluginOption } from 'vite'
-
-function cleanId(id: string): string {
-  // Remove null byte prefix used by Vite/Rollup for virtual modules
-  if (id.startsWith('\0')) {
-    id = id.slice(1)
-  }
-  const queryIndex = id.indexOf('?')
-  return queryIndex === -1 ? id : id.substring(0, queryIndex)
-}
-
-// Derive transform code filter from KindDetectionPatterns (single source of truth)
-function getTransformCodeFilterForEnv(env: 'client' | 'server'): Array<RegExp> {
-  const validKinds = LookupKindsPerEnv[env]
-  const patterns: Array<RegExp> = []
-  for (const [kind, pattern] of Object.entries(KindDetectionPatterns) as Array<
-    [LookupKind, RegExp]
-  >) {
-    if (validKinds.has(kind)) {
-      patterns.push(pattern)
-    }
-  }
-  return patterns
-}
-
-const getLookupConfigurationsForEnv = (
-  env: 'client' | 'server',
-  framework: CompileStartFrameworkOptions,
-): Array<LookupConfig> => {
-  // Common configs for all environments
-  const commonConfigs: Array<LookupConfig> = [
-    {
-      libName: `@tanstack/${framework}-start`,
-      rootExport: 'createServerFn',
-      kind: 'Root',
-    },
-    {
-      libName: `@tanstack/${framework}-start`,
-      rootExport: 'createIsomorphicFn',
-      kind: 'IsomorphicFn',
-    },
-    {
-      libName: `@tanstack/${framework}-start`,
-      rootExport: 'createServerOnlyFn',
-      kind: 'ServerOnlyFn',
-    },
-    {
-      libName: `@tanstack/${framework}-start`,
-      rootExport: 'createClientOnlyFn',
-      kind: 'ClientOnlyFn',
-    },
-  ]
-
-  if (env === 'client') {
-    return [
-      {
-        libName: `@tanstack/${framework}-start`,
-        rootExport: 'createMiddleware',
-        kind: 'Root',
-      },
-      {
-        libName: `@tanstack/${framework}-start`,
-        rootExport: 'createStart',
-        kind: 'Root',
-      },
-      ...commonConfigs,
-    ]
-  } else {
-    // Server-only: add ClientOnly JSX component lookup
-    return [
-      ...commonConfigs,
-      {
-        libName: `@tanstack/${framework}-router`,
-        rootExport: 'ClientOnly',
-        kind: 'ClientOnlyJSX',
-      },
-    ]
-  }
-}
-const SERVER_FN_LOOKUP = 'server-fn-module-lookup'
-
-function buildDirectiveSplitParam(directive: string) {
-  return `tsr-directive-${directive.replace(/[^a-zA-Z0-9]/g, '-')}`
-}
-
-export function createServerFnPlugin(opts: {
-  framework: CompileStartFrameworkOptions
-  directive: string
-  environments: Array<{ name: string; type: 'client' | 'server' }>
-}): PluginOption {
-  const compilers: Record<string /* envName */, ServerFnCompiler> = {}
-  const directiveSplitParam = buildDirectiveSplitParam(opts.directive)
-
-  function perEnvServerFnPlugin(environment: {
-    name: string
-    type: 'client' | 'server'
-  }): PluginOption {
-    // Derive transform code filter from KindDetectionPatterns (single source of truth)
-    const transformCodeFilter = getTransformCodeFilterForEnv(environment.type)
-
-    return {
-      name: `tanstack-start-core::server-fn:${environment.name}`,
-      enforce: 'pre',
-      applyToEnvironment(env) {
-        return env.name === environment.name
-      },
-      transform: {
-        filter: {
-          id: {
-            exclude: new RegExp(`${SERVER_FN_LOOKUP}$`),
-            include: TRANSFORM_ID_REGEX,
-          },
-          code: {
-            include: transformCodeFilter,
-          },
-        },
-        async handler(code, id) {
-          let compiler = compilers[this.environment.name]
-          if (!compiler) {
-            // Default to 'dev' mode for unknown environments (conservative: no caching)
-            const mode =
-              this.environment.mode === 'build' ? 'build' : ('dev' as const)
-            compiler = new ServerFnCompiler({
-              env: environment.type,
-              directive: opts.directive,
-              lookupKinds: LookupKindsPerEnv[environment.type],
-              lookupConfigurations: getLookupConfigurationsForEnv(
-                environment.type,
-                opts.framework,
-              ),
-              mode,
-              loadModule: async (id: string) => {
-                if (this.environment.mode === 'build') {
-                  const loaded = await this.load({ id })
-                  // Handle modules with no runtime code (e.g., type-only exports).
-                  // After TypeScript compilation, these become empty modules.
-                  // Create an empty module info instead of throwing.
-                  const code = loaded.code ?? ''
-                  compiler!.ingestModule({ code, id })
-                } else if (this.environment.mode === 'dev') {
-                  /**
-                   * in dev, vite does not return code from `ctx.load()`
-                   * so instead, we need to take a different approach
-                   * we must force vite to load the module and run it through the vite plugin pipeline
-                   * we can do this by using the `fetchModule` method
-                   * the `captureServerFnModuleLookupPlugin` captures the module code via its transform hook and invokes analyzeModuleAST
-                   */
-                  await this.environment.fetchModule(
-                    id + '?' + SERVER_FN_LOOKUP,
-                  )
-                } else {
-                  throw new Error(
-                    `could not load module ${id}: unknown environment mode ${this.environment.mode}`,
-                  )
-                }
-              },
-              resolveId: async (source: string, importer?: string) => {
-                const r = await this.resolve(source, importer)
-                if (r) {
-                  if (!r.external) {
-                    return cleanId(r.id)
-                  }
-                }
-                return null
-              },
-            })
-            compilers[this.environment.name] = compiler
-          }
-
-          const isProviderFile = id.includes(directiveSplitParam)
-
-          // Detect which kinds are present in this file before parsing
-          const detectedKinds = detectKindsInCode(code, environment.type)
-
-          id = cleanId(id)
-          const result = await compiler.compile({
-            id,
-            code,
-            isProviderFile,
-            detectedKinds,
-          })
-          return result
-        },
-      },
-
-      hotUpdate(ctx) {
-        const compiler = compilers[this.environment.name]
-
-        ctx.modules.forEach((m) => {
-          if (m.id) {
-            const deleted = compiler?.invalidateModule(m.id)
-            if (deleted) {
-              m.importers.forEach((importer) => {
-                if (importer.id) {
-                  compiler?.invalidateModule(importer.id)
-                }
-              })
-            }
-          }
-        })
-      },
-    }
-  }
-
-  return [
-    ...opts.environments.map(perEnvServerFnPlugin),
-    {
-      name: 'tanstack-start-core:capture-server-fn-module-lookup',
-      // we only need this plugin in dev mode
-      apply: 'serve',
-      applyToEnvironment(env) {
-        return !!opts.environments.find((e) => e.name === env.name)
-      },
-      transform: {
-        filter: {
-          id: new RegExp(`${SERVER_FN_LOOKUP}$`),
-        },
-        handler(code, id) {
-          const compiler = compilers[this.environment.name]
-          compiler?.ingestModule({ code, id: cleanId(id) })
-        },
-      },
-    },
-  ]
-}

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

@@ -1,34 +0,0 @@
-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
-
-/**
- * Information about a candidate that needs to be rewritten.
- */
-export interface RewriteCandidate {
-  path: babel.NodePath<t.CallExpression>
-  methodChain: MethodChainPaths
-}

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

@@ -1,24 +0,0 @@
-import { codeFrameColumns } from '@babel/code-frame'
-
-export 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)
-}