@tanstack/start-client-core 1.120.3 → 1.120.4-alpha.10

package/src/createMiddleware.ts

@@ -14,21 +14,225 @@ import type {
   SerializerStringify,
 } from '@tanstack/router-core'
 
-export type AssignAllMiddleware<
+export function createMiddleware<TType extends MiddlewareType>(
+  options: {
+    type: TType
+    validateClient?: boolean
+  },
+  __opts?: FunctionMiddlewareOptions<
+    unknown,
+    undefined,
+    undefined,
+    undefined,
+    ServerFnResponseType
+  >,
+): CreateMiddlewareResult<TType> {
+  // const resolvedOptions = (__opts || options) as MiddlewareOptions<
+  const resolvedOptions = {
+    type: 'function',
+    ...(__opts ||
+      (options as FunctionMiddlewareOptions<
+        unknown,
+        undefined,
+        undefined,
+        undefined,
+        ServerFnResponseType
+      >)),
+  }
+
+  return {
+    options: resolvedOptions,
+    middleware: (middleware: any) => {
+      return createMiddleware(
+        {} as any,
+        Object.assign(resolvedOptions, { middleware }),
+      ) as any
+    },
+    validator: (validator: any) => {
+      return createMiddleware(
+        {} as any,
+        Object.assign(resolvedOptions, { validator }),
+      ) as any
+    },
+    client: (client: any) => {
+      return createMiddleware(
+        {} as any,
+        Object.assign(resolvedOptions, { client }),
+      ) as any
+    },
+    server: (server: any) => {
+      return createMiddleware(
+        {} as any,
+        Object.assign(resolvedOptions, { server }),
+      ) as any
+    },
+  } as unknown as CreateMiddlewareResult<TType>
+}
+
+export type MiddlewareType = 'request' | 'function'
+
+export type CreateMiddlewareResult<TType extends MiddlewareType> =
+  'function' extends TType
+    ? FunctionMiddleware<ServerFnResponseType>
+    : RequestMiddleware
+
+export interface FunctionMiddleware<
+  TServerFnResponseType extends ServerFnResponseType,
+> extends FunctionMiddlewareAfterMiddleware<unknown, TServerFnResponseType> {
+  middleware: <const TNewMiddlewares = undefined>(
+    middlewares: Constrain<
+      TNewMiddlewares,
+      ReadonlyArray<AnyFunctionMiddleware>
+    >,
+  ) => FunctionMiddlewareAfterMiddleware<TNewMiddlewares, TServerFnResponseType>
+}
+
+export interface FunctionMiddlewareAfterMiddleware<
+  TMiddlewares,
+  TServerFnResponseType extends ServerFnResponseType,
+> extends FunctionMiddlewareWithTypes<
+      TMiddlewares,
+      undefined,
+      undefined,
+      undefined,
+      undefined,
+      undefined,
+      TServerFnResponseType
+    >,
+    FunctionMiddlewareServer<
+      TMiddlewares,
+      undefined,
+      undefined,
+      undefined,
+      TServerFnResponseType
+    >,
+    FunctionMiddlewareClient<TMiddlewares, undefined, TServerFnResponseType>,
+    FunctionMiddlewareValidator<TMiddlewares, TServerFnResponseType> {}
+
+export interface FunctionMiddlewareWithTypes<
+  TMiddlewares,
+  TValidator,
+  TServerContext,
+  TServerSendContext,
+  TClientContext,
+  TClientSendContext,
+  TServerFnResponseType extends ServerFnResponseType,
+> {
+  _types: FunctionMiddlewareTypes<
+    TMiddlewares,
+    TValidator,
+    TServerContext,
+    TServerSendContext,
+    TClientContext,
+    TClientSendContext
+  >
+  options: FunctionMiddlewareOptions<
+    TMiddlewares,
+    TValidator,
+    TServerContext,
+    TClientContext,
+    TServerFnResponseType
+  >
+}
+
+export interface FunctionMiddlewareTypes<
+  in out TMiddlewares,
+  in out TValidator,
+  in out TServerContext,
+  in out TServerSendContext,
+  in out TClientContext,
+  in out TClientSendContext,
+> {
+  type: 'function'
+  middlewares: TMiddlewares
+  input: ResolveValidatorInput<TValidator>
+  allInput: IntersectAllValidatorInputs<TMiddlewares, TValidator>
+  output: ResolveValidatorOutput<TValidator>
+  allOutput: IntersectAllValidatorOutputs<TMiddlewares, TValidator>
+  clientContext: TClientContext
+  allClientContextBeforeNext: AssignAllClientContextBeforeNext<
+    TMiddlewares,
+    TClientContext
+  >
+  allClientContextAfterNext: AssignAllClientContextAfterNext<
+    TMiddlewares,
+    TClientContext,
+    TClientSendContext
+  >
+  serverContext: TServerContext
+  serverSendContext: TServerSendContext
+  allServerSendContext: AssignAllServerSendContext<
+    TMiddlewares,
+    TServerSendContext
+  >
+  allServerContext: AssignAllServerContext<
+    TMiddlewares,
+    TServerSendContext,
+    TServerContext
+  >
+  clientSendContext: TClientSendContext
+  allClientSendContext: AssignAllClientSendContext<
+    TMiddlewares,
+    TClientSendContext
+  >
+  validator: TValidator
+}
+
+/**
+ * Recursively resolve the input type produced by a sequence of middleware
+ */
+export type IntersectAllValidatorInputs<TMiddlewares, TValidator> =
+  unknown extends TValidator
+    ? TValidator
+    : TValidator extends undefined
+      ? IntersectAllMiddleware<TMiddlewares, 'allInput'>
+      : IntersectAssign<
+          IntersectAllMiddleware<TMiddlewares, 'allInput'>,
+          ResolveValidatorInput<TValidator>
+        >
+
+export type IntersectAllMiddleware<
   TMiddlewares,
-  TType extends keyof AnyMiddleware['_types'],
+  TType extends
+    | keyof AnyFunctionMiddleware['_types']
+    | keyof AnyRequestMiddleware['_types'],
   TAcc = undefined,
-> = TMiddlewares extends readonly [
-  infer TMiddleware extends AnyMiddleware,
-  ...infer TRest,
-]
-  ? AssignAllMiddleware<
-      TRest,
-      TType,
-      Assign<TAcc, TMiddleware['_types'][TType]>
-    >
+> = TMiddlewares extends readonly [infer TMiddleware, ...infer TRest]
+  ? TMiddleware extends AnyFunctionMiddleware | AnyRequestMiddleware
+    ? IntersectAllMiddleware<
+        TRest,
+        TType,
+        IntersectAssign<
+          TAcc,
+          TMiddleware['_types'][TType & keyof TMiddleware['_types']]
+        >
+      >
+    : TAcc
   : TAcc
 
+export type AnyFunctionMiddleware = FunctionMiddlewareWithTypes<
+  any,
+  any,
+  any,
+  any,
+  any,
+  any,
+  any
+>
+
+/**
+ * Recursively merge the output type produced by a sequence of middleware
+ */
+export type IntersectAllValidatorOutputs<TMiddlewares, TValidator> =
+  unknown extends TValidator
+    ? TValidator
+    : TValidator extends undefined
+      ? IntersectAllMiddleware<TMiddlewares, 'allOutput'>
+      : IntersectAssign<
+          IntersectAllMiddleware<TMiddlewares, 'allOutput'>,
+          ResolveValidatorOutput<TValidator>
+        >
+
 /**
  * Recursively resolve the client context type produced by a sequence of middleware
  */
@@ -42,15 +246,21 @@ export type AssignAllClientContextBeforeNext<
       TClientContext
     >
 
-export type AssignAllClientSendContext<
+export type AssignAllMiddleware<
   TMiddlewares,
-  TSendContext = undefined,
-> = unknown extends TSendContext
-  ? TSendContext
-  : Assign<
-      AssignAllMiddleware<TMiddlewares, 'allClientSendContext'>,
-      TSendContext
-    >
+  TType extends
+    | keyof AnyFunctionMiddleware['_types']
+    | keyof AnyRequestMiddleware['_types'],
+  TAcc = undefined,
+> = TMiddlewares extends readonly [infer TMiddleware, ...infer TRest]
+  ? TMiddleware extends AnyFunctionMiddleware | AnyRequestMiddleware
+    ? AssignAllMiddleware<
+        TRest,
+        TType,
+        Assign<TAcc, TMiddleware['_types'][TType & keyof TMiddleware['_types']]>
+      >
+    : TAcc
+  : TAcc
 
 export type AssignAllClientContextAfterNext<
   TMiddlewares,
@@ -63,6 +273,16 @@ export type AssignAllClientContextAfterNext<
       Assign<TClientContext, TSendContext>
     >
 
+export type AssignAllServerSendContext<
+  TMiddlewares,
+  TSendContext = undefined,
+> = unknown extends TSendContext
+  ? TSendContext
+  : Assign<
+      AssignAllMiddleware<TMiddlewares, 'allServerSendContext'>,
+      TSendContext
+    >
+
 /**
  * Recursively resolve the server context type produced by a sequence of middleware
  */
@@ -77,57 +297,17 @@ export type AssignAllServerContext<
       Assign<TSendContext, TServerContext>
     >
 
-export type AssignAllServerSendContext<
+export type AssignAllClientSendContext<
   TMiddlewares,
   TSendContext = undefined,
 > = unknown extends TSendContext
   ? TSendContext
   : Assign<
-      AssignAllMiddleware<TMiddlewares, 'allServerSendContext'>,
+      AssignAllMiddleware<TMiddlewares, 'allClientSendContext'>,
       TSendContext
     >
 
-export type IntersectAllMiddleware<
-  TMiddlewares,
-  TType extends keyof AnyMiddleware['_types'],
-  TAcc = undefined,
-> = TMiddlewares extends readonly [
-  infer TMiddleware extends AnyMiddleware,
-  ...infer TRest,
-]
-  ? IntersectAllMiddleware<
-      TRest,
-      TType,
-      IntersectAssign<TAcc, TMiddleware['_types'][TType]>
-    >
-  : TAcc
-
-/**
- * Recursively resolve the input type produced by a sequence of middleware
- */
-export type IntersectAllValidatorInputs<TMiddlewares, TValidator> =
-  unknown extends TValidator
-    ? TValidator
-    : IntersectAssign<
-        IntersectAllMiddleware<TMiddlewares, 'allInput'>,
-        TValidator extends undefined
-          ? undefined
-          : ResolveValidatorInput<TValidator>
-      >
-/**
- * Recursively merge the output type produced by a sequence of middleware
- */
-export type IntersectAllValidatorOutputs<TMiddlewares, TValidator> =
-  unknown extends TValidator
-    ? TValidator
-    : IntersectAssign<
-        IntersectAllMiddleware<TMiddlewares, 'allOutput'>,
-        TValidator extends undefined
-          ? undefined
-          : ResolveValidatorOutput<TValidator>
-      >
-
-export interface MiddlewareOptions<
+export interface FunctionMiddlewareOptions<
   in out TMiddlewares,
   in out TValidator,
   in out TServerContext,
@@ -137,14 +317,14 @@ export interface MiddlewareOptions<
   validateClient?: boolean
   middleware?: TMiddlewares
   validator?: ConstrainValidator<TValidator>
-  client?: MiddlewareClientFn<
+  client?: FunctionMiddlewareClientFn<
     TMiddlewares,
     TValidator,
     TServerContext,
     TClientContext,
     TServerFnResponseType
   >
-  server?: MiddlewareServerFn<
+  server?: FunctionMiddlewareServerFn<
     TMiddlewares,
     TValidator,
     TServerContext,
@@ -154,38 +334,44 @@ export interface MiddlewareOptions<
   >
 }
 
-export type MiddlewareServerNextFn<TMiddlewares, TServerSendContext> = <
-  TNewServerContext = undefined,
+export type FunctionMiddlewareClientNextFn<TMiddlewares> = <
   TSendContext = undefined,
+  TNewClientContext = undefined,
 >(ctx?: {
-  context?: TNewServerContext
+  context?: TNewClientContext
   sendContext?: SerializerStringify<TSendContext>
+  headers?: HeadersInit
 }) => Promise<
-  ServerResultWithContext<
-    TMiddlewares,
-    TServerSendContext,
-    TNewServerContext,
-    TSendContext
-  >
+  FunctionClientResultWithContext<TMiddlewares, TSendContext, TNewClientContext>
 >
 
-export interface MiddlewareServerFnOptions<
-  in out TMiddlewares,
-  in out TValidator,
-  in out TServerSendContext,
-  in out TServerFnResponseType,
+export interface FunctionMiddlewareServer<
+  TMiddlewares,
+  TValidator,
+  TServerSendContext,
+  TClientContext,
+  TServerFnResponseType extends ServerFnResponseType,
 > {
-  data: Expand<IntersectAllValidatorOutputs<TMiddlewares, TValidator>>
-  context: Expand<AssignAllServerContext<TMiddlewares, TServerSendContext>>
-  next: MiddlewareServerNextFn<TMiddlewares, TServerSendContext>
-  response: TServerFnResponseType
-  method: Method
-  filename: string
-  functionId: string
-  signal: AbortSignal
+  server: <TNewServerContext = undefined, TSendContext = undefined>(
+    server: FunctionMiddlewareServerFn<
+      TMiddlewares,
+      TValidator,
+      TServerSendContext,
+      TNewServerContext,
+      TSendContext,
+      TServerFnResponseType
+    >,
+  ) => FunctionMiddlewareAfterServer<
+    TMiddlewares,
+    TValidator,
+    TNewServerContext,
+    TServerSendContext,
+    TClientContext,
+    TSendContext,
+    ServerFnResponseType
+  >
 }
-
-export type MiddlewareServerFn<
+export type FunctionMiddlewareServerFn<
   TMiddlewares,
   TValidator,
   TServerSendContext,
@@ -193,96 +379,47 @@ export type MiddlewareServerFn<
   TSendContext,
   TServerFnResponseType extends ServerFnResponseType,
 > = (
-  options: MiddlewareServerFnOptions<
+  options: FunctionMiddlewareServerFnOptions<
     TMiddlewares,
     TValidator,
     TServerSendContext,
     TServerFnResponseType
   >,
-) => MiddlewareServerFnResult<
+) => FunctionMiddlewareServerFnResult<
   TMiddlewares,
   TServerSendContext,
   TNewServerContext,
   TSendContext
 >
 
-export type MiddlewareServerFnResult<
-  TMiddlewares,
-  TServerSendContext,
-  TServerContext,
-  TSendContext,
-> =
-  | Promise<
-      ServerResultWithContext<
-        TMiddlewares,
-        TServerSendContext,
-        TServerContext,
-        TSendContext
-      >
-    >
-  | ServerResultWithContext<
-      TMiddlewares,
-      TServerSendContext,
-      TServerContext,
-      TSendContext
-    >
-
-export type MiddlewareClientNextFn<TMiddlewares> = <
-  TSendContext = undefined,
-  TNewClientContext = undefined,
->(ctx?: {
-  context?: TNewClientContext
-  sendContext?: SerializerStringify<TSendContext>
-  headers?: HeadersInit
-}) => Promise<
-  ClientResultWithContext<TMiddlewares, TSendContext, TNewClientContext>
->
-
-export interface MiddlewareClientFnOptions<
+export interface RequestMiddlewareServerFnOptions<
   in out TMiddlewares,
-  in out TValidator,
-  in out TServerFnResponseType extends ServerFnResponseType,
+  in out TServerSendContext,
 > {
-  data: Expand<IntersectAllValidatorInputs<TMiddlewares, TValidator>>
-  context: Expand<AssignAllClientContextBeforeNext<TMiddlewares>>
-  sendContext: Expand<AssignAllServerSendContext<TMiddlewares>>
+  request: Request
+  context: Expand<AssignAllServerContext<TMiddlewares, TServerSendContext>>
+  next: FunctionMiddlewareServerNextFn<TMiddlewares, TServerSendContext>
+  response: Response
   method: Method
-  response: TServerFnResponseType
   signal: AbortSignal
-  next: MiddlewareClientNextFn<TMiddlewares>
-  filename: string
-  functionId: string
-  type: ServerFnTypeOrTypeFn<
-    Method,
-    TServerFnResponseType,
-    TMiddlewares,
-    TValidator
-  >
 }
 
-export type MiddlewareClientFn<
-  TMiddlewares,
-  TValidator,
-  TSendContext,
-  TClientContext,
-  TServerFnResponseType extends ServerFnResponseType,
-> = (
-  options: MiddlewareClientFnOptions<
+export type FunctionMiddlewareServerNextFn<TMiddlewares, TServerSendContext> = <
+  TNewServerContext = undefined,
+  TSendContext = undefined,
+>(ctx?: {
+  context?: TNewServerContext
+  sendContext?: SerializerStringify<TSendContext>
+}) => Promise<
+  FunctionServerResultWithContext<
     TMiddlewares,
-    TValidator,
-    TServerFnResponseType
-  >,
-) => MiddlewareClientFnResult<TMiddlewares, TSendContext, TClientContext>
-
-export type MiddlewareClientFnResult<
-  TMiddlewares,
-  TSendContext,
-  TClientContext,
-> =
-  | Promise<ClientResultWithContext<TMiddlewares, TSendContext, TClientContext>>
-  | ClientResultWithContext<TMiddlewares, TSendContext, TClientContext>
+    TServerSendContext,
+    TNewServerContext,
+    TSendContext
+  >
+>
 
-export type ServerResultWithContext<
+export type FunctionServerResultWithContext<
   in out TMiddlewares,
   in out TServerSendContext,
   in out TServerContext,
@@ -299,70 +436,44 @@ export type ServerResultWithContext<
   sendContext: Expand<AssignAllClientSendContext<TMiddlewares, TSendContext>>
 }
 
-export type ClientResultWithContext<
-  in out TMiddlewares,
-  in out TSendContext,
-  in out TClientContext,
-> = {
-  'use functions must return the result of next()': true
-  context: Expand<AssignAllClientContextAfterNext<TMiddlewares, TClientContext>>
-  sendContext: Expand<AssignAllServerSendContext<TMiddlewares, TSendContext>>
-  headers: HeadersInit
-}
-
-export type AnyMiddleware = MiddlewareWithTypes<
-  any,
-  any,
-  any,
-  any,
-  any,
-  any,
-  any
->
-
-export interface MiddlewareTypes<
+export interface FunctionMiddlewareServerFnOptions<
   in out TMiddlewares,
   in out TValidator,
-  in out TServerContext,
   in out TServerSendContext,
-  in out TClientContext,
-  in out TClientSendContext,
+  in out TServerFnResponseType,
 > {
-  middlewares: TMiddlewares
-  input: ResolveValidatorInput<TValidator>
-  allInput: IntersectAllValidatorInputs<TMiddlewares, TValidator>
-  output: ResolveValidatorOutput<TValidator>
-  allOutput: IntersectAllValidatorOutputs<TMiddlewares, TValidator>
-  clientContext: TClientContext
-  allClientContextBeforeNext: AssignAllClientContextBeforeNext<
-    TMiddlewares,
-    TClientContext
-  >
-  allClientContextAfterNext: AssignAllClientContextAfterNext<
-    TMiddlewares,
-    TClientContext,
-    TClientSendContext
-  >
-  serverContext: TServerContext
-  serverSendContext: TServerSendContext
-  allServerSendContext: AssignAllServerSendContext<
-    TMiddlewares,
-    TServerSendContext
-  >
-  allServerContext: AssignAllServerContext<
-    TMiddlewares,
-    TServerSendContext,
-    TServerContext
-  >
-  clientSendContext: TClientSendContext
-  allClientSendContext: AssignAllClientSendContext<
-    TMiddlewares,
-    TClientSendContext
-  >
-  validator: TValidator
+  data: Expand<IntersectAllValidatorOutputs<TMiddlewares, TValidator>>
+  context: Expand<AssignAllServerContext<TMiddlewares, TServerSendContext>>
+  next: FunctionMiddlewareServerNextFn<TMiddlewares, TServerSendContext>
+  response: TServerFnResponseType
+  method: Method
+  filename: string
+  functionId: string
+  signal: AbortSignal
 }
 
-export interface MiddlewareWithTypes<
+export type FunctionMiddlewareServerFnResult<
+  TMiddlewares,
+  TServerSendContext,
+  TServerContext,
+  TSendContext,
+> =
+  | Promise<
+      FunctionServerResultWithContext<
+        TMiddlewares,
+        TServerSendContext,
+        TServerContext,
+        TSendContext
+      >
+    >
+  | FunctionServerResultWithContext<
+      TMiddlewares,
+      TServerSendContext,
+      TServerContext,
+      TSendContext
+    >
+
+export interface FunctionMiddlewareAfterServer<
   TMiddlewares,
   TValidator,
   TServerContext,
@@ -370,111 +481,110 @@ export interface MiddlewareWithTypes<
   TClientContext,
   TClientSendContext,
   TServerFnResponseType extends ServerFnResponseType,
-> {
-  _types: MiddlewareTypes<
+> extends FunctionMiddlewareWithTypes<
     TMiddlewares,
     TValidator,
     TServerContext,
     TServerSendContext,
     TClientContext,
-    TClientSendContext
-  >
-  options: MiddlewareOptions<
-    TMiddlewares,
-    TValidator,
-    TServerContext,
-    TClientContext,
+    TClientSendContext,
     TServerFnResponseType
-  >
-}
+  > {}
 
-export interface MiddlewareAfterValidator<
+export interface FunctionMiddlewareClient<
   TMiddlewares,
   TValidator,
   TServerFnResponseType extends ServerFnResponseType,
-> extends MiddlewareWithTypes<
-      TMiddlewares,
-      TValidator,
-      undefined,
-      undefined,
-      undefined,
-      undefined,
-      ServerFnResponseType
-    >,
-    MiddlewareServer<
+> {
+  client: <TSendServerContext = undefined, TNewClientContext = undefined>(
+    client: FunctionMiddlewareClientFn<
       TMiddlewares,
       TValidator,
-      undefined,
-      undefined,
+      TSendServerContext,
+      TNewClientContext,
       TServerFnResponseType
     >,
-    MiddlewareClient<TMiddlewares, TValidator, ServerFnResponseType> {}
-
-export interface MiddlewareValidator<
-  TMiddlewares,
-  TServerFnResponseType extends ServerFnResponseType,
-> {
-  validator: <TNewValidator>(
-    input: ConstrainValidator<TNewValidator>,
-  ) => MiddlewareAfterValidator<
+  ) => FunctionMiddlewareAfterClient<
     TMiddlewares,
-    TNewValidator,
-    TServerFnResponseType
+    TValidator,
+    TSendServerContext,
+    TNewClientContext,
+    ServerFnResponseType
   >
 }
 
-export interface MiddlewareAfterServer<
+export type FunctionMiddlewareClientFn<
   TMiddlewares,
   TValidator,
-  TServerContext,
-  TServerSendContext,
+  TSendContext,
   TClientContext,
-  TClientSendContext,
   TServerFnResponseType extends ServerFnResponseType,
-> extends MiddlewareWithTypes<
+> = (
+  options: FunctionMiddlewareClientFnOptions<
     TMiddlewares,
     TValidator,
-    TServerContext,
-    TServerSendContext,
-    TClientContext,
-    TClientSendContext,
     TServerFnResponseType
-  > {}
-
-export interface MiddlewareServer<
+  >,
+) => FunctionMiddlewareClientFnResult<
   TMiddlewares,
-  TValidator,
-  TServerSendContext,
-  TClientContext,
-  TServerFnResponseType extends ServerFnResponseType,
+  TSendContext,
+  TClientContext
+>
+
+export interface FunctionMiddlewareClientFnOptions<
+  in out TMiddlewares,
+  in out TValidator,
+  in out TServerFnResponseType extends ServerFnResponseType,
 > {
-  server: <TNewServerContext = undefined, TSendContext = undefined>(
-    server: MiddlewareServerFn<
-      TMiddlewares,
-      TValidator,
-      TServerSendContext,
-      TNewServerContext,
-      TSendContext,
-      TServerFnResponseType
-    >,
-  ) => MiddlewareAfterServer<
+  data: Expand<IntersectAllValidatorInputs<TMiddlewares, TValidator>>
+  context: Expand<AssignAllClientContextBeforeNext<TMiddlewares>>
+  sendContext: Expand<AssignAllServerSendContext<TMiddlewares>>
+  method: Method
+  response: TServerFnResponseType
+  signal: AbortSignal
+  next: FunctionMiddlewareClientNextFn<TMiddlewares>
+  filename: string
+  functionId: string
+  type: ServerFnTypeOrTypeFn<
+    Method,
+    TServerFnResponseType,
     TMiddlewares,
-    TValidator,
-    TNewServerContext,
-    TServerSendContext,
-    TClientContext,
-    TSendContext,
-    ServerFnResponseType
+    TValidator
   >
 }
 
-export interface MiddlewareAfterClient<
+export type FunctionMiddlewareClientFnResult<
+  TMiddlewares,
+  TSendContext,
+  TClientContext,
+> =
+  | Promise<
+      FunctionClientResultWithContext<
+        TMiddlewares,
+        TSendContext,
+        TClientContext
+      >
+    >
+  | FunctionClientResultWithContext<TMiddlewares, TSendContext, TClientContext>
+
+export type FunctionClientResultWithContext<
+  in out TMiddlewares,
+  in out TSendContext,
+  in out TClientContext,
+> = {
+  'use functions must return the result of next()': true
+  context: Expand<AssignAllClientContextAfterNext<TMiddlewares, TClientContext>>
+  sendContext: Expand<AssignAllServerSendContext<TMiddlewares, TSendContext>>
+  headers: HeadersInit
+}
+
+export interface FunctionMiddlewareAfterClient<
   TMiddlewares,
   TValidator,
   TServerSendContext,
   TClientContext,
   TServerFnResponseType extends ServerFnResponseType,
-> extends MiddlewareWithTypes<
+> extends FunctionMiddlewareWithTypes<
       TMiddlewares,
       TValidator,
       undefined,
@@ -483,7 +593,7 @@ export interface MiddlewareAfterClient<
       undefined,
       TServerFnResponseType
     >,
-    MiddlewareServer<
+    FunctionMiddlewareServer<
       TMiddlewares,
       TValidator,
       TServerSendContext,
@@ -491,105 +601,106 @@ export interface MiddlewareAfterClient<
       TServerFnResponseType
     > {}
 
-export interface MiddlewareClient<
+export interface FunctionMiddlewareValidator<
   TMiddlewares,
-  TValidator,
   TServerFnResponseType extends ServerFnResponseType,
 > {
-  client: <TSendServerContext = undefined, TNewClientContext = undefined>(
-    client: MiddlewareClientFn<
-      TMiddlewares,
-      TValidator,
-      TSendServerContext,
-      TNewClientContext,
-      TServerFnResponseType
-    >,
-  ) => MiddlewareAfterClient<
+  validator: <TNewValidator>(
+    input: ConstrainValidator<TNewValidator>,
+  ) => FunctionMiddlewareAfterValidator<
     TMiddlewares,
-    TValidator,
-    TSendServerContext,
-    TNewClientContext,
-    ServerFnResponseType
+    TNewValidator,
+    TServerFnResponseType
   >
 }
 
-export interface MiddlewareAfterMiddleware<
+export interface FunctionMiddlewareAfterValidator<
   TMiddlewares,
+  TValidator,
   TServerFnResponseType extends ServerFnResponseType,
-> extends MiddlewareWithTypes<
+> extends FunctionMiddlewareWithTypes<
       TMiddlewares,
+      TValidator,
       undefined,
       undefined,
       undefined,
       undefined,
-      undefined,
-      TServerFnResponseType
+      ServerFnResponseType
     >,
-    MiddlewareServer<
+    FunctionMiddlewareServer<
       TMiddlewares,
-      undefined,
+      TValidator,
       undefined,
       undefined,
       TServerFnResponseType
     >,
-    MiddlewareClient<TMiddlewares, undefined, TServerFnResponseType>,
-    MiddlewareValidator<TMiddlewares, TServerFnResponseType> {}
+    FunctionMiddlewareClient<TMiddlewares, TValidator, ServerFnResponseType> {}
 
-export interface Middleware<TServerFnResponseType extends ServerFnResponseType>
-  extends MiddlewareAfterMiddleware<unknown, TServerFnResponseType> {
-  middleware: <const TNewMiddlewares = undefined>(
-    middlewares: Constrain<TNewMiddlewares, ReadonlyArray<AnyMiddleware>>,
-  ) => MiddlewareAfterMiddleware<TNewMiddlewares, TServerFnResponseType>
+export interface RequestMiddleware
+  extends RequestMiddlewareAfterMiddleware<undefined> {
+  middleware: <const TMiddlewares = undefined>(
+    middlewares: Constrain<TMiddlewares, ReadonlyArray<AnyRequestMiddleware>>,
+  ) => RequestMiddlewareAfterMiddleware<TMiddlewares>
 }
 
-export function createMiddleware(
-  options?: {
-    validateClient?: boolean
-  },
-  __opts?: MiddlewareOptions<
-    unknown,
-    undefined,
-    undefined,
+export type AnyRequestMiddleware = RequestMiddlewareWithTypes<any, any>
+
+export interface RequestMiddlewareWithTypes<TMiddlewares, TServerContext> {
+  _types: RequestMiddlewareTypes<TMiddlewares, TServerContext>
+}
+
+export interface RequestMiddlewareTypes<TMiddlewares, TServerContext> {
+  type: 'request'
+  middlewares: TMiddlewares
+  serverContext: TServerContext
+  allServerContext: AssignAllServerContext<
+    TMiddlewares,
     undefined,
-    ServerFnResponseType
-  >,
-): Middleware<ServerFnResponseType> {
-  // const resolvedOptions = (__opts || options) as MiddlewareOptions<
-  const resolvedOptions =
-    __opts ||
-    ((options || {}) as MiddlewareOptions<
-      unknown,
-      undefined,
-      undefined,
-      undefined,
-      ServerFnResponseType
-    >)
+    TServerContext
+  >
+}
 
-  return {
-    options: resolvedOptions as any,
-    middleware: (middleware: any) => {
-      return createMiddleware(
-        undefined,
-        Object.assign(resolvedOptions, { middleware }),
-      ) as any
-    },
-    validator: (validator: any) => {
-      return createMiddleware(
-        undefined,
-        Object.assign(resolvedOptions, { validator }),
-      ) as any
-    },
-    client: (client: any) => {
-      return createMiddleware(
-        undefined,
-        Object.assign(resolvedOptions, { client }),
-      ) as any
-    },
-    server: (server: any) => {
-      return createMiddleware(
-        undefined,
-        Object.assign(resolvedOptions, { server }),
-      ) as any
-    },
-  } as unknown as Middleware<ServerFnResponseType>
+export interface RequestMiddlewareAfterMiddleware<TMiddlewares>
+  extends RequestMiddlewareWithTypes<TMiddlewares, undefined>,
+    RequestMiddlewareServer<TMiddlewares> {}
+
+export interface RequestMiddlewareServer<TMiddlewares> {
+  server: <TServerContext = undefined>(
+    fn: RequestServerFn<TMiddlewares, TServerContext>,
+  ) => RequestMiddlewareAfterServer<TMiddlewares, TServerContext>
+}
+
+export type RequestServerFn<TMiddlewares, TServerContext> = (
+  options: RequestServerOptions<TMiddlewares>,
+) => RequestMiddlewareServerFnResult<TMiddlewares, TServerContext>
+
+export interface RequestServerOptions<TMiddlewares> {
+  request: Request
+  pathname: string
+  context: AssignAllServerContext<TMiddlewares>
+  next: RequestServerNextFn<TMiddlewares>
+}
+
+export type RequestServerNextFn<TMiddlewares> = <TServerContext = undefined>(
+  options?: RequestServerNextFnOptions<TServerContext>,
+) => RequestMiddlewareServerFnResult<TMiddlewares, TServerContext>
+
+export interface RequestServerNextFnOptions<TServerContext> {
+  context?: TServerContext
+}
+
+export type RequestMiddlewareServerFnResult<TMiddlewares, TServerContext> =
+  | Promise<RequestServerResult<TMiddlewares, TServerContext>>
+  | RequestServerResult<TMiddlewares, TServerContext>
+
+export interface RequestServerResult<TMiddlewares, TServerContext> {
+  request: Request
+  pathname: string
+  context: Expand<
+    AssignAllServerContext<TMiddlewares, undefined, TServerContext>
+  >
+  response: Response
 }
+
+export interface RequestMiddlewareAfterServer<TMiddlewares, TServerContext>
+  extends RequestMiddlewareWithTypes<TMiddlewares, TServerContext> {}