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

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

@@ -1,11 +1,10 @@
 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({ type: 'function' })
+  const middleware = createMiddleware()
 
   expectTypeOf(middleware).toHaveProperty('middleware')
   expectTypeOf(middleware).toHaveProperty('server')
@@ -46,55 +45,51 @@ test('createServeMiddleware removes middleware after middleware,', () => {
 })
 
 test('createMiddleware merges server context', () => {
-  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 middleware1 = createMiddleware().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
-          }
-          sendContext: undefined
+    expectTypeOf(result).toEqualTypeOf<{
+      'use functions must return the result of next()': true
+      _types: {
+        context: {
+          a: boolean
         }
-        context: { a: boolean }
         sendContext: undefined
-      }>()
+      }
+      context: { a: boolean }
+      sendContext: undefined
+    }>()
 
-      return result
-    },
-  )
+    return result
+  })
 
-  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 middleware2 = createMiddleware().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
-          }
-          sendContext: undefined
+    expectTypeOf(result).toEqualTypeOf<{
+      'use functions must return the result of next()': true
+      _types: {
+        context: {
+          b: string
         }
-        context: { b: string }
         sendContext: undefined
-      }>()
+      }
+      context: { b: string }
+      sendContext: undefined
+    }>()
 
-      return result
-    },
-  )
+    return result
+  })
 
-  const middleware3 = createMiddleware({ type: 'function' })
+  const middleware3 = createMiddleware()
     .middleware([middleware1, middleware2])
     .server(async (options) => {
       expectTypeOf(options.context).toEqualTypeOf<{ a: boolean; b: string }>()
@@ -116,7 +111,7 @@ test('createMiddleware merges server context', () => {
       return result
     })
 
-  createMiddleware({ type: 'function' })
+  createMiddleware()
     .middleware([middleware3])
     .server(async (options) => {
       expectTypeOf(options.context).toEqualTypeOf<{
@@ -144,41 +139,37 @@ test('createMiddleware merges server context', () => {
 })
 
 test('createMiddleware merges client context and sends to the server', () => {
-  const middleware1 = createMiddleware({ type: 'function' }).client(
-    async (options) => {
-      expectTypeOf(options.context).toEqualTypeOf<undefined>()
+  const middleware1 = createMiddleware().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({ type: 'function' }).client(
-    async (options) => {
-      expectTypeOf(options.context).toEqualTypeOf<undefined>()
+  const middleware2 = createMiddleware().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({ type: 'function' })
+  const middleware3 = createMiddleware()
     .middleware([middleware1, middleware2])
     .client(async (options) => {
       expectTypeOf(options.context).toEqualTypeOf<{ a: boolean; b: string }>()
@@ -195,7 +186,7 @@ test('createMiddleware merges client context and sends to the server', () => {
       return result
     })
 
-  const middleware4 = createMiddleware({ type: 'function' })
+  const middleware4 = createMiddleware()
     .middleware([middleware3])
     .client(async (options) => {
       expectTypeOf(options.context).toEqualTypeOf<{
@@ -218,7 +209,7 @@ test('createMiddleware merges client context and sends to the server', () => {
       return result
     })
 
-  createMiddleware({ type: 'function' })
+  createMiddleware()
     .middleware([middleware4])
     .server(async (options) => {
       expectTypeOf(options.context).toEqualTypeOf<{
@@ -251,7 +242,7 @@ test('createMiddleware merges client context and sends to the server', () => {
 })
 
 test('createMiddleware merges input', () => {
-  const middleware1 = createMiddleware({ type: 'function' })
+  const middleware1 = createMiddleware()
     .validator(() => {
       return {
         a: 'a',
@@ -262,7 +253,7 @@ test('createMiddleware merges input', () => {
       return next()
     })
 
-  const middleware2 = createMiddleware({ type: 'function' })
+  const middleware2 = createMiddleware()
     .middleware([middleware1])
     .validator(() => {
       return {
@@ -274,7 +265,7 @@ test('createMiddleware merges input', () => {
       return next()
     })
 
-  createMiddleware({ type: 'function' })
+  createMiddleware()
     .middleware([middleware2])
     .validator(() => ({ c: 'c' }) as const)
     .server(({ next, data }) => {
@@ -288,7 +279,7 @@ test('createMiddleware merges input', () => {
 })
 
 test('createMiddleware merges server context and client context, sends server context to the client and merges ', () => {
-  const middleware1 = createMiddleware({ type: 'function' })
+  const middleware1 = createMiddleware()
     .client(async (options) => {
       expectTypeOf(options.context).toEqualTypeOf<undefined>()
 
@@ -327,7 +318,7 @@ test('createMiddleware merges server context and client context, sends server co
       return result
     })
 
-  const middleware2 = createMiddleware({ type: 'function' })
+  const middleware2 = createMiddleware()
     .client(async (options) => {
       expectTypeOf(options.context).toEqualTypeOf<undefined>()
 
@@ -366,7 +357,7 @@ test('createMiddleware merges server context and client context, sends server co
       return result
     })
 
-  const middleware3 = createMiddleware({ type: 'function' })
+  const middleware3 = createMiddleware()
     .middleware([middleware1, middleware2])
     .client(async (options) => {
       expectTypeOf(options.context).toEqualTypeOf<{
@@ -420,7 +411,7 @@ test('createMiddleware merges server context and client context, sends server co
       return result
     })
 
-  const middleware4 = createMiddleware({ type: 'function' })
+  const middleware4 = createMiddleware()
     .middleware([middleware3])
     .client(async (options) => {
       expectTypeOf(options.context).toEqualTypeOf<{
@@ -484,7 +475,7 @@ test('createMiddleware merges server context and client context, sends server co
       return result
     })
 
-  createMiddleware({ type: 'function' })
+  createMiddleware()
     .middleware([middleware4])
     .client(async (options) => {
       expectTypeOf(options.context).toEqualTypeOf<{
@@ -557,7 +548,7 @@ test('createMiddleware merges server context and client context, sends server co
 })
 
 test('createMiddleware sendContext cannot send a function', () => {
-  createMiddleware({ type: 'function' })
+  createMiddleware()
     .client(({ next }) => {
       expectTypeOf(next<{ func: () => 'func' }>)
         .parameter(0)
@@ -579,7 +570,7 @@ test('createMiddleware sendContext cannot send a function', () => {
 })
 
 test('createMiddleware cannot validate function', () => {
-  const validator = createMiddleware({ type: 'function' }).validator<
+  const validator = createMiddleware().validator<
     (input: { func: () => 'string' }) => { output: 'string' }
   >
 
@@ -594,7 +585,7 @@ test('createMiddleware cannot validate function', () => {
 })
 
 test('createMiddleware can validate Date', () => {
-  const validator = createMiddleware({ type: 'function' }).validator<
+  const validator = createMiddleware().validator<
     (input: Date) => { output: 'string' }
   >
 
@@ -604,7 +595,7 @@ test('createMiddleware can validate Date', () => {
 })
 
 test('createMiddleware can validate FormData', () => {
-  const validator = createMiddleware({ type: 'function' }).validator<
+  const validator = createMiddleware().validator<
     (input: FormData) => { output: 'string' }
   >
 
@@ -615,22 +606,8 @@ 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({ type: 'function' })
+  createMiddleware()
     .validator((input) => {
       expectTypeOf(input).toEqualTypeOf<unknown>()
 
@@ -644,93 +621,3 @@ 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
-    })
-})