@tanstack/start-server-core 1.121.0-alpha.22 → 1.121.0-alpha.26

package/src/index.tsx

@@ -18,5 +18,14 @@ export { handleServerAction } from './server-functions-handler'
 
 export * from './h3'
 
-export { createServerRoute, createServerFileRoute } from './serverRoute'
-export type { CreateServerFileRoute, FileRoutesByPath } from './serverRoute'
+export {
+  createServerRoute,
+  createServerFileRoute,
+  createServerRootRoute,
+} from './serverRoute'
+export type {
+  CreateServerFileRoute,
+  ServerFileRoutesByPath,
+} from './serverRoute'
+
+export * from './virtual-modules'

package/src/loadVirtualModule.ts

@@ -0,0 +1,21 @@
+import { VIRTUAL_MODULES } from './virtual-modules'
+import type { VirtualModules } from './virtual-modules'
+
+/**
+ * we need to explicitly enumerate all imports with string literals,
+ * otherwise vite will not pick them up during build
+ */
+export async function loadVirtualModule<TId extends keyof VirtualModules>(
+  id: TId,
+): Promise<VirtualModules[TId]> {
+  switch (id) {
+    case VIRTUAL_MODULES.routeTree:
+      return (await import('tanstack-start-route-tree:v')) as any
+    case VIRTUAL_MODULES.startManifest:
+      return (await import('tanstack-start-manifest:v')) as any
+    case VIRTUAL_MODULES.serverFnManifest:
+      return (await import('tanstack-start-server-fn-manifest:v')) as any
+    default:
+      throw new Error(`Unknown virtual module: ${id}`)
+  }
+}

package/src/router-manifest.ts

@@ -1,9 +1,6 @@
 import { joinPaths, rootRouteId } from '@tanstack/router-core'
-
-declare global {
-  // eslint-disable-next-line no-var
-  var TSS_INJECTED_HEAD_SCRIPTS: string | undefined
-}
+import { VIRTUAL_MODULES } from './virtual-modules'
+import { loadVirtualModule } from './loadVirtualModule'
 
 /**
  * @description Returns the router manifest that should be sent to the client.
@@ -12,7 +9,9 @@ declare global {
  * between routes or any other data that is not needed for the client.
  */
 export async function getStartManifest(opts: { basePath: string }) {
-  const { tsrStartManifest } = await import('tanstack-start-router-manifest:v')
+  const { tsrStartManifest } = await loadVirtualModule(
+    VIRTUAL_MODULES.startManifest,
+  )
   const startManifest = tsrStartManifest()
 
   const rootRoute = (startManifest.routes[rootRouteId] =

package/src/server-functions-handler.ts

@@ -2,6 +2,8 @@ import { isNotFound } from '@tanstack/router-core'
 import invariant from 'tiny-invariant'
 import { startSerializer } from '@tanstack/start-client-core'
 import { getEvent, getResponseStatus } from './h3'
+import { VIRTUAL_MODULES } from './virtual-modules'
+import { loadVirtualModule } from './loadVirtualModule'
 
 function sanitizeBase(base: string | undefined) {
   if (!base) {
@@ -42,19 +44,9 @@ export const handleServerAction = async ({ request }: { request: Request }) => {
     throw new Error('Invalid server action param for serverFnId: ' + serverFnId)
   }
 
-  const { default: serverFnManifest } = (await import(
-    // @ts-expect-error
-    'tanstack-start-server-fn-manifest:v'
-  )) as {
-    default: Record<
-      string,
-      {
-        functionName: string
-        extractedFilename: string
-        importer: () => Promise<any>
-      }
-    >
-  }
+  const { default: serverFnManifest } = await loadVirtualModule(
+    VIRTUAL_MODULES.serverFnManifest,
+  )
 
   const serverFnInfo = serverFnManifest[serverFnId]
 

package/src/serverRoute.ts

@@ -13,21 +13,22 @@ import type {
 } from '@tanstack/start-client-core'
 
 export function createServerFileRoute<
-  TFilePath extends keyof FileRoutesByPath,
+  TFilePath extends keyof ServerFileRoutesByPath,
   TParentRoute extends
-    AnyServerRouteWithTypes = FileRoutesByPath[TFilePath]['parentRoute'],
-  TId extends RouteConstraints['TId'] = FileRoutesByPath[TFilePath]['id'],
-  TPath extends RouteConstraints['TPath'] = FileRoutesByPath[TFilePath]['path'],
+    AnyServerRouteWithTypes = ServerFileRoutesByPath[TFilePath]['parentRoute'],
+  TId extends RouteConstraints['TId'] = ServerFileRoutesByPath[TFilePath]['id'],
+  TPath extends
+    RouteConstraints['TPath'] = ServerFileRoutesByPath[TFilePath]['path'],
   TFullPath extends
-    RouteConstraints['TFullPath'] = FileRoutesByPath[TFilePath]['fullPath'],
-  TChildren = FileRoutesByPath[TFilePath]['children'],
+    RouteConstraints['TFullPath'] = ServerFileRoutesByPath[TFilePath]['fullPath'],
+  TChildren = ServerFileRoutesByPath[TFilePath]['children'],
 >(_: TFilePath): ServerRoute<TParentRoute, TId, TPath, TFullPath, TChildren> {
   return createServerRoute<TParentRoute, TId, TPath, TFullPath, TChildren>(
     undefined,
   )
 }
 
-export interface FileRoutesByPath {}
+export interface ServerFileRoutesByPath {}
 
 export interface ServerRouteOptions<
   TParentRoute extends AnyServerRouteWithTypes,
@@ -181,6 +182,10 @@ export function createServerRoute<
   return route
 }
 
+// TODO this needs to be restricted to only allow middleware, no methods
+// TODO we also need to restrict pathless server routes to only allow middleware
+export const createServerRootRoute = createServerRoute
+
 export type ServerRouteAddFileChildrenFn<
   in out TParentRoute extends AnyServerRouteWithTypes,
   in out TId extends RouteConstraints['TId'],

package/src/tanstack-start.d.ts

@@ -1,5 +1,18 @@
-declare module 'tanstack-start-router-manifest:v' {
+declare module 'tanstack-start-manifest:v' {
   import type { Manifest } from '@tanstack/router-core'
 
   export const tsrStartManifest: () => Manifest
 }
+
+declare module 'tanstack-start-route-tree:v' {
+  import type { AnyServerRoute } from '@tanstack/start-server-core'
+
+  export const serverRouteTree: AnyServerRoute | undefined
+}
+
+declare module 'tanstack-start-server-fn-manifest:v' {
+  import type { DirectiveFn } from '@tanstack/directive-functions-plugin'
+
+  const serverFnManifest: Record<string, DirectiveFn>
+  export default serverFnManifest
+}

package/src/virtual-modules.ts

@@ -0,0 +1,13 @@
+/* eslint-disable @typescript-eslint/consistent-type-imports */
+
+export const VIRTUAL_MODULES = {
+  routeTree: 'tanstack-start-route-tree:v',
+  startManifest: 'tanstack-start-manifest:v',
+  serverFnManifest: 'tanstack-start-server-fn-manifest:v',
+} as const
+
+export type VirtualModules = {
+  [VIRTUAL_MODULES.routeTree]: typeof import('tanstack-start-route-tree:v')
+  [VIRTUAL_MODULES.startManifest]: typeof import('tanstack-start-manifest:v')
+  [VIRTUAL_MODULES.serverFnManifest]: typeof import('tanstack-start-server-fn-manifest:v')
+}