@tanstack/start-plugin-core 1.132.0-alpha.2 → 1.132.0-alpha.20

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

@@ -0,0 +1,58 @@
+import * as t from '@babel/types'
+import type * as babel from '@babel/core'
+
+import type { CompileOptions } from './compilers'
+
+function capitalize(str: string) {
+  if (!str) return ''
+  return str.charAt(0).toUpperCase() + str.slice(1).toLowerCase()
+}
+
+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(
+                `create${capitalize(env)}OnlyFn() functions can only be called on the ${env}!`,
+              ),
+            ]),
+          ),
+        ]),
+      ),
+    )
+  }
+}
+
+export const handleCreateServerOnlyFnCallExpression =
+  buildEnvOnlyCallExpressionHandler('server')
+export const handleCreateClientOnlyFnCallExpression =
+  buildEnvOnlyCallExpressionHandler('client')

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

@@ -0,0 +1,78 @@
+import * as t from '@babel/types'
+import { getRootCallExpression } from './utils'
+import type * as babel from '@babel/core'
+
+import type { CompileOptions } from './compilers'
+
+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)
+}

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

@@ -0,0 +1,79 @@
+import * as t from '@babel/types'
+import { getRootCallExpression } from './utils'
+import type * as babel from '@babel/core'
+
+import type { CompileOptions } from './compilers'
+
+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,
+      )
+    }
+  }
+}

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

@@ -0,0 +1,122 @@
+import { fileURLToPath, pathToFileURL } from 'node:url'
+import { createRequire } from 'node:module'
+import { logDiff } from '@tanstack/router-utils'
+
+import { VIRTUAL_MODULES } from '@tanstack/start-server-core'
+import { normalizePath } from 'vite'
+import path from 'pathe'
+import { VITE_ENVIRONMENT_NAMES } from '../constants'
+import { compileStartOutputFactory } from './compilers'
+import { transformFuncs } from './constants'
+import type { ViteEnvironmentNames } from '../constants'
+import type { Plugin } from 'vite'
+import type { CompileStartFrameworkOptions } from './compilers'
+
+const debug =
+  process.env.TSR_VITE_DEBUG &&
+  ['true', 'start-plugin'].includes(process.env.TSR_VITE_DEBUG)
+
+export type TanStackStartViteOptions = {
+  globalMiddlewareEntry: string
+}
+
+const tokenRegex = new RegExp(transformFuncs.join('|'))
+
+const require = createRequire(import.meta.url)
+
+function resolveRuntimeFiles(opts: { package: string; files: Array<string> }) {
+  const pkgRoot = resolvePackage(opts.package)
+  const basePath = path.join(pkgRoot, 'dist', 'esm')
+
+  return opts.files.map((file) => normalizePath(path.join(basePath, file)))
+}
+
+function resolvePackage(packageName: string): string {
+  const pkgRoot = path.dirname(require.resolve(packageName + '/package.json'))
+  return pkgRoot
+}
+
+export function startCompilerPlugin(
+  framework: CompileStartFrameworkOptions,
+): Plugin {
+  const compileStartOutput = compileStartOutputFactory(framework)
+
+  return {
+    name: 'tanstack-start-core:compiler',
+    enforce: 'pre',
+    applyToEnvironment(env) {
+      return [
+        VITE_ENVIRONMENT_NAMES.client,
+        VITE_ENVIRONMENT_NAMES.server,
+      ].includes(env.name as ViteEnvironmentNames)
+    },
+    transform: {
+      filter: {
+        code: tokenRegex,
+        id: {
+          exclude: [
+            VIRTUAL_MODULES.serverFnManifest,
+            // N.B. the following files either just re-export or provide the runtime implementation of those functions
+            // we do not want to include them in the transformation
+            // however, those packages (especially start-client-core ATM) also USE these functions
+            // (namely `createIsomorphicFn` in `packages/start-client-core/src/getRouterInstance.ts`) and thus need to be transformed
+            ...resolveRuntimeFiles({
+              package: '@tanstack/start-client-core',
+              files: [
+                'index.js',
+                'createIsomorphicFn.js',
+                'envOnly.js',
+                'createServerFn.js',
+                'createMiddleware.js',
+                'serverFnFetcher.js',
+              ],
+            }),
+            ...resolveRuntimeFiles({
+              package: '@tanstack/start-server-core',
+              files: [
+                'index.js',
+                'server-functions-handler.js',
+                'serverRoute.js',
+              ],
+            }),
+            ...resolveRuntimeFiles({
+              package: `@tanstack/${framework}-start-client`,
+              files: ['index.js'],
+            }),
+          ],
+        },
+      },
+      handler(code, id) {
+        const env =
+          this.environment.name === VITE_ENVIRONMENT_NAMES.client
+            ? 'client'
+            : this.environment.name === VITE_ENVIRONMENT_NAMES.server
+              ? 'server'
+              : (() => {
+                  throw new Error(
+                    `Environment ${this.environment.name} not configured`,
+                  )
+                })()
+
+        const url = pathToFileURL(id)
+        url.searchParams.delete('v')
+        id = fileURLToPath(url).replace(/\\/g, '/')
+
+        if (debug) console.info(`${env} Compiling Start: `, id)
+
+        const compiled = compileStartOutput({
+          code,
+          filename: id,
+          env,
+        })
+
+        if (debug) {
+          logDiff(code, compiled.code)
+          console.log('Output:\n', compiled.code + '\n\n')
+        }
+
+        return compiled
+      },
+    },
+  }
+}

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

@@ -0,0 +1,59 @@
+import * as t from '@babel/types'
+import type * as babel from '@babel/core'
+
+import type { CompileOptions, CompileStartFrameworkOptions } from './compilers'
+
+export 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)
+    }
+  }
+}

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

@@ -0,0 +1,41 @@
+import { codeFrameColumns } from '@babel/code-frame'
+import type * as t from '@babel/types'
+import type * as babel from '@babel/core'
+
+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
+}
+
+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)
+}

package/dist/esm/compilers.d.ts

@@ -1,21 +0,0 @@
-import { GeneratorResult, ParseAstOptions } from '@tanstack/router-utils';
-import * as babel from '@babel/core';
-import * as t from '@babel/types';
-export type CompileStartFrameworkOptions = 'react' | 'solid';
-export declare function compileStartOutputFactory(framework: CompileStartFrameworkOptions): (opts: CompileOptions) => GeneratorResult;
-export declare const handleServerOnlyCallExpression: (path: babel.NodePath<t.CallExpression>, opts: CompileOptions) => void;
-export declare const handleClientOnlyCallExpression: (path: babel.NodePath<t.CallExpression>, opts: CompileOptions) => void;
-export type CompileOptions = ParseAstOptions & {
-    env: 'server' | 'client';
-    dce?: boolean;
-    filename: string;
-};
-export type IdentifierConfig = {
-    name: string;
-    handleCallExpression: (path: babel.NodePath<t.CallExpression>, opts: CompileOptions) => void;
-    paths: Array<babel.NodePath>;
-};
-export declare function handleCreateServerFnCallExpression(path: babel.NodePath<t.CallExpression>, opts: CompileOptions): void;
-export declare function handleCreateMiddlewareCallExpression(path: babel.NodePath<t.CallExpression>, opts: CompileOptions): void;
-export declare function handleCreateIsomorphicFnCallExpression(path: babel.NodePath<t.CallExpression>, opts: CompileOptions): void;
-export declare function getRootCallExpression(path: babel.NodePath<t.CallExpression>): babel.NodePath<t.CallExpression>;