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

package/src/createServerFn.ts

@@ -3,17 +3,17 @@ import { mergeHeaders } from '@tanstack/router-core/ssr/client'
 import { globalMiddleware } from './registerGlobalMiddleware'
 
 import { getRouterInstance } from './getRouterInstance'
-import type {
-  SerializerParse,
-  SerializerStringify,
-  SerializerStringifyBy,
-} from './serializer'
 import type {
   AnyRouter,
   AnyValidator,
   Constrain,
   Expand,
+  Register,
+  RegisteredSerializableInput,
   ResolveValidatorInput,
+  ValidateSerializable,
+  ValidateSerializableInput,
+  ValidateSerializableInputResult,
   Validator,
 } from '@tanstack/router-core'
 import type { JsonResponse } from '@tanstack/router-core/ssr/client'
@@ -31,6 +31,7 @@ import type {
 type TODO = any
 
 export function createServerFn<
+  TRegister extends Register,
   TMethod extends Method,
   TServerFnResponseType extends ServerFnResponseType = 'data',
   TResponse = unknown,
@@ -42,14 +43,16 @@ export function createServerFn<
     response?: TServerFnResponseType
   },
   __opts?: ServerFnBaseOptions<
+    TRegister,
     TMethod,
     TServerFnResponseType,
     TResponse,
     TMiddlewares,
     TValidator
   >,
-): ServerFnBuilder<TMethod, TServerFnResponseType> {
+): ServerFnBuilder<TRegister, TMethod, TServerFnResponseType> {
   const resolvedOptions = (__opts || options || {}) as ServerFnBaseOptions<
+    TRegister,
     TMethod,
     ServerFnResponseType,
     TResponse,
@@ -65,6 +68,7 @@ export function createServerFn<
     options: resolvedOptions as any,
     middleware: (middleware) => {
       return createServerFn<
+        TRegister,
         TMethod,
         ServerFnResponseType,
         TResponse,
@@ -74,6 +78,7 @@ export function createServerFn<
     },
     validator: (validator) => {
       return createServerFn<
+        TRegister,
         TMethod,
         ServerFnResponseType,
         TResponse,
@@ -86,8 +91,9 @@ export function createServerFn<
       // in the babel plugin. We need to cast it to the correct
       // function signature post-transformation
       const [extractedFn, serverFn] = args as unknown as [
-        CompiledFetcherFn<TResponse, TServerFnResponseType>,
+        CompiledFetcherFn<TRegister, TResponse, TServerFnResponseType>,
         ServerFn<
+          TRegister,
           TMethod,
           TServerFnResponseType,
           TMiddlewares,
@@ -230,6 +236,7 @@ export type CompiledFetcherFnOptions = {
 }
 
 export type Fetcher<
+  TRegister extends Register,
   TMiddlewares,
   TValidator,
   TResponse,
@@ -237,12 +244,14 @@ export type Fetcher<
 > =
   undefined extends IntersectAllValidatorInputs<TMiddlewares, TValidator>
     ? OptionalFetcher<
+        TRegister,
         TMiddlewares,
         TValidator,
         TResponse,
         TServerFnResponseType
       >
     : RequiredFetcher<
+        TRegister,
         TMiddlewares,
         TValidator,
         TResponse,
@@ -262,16 +271,18 @@ export interface FetcherBase {
 }
 
 export type FetchResult<
+  TRegister extends Register,
   TMiddlewares,
   TResponse,
   TServerFnResponseType extends ServerFnResponseType,
 > = TServerFnResponseType extends 'raw'
   ? Promise<Response>
   : TServerFnResponseType extends 'full'
-    ? Promise<FullFetcherData<TMiddlewares, TResponse>>
-    : Promise<FetcherData<TResponse>>
+    ? Promise<FullFetcherData<TRegister, TMiddlewares, TResponse>>
+    : Promise<FetcherData<TRegister, TResponse>>
 
 export interface OptionalFetcher<
+  TRegister extends Register,
   TMiddlewares,
   TValidator,
   TResponse,
@@ -279,10 +290,11 @@ export interface OptionalFetcher<
 > extends FetcherBase {
   (
     options?: OptionalFetcherDataOptions<TMiddlewares, TValidator>,
-  ): FetchResult<TMiddlewares, TResponse, TServerFnResponseType>
+  ): FetchResult<TRegister, TMiddlewares, TResponse, TServerFnResponseType>
 }
 
 export interface RequiredFetcher<
+  TRegister extends Register,
   TMiddlewares,
   TValidator,
   TResponse,
@@ -290,7 +302,7 @@ export interface RequiredFetcher<
 > extends FetcherBase {
   (
     opts: RequiredFetcherDataOptions<TMiddlewares, TValidator>,
-  ): FetchResult<TMiddlewares, TResponse, TServerFnResponseType>
+  ): FetchResult<TRegister, TMiddlewares, TResponse, TServerFnResponseType>
 }
 
 export type FetcherBaseOptions = {
@@ -308,16 +320,20 @@ export interface RequiredFetcherDataOptions<TMiddlewares, TValidator>
   data: Expand<IntersectAllValidatorInputs<TMiddlewares, TValidator>>
 }
 
-export interface FullFetcherData<TMiddlewares, TResponse> {
+export interface FullFetcherData<
+  TRegister extends Register,
+  TMiddlewares,
+  TResponse,
+> {
   error: unknown
-  result: FetcherData<TResponse>
+  result: FetcherData<TRegister, TResponse>
   context: AssignAllClientSendContext<TMiddlewares>
 }
 
-export type FetcherData<TResponse> =
+export type FetcherData<TRegister extends Register, TResponse> =
   TResponse extends JsonResponse<any>
-    ? SerializerParse<ReturnType<TResponse['json']>>
-    : SerializerParse<TResponse>
+    ? ValidateSerializableInputResult<TRegister, ReturnType<TResponse['json']>>
+    : ValidateSerializableInputResult<TRegister, TResponse>
 
 export type RscStream<T> = {
   __cacheState: T
@@ -330,13 +346,17 @@ export type ServerFnResponseType = 'data' | 'full' | 'raw'
 export type RawResponse = Response | ReadableStream | Readable | null | string
 
 export type ServerFnReturnType<
+  TRegister extends Register,
   TServerFnResponseType extends ServerFnResponseType,
   TResponse,
 > = TServerFnResponseType extends 'raw'
   ? RawResponse | Promise<RawResponse>
-  : Promise<SerializerStringify<TResponse>> | SerializerStringify<TResponse>
+  :
+      | Promise<ValidateSerializableInput<TRegister, TResponse>>
+      | ValidateSerializableInput<TRegister, TResponse>
 
 export type ServerFn<
+  TRegister extends Register,
   TMethod,
   TServerFnResponseType extends ServerFnResponseType,
   TMiddlewares,
@@ -344,7 +364,7 @@ export type ServerFn<
   TResponse,
 > = (
   ctx: ServerFnCtx<TMethod, TServerFnResponseType, TMiddlewares, TValidator>,
-) => ServerFnReturnType<TServerFnResponseType, TResponse>
+) => ServerFnReturnType<TRegister, TServerFnResponseType, TResponse>
 
 export interface ServerFnCtx<
   TMethod,
@@ -360,17 +380,19 @@ export interface ServerFnCtx<
 }
 
 export type CompiledFetcherFn<
+  TRegister extends Register,
   TResponse,
   TServerFnResponseType extends ServerFnResponseType,
 > = {
   (
     opts: CompiledFetcherFnOptions &
-      ServerFnBaseOptions<Method, TServerFnResponseType>,
+      ServerFnBaseOptions<TRegister, Method, TServerFnResponseType>,
   ): Promise<TResponse>
   url: string
 }
 
 export type ServerFnBaseOptions<
+  TRegister extends Register,
   TMethod extends Method = 'GET',
   TServerFnResponseType extends ServerFnResponseType = 'data',
   TResponse = unknown,
@@ -381,9 +403,10 @@ export type ServerFnBaseOptions<
   response?: TServerFnResponseType
   validateClient?: boolean
   middleware?: Constrain<TMiddlewares, ReadonlyArray<AnyFunctionMiddleware>>
-  validator?: ConstrainValidator<TInput>
-  extractedFn?: CompiledFetcherFn<TResponse, TServerFnResponseType>
+  validator?: ConstrainValidator<TRegister, TInput>
+  extractedFn?: CompiledFetcherFn<TRegister, TResponse, TServerFnResponseType>
   serverFn?: ServerFn<
+    TRegister,
     TMethod,
     TServerFnResponseType,
     TMiddlewares,
@@ -393,25 +416,32 @@ export type ServerFnBaseOptions<
   functionId: string
 }
 
-export type ValidatorInputStringify<TValidator> = SerializerStringifyBy<
+export type ValidateValidatorInput<
+  TRegister extends Register,
+  TValidator,
+> = ValidateSerializable<
   ResolveValidatorInput<TValidator>,
-  Date | undefined | FormData
+  RegisteredSerializableInput<TRegister> | FormData
 >
 
-export type ValidatorSerializerStringify<TValidator> =
-  ValidatorInputStringify<TValidator> extends infer TInput
+export type ValidateValidator<TRegister extends Register, TValidator> =
+  ValidateValidatorInput<TRegister, TValidator> extends infer TInput
     ? Validator<TInput, any>
     : never
 
-export type ConstrainValidator<TValidator> =
+export type ConstrainValidator<TRegister extends Register, TValidator> =
   | (unknown extends TValidator
       ? TValidator
-      : ResolveValidatorInput<TValidator> extends ValidatorInputStringify<TValidator>
+      : ResolveValidatorInput<TValidator> extends ValidateValidator<
+            TRegister,
+            TValidator
+          >
         ? TValidator
         : never)
-  | ValidatorSerializerStringify<TValidator>
+  | ValidateValidator<TRegister, TValidator>
 
 export interface ServerFnMiddleware<
+  TRegister extends Register,
   TMethod extends Method,
   TServerFnResponseType extends ServerFnResponseType,
   TValidator,
@@ -422,6 +452,7 @@ export interface ServerFnMiddleware<
       ReadonlyArray<AnyFunctionMiddleware>
     >,
   ) => ServerFnAfterMiddleware<
+    TRegister,
     TMethod,
     TServerFnResponseType,
     TNewMiddlewares,
@@ -430,20 +461,34 @@ export interface ServerFnMiddleware<
 }
 
 export interface ServerFnAfterMiddleware<
+  TRegister extends Register,
   TMethod extends Method,
   TServerFnResponseType extends ServerFnResponseType,
   TMiddlewares,
   TValidator,
-> extends ServerFnValidator<TMethod, TServerFnResponseType, TMiddlewares>,
-    ServerFnHandler<TMethod, TServerFnResponseType, TMiddlewares, TValidator> {}
+> extends ServerFnValidator<
+      TRegister,
+      TMethod,
+      TServerFnResponseType,
+      TMiddlewares
+    >,
+    ServerFnHandler<
+      TRegister,
+      TMethod,
+      TServerFnResponseType,
+      TMiddlewares,
+      TValidator
+    > {}
 
 export type ValidatorFn<
+  TRegister extends Register,
   TMethod extends Method,
   TServerFnResponseType extends ServerFnResponseType,
   TMiddlewares,
 > = <TValidator>(
-  validator: ConstrainValidator<TValidator>,
+  validator: ConstrainValidator<TRegister, TValidator>,
 ) => ServerFnAfterValidator<
+  TRegister,
   TMethod,
   TServerFnResponseType,
   TMiddlewares,
@@ -451,27 +496,47 @@ export type ValidatorFn<
 >
 
 export interface ServerFnValidator<
+  TRegister extends Register,
   TMethod extends Method,
   TServerFnResponseType extends ServerFnResponseType,
   TMiddlewares,
 > {
-  validator: ValidatorFn<TMethod, TServerFnResponseType, TMiddlewares>
+  validator: ValidatorFn<
+    TRegister,
+    TMethod,
+    TServerFnResponseType,
+    TMiddlewares
+  >
 }
 
 export interface ServerFnAfterValidator<
+  TRegister extends Register,
   TMethod extends Method,
   TServerFnResponseType extends ServerFnResponseType,
   TMiddlewares,
   TValidator,
-> extends ServerFnMiddleware<TMethod, TServerFnResponseType, TValidator>,
-    ServerFnHandler<TMethod, TServerFnResponseType, TMiddlewares, TValidator> {}
+> extends ServerFnMiddleware<
+      TRegister,
+      TMethod,
+      TServerFnResponseType,
+      TValidator
+    >,
+    ServerFnHandler<
+      TRegister,
+      TMethod,
+      TServerFnResponseType,
+      TMiddlewares,
+      TValidator
+    > {}
 
 export interface ServerFnAfterTyper<
+  TRegister extends Register,
   TMethod extends Method,
   TServerFnResponseType extends ServerFnResponseType,
   TMiddlewares,
   TValidator,
 > extends ServerFnHandler<
+    TRegister,
     TMethod,
     TServerFnResponseType,
     TMiddlewares,
@@ -480,6 +545,7 @@ export interface ServerFnAfterTyper<
 
 // Handler
 export interface ServerFnHandler<
+  TRegister extends Register,
   TMethod extends Method,
   TServerFnResponseType extends ServerFnResponseType,
   TMiddlewares,
@@ -487,22 +553,42 @@ export interface ServerFnHandler<
 > {
   handler: <TNewResponse>(
     fn?: ServerFn<
+      TRegister,
       TMethod,
       TServerFnResponseType,
       TMiddlewares,
       TValidator,
       TNewResponse
     >,
-  ) => Fetcher<TMiddlewares, TValidator, TNewResponse, TServerFnResponseType>
+  ) => Fetcher<
+    TRegister,
+    TMiddlewares,
+    TValidator,
+    TNewResponse,
+    TServerFnResponseType
+  >
 }
 
 export interface ServerFnBuilder<
+  TRegister extends Register,
   TMethod extends Method = 'GET',
   TServerFnResponseType extends ServerFnResponseType = 'data',
-> extends ServerFnMiddleware<TMethod, TServerFnResponseType, undefined>,
-    ServerFnValidator<TMethod, TServerFnResponseType, undefined>,
-    ServerFnHandler<TMethod, TServerFnResponseType, undefined, undefined> {
+> extends ServerFnMiddleware<
+      TRegister,
+      TMethod,
+      TServerFnResponseType,
+      undefined
+    >,
+    ServerFnValidator<TRegister, TMethod, TServerFnResponseType, undefined>,
+    ServerFnHandler<
+      TRegister,
+      TMethod,
+      TServerFnResponseType,
+      undefined,
+      undefined
+    > {
   options: ServerFnBaseOptions<
+    TRegister,
     TMethod,
     TServerFnResponseType,
     unknown,
@@ -627,7 +713,7 @@ export function execValidator(
 }
 
 export function serverFnBaseToMiddleware(
-  options: ServerFnBaseOptions<any, any, any, any, any>,
+  options: ServerFnBaseOptions<any, any, any, any, any, any>,
 ): AnyFunctionMiddleware {
   return {
     _types: undefined!,

package/src/index.tsx

@@ -5,15 +5,6 @@ export type {
 
 export { hydrate, json, mergeHeaders } from '@tanstack/router-core/ssr/client'
 
-export type {
-  Serializable,
-  SerializerParse,
-  SerializerParseBy,
-  SerializerStringify,
-  SerializerStringifyBy,
-  SerializerExtensions,
-} from './serializer'
-
 export {
   createIsomorphicFn,
   type IsomorphicFn,

package/src/serializer/ServerFunctionSerializationAdapter.ts

@@ -4,7 +4,13 @@ import { TSS_SERVER_FUNCTION } from '../constants'
 
 export const ServerFunctionSerializationAdapter = createSerializationAdapter({
   key: '$TSS/serverfn',
-  test: (v): v is { functionId: string } => v[TSS_SERVER_FUNCTION],
+  test: (v): v is { functionId: string } => {
+    if (typeof v !== 'object' || v === null) return false
+
+    if (!(TSS_SERVER_FUNCTION in v)) return false
+
+    return !!v[TSS_SERVER_FUNCTION]
+  },
   toSerializable: ({ functionId }) => ({ functionId }),
   fromSerializable: ({ functionId }) => createClientRpc(functionId),
 })

package/src/serializer/getDefaultSerovalPlugins.ts

@@ -5,7 +5,7 @@ import {
 } from '@tanstack/router-core'
 import { FormDataPlugin } from 'seroval-plugins/web'
 import { getRouterInstance } from '../getRouterInstance'
-import type { AnyTransformer } from '@tanstack/router-core'
+import type { AnySerializationAdapter } from '@tanstack/router-core'
 
 import type { Plugin } from 'seroval'
 
@@ -18,7 +18,7 @@ export function getDefaultSerovalPlugins() {
   const router = getRouterInstance()
   invariant(router, 'Expected router instance to be available')
   const adapters = router.options.serializationAdapters as
-    | Array<AnyTransformer>
+    | Array<AnySerializationAdapter>
     | undefined
   return [...(adapters?.map(makeSerovalPlugin) ?? []), ...defaultSerovalPlugins]
 }

package/src/serverFnFetcher.ts

@@ -30,6 +30,7 @@ export async function serverFnFetcher(
       any,
       any,
       any,
+      any,
       any
     > & {
       headers: HeadersInit
@@ -100,7 +101,7 @@ export async function serverFnFetcher(
 }
 
 async function serializePayload(
-  opts: FunctionMiddlewareClientFnOptions<any, any, any, any>,
+  opts: FunctionMiddlewareClientFnOptions<any, any, any, any, any>,
 ) {
   const payloadToSerialize: any = {}
   if (opts.data) {
@@ -121,7 +122,7 @@ async function serialize(data: any) {
 }
 
 async function getFetcherRequestOptions(
-  opts: FunctionMiddlewareClientFnOptions<any, any, any, any>,
+  opts: FunctionMiddlewareClientFnOptions<any, any, any, any, any>,
 ) {
   if (opts.method === 'POST') {
     if (opts.data instanceof FormData) {

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', () => {
@@ -398,7 +398,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 +411,7 @@ test('createServerFn can validate FormData', () => {
   expectTypeOf(validator)
     .parameter(0)
     .toEqualTypeOf<
-      ConstrainValidator<(input: FormData) => { output: 'string' }>
+      ConstrainValidator<Register, (input: FormData) => { output: 'string' }>
     >()
 })
 

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>