@tanstack/start-client-core 1.120.7 → 1.121.0-alpha.11

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
+    })
+})