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

package/src/createServerFn.ts

@@ -1,10 +1,10 @@
 import { isNotFound, isRedirect } from '@tanstack/router-core'
 import { mergeHeaders } from '@tanstack/router-core/ssr/client'
-import { globalMiddleware } from './registerGlobalMiddleware'
 
-import { getRouterInstance } from './getRouterInstance'
+import { TSS_SERVER_FUNCTION_FACTORY } from './constants'
+import { getServerContextAfterGlobalMiddlewares } from './getServerContextAfterGlobalMiddlewares'
+import { getStartOptions } from './getStartOptions'
 import type {
-  AnyRouter,
   AnyValidator,
   Constrain,
   Expand,
@@ -17,11 +17,10 @@ import type {
   Validator,
 } from '@tanstack/router-core'
 import type { JsonResponse } from '@tanstack/router-core/ssr/client'
-import type { Readable } from 'node:stream'
 import type {
   AnyFunctionMiddleware,
-  AssignAllClientSendContext,
-  AssignAllServerContext,
+  AnyRequestMiddleware,
+  AssignAllServerFnContext,
   FunctionMiddlewareClientFnResult,
   FunctionMiddlewareServerFnResult,
   IntersectAllValidatorInputs,
@@ -30,89 +29,82 @@ import type {
 
 type TODO = any
 
-export function createServerFn<
-  TRegister extends Register,
+export type CreateServerFn<TRegister> = <
   TMethod extends Method,
-  TServerFnResponseType extends ServerFnResponseType = 'data',
   TResponse = unknown,
   TMiddlewares = undefined,
-  TValidator = undefined,
+  TInputValidator = undefined,
 >(
   options?: {
     method?: TMethod
-    response?: TServerFnResponseType
   },
   __opts?: ServerFnBaseOptions<
     TRegister,
     TMethod,
-    TServerFnResponseType,
     TResponse,
     TMiddlewares,
-    TValidator
+    TInputValidator
   >,
-): ServerFnBuilder<TRegister, TMethod, TServerFnResponseType> {
+) => ServerFnBuilder<TRegister, TMethod>
+
+export const createServerFn: CreateServerFn<Register> = (options, __opts) => {
   const resolvedOptions = (__opts || options || {}) as ServerFnBaseOptions<
-    TRegister,
-    TMethod,
-    ServerFnResponseType,
-    TResponse,
-    TMiddlewares,
-    TValidator
+    any,
+    any,
+    any,
+    any,
+    any
   >
 
   if (typeof resolvedOptions.method === 'undefined') {
-    resolvedOptions.method = 'GET' as TMethod
+    resolvedOptions.method = 'GET' as Method
   }
 
-  return {
+  const res: ServerFnBuilder<Register, Method> = {
     options: resolvedOptions as any,
     middleware: (middleware) => {
-      return createServerFn<
-        TRegister,
-        TMethod,
-        ServerFnResponseType,
-        TResponse,
-        TMiddlewares,
-        TValidator
-      >(undefined, Object.assign(resolvedOptions, { middleware })) as any
+      // 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(undefined, newOptions) as any
+      res[TSS_SERVER_FUNCTION_FACTORY] = true
+      return res
     },
-    validator: (validator) => {
-      return createServerFn<
-        TRegister,
-        TMethod,
-        ServerFnResponseType,
-        TResponse,
-        TMiddlewares,
-        TValidator
-      >(undefined, Object.assign(resolvedOptions, { validator })) as any
+    inputValidator: (inputValidator) => {
+      const newOptions = { ...resolvedOptions, inputValidator }
+      return createServerFn(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<TRegister, TResponse, TServerFnResponseType>,
-        ServerFn<
-          TRegister,
-          TMethod,
-          TServerFnResponseType,
-          TMiddlewares,
-          TValidator,
-          TResponse
-        >,
+        CompiledFetcherFn<Register, any>,
+        ServerFn<Register, Method, any, any, any>,
       ]
 
       // 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
@@ -123,16 +115,12 @@ 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,9 +131,15 @@ export function createServerFn<
           // The extracted function on the server-side calls
           // this function
           __executeServer: async (opts: any, signal: AbortSignal) => {
+            const serverContextAfterGlobalMiddlewares =
+              getServerContextAfterGlobalMiddlewares()
             const ctx = {
               ...extractedFn,
               ...opts,
+              context: {
+                ...serverContextAfterGlobalMiddlewares,
+                ...opts.context,
+              },
               signal,
             }
 
@@ -161,16 +155,27 @@ export function createServerFn<
         },
       ) as any
     },
+  } as ServerFnBuilder<Register, Method>
+  const fun = (options?: { method?: Method }) => {
+    return {
+      ...res,
+      options: {
+        ...res.options,
+        ...options,
+      },
+    }
   }
+  return Object.assign(fun, res) as any
 }
 
 export async function executeMiddleware(
-  middlewares: Array<AnyFunctionMiddleware>,
+  middlewares: Array<AnyFunctionMiddleware | AnyRequestMiddleware>,
   env: 'client' | 'server',
   opts: ServerFnMiddlewareOptions,
 ): Promise<ServerFnMiddlewareResult> {
+  const globalMiddlewares = getStartOptions().functionMiddleware || []
   const flattenedMiddlewares = flattenMiddlewares([
-    ...globalMiddleware,
+    ...globalMiddlewares,
     ...middlewares,
   ])
 
@@ -184,15 +189,19 @@ export async function executeMiddleware(
     }
 
     if (
-      nextMiddleware.options.validator &&
-      (env === 'client' ? nextMiddleware.options.validateClient : true)
+      'inputValidator' in nextMiddleware.options &&
+      nextMiddleware.options.inputValidator &&
+      env === 'server'
     ) {
       // Execute the middleware's input function
-      ctx.data = await execValidator(nextMiddleware.options.validator, ctx.data)
+      ctx.data = await execValidator(
+        nextMiddleware.options.inputValidator,
+        ctx.data,
+      )
     }
 
     const middlewareFn = (
-      env === 'client'
+      env === 'client' && 'client' in nextMiddleware.options
         ? nextMiddleware.options.client
         : nextMiddleware.options.server
     ) as MiddlewareFn | undefined
@@ -228,41 +237,20 @@ export async function executeMiddleware(
 export type CompiledFetcherFnOptions = {
   method: Method
   data: unknown
-  response?: ServerFnResponseType
   headers?: HeadersInit
   signal?: AbortSignal
   context?: any
-  // router?: AnyRouter
 }
 
-export type Fetcher<
-  TRegister extends Register,
-  TMiddlewares,
-  TValidator,
-  TResponse,
-  TServerFnResponseType extends ServerFnResponseType,
-> =
-  undefined extends IntersectAllValidatorInputs<TMiddlewares, TValidator>
-    ? OptionalFetcher<
-        TRegister,
-        TMiddlewares,
-        TValidator,
-        TResponse,
-        TServerFnResponseType
-      >
-    : RequiredFetcher<
-        TRegister,
-        TMiddlewares,
-        TValidator,
-        TResponse,
-        TServerFnResponseType
-      >
+export type Fetcher<TRegister, TMiddlewares, TInputValidator, TResponse> =
+  undefined extends IntersectAllValidatorInputs<TMiddlewares, TInputValidator>
+    ? OptionalFetcher<TRegister, TMiddlewares, TInputValidator, TResponse>
+    : RequiredFetcher<TRegister, TMiddlewares, TInputValidator, TResponse>
 
 export interface FetcherBase {
   url: string
   __executeServer: (opts: {
     method: Method
-    response?: ServerFnResponseType
     data: unknown
     headers?: HeadersInit
     context?: any
@@ -270,39 +258,26 @@ export interface FetcherBase {
   }) => Promise<unknown>
 }
 
-export type FetchResult<
-  TRegister extends Register,
-  TMiddlewares,
-  TResponse,
-  TServerFnResponseType extends ServerFnResponseType,
-> = TServerFnResponseType extends 'raw'
-  ? Promise<Response>
-  : TServerFnResponseType extends 'full'
-    ? Promise<FullFetcherData<TRegister, TMiddlewares, TResponse>>
-    : Promise<FetcherData<TRegister, TResponse>>
-
 export interface OptionalFetcher<
-  TRegister extends Register,
+  TRegister,
   TMiddlewares,
-  TValidator,
+  TInputValidator,
   TResponse,
-  TServerFnResponseType extends ServerFnResponseType,
 > extends FetcherBase {
   (
-    options?: OptionalFetcherDataOptions<TMiddlewares, TValidator>,
-  ): FetchResult<TRegister, TMiddlewares, TResponse, TServerFnResponseType>
+    options?: OptionalFetcherDataOptions<TMiddlewares, TInputValidator>,
+  ): Promise<FetcherData<TRegister, TResponse>>
 }
 
 export interface RequiredFetcher<
-  TRegister extends Register,
+  TRegister,
   TMiddlewares,
-  TValidator,
+  TInputValidator,
   TResponse,
-  TServerFnResponseType extends ServerFnResponseType,
 > extends FetcherBase {
   (
-    opts: RequiredFetcherDataOptions<TMiddlewares, TValidator>,
-  ): FetchResult<TRegister, TMiddlewares, TResponse, TServerFnResponseType>
+    opts: RequiredFetcherDataOptions<TMiddlewares, TInputValidator>,
+  ): Promise<FetcherData<TRegister, TResponse>>
 }
 
 export type FetcherBaseOptions = {
@@ -310,28 +285,19 @@ export type FetcherBaseOptions = {
   signal?: AbortSignal
 }
 
-export interface OptionalFetcherDataOptions<TMiddlewares, TValidator>
+export interface OptionalFetcherDataOptions<TMiddlewares, TInputValidator>
   extends FetcherBaseOptions {
-  data?: Expand<IntersectAllValidatorInputs<TMiddlewares, TValidator>>
+  data?: Expand<IntersectAllValidatorInputs<TMiddlewares, TInputValidator>>
 }
 
-export interface RequiredFetcherDataOptions<TMiddlewares, TValidator>
+export interface RequiredFetcherDataOptions<TMiddlewares, TInputValidator>
   extends FetcherBaseOptions {
-  data: Expand<IntersectAllValidatorInputs<TMiddlewares, TValidator>>
+  data: Expand<IntersectAllValidatorInputs<TMiddlewares, TInputValidator>>
 }
 
-export interface FullFetcherData<
-  TRegister extends Register,
-  TMiddlewares,
-  TResponse,
-> {
-  error: unknown
-  result: FetcherData<TRegister, TResponse>
-  context: AssignAllClientSendContext<TMiddlewares>
-}
-
-export type FetcherData<TRegister extends Register, TResponse> =
-  TResponse extends JsonResponse<any>
+export type FetcherData<TRegister, TResponse> = TResponse extends Response
+  ? Response
+  : TResponse extends JsonResponse<any>
     ? ValidateSerializableInputResult<TRegister, ReturnType<TResponse['json']>>
     : ValidateSerializableInputResult<TRegister, TResponse>
 
@@ -340,270 +306,293 @@ export type RscStream<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<
-  TRegister extends Register,
-  TServerFnResponseType extends ServerFnResponseType,
-  TResponse,
-> = TServerFnResponseType extends 'raw'
-  ? RawResponse | Promise<RawResponse>
-  :
-      | Promise<ValidateSerializableInput<TRegister, TResponse>>
-      | ValidateSerializableInput<TRegister, TResponse>
+export type ServerFnReturnType<TRegister, TResponse> =
+  | Response
+  | Promise<ValidateSerializableInput<TRegister, TResponse>>
+  | ValidateSerializableInput<TRegister, TResponse>
 
 export type ServerFn<
-  TRegister extends Register,
+  TRegister,
   TMethod,
-  TServerFnResponseType extends ServerFnResponseType,
   TMiddlewares,
-  TValidator,
+  TInputValidator,
   TResponse,
 > = (
-  ctx: ServerFnCtx<TMethod, TServerFnResponseType, TMiddlewares, TValidator>,
-) => ServerFnReturnType<TRegister, TServerFnResponseType, TResponse>
+  ctx: ServerFnCtx<TRegister, TMethod, TMiddlewares, TInputValidator>,
+) => ServerFnReturnType<TRegister, TResponse>
 
 export interface ServerFnCtx<
+  TRegister,
   TMethod,
-  TServerFnResponseType extends ServerFnResponseType,
   TMiddlewares,
-  TValidator,
+  TInputValidator,
 > {
   method: TMethod
-  response: TServerFnResponseType
-  data: Expand<IntersectAllValidatorOutputs<TMiddlewares, TValidator>>
-  context: Expand<AssignAllServerContext<TMiddlewares>>
+  data: Expand<IntersectAllValidatorOutputs<TMiddlewares, TInputValidator>>
+  context: Expand<AssignAllServerFnContext<TRegister, TMiddlewares, {}>>
   signal: AbortSignal
 }
 
-export type CompiledFetcherFn<
-  TRegister extends Register,
-  TResponse,
-  TServerFnResponseType extends ServerFnResponseType,
-> = {
+export type CompiledFetcherFn<TRegister, TResponse> = {
   (
-    opts: CompiledFetcherFnOptions &
-      ServerFnBaseOptions<TRegister, Method, TServerFnResponseType>,
+    opts: CompiledFetcherFnOptions & ServerFnBaseOptions<TRegister, Method>,
   ): Promise<TResponse>
   url: string
 }
 
 export type ServerFnBaseOptions<
-  TRegister extends Register,
+  TRegister,
   TMethod extends Method = 'GET',
-  TServerFnResponseType extends ServerFnResponseType = 'data',
   TResponse = unknown,
   TMiddlewares = unknown,
-  TInput = unknown,
+  TInputValidator = unknown,
 > = {
   method: TMethod
-  response?: TServerFnResponseType
-  validateClient?: boolean
-  middleware?: Constrain<TMiddlewares, ReadonlyArray<AnyFunctionMiddleware>>
-  validator?: ConstrainValidator<TRegister, TInput>
-  extractedFn?: CompiledFetcherFn<TRegister, TResponse, TServerFnResponseType>
+  middleware?: Constrain<
+    TMiddlewares,
+    ReadonlyArray<AnyFunctionMiddleware | AnyRequestMiddleware>
+  >
+  inputValidator?: ConstrainValidator<TRegister, TMethod, TInputValidator>
+  extractedFn?: CompiledFetcherFn<TRegister, TResponse>
   serverFn?: ServerFn<
     TRegister,
     TMethod,
-    TServerFnResponseType,
     TMiddlewares,
-    TInput,
+    TInputValidator,
     TResponse
   >
   functionId: string
 }
 
 export type ValidateValidatorInput<
-  TRegister extends Register,
-  TValidator,
-> = ValidateSerializable<
-  ResolveValidatorInput<TValidator>,
-  RegisteredSerializableInput<TRegister> | FormData
->
-
-export type ValidateValidator<TRegister extends Register, TValidator> =
-  ValidateValidatorInput<TRegister, TValidator> extends infer TInput
+  TRegister,
+  TMethod extends Method,
+  TInputValidator,
+> = TMethod extends 'POST'
+  ? ResolveValidatorInput<TInputValidator> extends FormData
+    ? ResolveValidatorInput<TInputValidator>
+    : ValidateSerializable<
+        ResolveValidatorInput<TInputValidator>,
+        RegisteredSerializableInput<TRegister>
+      >
+  : ValidateSerializable<
+      ResolveValidatorInput<TInputValidator>,
+      RegisteredSerializableInput<TRegister>
+    >
+
+export type ValidateValidator<
+  TRegister,
+  TMethod extends Method,
+  TInputValidator,
+> =
+  ValidateValidatorInput<
+    TRegister,
+    TMethod,
+    TInputValidator
+  > extends infer TInput
     ? Validator<TInput, any>
     : never
 
-export type ConstrainValidator<TRegister extends Register, TValidator> =
-  | (unknown extends TValidator
-      ? TValidator
-      : ResolveValidatorInput<TValidator> extends ValidateValidator<
+export type ConstrainValidator<
+  TRegister,
+  TMethod extends Method,
+  TInputValidator,
+> =
+  | (unknown extends TInputValidator
+      ? TInputValidator
+      : ResolveValidatorInput<TInputValidator> extends ValidateValidator<
             TRegister,
-            TValidator
+            TMethod,
+            TInputValidator
           >
-        ? TValidator
+        ? TInputValidator
         : never)
-  | ValidateValidator<TRegister, TValidator>
+  | ValidateValidator<TRegister, TMethod, TInputValidator>
+
+export type AppendMiddlewares<TMiddlewares, TNewMiddlewares> =
+  TMiddlewares extends ReadonlyArray<any>
+    ? TNewMiddlewares extends ReadonlyArray<any>
+      ? readonly [...TMiddlewares, ...TNewMiddlewares]
+      : TMiddlewares
+    : TNewMiddlewares
 
 export interface ServerFnMiddleware<
-  TRegister extends Register,
+  TRegister,
   TMethod extends Method,
-  TServerFnResponseType extends ServerFnResponseType,
-  TValidator,
+  TMiddlewares,
+  TInputValidator,
 > {
-  middleware: <const TNewMiddlewares = undefined>(
+  middleware: <const TNewMiddlewares>(
     middlewares: Constrain<
       TNewMiddlewares,
-      ReadonlyArray<AnyFunctionMiddleware>
+      ReadonlyArray<AnyFunctionMiddleware | AnyRequestMiddleware | AnyServerFn>
     >,
   ) => ServerFnAfterMiddleware<
     TRegister,
     TMethod,
-    TServerFnResponseType,
-    TNewMiddlewares,
-    TValidator
+    AppendMiddlewares<TMiddlewares, TNewMiddlewares>,
+    TInputValidator
   >
 }
 
 export interface ServerFnAfterMiddleware<
-  TRegister extends Register,
+  TRegister,
   TMethod extends Method,
-  TServerFnResponseType extends ServerFnResponseType,
   TMiddlewares,
-  TValidator,
-> extends ServerFnValidator<
+  TInputValidator,
+> extends ServerFnWithTypes<
       TRegister,
       TMethod,
-      TServerFnResponseType,
-      TMiddlewares
-    >,
-    ServerFnHandler<
-      TRegister,
-      TMethod,
-      TServerFnResponseType,
       TMiddlewares,
-      TValidator
-    > {}
+      TInputValidator,
+      undefined
+    >,
+    ServerFnMiddleware<TRegister, TMethod, TMiddlewares, undefined>,
+    ServerFnValidator<TRegister, TMethod, TMiddlewares>,
+    ServerFnHandler<TRegister, TMethod, TMiddlewares, TInputValidator> {
+  <TNewMethod extends Method = TMethod>(options?: {
+    method?: TNewMethod
+  }): ServerFnAfterMiddleware<
+    TRegister,
+    TNewMethod,
+    TMiddlewares,
+    TInputValidator
+  >
+}
 
-export type ValidatorFn<
-  TRegister extends Register,
-  TMethod extends Method,
-  TServerFnResponseType extends ServerFnResponseType,
-  TMiddlewares,
-> = <TValidator>(
-  validator: ConstrainValidator<TRegister, TValidator>,
-) => ServerFnAfterValidator<
-  TRegister,
-  TMethod,
-  TServerFnResponseType,
-  TMiddlewares,
-  TValidator
->
+export type ValidatorFn<TRegister, TMethod extends Method, TMiddlewares> = <
+  TInputValidator,
+>(
+  inputValidator: ConstrainValidator<TRegister, TMethod, TInputValidator>,
+) => ServerFnAfterValidator<TRegister, TMethod, TMiddlewares, TInputValidator>
 
 export interface ServerFnValidator<
-  TRegister extends Register,
+  TRegister,
   TMethod extends Method,
-  TServerFnResponseType extends ServerFnResponseType,
   TMiddlewares,
 > {
-  validator: ValidatorFn<
-    TRegister,
-    TMethod,
-    TServerFnResponseType,
-    TMiddlewares
-  >
+  inputValidator: ValidatorFn<TRegister, TMethod, TMiddlewares>
 }
 
 export interface ServerFnAfterValidator<
-  TRegister extends Register,
+  TRegister,
   TMethod extends Method,
-  TServerFnResponseType extends ServerFnResponseType,
   TMiddlewares,
-  TValidator,
-> extends ServerFnMiddleware<
-      TRegister,
-      TMethod,
-      TServerFnResponseType,
-      TValidator
-    >,
-    ServerFnHandler<
+  TInputValidator,
+> extends ServerFnWithTypes<
       TRegister,
       TMethod,
-      TServerFnResponseType,
       TMiddlewares,
-      TValidator
-    > {}
+      TInputValidator,
+      undefined
+    >,
+    ServerFnMiddleware<TRegister, TMethod, TMiddlewares, TInputValidator>,
+    ServerFnHandler<TRegister, TMethod, TMiddlewares, TInputValidator> {}
 
 export interface ServerFnAfterTyper<
-  TRegister extends Register,
+  TRegister,
   TMethod extends Method,
-  TServerFnResponseType extends ServerFnResponseType,
   TMiddlewares,
-  TValidator,
-> extends ServerFnHandler<
-    TRegister,
-    TMethod,
-    TServerFnResponseType,
-    TMiddlewares,
-    TValidator
-  > {}
+  TInputValidator,
+> extends ServerFnWithTypes<
+      TRegister,
+      TMethod,
+      TMiddlewares,
+      TInputValidator,
+      undefined
+    >,
+    ServerFnHandler<TRegister, TMethod, TMiddlewares, TInputValidator> {}
 
 // Handler
 export interface ServerFnHandler<
-  TRegister extends Register,
+  TRegister,
   TMethod extends Method,
-  TServerFnResponseType extends ServerFnResponseType,
   TMiddlewares,
-  TValidator,
+  TInputValidator,
 > {
   handler: <TNewResponse>(
     fn?: ServerFn<
       TRegister,
       TMethod,
-      TServerFnResponseType,
       TMiddlewares,
-      TValidator,
+      TInputValidator,
       TNewResponse
     >,
-  ) => Fetcher<
-    TRegister,
-    TMiddlewares,
-    TValidator,
-    TNewResponse,
-    TServerFnResponseType
-  >
+  ) => Fetcher<TRegister, TMiddlewares, TInputValidator, TNewResponse>
 }
 
-export interface ServerFnBuilder<
-  TRegister extends Register,
-  TMethod extends Method = 'GET',
-  TServerFnResponseType extends ServerFnResponseType = 'data',
-> extends ServerFnMiddleware<
-      TRegister,
-      TMethod,
-      TServerFnResponseType,
-      undefined
-    >,
-    ServerFnValidator<TRegister, TMethod, TServerFnResponseType, undefined>,
-    ServerFnHandler<
+export interface ServerFnBuilder<TRegister, TMethod extends Method = 'GET'>
+  extends ServerFnWithTypes<
       TRegister,
       TMethod,
-      TServerFnResponseType,
+      undefined,
       undefined,
       undefined
-    > {
+    >,
+    ServerFnMiddleware<TRegister, TMethod, undefined, undefined>,
+    ServerFnValidator<TRegister, TMethod, undefined>,
+    ServerFnHandler<TRegister, TMethod, undefined, undefined> {
   options: ServerFnBaseOptions<
     TRegister,
     TMethod,
-    TServerFnResponseType,
     unknown,
     undefined,
     undefined
   >
 }
 
-export function flattenMiddlewares(
-  middlewares: Array<AnyFunctionMiddleware>,
-): Array<AnyFunctionMiddleware> {
-  const seen = new Set<AnyFunctionMiddleware>()
-  const flattened: Array<AnyFunctionMiddleware> = []
+export interface ServerFnWithTypes<
+  in out TRegister,
+  in out TMethod extends Method,
+  in out TMiddlewares,
+  in out TInputValidator,
+  in out TResponse,
+> {
+  _types: ServerFnTypes<
+    TRegister,
+    TMethod,
+    TMiddlewares,
+    TInputValidator,
+    TResponse
+  >
+  options: ServerFnBaseOptions<
+    TRegister,
+    TMethod,
+    unknown,
+    undefined,
+    undefined
+  >
+  [TSS_SERVER_FUNCTION_FACTORY]: true
+}
 
-  const recurse = (middleware: Array<AnyFunctionMiddleware>) => {
+export type AnyServerFn = ServerFnWithTypes<any, any, any, any, any>
+
+export interface ServerFnTypes<
+  in out TRegister,
+  in out TMethod extends Method,
+  in out TMiddlewares,
+  in out TInputValidator,
+  in out TResponse,
+> {
+  method: TMethod
+  middlewares: TMiddlewares
+  inputValidator: TInputValidator
+  response: TResponse
+  allServerContext: AssignAllServerFnContext<TRegister, TMiddlewares>
+  allInput: IntersectAllValidatorInputs<TMiddlewares, TInputValidator>
+  allOutput: IntersectAllValidatorOutputs<TMiddlewares, TInputValidator>
+}
+
+export function flattenMiddlewares(
+  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)
@@ -623,14 +612,12 @@ export function flattenMiddlewares(
 
 export type ServerFnMiddlewareOptions = {
   method: Method
-  response?: ServerFnResponseType
   data: any
   headers?: HeadersInit
   signal?: AbortSignal
   sendContext?: any
   context?: any
   functionId: string
-  router?: AnyRouter
 }
 
 export type ServerFnMiddlewareResult = ServerFnMiddlewareOptions & {
@@ -674,7 +661,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,
@@ -712,14 +699,13 @@ export function execValidator(
   throw new Error('Invalid validator type!')
 }
 
-export function serverFnBaseToMiddleware(
-  options: ServerFnBaseOptions<any, any, any, any, any, any>,
+function serverFnBaseToMiddleware(
+  options: ServerFnBaseOptions<any, any, any, any, any>,
 ): AnyFunctionMiddleware {
   return {
     _types: undefined!,
     options: {
-      validator: options.validator,
-      validateClient: options.validateClient,
+      inputValidator: options.inputValidator,
       client: async ({ next, sendContext, ...ctx }) => {
         const payload = {
           ...ctx,
@@ -748,6 +734,7 @@ export function serverFnBaseToMiddleware(
           any,
           any,
           any,
+          any,
           any
         >
       },