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

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,
@@ -61,33 +64,43 @@ export function createServerFn<
     resolvedOptions.method = 'GET' as TMethod
   }
 
-  return {
+  const res: ServerFnBuilder<TRegister, TMethod, TServerFnResponseType> = {
     options: resolvedOptions as any,
     middleware: (middleware) => {
+      // multiple calls to `middleware()` merge the middlewares with the previously supplied ones
+      // this is primarily useful for letting users create their own abstractions on top of `createServerFn`
+      const newOptions = {
+        ...resolvedOptions,
+        middleware: [...(resolvedOptions.middleware || []), ...middleware],
+      }
       return createServerFn<
+        TRegister,
         TMethod,
         ServerFnResponseType,
         TResponse,
         TMiddlewares,
         TValidator
-      >(undefined, Object.assign(resolvedOptions, { middleware })) as any
+      >(undefined, newOptions) as any
     },
     validator: (validator) => {
+      const newOptions = { ...resolvedOptions, validator: validator as any }
       return createServerFn<
+        TRegister,
         TMethod,
         ServerFnResponseType,
         TResponse,
         TMiddlewares,
         TValidator
-      >(undefined, Object.assign(resolvedOptions, { validator })) as any
+      >(undefined, newOptions) as any
     },
     handler: (...args) => {
       // This function signature changes due to AST transformations
       // 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,
@@ -98,15 +111,11 @@ export function createServerFn<
 
       // Keep the original function around so we can use it
       // in the server environment
-      Object.assign(resolvedOptions, {
-        ...extractedFn,
-        extractedFn,
-        serverFn,
-      })
+      const newOptions = { ...resolvedOptions, extractedFn, serverFn }
 
       const resolvedMiddleware = [
-        ...(resolvedOptions.middleware || []),
-        serverFnBaseToMiddleware(resolvedOptions),
+        ...(newOptions.middleware || []),
+        serverFnBaseToMiddleware(newOptions),
       ]
 
       // We want to make sure the new function has the same
@@ -117,14 +126,14 @@ export function createServerFn<
           // Start by executing the client-side middleware chain
           return executeMiddleware(resolvedMiddleware, 'client', {
             ...extractedFn,
-            ...resolvedOptions,
+            ...newOptions,
             data: opts?.data as any,
             headers: opts?.headers,
             signal: opts?.signal,
             context: {},
             router: getRouterInstance(),
           }).then((d) => {
-            if (resolvedOptions.response === 'full') {
+            if (newOptions.response === 'full') {
               return d
             }
             if (d.error) throw d.error
@@ -156,6 +165,19 @@ export function createServerFn<
       ) as any
     },
   }
+  const fun = (options?: {
+    method?: TMethod
+    response?: TServerFnResponseType
+  }) => {
+    return {
+      ...res,
+      options: {
+        ...res.options,
+        ...options,
+      },
+    }
+  }
+  return Object.assign(fun, res)
 }
 
 export async function executeMiddleware(
@@ -230,6 +252,7 @@ export type CompiledFetcherFnOptions = {
 }
 
 export type Fetcher<
+  TRegister extends Register,
   TMiddlewares,
   TValidator,
   TResponse,
@@ -237,12 +260,14 @@ export type Fetcher<
 > =
   undefined extends IntersectAllValidatorInputs<TMiddlewares, TValidator>
     ? OptionalFetcher<
+        TRegister,
         TMiddlewares,
         TValidator,
         TResponse,
         TServerFnResponseType
       >
     : RequiredFetcher<
+        TRegister,
         TMiddlewares,
         TValidator,
         TResponse,
@@ -262,16 +287,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 +306,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 +318,7 @@ export interface RequiredFetcher<
 > extends FetcherBase {
   (
     opts: RequiredFetcherDataOptions<TMiddlewares, TValidator>,
-  ): FetchResult<TMiddlewares, TResponse, TServerFnResponseType>
+  ): FetchResult<TRegister, TMiddlewares, TResponse, TServerFnResponseType>
 }
 
 export type FetcherBaseOptions = {
@@ -308,16 +336,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 +362,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 +380,7 @@ export type ServerFn<
   TResponse,
 > = (
   ctx: ServerFnCtx<TMethod, TServerFnResponseType, TMiddlewares, TValidator>,
-) => ServerFnReturnType<TServerFnResponseType, TResponse>
+) => ServerFnReturnType<TRegister, TServerFnResponseType, TResponse>
 
 export interface ServerFnCtx<
   TMethod,
@@ -360,17 +396,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 +419,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,27 +432,38 @@ 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>
+
+type ToTuple<T> =
+  T extends ReadonlyArray<infer U> ? T : T extends undefined ? [] : [T]
 
 export interface ServerFnMiddleware<
+  TRegister extends Register,
   TMethod extends Method,
   TServerFnResponseType extends ServerFnResponseType,
+  TMiddlewares,
   TValidator,
 > {
   middleware: <const TNewMiddlewares = undefined>(
@@ -422,28 +472,60 @@ export interface ServerFnMiddleware<
       ReadonlyArray<AnyFunctionMiddleware>
     >,
   ) => ServerFnAfterMiddleware<
+    TRegister,
     TMethod,
     TServerFnResponseType,
-    TNewMiddlewares,
+    [...ToTuple<TMiddlewares>, ...ToTuple<TNewMiddlewares>],
     TValidator
   >
 }
 
 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 ServerFnMiddleware<
+      TRegister,
+      TMethod,
+      TServerFnResponseType,
+      TMiddlewares,
+      undefined
+    >,
+    ServerFnValidator<TRegister, TMethod, TServerFnResponseType, TMiddlewares>,
+    ServerFnHandler<
+      TRegister,
+      TMethod,
+      TServerFnResponseType,
+      TMiddlewares,
+      TValidator
+    > {
+  <
+    TNewMethod extends Method = TMethod,
+    TNewServerFnResponseType extends
+      ServerFnResponseType = TServerFnResponseType,
+  >(options?: {
+    method?: TNewMethod
+    response?: TNewServerFnResponseType
+  }): ServerFnAfterMiddleware<
+    TRegister,
+    TNewMethod,
+    TNewServerFnResponseType,
+    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 +533,48 @@ 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,
+      TMiddlewares,
+      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 +583,7 @@ export interface ServerFnAfterTyper<
 
 // Handler
 export interface ServerFnHandler<
+  TRegister extends Register,
   TMethod extends Method,
   TServerFnResponseType extends ServerFnResponseType,
   TMiddlewares,
@@ -487,22 +591,43 @@ 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,
+      undefined
+    >,
+    ServerFnValidator<TRegister, TMethod, TServerFnResponseType, undefined>,
+    ServerFnHandler<
+      TRegister,
+      TMethod,
+      TServerFnResponseType,
+      undefined,
+      undefined
+    > {
   options: ServerFnBaseOptions<
+    TRegister,
     TMethod,
     TServerFnResponseType,
     unknown,
@@ -627,7 +752,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) {