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

package/src/createServerFn.ts

@@ -16,17 +16,15 @@ import type {
 } from '@tanstack/router-core'
 import type { Readable } from 'node:stream'
 import type {
-  AnyFunctionMiddleware,
+  AnyMiddleware,
   AssignAllClientSendContext,
   AssignAllServerContext,
-  FunctionMiddlewareClientFnResult,
-  FunctionMiddlewareServerFnResult,
   IntersectAllValidatorInputs,
   IntersectAllValidatorOutputs,
+  MiddlewareClientFnResult,
+  MiddlewareServerFnResult,
 } from './createMiddleware'
 
-type TODO = any
-
 export function createServerFn<
   TMethod extends Method,
   TServerFnResponseType extends ServerFnResponseType = 'data',
@@ -217,8 +215,8 @@ export function createServerFn<
   }
 }
 
-export async function executeMiddleware(
-  middlewares: Array<AnyFunctionMiddleware>,
+async function executeMiddleware(
+  middlewares: Array<AnyMiddleware>,
   env: 'client' | 'server',
   opts: ServerFnMiddlewareOptions,
 ): Promise<ServerFnMiddlewareResult> {
@@ -400,7 +398,6 @@ export type ServerFnReturnType<
 > = TServerFnResponseType extends 'raw'
   ? RawResponse | Promise<RawResponse>
   : Promise<SerializerStringify<TResponse>> | SerializerStringify<TResponse>
-
 export type ServerFn<
   TMethod,
   TServerFnResponseType extends ServerFnResponseType,
@@ -445,7 +442,7 @@ export type ServerFnBaseOptions<
   method: TMethod
   response?: TServerFnResponseType
   validateClient?: boolean
-  middleware?: Constrain<TMiddlewares, ReadonlyArray<AnyFunctionMiddleware>>
+  middleware?: Constrain<TMiddlewares, ReadonlyArray<AnyMiddleware>>
   validator?: ConstrainValidator<TInput>
   extractedFn?: CompiledFetcherFn<TResponse, TServerFnResponseType>
   serverFn?: ServerFn<
@@ -488,10 +485,7 @@ export interface ServerFnMiddleware<
   TValidator,
 > {
   middleware: <const TNewMiddlewares = undefined>(
-    middlewares: Constrain<
-      TNewMiddlewares,
-      ReadonlyArray<AnyFunctionMiddleware>
-    >,
+    middlewares: Constrain<TNewMiddlewares, ReadonlyArray<AnyMiddleware>>,
   ) => ServerFnAfterMiddleware<
     TMethod,
     TServerFnResponseType,
@@ -818,12 +812,12 @@ export function extractFormDataContext(formData: FormData) {
 }
 
 export function flattenMiddlewares(
-  middlewares: Array<AnyFunctionMiddleware>,
-): Array<AnyFunctionMiddleware> {
-  const seen = new Set<AnyFunctionMiddleware>()
-  const flattened: Array<AnyFunctionMiddleware> = []
+  middlewares: Array<AnyMiddleware>,
+): Array<AnyMiddleware> {
+  const seen = new Set<AnyMiddleware>()
+  const flattened: Array<AnyMiddleware> = []
 
-  const recurse = (middleware: Array<AnyFunctionMiddleware>) => {
+  const recurse = (middleware: Array<AnyMiddleware>) => {
     middleware.forEach((m) => {
       if (m.options.middleware) {
         recurse(m.options.middleware)
@@ -935,7 +929,7 @@ export function execValidator(
 
 export function serverFnBaseToMiddleware(
   options: ServerFnBaseOptions<any, any, any, any, any>,
-): AnyFunctionMiddleware {
+): AnyMiddleware {
   return {
     _types: undefined!,
     options: {
@@ -979,25 +973,16 @@ export function serverFnBaseToMiddleware(
         // but not before serializing the context
         const res = await options.extractedFn?.(payload)
 
-        return next(res) as unknown as FunctionMiddlewareClientFnResult<
-          any,
-          any,
-          any
-        >
+        return next(res) as unknown as MiddlewareClientFnResult<any, any, any>
       },
       server: async ({ next, ...ctx }) => {
         // Execute the server function
-        const result = await options.serverFn?.(ctx as TODO)
+        const result = await options.serverFn?.(ctx)
 
         return next({
           ...ctx,
           result,
-        } as any) as unknown as FunctionMiddlewareServerFnResult<
-          any,
-          any,
-          any,
-          any
-        >
+        } as any) as unknown as MiddlewareServerFnResult<any, any, any, any>
       },
     },
   }

package/src/index.tsx

@@ -25,30 +25,30 @@ export {
   createMiddleware,
   type IntersectAllValidatorInputs,
   type IntersectAllValidatorOutputs,
-  type FunctionMiddlewareServerFn,
-  type AnyFunctionMiddleware,
-  type FunctionMiddlewareOptions,
-  type FunctionMiddlewareWithTypes,
-  type FunctionMiddlewareValidator,
-  type FunctionMiddlewareServer,
-  type FunctionMiddlewareAfterClient,
-  type FunctionMiddlewareAfterServer,
-  type FunctionMiddleware,
-  type FunctionMiddlewareClientFnOptions,
-  type FunctionMiddlewareClientFnResult,
-  type FunctionMiddlewareClientNextFn,
-  type FunctionClientResultWithContext,
+  type MiddlewareServerFn,
+  type AnyMiddleware,
+  type MiddlewareOptions,
+  type MiddlewareWithTypes,
+  type MiddlewareValidator,
+  type MiddlewareServer,
+  type MiddlewareAfterClient,
+  type MiddlewareAfterMiddleware,
+  type MiddlewareAfterServer,
+  type Middleware,
+  type MiddlewareClientFnOptions,
+  type MiddlewareClientFnResult,
+  type MiddlewareClientNextFn,
+  type ClientResultWithContext,
   type AssignAllClientContextBeforeNext,
   type AssignAllMiddleware,
   type AssignAllServerContext,
-  type FunctionMiddlewareAfterValidator,
-  type FunctionMiddlewareClientFn,
-  type FunctionMiddlewareServerFnResult,
-  type FunctionMiddlewareClient,
-  type FunctionMiddlewareServerFnOptions,
-  type FunctionMiddlewareServerNextFn,
-  type FunctionServerResultWithContext,
-  type AnyRequestMiddleware,
+  type MiddlewareAfterValidator,
+  type MiddlewareClientFn,
+  type MiddlewareServerFnResult,
+  type MiddlewareClient,
+  type MiddlewareServerFnOptions,
+  type MiddlewareServerNextFn,
+  type ServerResultWithContext,
 } from './createMiddleware'
 export {
   registerGlobalMiddleware,
@@ -84,5 +84,4 @@ export {
   extractFormDataContext,
   flattenMiddlewares,
   serverFnStaticCache,
-  executeMiddleware,
 } from './createServerFn'

package/src/registerGlobalMiddleware.ts

@@ -1,9 +1,9 @@
-import type { AnyFunctionMiddleware } from './createMiddleware'
+import type { AnyMiddleware } from './createMiddleware'
 
-export const globalMiddleware: Array<AnyFunctionMiddleware> = []
+export const globalMiddleware: Array<AnyMiddleware> = []
 
 export function registerGlobalMiddleware(options: {
-  middleware: Array<AnyFunctionMiddleware>
+  middleware: Array<AnyMiddleware>
 }) {
   globalMiddleware.push(...options.middleware)
 }

package/src/ssr-client.tsx

@@ -77,16 +77,15 @@ export interface ResolvePromiseState {
 export interface DehydratedRouter {
   manifest: Manifest | undefined
   dehydratedData: any
-  lastMatchId: string
 }
 
-export async function hydrate(router: AnyRouter): Promise<any> {
+export function hydrate(router: AnyRouter) {
   invariant(
     window.__TSR_SSR__?.dehydrated,
     'Expected to find a dehydrated data on window.__TSR_SSR__.dehydrated... but we did not. Please file an issue!',
   )
 
-  const { manifest, dehydratedData, lastMatchId } = startSerializer.parse(
+  const { manifest, dehydratedData } = startSerializer.parse(
     window.__TSR_SSR__.dehydrated,
   ) as DehydratedRouter
 
@@ -117,7 +116,6 @@ export async function hydrate(router: AnyRouter): Promise<any> {
 
   // Hydrate the router state
   const matches = router.matchRoutes(router.state.location)
-
   // kick off loading the route chunks
   const routeChunkPromise = Promise.all(
     matches.map((match) => {
@@ -125,7 +123,6 @@ export async function hydrate(router: AnyRouter): Promise<any> {
       return router.loadRouteChunk(route)
     }),
   )
-
   // Right after hydration and before the first render, we need to rehydrate each match
   // First step is to reyhdrate loaderData and __beforeLoadContext
   matches.forEach((match) => {
@@ -133,36 +130,39 @@ export async function hydrate(router: AnyRouter): Promise<any> {
       (d) => d.id === match.id,
     )
 
-    if (!dehydratedMatch) {
-      return
-    }
+    if (dehydratedMatch) {
+      Object.assign(match, dehydratedMatch)
 
-    Object.assign(match, dehydratedMatch)
+      // Handle beforeLoadContext
+      if (dehydratedMatch.__beforeLoadContext) {
+        match.__beforeLoadContext = router.ssr!.serializer.parse(
+          dehydratedMatch.__beforeLoadContext,
+        ) as any
+      }
 
-    // Handle beforeLoadContext
-    if (dehydratedMatch.__beforeLoadContext) {
-      match.__beforeLoadContext = router.ssr!.serializer.parse(
-        dehydratedMatch.__beforeLoadContext,
-      ) as any
-    }
+      // Handle loaderData
+      if (dehydratedMatch.loaderData) {
+        match.loaderData = router.ssr!.serializer.parse(
+          dehydratedMatch.loaderData,
+        )
+      }
 
-    // Handle loaderData
-    if (dehydratedMatch.loaderData) {
-      match.loaderData = router.ssr!.serializer.parse(
-        dehydratedMatch.loaderData,
-      )
-    }
+      // Handle error
+      if (dehydratedMatch.error) {
+        match.error = router.ssr!.serializer.parse(dehydratedMatch.error)
+      }
 
-    // Handle error
-    if (dehydratedMatch.error) {
-      match.error = router.ssr!.serializer.parse(dehydratedMatch.error)
+      // Handle extracted
+      ;(match as unknown as SsrMatch).extracted?.forEach((ex) => {
+        deepMutableSetByPath(match, ['loaderData', ...ex.path], ex.value)
+      })
+    } else {
+      Object.assign(match, {
+        status: 'success',
+        updatedAt: Date.now(),
+      })
     }
 
-    // Handle extracted
-    ;(match as unknown as SsrMatch).extracted?.forEach((ex) => {
-      deepMutableSetByPath(match, ['loaderData', ...ex.path], ex.value)
-    })
-
     return match
   })
 
@@ -224,10 +224,6 @@ export async function hydrate(router: AnyRouter): Promise<any> {
     match.scripts = scripts
   })
 
-  if (matches[matches.length - 1]!.id !== lastMatchId) {
-    return await Promise.all([routeChunkPromise, router.load()])
-  }
-
   return routeChunkPromise
 }
 

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

@@ -60,25 +60,21 @@ test('createServerFn with validator', () => {
 })
 
 test('createServerFn with middleware and context', () => {
-  const middleware1 = createMiddleware({ type: 'function' }).server(
-    ({ next }) => {
-      return next({ context: { a: 'a' } as const })
-    },
-  )
+  const middleware1 = createMiddleware().server(({ next }) => {
+    return next({ context: { a: 'a' } as const })
+  })
 
-  const middleware2 = createMiddleware({ type: 'function' }).server(
-    ({ next }) => {
-      return next({ context: { b: 'b' } as const })
-    },
-  )
+  const middleware2 = createMiddleware().server(({ next }) => {
+    return next({ context: { b: 'b' } as const })
+  })
 
-  const middleware3 = createMiddleware({ type: 'function' })
+  const middleware3 = createMiddleware()
     .middleware([middleware1, middleware2])
     .client(({ next }) => {
       return next({ context: { c: 'c' } as const })
     })
 
-  const middleware4 = createMiddleware({ type: 'function' })
+  const middleware4 = createMiddleware()
     .middleware([middleware3])
     .client(({ context, next }) => {
       return next({ sendContext: context })
@@ -117,24 +113,21 @@ test('createServerFn with middleware and context', () => {
 })
 
 describe('createServerFn with middleware and validator', () => {
-  const middleware1 = createMiddleware({ type: 'function' }).validator(
+  const middleware1 = createMiddleware().validator(
     (input: { readonly inputA: 'inputA' }) =>
       ({
         outputA: 'outputA',
       }) as const,
   )
 
-  const middleware2 = createMiddleware({ type: 'function' }).validator(
+  const middleware2 = createMiddleware().validator(
     (input: { readonly inputB: 'inputB' }) =>
       ({
         outputB: 'outputB',
       }) as const,
   )
 
-  const middleware3 = createMiddleware({ type: 'function' }).middleware([
-    middleware1,
-    middleware2,
-  ])
+  const middleware3 = createMiddleware().middleware([middleware1, middleware2])
 
   test(`response: 'data'`, () => {
     const fn = createServerFn({ method: 'GET', response: 'data' })
@@ -229,7 +222,7 @@ describe('createServerFn with middleware and validator', () => {
 })
 
 test('createServerFn overrides properties', () => {
-  const middleware1 = createMiddleware({ type: 'function' })
+  const middleware1 = createMiddleware()
     .validator(
       () =>
         ({
@@ -253,7 +246,7 @@ test('createServerFn overrides properties', () => {
       return next({ sendContext: newContext, context: newContext })
     })
 
-  const middleware2 = createMiddleware({ type: 'function' })
+  const middleware2 = createMiddleware()
     .middleware([middleware1])
     .validator(
       () =>