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

package/src/createMiddleware.ts

@@ -1,43 +1,42 @@
-import type {
-  ConstrainValidator,
-  Method,
-  ServerFnResponseType,
-} from './createServerFn'
+import type { ConstrainValidator, Method } from './createServerFn'
 import type {
   AnyRouter,
   Assign,
   Constrain,
   Expand,
   IntersectAssign,
+  Register,
   RegisteredRouter,
   ResolveValidatorInput,
   ResolveValidatorOutput,
+  ValidateSerializableInput,
 } from '@tanstack/router-core'
-import type { SerializerStringify } from './serializer'
 
-export function createMiddleware<TType extends MiddlewareType>(
+export function createMiddleware<
+  TRegister extends Register,
+  TType extends MiddlewareType,
+>(
   options: {
     type: TType
-    validateClient?: boolean
   },
   __opts?: FunctionMiddlewareOptions<
+    TRegister,
     unknown,
     undefined,
     undefined,
-    undefined,
-    ServerFnResponseType
+    undefined
   >,
-): CreateMiddlewareResult<TType> {
+): CreateMiddlewareResult<TRegister, TType> {
   // const resolvedOptions = (__opts || options) as MiddlewareOptions<
   const resolvedOptions = {
     type: 'function',
     ...(__opts ||
       (options as FunctionMiddlewareOptions<
+        TRegister,
         unknown,
         undefined,
         undefined,
-        undefined,
-        ServerFnResponseType
+        undefined
       >)),
   }
 
@@ -67,57 +66,56 @@ export function createMiddleware<TType extends MiddlewareType>(
         Object.assign(resolvedOptions, { server }),
       ) as any
     },
-  } as unknown as CreateMiddlewareResult<TType>
+  } as unknown as CreateMiddlewareResult<TRegister, TType>
 }
 
 export type MiddlewareType = 'request' | 'function'
 
-export type CreateMiddlewareResult<TType extends MiddlewareType> =
-  'function' extends TType
-    ? FunctionMiddleware<ServerFnResponseType>
-    : RequestMiddleware
+export type CreateMiddlewareResult<
+  TRegister extends Register,
+  TType extends MiddlewareType,
+> = 'function' extends TType ? FunctionMiddleware<TRegister> : RequestMiddleware
 
-export interface FunctionMiddleware<
-  TServerFnResponseType extends ServerFnResponseType,
-> extends FunctionMiddlewareAfterMiddleware<unknown, TServerFnResponseType> {
+export interface FunctionMiddleware<TRegister extends Register>
+  extends FunctionMiddlewareAfterMiddleware<TRegister, unknown> {
   middleware: <const TNewMiddlewares = undefined>(
     middlewares: Constrain<
       TNewMiddlewares,
       ReadonlyArray<AnyFunctionMiddleware>
     >,
-  ) => FunctionMiddlewareAfterMiddleware<TNewMiddlewares, TServerFnResponseType>
+  ) => FunctionMiddlewareAfterMiddleware<TRegister, TNewMiddlewares>
 }
 
 export interface FunctionMiddlewareAfterMiddleware<
+  TRegister extends Register,
   TMiddlewares,
-  TServerFnResponseType extends ServerFnResponseType,
 > extends FunctionMiddlewareWithTypes<
+      TRegister,
       TMiddlewares,
       undefined,
       undefined,
       undefined,
       undefined,
-      undefined,
-      TServerFnResponseType
+      undefined
     >,
     FunctionMiddlewareServer<
+      TRegister,
       TMiddlewares,
       undefined,
       undefined,
-      undefined,
-      TServerFnResponseType
+      undefined
     >,
-    FunctionMiddlewareClient<TMiddlewares, undefined, TServerFnResponseType>,
-    FunctionMiddlewareValidator<TMiddlewares, TServerFnResponseType> {}
+    FunctionMiddlewareClient<TRegister, TMiddlewares, undefined>,
+    FunctionMiddlewareValidator<TRegister, TMiddlewares> {}
 
 export interface FunctionMiddlewareWithTypes<
+  TRegister extends Register,
   TMiddlewares,
   TValidator,
   TServerContext,
   TServerSendContext,
   TClientContext,
   TClientSendContext,
-  TServerFnResponseType extends ServerFnResponseType,
 > {
   _types: FunctionMiddlewareTypes<
     TMiddlewares,
@@ -128,11 +126,11 @@ export interface FunctionMiddlewareWithTypes<
     TClientSendContext
   >
   options: FunctionMiddlewareOptions<
+    TRegister,
     TMiddlewares,
     TValidator,
     TServerContext,
-    TClientContext,
-    TServerFnResponseType
+    TClientContext
   >
 }
 
@@ -309,82 +307,82 @@ export type AssignAllClientSendContext<
     >
 
 export interface FunctionMiddlewareOptions<
+  in out TRegister extends Register,
   in out TMiddlewares,
   in out TValidator,
   in out TServerContext,
   in out TClientContext,
-  in out TServerFnResponseType extends ServerFnResponseType,
 > {
-  validateClient?: boolean
   middleware?: TMiddlewares
-  validator?: ConstrainValidator<TValidator>
+  validator?: ConstrainValidator<TRegister, TValidator>
   client?: FunctionMiddlewareClientFn<
+    TRegister,
     TMiddlewares,
     TValidator,
     TServerContext,
-    TClientContext,
-    TServerFnResponseType
+    TClientContext
   >
   server?: FunctionMiddlewareServerFn<
+    TRegister,
     TMiddlewares,
     TValidator,
     TServerContext,
     unknown,
-    unknown,
-    TServerFnResponseType
+    unknown
   >
 }
 
-export type FunctionMiddlewareClientNextFn<TMiddlewares> = <
-  TSendContext = undefined,
-  TNewClientContext = undefined,
->(ctx?: {
+export type FunctionMiddlewareClientNextFn<
+  TRegister extends Register,
+  TMiddlewares,
+> = <TSendContext = undefined, TNewClientContext = undefined>(ctx?: {
   context?: TNewClientContext
-  sendContext?: SerializerStringify<TSendContext>
+  sendContext?: ValidateSerializableInput<TRegister, TSendContext>
   headers?: HeadersInit
 }) => Promise<
   FunctionClientResultWithContext<TMiddlewares, TSendContext, TNewClientContext>
 >
 
 export interface FunctionMiddlewareServer<
+  TRegister extends Register,
   TMiddlewares,
   TValidator,
   TServerSendContext,
   TClientContext,
-  TServerFnResponseType extends ServerFnResponseType,
 > {
   server: <TNewServerContext = undefined, TSendContext = undefined>(
     server: FunctionMiddlewareServerFn<
+      TRegister,
       TMiddlewares,
       TValidator,
       TServerSendContext,
       TNewServerContext,
-      TSendContext,
-      TServerFnResponseType
+      TSendContext
     >,
   ) => FunctionMiddlewareAfterServer<
+    TRegister,
     TMiddlewares,
     TValidator,
     TNewServerContext,
     TServerSendContext,
     TClientContext,
-    TSendContext,
-    ServerFnResponseType
+    TSendContext
   >
 }
+
 export type FunctionMiddlewareServerFn<
+  TRegister extends Register,
   TMiddlewares,
   TValidator,
   TServerSendContext,
   TNewServerContext,
   TSendContext,
-  TServerFnResponseType extends ServerFnResponseType,
 > = (
   options: FunctionMiddlewareServerFnOptions<
+    TRegister,
     TMiddlewares,
     TValidator,
-    TServerSendContext,
-    TServerFnResponseType
+    TServerSendContext
   >,
 ) => FunctionMiddlewareServerFnResult<
   TMiddlewares,
@@ -394,23 +392,29 @@ export type FunctionMiddlewareServerFn<
 >
 
 export interface RequestMiddlewareServerFnOptions<
+  in out TRegister extends Register,
   in out TMiddlewares,
   in out TServerSendContext,
 > {
   request: Request
   context: Expand<AssignAllServerContext<TMiddlewares, TServerSendContext>>
-  next: FunctionMiddlewareServerNextFn<TMiddlewares, TServerSendContext>
+  next: FunctionMiddlewareServerNextFn<
+    TRegister,
+    TMiddlewares,
+    TServerSendContext
+  >
   response: Response
   method: Method
   signal: AbortSignal
 }
 
-export type FunctionMiddlewareServerNextFn<TMiddlewares, TServerSendContext> = <
-  TNewServerContext = undefined,
-  TSendContext = undefined,
->(ctx?: {
+export type FunctionMiddlewareServerNextFn<
+  TRegister extends Register,
+  TMiddlewares,
+  TServerSendContext,
+> = <TNewServerContext = undefined, TSendContext = undefined>(ctx?: {
   context?: TNewServerContext
-  sendContext?: SerializerStringify<TSendContext>
+  sendContext?: ValidateSerializableInput<TRegister, TSendContext>
 }) => Promise<
   FunctionServerResultWithContext<
     TMiddlewares,
@@ -438,15 +442,18 @@ export type FunctionServerResultWithContext<
 }
 
 export interface FunctionMiddlewareServerFnOptions<
+  in out TRegister extends Register,
   in out TMiddlewares,
   in out TValidator,
   in out TServerSendContext,
-  in out TServerFnResponseType,
 > {
   data: Expand<IntersectAllValidatorOutputs<TMiddlewares, TValidator>>
   context: Expand<AssignAllServerContext<TMiddlewares, TServerSendContext>>
-  next: FunctionMiddlewareServerNextFn<TMiddlewares, TServerSendContext>
-  response: TServerFnResponseType
+  next: FunctionMiddlewareServerNextFn<
+    TRegister,
+    TMiddlewares,
+    TServerSendContext
+  >
   method: Method
   filename: string
   functionId: string
@@ -475,59 +482,59 @@ export type FunctionMiddlewareServerFnResult<
     >
 
 export interface FunctionMiddlewareAfterServer<
+  TRegister extends Register,
   TMiddlewares,
   TValidator,
   TServerContext,
   TServerSendContext,
   TClientContext,
   TClientSendContext,
-  TServerFnResponseType extends ServerFnResponseType,
 > extends FunctionMiddlewareWithTypes<
+    TRegister,
     TMiddlewares,
     TValidator,
     TServerContext,
     TServerSendContext,
     TClientContext,
-    TClientSendContext,
-    TServerFnResponseType
+    TClientSendContext
   > {}
 
 export interface FunctionMiddlewareClient<
+  TRegister extends Register,
   TMiddlewares,
   TValidator,
-  TServerFnResponseType extends ServerFnResponseType,
   TRouter extends AnyRouter = RegisteredRouter,
 > {
   client: <TSendServerContext = undefined, TNewClientContext = undefined>(
     client: FunctionMiddlewareClientFn<
+      TRegister,
       TMiddlewares,
       TValidator,
       TSendServerContext,
       TNewClientContext,
-      TServerFnResponseType,
       TRouter
     >,
   ) => FunctionMiddlewareAfterClient<
+    TRegister,
     TMiddlewares,
     TValidator,
     TSendServerContext,
-    TNewClientContext,
-    ServerFnResponseType
+    TNewClientContext
   >
 }
 
 export type FunctionMiddlewareClientFn<
+  TRegister extends Register,
   TMiddlewares,
   TValidator,
   TSendContext,
   TClientContext,
-  TServerFnResponseType extends ServerFnResponseType,
   TRouter extends AnyRouter = RegisteredRouter,
 > = (
   options: FunctionMiddlewareClientFnOptions<
+    TRegister,
     TMiddlewares,
     TValidator,
-    TServerFnResponseType,
     TRouter
   >,
 ) => FunctionMiddlewareClientFnResult<
@@ -537,18 +544,17 @@ export type FunctionMiddlewareClientFn<
 >
 
 export interface FunctionMiddlewareClientFnOptions<
+  in out TRegister extends Register,
   in out TMiddlewares,
   in out TValidator,
-  in out TServerFnResponseType extends ServerFnResponseType,
   in out TRouter extends AnyRouter,
 > {
   data: Expand<IntersectAllValidatorInputs<TMiddlewares, TValidator>>
   context: Expand<AssignAllClientContextBeforeNext<TMiddlewares>>
   sendContext: Expand<AssignAllServerSendContext<TMiddlewares>>
   method: Method
-  response: TServerFnResponseType
   signal: AbortSignal
-  next: FunctionMiddlewareClientNextFn<TMiddlewares>
+  next: FunctionMiddlewareClientNextFn<TRegister, TMiddlewares>
   filename: string
   functionId: string
   router: TRouter
@@ -580,62 +586,58 @@ export type FunctionClientResultWithContext<
 }
 
 export interface FunctionMiddlewareAfterClient<
+  TRegister extends Register,
   TMiddlewares,
   TValidator,
   TServerSendContext,
   TClientContext,
-  TServerFnResponseType extends ServerFnResponseType,
 > extends FunctionMiddlewareWithTypes<
+      TRegister,
       TMiddlewares,
       TValidator,
       undefined,
       TServerSendContext,
       TClientContext,
-      undefined,
-      TServerFnResponseType
+      undefined
     >,
     FunctionMiddlewareServer<
+      TRegister,
       TMiddlewares,
       TValidator,
       TServerSendContext,
-      TClientContext,
-      TServerFnResponseType
+      TClientContext
     > {}
 
 export interface FunctionMiddlewareValidator<
+  TRegister extends Register,
   TMiddlewares,
-  TServerFnResponseType extends ServerFnResponseType,
 > {
   validator: <TNewValidator>(
-    input: ConstrainValidator<TNewValidator>,
-  ) => FunctionMiddlewareAfterValidator<
-    TMiddlewares,
-    TNewValidator,
-    TServerFnResponseType
-  >
+    input: ConstrainValidator<TRegister, TNewValidator>,
+  ) => FunctionMiddlewareAfterValidator<TRegister, TMiddlewares, TNewValidator>
 }
 
 export interface FunctionMiddlewareAfterValidator<
+  TRegister extends Register,
   TMiddlewares,
   TValidator,
-  TServerFnResponseType extends ServerFnResponseType,
 > extends FunctionMiddlewareWithTypes<
+      TRegister,
       TMiddlewares,
       TValidator,
       undefined,
       undefined,
       undefined,
-      undefined,
-      ServerFnResponseType
+      undefined
     >,
     FunctionMiddlewareServer<
+      TRegister,
       TMiddlewares,
       TValidator,
       undefined,
-      undefined,
-      TServerFnResponseType
+      undefined
     >,
-    FunctionMiddlewareClient<TMiddlewares, TValidator, ServerFnResponseType> {}
+    FunctionMiddlewareClient<TRegister, TMiddlewares, TValidator> {}
 
 export interface RequestMiddleware
   extends RequestMiddlewareAfterMiddleware<undefined> {