@tanstack/start-client-core 1.132.0-alpha.1 → 1.132.0-alpha.11

package/src/createServerFn.ts

@@ -1,29 +1,26 @@
 import { isNotFound, isRedirect } from '@tanstack/router-core'
 import { mergeHeaders } from '@tanstack/router-core/ssr/client'
-import { getStartContext } from '@tanstack/start-storage-context'
 import { globalMiddleware } from './registerGlobalMiddleware'
 
-import { startSerializer } from './serializer'
-
-import { createIsomorphicFn } from './createIsomorphicFn'
-import type {
-  SerializerParse,
-  SerializerStringify,
-  SerializerStringifyBy,
-} from './serializer'
+import { getRouterInstance } from './getRouterInstance'
+import { TSS_SERVER_FUNCTION_FACTORY } from './constants'
 import type {
   AnyRouter,
   AnyValidator,
   Constrain,
   Expand,
+  Register,
+  RegisteredSerializableInput,
   ResolveValidatorInput,
+  ValidateSerializable,
+  ValidateSerializableInput,
+  ValidateSerializableInputResult,
   Validator,
 } from '@tanstack/router-core'
 import type { JsonResponse } from '@tanstack/router-core/ssr/client'
-import type { Readable } from 'node:stream'
 import type {
   AnyFunctionMiddleware,
-  AssignAllClientSendContext,
+  AnyRequestMiddleware,
   AssignAllServerContext,
   FunctionMiddlewareClientFnResult,
   FunctionMiddlewareServerFnResult,
@@ -33,32 +30,27 @@ import type {
 
 type TODO = any
 
-const getRouterInstance = createIsomorphicFn()
-  .client(() => window.__TSR_ROUTER__!)
-  .server(() => getStartContext({ throwIfNotFound: false })?.router)
-
 export function createServerFn<
+  TRegister extends Register,
   TMethod extends Method,
-  TServerFnResponseType extends ServerFnResponseType = 'data',
   TResponse = unknown,
   TMiddlewares = undefined,
   TValidator = undefined,
 >(
   options?: {
     method?: TMethod
-    response?: TServerFnResponseType
   },
   __opts?: ServerFnBaseOptions<
+    TRegister,
     TMethod,
-    TServerFnResponseType,
     TResponse,
     TMiddlewares,
     TValidator
   >,
-): ServerFnBuilder<TMethod, TServerFnResponseType> {
+): ServerFnBuilder<TRegister, TMethod> {
   const resolvedOptions = (__opts || options || {}) as ServerFnBaseOptions<
+    TRegister,
     TMethod,
-    ServerFnResponseType,
     TResponse,
     TMiddlewares,
     TValidator
@@ -68,52 +60,63 @@ export function createServerFn<
     resolvedOptions.method = 'GET' as TMethod
   }
 
-  return {
+  const res: ServerFnBuilder<TRegister, TMethod> = {
     options: resolvedOptions as any,
     middleware: (middleware) => {
-      return createServerFn<
+      // multiple calls to `middleware()` merge the middlewares with the previously supplied ones
+      // this is primarily useful for letting users create their own abstractions on top of `createServerFn`
+
+      const newMiddleware = [...(resolvedOptions.middleware || [])]
+      middleware.map((m) => {
+        if (TSS_SERVER_FUNCTION_FACTORY in m) {
+          if (m.options.middleware) {
+            newMiddleware.push(...m.options.middleware)
+          }
+        } else {
+          newMiddleware.push(m)
+        }
+      })
+
+      const newOptions = {
+        ...resolvedOptions,
+        middleware: newMiddleware,
+      }
+      const res = createServerFn<
+        TRegister,
         TMethod,
-        ServerFnResponseType,
         TResponse,
         TMiddlewares,
         TValidator
-      >(undefined, Object.assign(resolvedOptions, { middleware })) as any
+      >(undefined, newOptions) as any
+      res[TSS_SERVER_FUNCTION_FACTORY] = true
+      return res
     },
     validator: (validator) => {
+      const newOptions = { ...resolvedOptions, validator: validator as any }
       return createServerFn<
+        TRegister,
         TMethod,
-        ServerFnResponseType,
         TResponse,
         TMiddlewares,
         TValidator
-      >(undefined, Object.assign(resolvedOptions, { validator })) as any
+      >(undefined, newOptions) as any
     },
     handler: (...args) => {
       // This function signature changes due to AST transformations
       // in the babel plugin. We need to cast it to the correct
       // function signature post-transformation
       const [extractedFn, serverFn] = args as unknown as [
-        CompiledFetcherFn<TResponse, TServerFnResponseType>,
-        ServerFn<
-          TMethod,
-          TServerFnResponseType,
-          TMiddlewares,
-          TValidator,
-          TResponse
-        >,
+        CompiledFetcherFn<TRegister, TResponse>,
+        ServerFn<TRegister, TMethod, TMiddlewares, TValidator, TResponse>,
       ]
 
       // Keep the original function around so we can use it
       // in the server environment
-      Object.assign(resolvedOptions, {
-        ...extractedFn,
-        extractedFn,
-        serverFn,
-      })
+      const newOptions = { ...resolvedOptions, extractedFn, serverFn }
 
       const resolvedMiddleware = [
-        ...(resolvedOptions.middleware || []),
-        serverFnBaseToMiddleware(resolvedOptions),
+        ...(newOptions.middleware || []),
+        serverFnBaseToMiddleware(newOptions),
       ]
 
       // We want to make sure the new function has the same
@@ -124,16 +127,13 @@ export function createServerFn<
           // Start by executing the client-side middleware chain
           return executeMiddleware(resolvedMiddleware, 'client', {
             ...extractedFn,
-            ...resolvedOptions,
+            ...newOptions,
             data: opts?.data as any,
             headers: opts?.headers,
             signal: opts?.signal,
             context: {},
             router: getRouterInstance(),
           }).then((d) => {
-            if (resolvedOptions.response === 'full') {
-              return d
-            }
             if (d.error) throw d.error
             return d.result
           })
@@ -143,10 +143,7 @@ export function createServerFn<
           ...extractedFn,
           // The extracted function on the server-side calls
           // this function
-          __executeServer: async (opts_: any, signal: AbortSignal) => {
-            const opts =
-              opts_ instanceof FormData ? extractFormDataContext(opts_) : opts_
-
+          __executeServer: async (opts: any, signal: AbortSignal) => {
             const ctx = {
               ...extractedFn,
               ...opts,
@@ -166,10 +163,20 @@ export function createServerFn<
       ) as any
     },
   }
+  const fun = (options?: { method?: TMethod }) => {
+    return {
+      ...res,
+      options: {
+        ...res.options,
+        ...options,
+      },
+    }
+  }
+  return Object.assign(fun, res)
 }
 
 export async function executeMiddleware(
-  middlewares: Array<AnyFunctionMiddleware>,
+  middlewares: Array<AnyFunctionMiddleware | AnyRequestMiddleware>,
   env: 'client' | 'server',
   opts: ServerFnMiddlewareOptions,
 ): Promise<ServerFnMiddlewareResult> {
@@ -188,15 +195,16 @@ export async function executeMiddleware(
     }
 
     if (
+      'validator' in nextMiddleware.options &&
       nextMiddleware.options.validator &&
-      (env === 'client' ? nextMiddleware.options.validateClient : true)
+      env === 'server'
     ) {
       // Execute the middleware's input function
       ctx.data = await execValidator(nextMiddleware.options.validator, ctx.data)
     }
 
     const middlewareFn = (
-      env === 'client'
+      env === 'client' && 'client' in nextMiddleware.options
         ? nextMiddleware.options.client
         : nextMiddleware.options.server
     ) as MiddlewareFn | undefined
@@ -232,7 +240,6 @@ export async function executeMiddleware(
 export type CompiledFetcherFnOptions = {
   method: Method
   data: unknown
-  response?: ServerFnResponseType
   headers?: HeadersInit
   signal?: AbortSignal
   context?: any
@@ -240,30 +247,19 @@ export type CompiledFetcherFnOptions = {
 }
 
 export type Fetcher<
+  TRegister extends Register,
   TMiddlewares,
   TValidator,
   TResponse,
-  TServerFnResponseType extends ServerFnResponseType,
 > =
   undefined extends IntersectAllValidatorInputs<TMiddlewares, TValidator>
-    ? OptionalFetcher<
-        TMiddlewares,
-        TValidator,
-        TResponse,
-        TServerFnResponseType
-      >
-    : RequiredFetcher<
-        TMiddlewares,
-        TValidator,
-        TResponse,
-        TServerFnResponseType
-      >
+    ? OptionalFetcher<TRegister, TMiddlewares, TValidator, TResponse>
+    : RequiredFetcher<TRegister, TMiddlewares, TValidator, TResponse>
 
 export interface FetcherBase {
   url: string
   __executeServer: (opts: {
     method: Method
-    response?: ServerFnResponseType
     data: unknown
     headers?: HeadersInit
     context?: any
@@ -271,36 +267,26 @@ export interface FetcherBase {
   }) => Promise<unknown>
 }
 
-export type FetchResult<
-  TMiddlewares,
-  TResponse,
-  TServerFnResponseType extends ServerFnResponseType,
-> = TServerFnResponseType extends 'raw'
-  ? Promise<Response>
-  : TServerFnResponseType extends 'full'
-    ? Promise<FullFetcherData<TMiddlewares, TResponse>>
-    : Promise<FetcherData<TResponse>>
-
 export interface OptionalFetcher<
+  TRegister extends Register,
   TMiddlewares,
   TValidator,
   TResponse,
-  TServerFnResponseType extends ServerFnResponseType,
 > extends FetcherBase {
   (
     options?: OptionalFetcherDataOptions<TMiddlewares, TValidator>,
-  ): FetchResult<TMiddlewares, TResponse, TServerFnResponseType>
+  ): Promise<FetcherData<TRegister, TResponse>>
 }
 
 export interface RequiredFetcher<
+  TRegister extends Register,
   TMiddlewares,
   TValidator,
   TResponse,
-  TServerFnResponseType extends ServerFnResponseType,
 > extends FetcherBase {
   (
     opts: RequiredFetcherDataOptions<TMiddlewares, TValidator>,
-  ): FetchResult<TMiddlewares, TResponse, TServerFnResponseType>
+  ): Promise<FetcherData<TRegister, TResponse>>
 }
 
 export type FetcherBaseOptions = {
@@ -318,240 +304,220 @@ export interface RequiredFetcherDataOptions<TMiddlewares, TValidator>
   data: Expand<IntersectAllValidatorInputs<TMiddlewares, TValidator>>
 }
 
-export interface FullFetcherData<TMiddlewares, TResponse> {
-  error: unknown
-  result: FetcherData<TResponse>
-  context: AssignAllClientSendContext<TMiddlewares>
-}
-
-export type FetcherData<TResponse> =
-  TResponse extends JsonResponse<any>
-    ? SerializerParse<ReturnType<TResponse['json']>>
-    : SerializerParse<TResponse>
+export type FetcherData<
+  TRegister extends Register,
+  TResponse,
+> = TResponse extends Response
+  ? Response
+  : TResponse extends JsonResponse<any>
+    ? ValidateSerializableInputResult<TRegister, ReturnType<TResponse['json']>>
+    : ValidateSerializableInputResult<TRegister, TResponse>
 
 export type RscStream<T> = {
   __cacheState: T
 }
 
 export type Method = 'GET' | 'POST'
-export type ServerFnResponseType = 'data' | 'full' | 'raw'
 
-// see https://h3.unjs.io/guide/event-handler#responses-types
-export type RawResponse = Response | ReadableStream | Readable | null | string
-
-export type ServerFnReturnType<
-  TServerFnResponseType extends ServerFnResponseType,
-  TResponse,
-> = TServerFnResponseType extends 'raw'
-  ? RawResponse | Promise<RawResponse>
-  : Promise<SerializerStringify<TResponse>> | SerializerStringify<TResponse>
+export type ServerFnReturnType<TRegister extends Register, TResponse> =
+  | Response
+  | Promise<ValidateSerializableInput<TRegister, TResponse>>
+  | ValidateSerializableInput<TRegister, TResponse>
 
 export type ServerFn<
+  TRegister extends Register,
   TMethod,
-  TServerFnResponseType extends ServerFnResponseType,
   TMiddlewares,
   TValidator,
   TResponse,
 > = (
-  ctx: ServerFnCtx<TMethod, TServerFnResponseType, TMiddlewares, TValidator>,
-) => ServerFnReturnType<TServerFnResponseType, TResponse>
+  ctx: ServerFnCtx<TMethod, TMiddlewares, TValidator>,
+) => ServerFnReturnType<TRegister, TResponse>
 
-export interface ServerFnCtx<
-  TMethod,
-  TServerFnResponseType extends ServerFnResponseType,
-  TMiddlewares,
-  TValidator,
-> {
+export interface ServerFnCtx<TMethod, TMiddlewares, TValidator> {
   method: TMethod
-  response: TServerFnResponseType
   data: Expand<IntersectAllValidatorOutputs<TMiddlewares, TValidator>>
   context: Expand<AssignAllServerContext<TMiddlewares>>
   signal: AbortSignal
 }
 
-export type CompiledFetcherFn<
-  TResponse,
-  TServerFnResponseType extends ServerFnResponseType,
-> = {
+export type CompiledFetcherFn<TRegister extends Register, TResponse> = {
   (
-    opts: CompiledFetcherFnOptions &
-      ServerFnBaseOptions<Method, TServerFnResponseType>,
+    opts: CompiledFetcherFnOptions & ServerFnBaseOptions<TRegister, Method>,
   ): Promise<TResponse>
   url: string
 }
 
 export type ServerFnBaseOptions<
+  TRegister extends Register,
   TMethod extends Method = 'GET',
-  TServerFnResponseType extends ServerFnResponseType = 'data',
   TResponse = unknown,
   TMiddlewares = unknown,
   TInput = unknown,
 > = {
   method: TMethod
-  response?: TServerFnResponseType
-  validateClient?: boolean
-  middleware?: Constrain<TMiddlewares, ReadonlyArray<AnyFunctionMiddleware>>
-  validator?: ConstrainValidator<TInput>
-  extractedFn?: CompiledFetcherFn<TResponse, TServerFnResponseType>
-  serverFn?: ServerFn<
-    TMethod,
-    TServerFnResponseType,
+  middleware?: Constrain<
     TMiddlewares,
-    TInput,
-    TResponse
+    ReadonlyArray<AnyFunctionMiddleware | AnyRequestMiddleware>
   >
+  validator?: ConstrainValidator<TRegister, TInput>
+  extractedFn?: CompiledFetcherFn<TRegister, TResponse>
+  serverFn?: ServerFn<TRegister, TMethod, TMiddlewares, TInput, TResponse>
   functionId: string
 }
 
-export type ValidatorInputStringify<TValidator> = SerializerStringifyBy<
+export type ValidateValidatorInput<
+  TRegister extends Register,
+  TValidator,
+> = ValidateSerializable<
   ResolveValidatorInput<TValidator>,
-  Date | undefined | FormData
+  RegisteredSerializableInput<TRegister> | FormData
 >
 
-export type ValidatorSerializerStringify<TValidator> =
-  ValidatorInputStringify<TValidator> extends infer TInput
+export type ValidateValidator<TRegister extends Register, TValidator> =
+  ValidateValidatorInput<TRegister, TValidator> extends infer TInput
     ? Validator<TInput, any>
     : never
 
-export type ConstrainValidator<TValidator> =
+export type ConstrainValidator<TRegister extends Register, TValidator> =
   | (unknown extends TValidator
       ? TValidator
-      : ResolveValidatorInput<TValidator> extends ValidatorInputStringify<TValidator>
+      : ResolveValidatorInput<TValidator> extends ValidateValidator<
+            TRegister,
+            TValidator
+          >
         ? TValidator
         : never)
-  | ValidatorSerializerStringify<TValidator>
+  | ValidateValidator<TRegister, TValidator>
+
+type ToTuple<T> = T extends undefined
+  ? []
+  : T extends ReadonlyArray<any>
+    ? T
+    : [T]
+
+type ExtractMiddlewareArray<T> = T extends readonly [infer Head, ...infer Tail]
+  ? Head extends ServerFnAfterMiddleware<
+      any,
+      any,
+      infer TMiddlewares extends ReadonlyArray<unknown>,
+      any
+    >
+    ? [...TMiddlewares, ...ExtractMiddlewareArray<Tail>]
+    : [Head, ...ExtractMiddlewareArray<Tail>]
+  : []
 
 export interface ServerFnMiddleware<
+  TRegister extends Register,
   TMethod extends Method,
-  TServerFnResponseType extends ServerFnResponseType,
+  TMiddlewares,
   TValidator,
 > {
-  middleware: <const TNewMiddlewares = undefined>(
+  middleware: <const TNewMiddlewares>(
     middlewares: Constrain<
       TNewMiddlewares,
-      ReadonlyArray<AnyFunctionMiddleware>
+      ReadonlyArray<
+        | AnyFunctionMiddleware
+        | AnyRequestMiddleware
+        | ServerFnAfterMiddleware<any, any, any, any>
+      >
     >,
   ) => ServerFnAfterMiddleware<
+    TRegister,
     TMethod,
-    TServerFnResponseType,
-    TNewMiddlewares,
+    [...ToTuple<TMiddlewares>, ...ExtractMiddlewareArray<TNewMiddlewares>],
     TValidator
   >
 }
 
 export interface ServerFnAfterMiddleware<
+  TRegister extends Register,
   TMethod extends Method,
-  TServerFnResponseType extends ServerFnResponseType,
   TMiddlewares,
   TValidator,
-> extends ServerFnValidator<TMethod, TServerFnResponseType, TMiddlewares>,
-    ServerFnHandler<TMethod, TServerFnResponseType, TMiddlewares, TValidator> {}
+> extends ServerFnMiddleware<TRegister, TMethod, TMiddlewares, undefined>,
+    ServerFnValidator<TRegister, TMethod, TMiddlewares>,
+    ServerFnHandler<TRegister, TMethod, TMiddlewares, TValidator> {
+  <TNewMethod extends Method = TMethod>(options?: {
+    method?: TNewMethod
+  }): ServerFnAfterMiddleware<TRegister, TNewMethod, TMiddlewares, TValidator>
+  options: ServerFnBaseOptions<
+    TRegister,
+    TMethod,
+    unknown,
+    TMiddlewares,
+    TValidator
+  >
+  [TSS_SERVER_FUNCTION_FACTORY]: true
+}
 
 export type ValidatorFn<
+  TRegister extends Register,
   TMethod extends Method,
-  TServerFnResponseType extends ServerFnResponseType,
   TMiddlewares,
 > = <TValidator>(
-  validator: ConstrainValidator<TValidator>,
-) => ServerFnAfterValidator<
-  TMethod,
-  TServerFnResponseType,
-  TMiddlewares,
-  TValidator
->
+  validator: ConstrainValidator<TRegister, TValidator>,
+) => ServerFnAfterValidator<TRegister, TMethod, TMiddlewares, TValidator>
 
 export interface ServerFnValidator<
+  TRegister extends Register,
   TMethod extends Method,
-  TServerFnResponseType extends ServerFnResponseType,
   TMiddlewares,
 > {
-  validator: ValidatorFn<TMethod, TServerFnResponseType, TMiddlewares>
+  validator: ValidatorFn<TRegister, TMethod, TMiddlewares>
 }
 
 export interface ServerFnAfterValidator<
+  TRegister extends Register,
   TMethod extends Method,
-  TServerFnResponseType extends ServerFnResponseType,
   TMiddlewares,
   TValidator,
-> extends ServerFnMiddleware<TMethod, TServerFnResponseType, TValidator>,
-    ServerFnHandler<TMethod, TServerFnResponseType, TMiddlewares, TValidator> {}
+> extends ServerFnMiddleware<TRegister, TMethod, TMiddlewares, TValidator>,
+    ServerFnHandler<TRegister, TMethod, TMiddlewares, TValidator> {}
 
 export interface ServerFnAfterTyper<
+  TRegister extends Register,
   TMethod extends Method,
-  TServerFnResponseType extends ServerFnResponseType,
   TMiddlewares,
   TValidator,
-> extends ServerFnHandler<
-    TMethod,
-    TServerFnResponseType,
-    TMiddlewares,
-    TValidator
-  > {}
+> extends ServerFnHandler<TRegister, TMethod, TMiddlewares, TValidator> {}
 
 // Handler
 export interface ServerFnHandler<
+  TRegister extends Register,
   TMethod extends Method,
-  TServerFnResponseType extends ServerFnResponseType,
   TMiddlewares,
   TValidator,
 > {
   handler: <TNewResponse>(
-    fn?: ServerFn<
-      TMethod,
-      TServerFnResponseType,
-      TMiddlewares,
-      TValidator,
-      TNewResponse
-    >,
-  ) => Fetcher<TMiddlewares, TValidator, TNewResponse, TServerFnResponseType>
+    fn?: ServerFn<TRegister, TMethod, TMiddlewares, TValidator, TNewResponse>,
+  ) => Fetcher<TRegister, TMiddlewares, TValidator, TNewResponse>
 }
 
 export interface ServerFnBuilder<
+  TRegister extends Register,
   TMethod extends Method = 'GET',
-  TServerFnResponseType extends ServerFnResponseType = 'data',
-> extends ServerFnMiddleware<TMethod, TServerFnResponseType, undefined>,
-    ServerFnValidator<TMethod, TServerFnResponseType, undefined>,
-    ServerFnHandler<TMethod, TServerFnResponseType, undefined, undefined> {
+> extends ServerFnMiddleware<TRegister, TMethod, undefined, undefined>,
+    ServerFnValidator<TRegister, TMethod, undefined>,
+    ServerFnHandler<TRegister, TMethod, undefined, undefined> {
   options: ServerFnBaseOptions<
+    TRegister,
     TMethod,
-    TServerFnResponseType,
     unknown,
     undefined,
     undefined
   >
 }
 
-export function extractFormDataContext(formData: FormData) {
-  const serializedContext = formData.get('__TSR_CONTEXT')
-  formData.delete('__TSR_CONTEXT')
-
-  if (typeof serializedContext !== 'string') {
-    return {
-      context: {},
-      data: formData,
-    }
-  }
-
-  try {
-    const context = startSerializer.parse(serializedContext)
-    return {
-      context,
-      data: formData,
-    }
-  } catch {
-    return {
-      data: formData,
-    }
-  }
-}
-
 export function flattenMiddlewares(
-  middlewares: Array<AnyFunctionMiddleware>,
-): Array<AnyFunctionMiddleware> {
-  const seen = new Set<AnyFunctionMiddleware>()
-  const flattened: Array<AnyFunctionMiddleware> = []
-
-  const recurse = (middleware: Array<AnyFunctionMiddleware>) => {
+  middlewares: Array<AnyFunctionMiddleware | AnyRequestMiddleware>,
+): Array<AnyFunctionMiddleware | AnyRequestMiddleware> {
+  const seen = new Set<AnyFunctionMiddleware | AnyRequestMiddleware>()
+  const flattened: Array<AnyFunctionMiddleware | AnyRequestMiddleware> = []
+
+  const recurse = (
+    middleware: Array<AnyFunctionMiddleware | AnyRequestMiddleware>,
+  ) => {
     middleware.forEach((m) => {
       if (m.options.middleware) {
         recurse(m.options.middleware)
@@ -571,7 +537,6 @@ export function flattenMiddlewares(
 
 export type ServerFnMiddlewareOptions = {
   method: Method
-  response?: ServerFnResponseType
   data: any
   headers?: HeadersInit
   signal?: AbortSignal
@@ -622,7 +587,7 @@ export const applyMiddleware = async (
         result:
           userCtx.result !== undefined
             ? userCtx.result
-            : ctx.response === 'raw'
+            : userCtx instanceof Response
               ? userCtx
               : (ctx as any).result,
         error: userCtx.error ?? (ctx as any).error,
@@ -667,7 +632,6 @@ export function serverFnBaseToMiddleware(
     _types: undefined!,
     options: {
       validator: options.validator,
-      validateClient: options.validateClient,
       client: async ({ next, sendContext, ...ctx }) => {
         const payload = {
           ...ctx,

package/src/envOnly.ts

@@ -2,8 +2,8 @@ type EnvOnlyFn = <TFn extends (...args: Array<any>) => any>(fn: TFn) => TFn
 
 // A function that will only be available in the server build
 // If called on the client, it will throw an error
-export const serverOnly: EnvOnlyFn = (fn) => fn
+export const createServerOnlyFn: EnvOnlyFn = (fn) => fn
 
 // A function that will only be available in the client build
 // If called on the server, it will throw an error
-export const clientOnly: EnvOnlyFn = (fn) => fn
+export const createClientOnlyFn: EnvOnlyFn = (fn) => fn