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

package/src/createServerFn.ts

@@ -16,15 +16,17 @@ import type {
 } from '@tanstack/router-core'
 import type { Readable } from 'node:stream'
 import type {
-  AnyMiddleware,
+  AnyFunctionMiddleware,
   AssignAllClientSendContext,
   AssignAllServerContext,
+  FunctionMiddlewareClientFnResult,
+  FunctionMiddlewareServerFnResult,
   IntersectAllValidatorInputs,
   IntersectAllValidatorOutputs,
-  MiddlewareClientFnResult,
-  MiddlewareServerFnResult,
 } from './createMiddleware'
 
+type TODO = any
+
 export function createServerFn<
   TMethod extends Method,
   TServerFnResponseType extends ServerFnResponseType = 'data',
@@ -215,8 +217,8 @@ export function createServerFn<
   }
 }
 
-async function executeMiddleware(
-  middlewares: Array<AnyMiddleware>,
+export async function executeMiddleware(
+  middlewares: Array<AnyFunctionMiddleware>,
   env: 'client' | 'server',
   opts: ServerFnMiddlewareOptions,
 ): Promise<ServerFnMiddlewareResult> {
@@ -398,6 +400,7 @@ export type ServerFnReturnType<
 > = TServerFnResponseType extends 'raw'
   ? RawResponse | Promise<RawResponse>
   : Promise<SerializerStringify<TResponse>> | SerializerStringify<TResponse>
+
 export type ServerFn<
   TMethod,
   TServerFnResponseType extends ServerFnResponseType,
@@ -442,7 +445,7 @@ export type ServerFnBaseOptions<
   method: TMethod
   response?: TServerFnResponseType
   validateClient?: boolean
-  middleware?: Constrain<TMiddlewares, ReadonlyArray<AnyMiddleware>>
+  middleware?: Constrain<TMiddlewares, ReadonlyArray<AnyFunctionMiddleware>>
   validator?: ConstrainValidator<TInput>
   extractedFn?: CompiledFetcherFn<TResponse, TServerFnResponseType>
   serverFn?: ServerFn<
@@ -485,7 +488,10 @@ export interface ServerFnMiddleware<
   TValidator,
 > {
   middleware: <const TNewMiddlewares = undefined>(
-    middlewares: Constrain<TNewMiddlewares, ReadonlyArray<AnyMiddleware>>,
+    middlewares: Constrain<
+      TNewMiddlewares,
+      ReadonlyArray<AnyFunctionMiddleware>
+    >,
   ) => ServerFnAfterMiddleware<
     TMethod,
     TServerFnResponseType,
@@ -812,12 +818,12 @@ export function extractFormDataContext(formData: FormData) {
 }
 
 export function flattenMiddlewares(
-  middlewares: Array<AnyMiddleware>,
-): Array<AnyMiddleware> {
-  const seen = new Set<AnyMiddleware>()
-  const flattened: Array<AnyMiddleware> = []
+  middlewares: Array<AnyFunctionMiddleware>,
+): Array<AnyFunctionMiddleware> {
+  const seen = new Set<AnyFunctionMiddleware>()
+  const flattened: Array<AnyFunctionMiddleware> = []
 
-  const recurse = (middleware: Array<AnyMiddleware>) => {
+  const recurse = (middleware: Array<AnyFunctionMiddleware>) => {
     middleware.forEach((m) => {
       if (m.options.middleware) {
         recurse(m.options.middleware)
@@ -929,7 +935,7 @@ export function execValidator(
 
 export function serverFnBaseToMiddleware(
   options: ServerFnBaseOptions<any, any, any, any, any>,
-): AnyMiddleware {
+): AnyFunctionMiddleware {
   return {
     _types: undefined!,
     options: {
@@ -973,16 +979,25 @@ export function serverFnBaseToMiddleware(
         // but not before serializing the context
         const res = await options.extractedFn?.(payload)
 
-        return next(res) as unknown as MiddlewareClientFnResult<any, any, any>
+        return next(res) as unknown as FunctionMiddlewareClientFnResult<
+          any,
+          any,
+          any
+        >
       },
       server: async ({ next, ...ctx }) => {
         // Execute the server function
-        const result = await options.serverFn?.(ctx)
+        const result = await options.serverFn?.(ctx as TODO)
 
         return next({
           ...ctx,
           result,
-        } as any) as unknown as MiddlewareServerFnResult<any, any, any, any>
+        } as any) as unknown as FunctionMiddlewareServerFnResult<
+          any,
+          any,
+          any,
+          any
+        >
       },
     },
   }

package/src/index.tsx

@@ -25,30 +25,30 @@ export {
   createMiddleware,
   type IntersectAllValidatorInputs,
   type IntersectAllValidatorOutputs,
-  type MiddlewareServerFn,
-  type AnyMiddleware,
-  type MiddlewareOptions,
-  type MiddlewareWithTypes,
-  type MiddlewareValidator,
-  type MiddlewareServer,
-  type MiddlewareAfterClient,
-  type MiddlewareAfterMiddleware,
-  type MiddlewareAfterServer,
-  type Middleware,
-  type MiddlewareClientFnOptions,
-  type MiddlewareClientFnResult,
-  type MiddlewareClientNextFn,
-  type ClientResultWithContext,
+  type FunctionMiddlewareServerFn,
+  type AnyFunctionMiddleware,
+  type FunctionMiddlewareOptions,
+  type FunctionMiddlewareWithTypes,
+  type FunctionMiddlewareValidator,
+  type FunctionMiddlewareServer,
+  type FunctionMiddlewareAfterClient,
+  type FunctionMiddlewareAfterServer,
+  type FunctionMiddleware,
+  type FunctionMiddlewareClientFnOptions,
+  type FunctionMiddlewareClientFnResult,
+  type FunctionMiddlewareClientNextFn,
+  type FunctionClientResultWithContext,
   type AssignAllClientContextBeforeNext,
   type AssignAllMiddleware,
   type AssignAllServerContext,
-  type MiddlewareAfterValidator,
-  type MiddlewareClientFn,
-  type MiddlewareServerFnResult,
-  type MiddlewareClient,
-  type MiddlewareServerFnOptions,
-  type MiddlewareServerNextFn,
-  type ServerResultWithContext,
+  type FunctionMiddlewareAfterValidator,
+  type FunctionMiddlewareClientFn,
+  type FunctionMiddlewareServerFnResult,
+  type FunctionMiddlewareClient,
+  type FunctionMiddlewareServerFnOptions,
+  type FunctionMiddlewareServerNextFn,
+  type FunctionServerResultWithContext,
+  type AnyRequestMiddleware,
 } from './createMiddleware'
 export {
   registerGlobalMiddleware,
@@ -84,4 +84,5 @@ export {
   extractFormDataContext,
   flattenMiddlewares,
   serverFnStaticCache,
+  executeMiddleware,
 } from './createServerFn'

package/src/registerGlobalMiddleware.ts

@@ -1,9 +1,9 @@
-import type { AnyMiddleware } from './createMiddleware'
+import type { AnyFunctionMiddleware } from './createMiddleware'
 
-export const globalMiddleware: Array<AnyMiddleware> = []
+export const globalMiddleware: Array<AnyFunctionMiddleware> = []
 
 export function registerGlobalMiddleware(options: {
-  middleware: Array<AnyMiddleware>
+  middleware: Array<AnyFunctionMiddleware>
 }) {
   globalMiddleware.push(...options.middleware)
 }

package/src/tests/createServerFn.test-d.ts

@@ -60,21 +60,25 @@ test('createServerFn with validator', () => {
 })
 
 test('createServerFn with middleware and context', () => {
-  const middleware1 = createMiddleware().server(({ next }) => {
-    return next({ context: { a: 'a' } as const })
-  })
+  const middleware1 = createMiddleware({ type: 'function' }).server(
+    ({ next }) => {
+      return next({ context: { a: 'a' } as const })
+    },
+  )
 
-  const middleware2 = createMiddleware().server(({ next }) => {
-    return next({ context: { b: 'b' } as const })
-  })
+  const middleware2 = createMiddleware({ type: 'function' }).server(
+    ({ next }) => {
+      return next({ context: { b: 'b' } as const })
+    },
+  )
 
-  const middleware3 = createMiddleware()
+  const middleware3 = createMiddleware({ type: 'function' })
     .middleware([middleware1, middleware2])
     .client(({ next }) => {
       return next({ context: { c: 'c' } as const })
     })
 
-  const middleware4 = createMiddleware()
+  const middleware4 = createMiddleware({ type: 'function' })
     .middleware([middleware3])
     .client(({ context, next }) => {
       return next({ sendContext: context })
@@ -113,21 +117,24 @@ test('createServerFn with middleware and context', () => {
 })
 
 describe('createServerFn with middleware and validator', () => {
-  const middleware1 = createMiddleware().validator(
+  const middleware1 = createMiddleware({ type: 'function' }).validator(
     (input: { readonly inputA: 'inputA' }) =>
       ({
         outputA: 'outputA',
       }) as const,
   )
 
-  const middleware2 = createMiddleware().validator(
+  const middleware2 = createMiddleware({ type: 'function' }).validator(
     (input: { readonly inputB: 'inputB' }) =>
       ({
         outputB: 'outputB',
       }) as const,
   )
 
-  const middleware3 = createMiddleware().middleware([middleware1, middleware2])
+  const middleware3 = createMiddleware({ type: 'function' }).middleware([
+    middleware1,
+    middleware2,
+  ])
 
   test(`response: 'data'`, () => {
     const fn = createServerFn({ method: 'GET', response: 'data' })
@@ -222,7 +229,7 @@ describe('createServerFn with middleware and validator', () => {
 })
 
 test('createServerFn overrides properties', () => {
-  const middleware1 = createMiddleware()
+  const middleware1 = createMiddleware({ type: 'function' })
     .validator(
       () =>
         ({
@@ -246,7 +253,7 @@ test('createServerFn overrides properties', () => {
       return next({ sendContext: newContext, context: newContext })
     })
 
-  const middleware2 = createMiddleware()
+  const middleware2 = createMiddleware({ type: 'function' })
     .middleware([middleware1])
     .validator(
       () =>

package/src/tests/createServerMiddleware.test-d.ts

@@ -1,10 +1,11 @@
 import { expectTypeOf, test } from 'vitest'
 import { createMiddleware } from '../createMiddleware'
+import type { RequestServerNextFn } from '../createMiddleware'
 import type { Constrain, Validator } from '@tanstack/router-core'
 import type { ConstrainValidator } from '../createServerFn'
 
 test('createServeMiddleware removes middleware after middleware,', () => {
-  const middleware = createMiddleware()
+  const middleware = createMiddleware({ type: 'function' })
 
   expectTypeOf(middleware).toHaveProperty('middleware')
   expectTypeOf(middleware).toHaveProperty('server')
@@ -45,51 +46,55 @@ test('createServeMiddleware removes middleware after middleware,', () => {
 })
 
 test('createMiddleware merges server context', () => {
-  const middleware1 = createMiddleware().server(async (options) => {
-    expectTypeOf(options.context).toEqualTypeOf<undefined>()
-    expectTypeOf(options.data).toEqualTypeOf<undefined>()
-    expectTypeOf(options.method).toEqualTypeOf<'GET' | 'POST'>()
+  const middleware1 = createMiddleware({ type: 'function' }).server(
+    async (options) => {
+      expectTypeOf(options.context).toEqualTypeOf<undefined>()
+      expectTypeOf(options.data).toEqualTypeOf<undefined>()
+      expectTypeOf(options.method).toEqualTypeOf<'GET' | 'POST'>()
 
-    const result = await options.next({ context: { a: true } })
+      const result = await options.next({ context: { a: true } })
 
-    expectTypeOf(result).toEqualTypeOf<{
-      'use functions must return the result of next()': true
-      _types: {
-        context: {
-          a: boolean
+      expectTypeOf(result).toEqualTypeOf<{
+        'use functions must return the result of next()': true
+        _types: {
+          context: {
+            a: boolean
+          }
+          sendContext: undefined
         }
+        context: { a: boolean }
         sendContext: undefined
-      }
-      context: { a: boolean }
-      sendContext: undefined
-    }>()
+      }>()
 
-    return result
-  })
+      return result
+    },
+  )
 
-  const middleware2 = createMiddleware().server(async (options) => {
-    expectTypeOf(options.context).toEqualTypeOf<undefined>()
-    expectTypeOf(options.data).toEqualTypeOf<undefined>()
-    expectTypeOf(options.method).toEqualTypeOf<'GET' | 'POST'>()
+  const middleware2 = createMiddleware({ type: 'function' }).server(
+    async (options) => {
+      expectTypeOf(options.context).toEqualTypeOf<undefined>()
+      expectTypeOf(options.data).toEqualTypeOf<undefined>()
+      expectTypeOf(options.method).toEqualTypeOf<'GET' | 'POST'>()
 
-    const result = await options.next({ context: { b: 'test' } })
+      const result = await options.next({ context: { b: 'test' } })
 
-    expectTypeOf(result).toEqualTypeOf<{
-      'use functions must return the result of next()': true
-      _types: {
-        context: {
-          b: string
+      expectTypeOf(result).toEqualTypeOf<{
+        'use functions must return the result of next()': true
+        _types: {
+          context: {
+            b: string
+          }
+          sendContext: undefined
         }
+        context: { b: string }
         sendContext: undefined
-      }
-      context: { b: string }
-      sendContext: undefined
-    }>()
+      }>()
 
-    return result
-  })
+      return result
+    },
+  )
 
-  const middleware3 = createMiddleware()
+  const middleware3 = createMiddleware({ type: 'function' })
     .middleware([middleware1, middleware2])
     .server(async (options) => {
       expectTypeOf(options.context).toEqualTypeOf<{ a: boolean; b: string }>()
@@ -111,7 +116,7 @@ test('createMiddleware merges server context', () => {
       return result
     })
 
-  createMiddleware()
+  createMiddleware({ type: 'function' })
     .middleware([middleware3])
     .server(async (options) => {
       expectTypeOf(options.context).toEqualTypeOf<{
@@ -139,37 +144,41 @@ test('createMiddleware merges server context', () => {
 })
 
 test('createMiddleware merges client context and sends to the server', () => {
-  const middleware1 = createMiddleware().client(async (options) => {
-    expectTypeOf(options.context).toEqualTypeOf<undefined>()
+  const middleware1 = createMiddleware({ type: 'function' }).client(
+    async (options) => {
+      expectTypeOf(options.context).toEqualTypeOf<undefined>()
 
-    const result = await options.next({ context: { a: true } })
+      const result = await options.next({ context: { a: true } })
 
-    expectTypeOf(result).toEqualTypeOf<{
-      'use functions must return the result of next()': true
-      context: { a: boolean }
-      sendContext: undefined
-      headers: HeadersInit
-    }>()
+      expectTypeOf(result).toEqualTypeOf<{
+        'use functions must return the result of next()': true
+        context: { a: boolean }
+        sendContext: undefined
+        headers: HeadersInit
+      }>()
 
-    return result
-  })
+      return result
+    },
+  )
 
-  const middleware2 = createMiddleware().client(async (options) => {
-    expectTypeOf(options.context).toEqualTypeOf<undefined>()
+  const middleware2 = createMiddleware({ type: 'function' }).client(
+    async (options) => {
+      expectTypeOf(options.context).toEqualTypeOf<undefined>()
 
-    const result = await options.next({ context: { b: 'test' } })
+      const result = await options.next({ context: { b: 'test' } })
 
-    expectTypeOf(result).toEqualTypeOf<{
-      'use functions must return the result of next()': true
-      context: { b: string }
-      sendContext: undefined
-      headers: HeadersInit
-    }>()
+      expectTypeOf(result).toEqualTypeOf<{
+        'use functions must return the result of next()': true
+        context: { b: string }
+        sendContext: undefined
+        headers: HeadersInit
+      }>()
 
-    return result
-  })
+      return result
+    },
+  )
 
-  const middleware3 = createMiddleware()
+  const middleware3 = createMiddleware({ type: 'function' })
     .middleware([middleware1, middleware2])
     .client(async (options) => {
       expectTypeOf(options.context).toEqualTypeOf<{ a: boolean; b: string }>()
@@ -186,7 +195,7 @@ test('createMiddleware merges client context and sends to the server', () => {
       return result
     })
 
-  const middleware4 = createMiddleware()
+  const middleware4 = createMiddleware({ type: 'function' })
     .middleware([middleware3])
     .client(async (options) => {
       expectTypeOf(options.context).toEqualTypeOf<{
@@ -209,7 +218,7 @@ test('createMiddleware merges client context and sends to the server', () => {
       return result
     })
 
-  createMiddleware()
+  createMiddleware({ type: 'function' })
     .middleware([middleware4])
     .server(async (options) => {
       expectTypeOf(options.context).toEqualTypeOf<{
@@ -242,7 +251,7 @@ test('createMiddleware merges client context and sends to the server', () => {
 })
 
 test('createMiddleware merges input', () => {
-  const middleware1 = createMiddleware()
+  const middleware1 = createMiddleware({ type: 'function' })
     .validator(() => {
       return {
         a: 'a',
@@ -253,7 +262,7 @@ test('createMiddleware merges input', () => {
       return next()
     })
 
-  const middleware2 = createMiddleware()
+  const middleware2 = createMiddleware({ type: 'function' })
     .middleware([middleware1])
     .validator(() => {
       return {
@@ -265,7 +274,7 @@ test('createMiddleware merges input', () => {
       return next()
     })
 
-  createMiddleware()
+  createMiddleware({ type: 'function' })
     .middleware([middleware2])
     .validator(() => ({ c: 'c' }) as const)
     .server(({ next, data }) => {
@@ -279,7 +288,7 @@ test('createMiddleware merges input', () => {
 })
 
 test('createMiddleware merges server context and client context, sends server context to the client and merges ', () => {
-  const middleware1 = createMiddleware()
+  const middleware1 = createMiddleware({ type: 'function' })
     .client(async (options) => {
       expectTypeOf(options.context).toEqualTypeOf<undefined>()
 
@@ -318,7 +327,7 @@ test('createMiddleware merges server context and client context, sends server co
       return result
     })
 
-  const middleware2 = createMiddleware()
+  const middleware2 = createMiddleware({ type: 'function' })
     .client(async (options) => {
       expectTypeOf(options.context).toEqualTypeOf<undefined>()
 
@@ -357,7 +366,7 @@ test('createMiddleware merges server context and client context, sends server co
       return result
     })
 
-  const middleware3 = createMiddleware()
+  const middleware3 = createMiddleware({ type: 'function' })
     .middleware([middleware1, middleware2])
     .client(async (options) => {
       expectTypeOf(options.context).toEqualTypeOf<{
@@ -411,7 +420,7 @@ test('createMiddleware merges server context and client context, sends server co
       return result
     })
 
-  const middleware4 = createMiddleware()
+  const middleware4 = createMiddleware({ type: 'function' })
     .middleware([middleware3])
     .client(async (options) => {
       expectTypeOf(options.context).toEqualTypeOf<{
@@ -475,7 +484,7 @@ test('createMiddleware merges server context and client context, sends server co
       return result
     })
 
-  createMiddleware()
+  createMiddleware({ type: 'function' })
     .middleware([middleware4])
     .client(async (options) => {
       expectTypeOf(options.context).toEqualTypeOf<{
@@ -548,7 +557,7 @@ test('createMiddleware merges server context and client context, sends server co
 })
 
 test('createMiddleware sendContext cannot send a function', () => {
-  createMiddleware()
+  createMiddleware({ type: 'function' })
     .client(({ next }) => {
       expectTypeOf(next<{ func: () => 'func' }>)
         .parameter(0)
@@ -570,7 +579,7 @@ test('createMiddleware sendContext cannot send a function', () => {
 })
 
 test('createMiddleware cannot validate function', () => {
-  const validator = createMiddleware().validator<
+  const validator = createMiddleware({ type: 'function' }).validator<
     (input: { func: () => 'string' }) => { output: 'string' }
   >
 
@@ -585,7 +594,7 @@ test('createMiddleware cannot validate function', () => {
 })
 
 test('createMiddleware can validate Date', () => {
-  const validator = createMiddleware().validator<
+  const validator = createMiddleware({ type: 'function' }).validator<
     (input: Date) => { output: 'string' }
   >
 
@@ -595,7 +604,7 @@ test('createMiddleware can validate Date', () => {
 })
 
 test('createMiddleware can validate FormData', () => {
-  const validator = createMiddleware().validator<
+  const validator = createMiddleware({ type: 'function' }).validator<
     (input: FormData) => { output: 'string' }
   >
 
@@ -606,8 +615,22 @@ test('createMiddleware can validate FormData', () => {
     >()
 })
 
+test('createMiddleware merging from parent with undefined validator', () => {
+  const middleware1 = createMiddleware({ type: 'function' }).validator(
+    (input: { test: string }) => input.test,
+  )
+
+  createMiddleware({ type: 'function' })
+    .middleware([middleware1])
+    .server((ctx) => {
+      expectTypeOf(ctx.data).toEqualTypeOf<string>()
+
+      return ctx.next()
+    })
+})
+
 test('createMiddleware validator infers unknown for default input type', () => {
-  createMiddleware()
+  createMiddleware({ type: 'function' })
     .validator((input) => {
       expectTypeOf(input).toEqualTypeOf<unknown>()
 
@@ -621,3 +644,93 @@ test('createMiddleware validator infers unknown for default input type', () => {
       return next()
     })
 })
+
+test('createMiddleware with type request, no middleware or context', () => {
+  createMiddleware({ type: 'request' }).server(async (options) => {
+    expectTypeOf(options).toEqualTypeOf<{
+      request: Request
+      next: RequestServerNextFn<undefined>
+      pathname: string
+      context: undefined
+    }>()
+
+    const result = await options.next()
+
+    expectTypeOf(result).toEqualTypeOf<{
+      context: undefined
+      pathname: string
+      request: Request
+      response: Response
+    }>()
+
+    return result
+  })
+})
+
+test('createMiddleware with type request, no middleware with context', () => {
+  createMiddleware({ type: 'request' }).server(async (options) => {
+    expectTypeOf(options).toEqualTypeOf<{
+      request: Request
+      next: RequestServerNextFn<undefined>
+      pathname: string
+      context: undefined
+    }>()
+
+    const result = await options.next({ context: { a: 'a' } })
+
+    expectTypeOf(result).toEqualTypeOf<{
+      context: { a: string }
+      pathname: string
+      request: Request
+      response: Response
+    }>()
+
+    return result
+  })
+})
+
+test('createMiddleware with type request, middleware and context', () => {
+  const middleware1 = createMiddleware({ type: 'request' }).server(
+    async (options) => {
+      expectTypeOf(options).toEqualTypeOf<{
+        request: Request
+        next: RequestServerNextFn<undefined>
+        pathname: string
+        context: undefined
+      }>()
+
+      const result = await options.next({ context: { a: 'a' } })
+
+      expectTypeOf(result).toEqualTypeOf<{
+        context: { a: string }
+        pathname: string
+        request: Request
+        response: Response
+      }>()
+
+      return result
+    },
+  )
+
+  createMiddleware({ type: 'request' })
+    .middleware([middleware1])
+    .server(async (options) => {
+      expectTypeOf(options).toEqualTypeOf<{
+        request: Request
+        next: RequestServerNextFn<undefined>
+        pathname: string
+        context: { a: string }
+      }>()
+
+      const result = await options.next({ context: { b: 'b' } })
+
+      expectTypeOf(result).toEqualTypeOf<{
+        context: { a: string; b: string }
+        pathname: string
+        request: Request
+        response: Response
+      }>()
+
+      return result
+    })
+})