@tanstack/start-client-core 1.132.0-alpha.7 → 1.132.0-alpha.9

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

@@ -1,7 +1,7 @@
 import { describe, expectTypeOf, test } from 'vitest'
 import { createMiddleware } from '../createMiddleware'
 import { createServerFn } from '../createServerFn'
-import type { Constrain, Validator } from '@tanstack/router-core'
+import type { Constrain, Register, Validator } from '@tanstack/router-core'
 import type { ConstrainValidator } from '../createServerFn'
 
 test('createServerFn method with autocomplete', () => {
@@ -97,7 +97,6 @@ test('createServerFn with middleware and context', () => {
 
   expectTypeOf(fnWithMiddleware).toHaveProperty('handler')
   expectTypeOf(fnWithMiddleware).toHaveProperty('validator')
-  expectTypeOf(fnWithMiddleware).not.toHaveProperty('middleware')
 
   fnWithMiddleware.handler((options) => {
     expectTypeOf(options).toEqualTypeOf<{
@@ -398,7 +397,9 @@ test('createServerFn can validate Date', () => {
 
   expectTypeOf(validator)
     .parameter(0)
-    .toEqualTypeOf<ConstrainValidator<(input: Date) => { output: 'string' }>>()
+    .toEqualTypeOf<
+      ConstrainValidator<Register, (input: Date) => { output: 'string' }>
+    >()
 })
 
 test('createServerFn can validate FormData', () => {
@@ -409,7 +410,7 @@ test('createServerFn can validate FormData', () => {
   expectTypeOf(validator)
     .parameter(0)
     .toEqualTypeOf<
-      ConstrainValidator<(input: FormData) => { output: 'string' }>
+      ConstrainValidator<Register, (input: FormData) => { output: 'string' }>
     >()
 })
 
@@ -511,3 +512,88 @@ test('createServerFn validator infers unknown for default input type', () => {
 
   expectTypeOf(fn()).toEqualTypeOf<Promise<'failed' | 'success'>>()
 })
+
+test('incrementally building createServerFn with multiple middleware calls', () => {
+  const middleware1 = createMiddleware({ type: 'function' }).server(
+    ({ next }) => {
+      return next({ context: { a: 'a' } as const })
+    },
+  )
+
+  const middleware2 = createMiddleware({ type: 'function' }).server(
+    ({ next }) => {
+      return next({ context: { b: 'b' } as const })
+    },
+  )
+
+  const middleware3 = createMiddleware({ type: 'function' }).server(
+    ({ next }) => {
+      return next({ context: { c: 'c' } as const })
+    },
+  )
+
+  const builderWithMw1 = createServerFn({ method: 'GET' }).middleware([
+    middleware1,
+  ])
+
+  expectTypeOf(builderWithMw1).toHaveProperty('handler')
+  expectTypeOf(builderWithMw1).toHaveProperty('validator')
+  expectTypeOf(builderWithMw1).toHaveProperty('middleware')
+
+  builderWithMw1.handler((options) => {
+    expectTypeOf(options).toEqualTypeOf<{
+      method: 'GET'
+      context: {
+        readonly a: 'a'
+      }
+      data: undefined
+      signal: AbortSignal
+      response: 'data'
+    }>()
+  })
+
+  // overrides method
+  const builderWithMw2 = builderWithMw1({ method: 'POST' }).middleware([
+    middleware2,
+  ])
+
+  expectTypeOf(builderWithMw2).toHaveProperty('handler')
+  expectTypeOf(builderWithMw2).toHaveProperty('validator')
+  expectTypeOf(builderWithMw2).toHaveProperty('middleware')
+
+  builderWithMw2.handler((options) => {
+    expectTypeOf(options).toEqualTypeOf<{
+      method: 'POST'
+      context: {
+        readonly a: 'a'
+        readonly b: 'b'
+      }
+      data: undefined
+      signal: AbortSignal
+      response: 'data'
+    }>()
+  })
+
+  // overrides method again
+  const builderWithMw3 = builderWithMw2({ method: 'GET' }).middleware([
+    middleware3,
+  ])
+
+  expectTypeOf(builderWithMw3).toHaveProperty('handler')
+  expectTypeOf(builderWithMw3).toHaveProperty('validator')
+  expectTypeOf(builderWithMw3).toHaveProperty('middleware')
+
+  builderWithMw3.handler((options) => {
+    expectTypeOf(options).toEqualTypeOf<{
+      method: 'GET'
+      context: {
+        readonly a: 'a'
+        readonly b: 'b'
+        readonly c: 'c'
+      }
+      data: undefined
+      signal: AbortSignal
+      response: 'data'
+    }>()
+  })
+})

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

@@ -1,8 +1,8 @@
 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'
+import type { Register } from '@tanstack/router-core'
 
 test('createServeMiddleware removes middleware after middleware,', () => {
   const middleware = createMiddleware({ type: 'function' })
@@ -211,7 +211,7 @@ test('createMiddleware merges client context and sends to the server', () => {
       expectTypeOf(result).toEqualTypeOf<{
         'use functions must return the result of next()': true
         context: { a: boolean; b: string; c: number }
-        sendContext: { a: boolean; b: string; c: number; d: number }
+        sendContext: { a: boolean; b: string; c: number; d: 5 }
         headers: HeadersInit
       }>()
 
@@ -225,7 +225,7 @@ test('createMiddleware merges client context and sends to the server', () => {
         a: boolean
         b: string
         c: number
-        d: number
+        d: 5
       }>()
 
       const result = await options.next({
@@ -242,7 +242,7 @@ test('createMiddleware merges client context and sends to the server', () => {
           }
           sendContext: undefined
         }
-        context: { a: boolean; b: string; c: number; d: number; e: string }
+        context: { a: boolean; b: string; c: number; d: 5; e: string }
         sendContext: undefined
       }>()
 
@@ -586,9 +586,9 @@ test('createMiddleware cannot validate function', () => {
   expectTypeOf(validator)
     .parameter(0)
     .toEqualTypeOf<
-      Constrain<
-        (input: { func: () => 'string' }) => { output: 'string' },
-        Validator<{ func: 'Function is not serializable' }, any>
+      ConstrainValidator<
+        Register,
+        (input: { func: () => 'string' }) => { output: 'string' }
       >
     >()
 })
@@ -600,7 +600,9 @@ test('createMiddleware can validate Date', () => {
 
   expectTypeOf(validator)
     .parameter(0)
-    .toEqualTypeOf<ConstrainValidator<(input: Date) => { output: 'string' }>>()
+    .toEqualTypeOf<
+      ConstrainValidator<Register, (input: Date) => { output: 'string' }>
+    >()
 })
 
 test('createMiddleware can validate FormData', () => {
@@ -611,7 +613,7 @@ test('createMiddleware can validate FormData', () => {
   expectTypeOf(validator)
     .parameter(0)
     .toEqualTypeOf<
-      ConstrainValidator<(input: FormData) => { output: 'string' }>
+      ConstrainValidator<Register, (input: FormData) => { output: 'string' }>
     >()
 })
 

package/dist/esm/serializer.d.ts

@@ -1,16 +0,0 @@
-export type SerializerStringifyBy<T, TSerializable> = T extends TSerializable ? T : T extends (...args: Array<any>) => any ? 'Function is not serializable' : {
-    [K in keyof T]: SerializerStringifyBy<T[K], TSerializable>;
-};
-export type SerializerParseBy<T, TSerializable> = T extends TSerializable ? T : unknown extends SerializerExtensions['ReadableStream'] ? {
-    [K in keyof T]: SerializerParseBy<T[K], TSerializable>;
-} : T extends SerializerExtensions['ReadableStream'] ? ReadableStream : {
-    [K in keyof T]: SerializerParseBy<T[K], TSerializable>;
-};
-export interface DefaultSerializerExtensions {
-    ReadableStream: unknown;
-}
-export interface SerializerExtensions extends DefaultSerializerExtensions {
-}
-export type Serializable = Date | undefined | Error | FormData | bigint;
-export type SerializerStringify<T> = SerializerStringifyBy<T, Serializable>;
-export type SerializerParse<T> = SerializerParseBy<T, Serializable>;

package/src/serializer.ts

@@ -1,25 +0,0 @@
-export type SerializerStringifyBy<T, TSerializable> = T extends TSerializable
-  ? T
-  : T extends (...args: Array<any>) => any
-    ? 'Function is not serializable'
-    : { [K in keyof T]: SerializerStringifyBy<T[K], TSerializable> }
-
-export type SerializerParseBy<T, TSerializable> = T extends TSerializable
-  ? T
-  : unknown extends SerializerExtensions['ReadableStream']
-    ? { [K in keyof T]: SerializerParseBy<T[K], TSerializable> }
-    : T extends SerializerExtensions['ReadableStream']
-      ? ReadableStream
-      : { [K in keyof T]: SerializerParseBy<T[K], TSerializable> }
-
-export interface DefaultSerializerExtensions {
-  ReadableStream: unknown
-}
-
-export interface SerializerExtensions extends DefaultSerializerExtensions {}
-
-export type Serializable = Date | undefined | Error | FormData | bigint
-
-export type SerializerStringify<T> = SerializerStringifyBy<T, Serializable>
-
-export type SerializerParse<T> = SerializerParseBy<T, Serializable>