@tanstack/start-client-core 1.120.4-alpha.19 → 1.120.5

package/src/createMiddleware.ts

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