@tanstack/start-client-core 1.121.0-alpha.27 → 1.121.0-alpha.28

package/src/createServerFn.ts

@@ -1,19 +1,25 @@
-import { default as invariant } from 'tiny-invariant'
-import { default as warning } from 'tiny-warning'
 import { isNotFound, isRedirect } from '@tanstack/router-core'
-import { startSerializer } from './serializer'
-import { mergeHeaders } from './headers'
+import { mergeHeaders } from '@tanstack/router-core/ssr/client'
+import { getStartContext } from '@tanstack/start-storage-context'
 import { globalMiddleware } from './registerGlobalMiddleware'
+
+import { startSerializer } from './serializer'
+
+import { createIsomorphicFn } from './createIsomorphicFn'
+import type {
+  SerializerParse,
+  SerializerStringify,
+  SerializerStringifyBy,
+} from './serializer'
 import type {
+  AnyRouter,
   AnyValidator,
   Constrain,
   Expand,
   ResolveValidatorInput,
-  SerializerParse,
-  SerializerStringify,
-  SerializerStringifyBy,
   Validator,
 } from '@tanstack/router-core'
+import type { JsonResponse } from '@tanstack/router-core/ssr/client'
 import type { Readable } from 'node:stream'
 import type {
   AnyFunctionMiddleware,
@@ -27,6 +33,10 @@ import type {
 
 type TODO = any
 
+const getRouterInstance = createIsomorphicFn()
+  .client(() => window.__TSR_ROUTER__!)
+  .server(() => getStartContext({ throwIfNotFound: false })?.router)
+
 export function createServerFn<
   TMethod extends Method,
   TServerFnResponseType extends ServerFnResponseType = 'data',
@@ -37,7 +47,6 @@ export function createServerFn<
   options?: {
     method?: TMethod
     response?: TServerFnResponseType
-    type?: ServerFnType
   },
   __opts?: ServerFnBaseOptions<
     TMethod,
@@ -79,15 +88,6 @@ export function createServerFn<
         TValidator
       >(undefined, Object.assign(resolvedOptions, { validator })) as any
     },
-    type: (type) => {
-      return createServerFn<
-        TMethod,
-        ServerFnResponseType,
-        TResponse,
-        TMiddlewares,
-        TValidator
-      >(undefined, Object.assign(resolvedOptions, { type })) as any
-    },
     handler: (...args) => {
       // This function signature changes due to AST transformations
       // in the babel plugin. We need to cast it to the correct
@@ -129,6 +129,7 @@ export function createServerFn<
             headers: opts?.headers,
             signal: opts?.signal,
             context: {},
+            router: getRouterInstance(),
           }).then((d) => {
             if (resolvedOptions.response === 'full') {
               return d
@@ -146,70 +147,20 @@ export function createServerFn<
             const opts =
               opts_ instanceof FormData ? extractFormDataContext(opts_) : opts_
 
-            opts.type =
-              typeof resolvedOptions.type === 'function'
-                ? resolvedOptions.type(opts)
-                : resolvedOptions.type
-
             const ctx = {
               ...extractedFn,
               ...opts,
               signal,
             }
 
-            const run = () =>
-              executeMiddleware(resolvedMiddleware, 'server', ctx).then(
-                (d) => ({
-                  // Only send the result and sendContext back to the client
-                  result: d.result,
-                  error: d.error,
-                  context: d.sendContext,
-                }),
-              )
-
-            if (ctx.type === 'static') {
-              let response: StaticCachedResult | undefined
-
-              // If we can get the cached item, try to get it
-              if (serverFnStaticCache?.getItem) {
-                // If this throws, it's okay to let it bubble up
-                response = await serverFnStaticCache.getItem(ctx)
-              }
-
-              if (!response) {
-                // If there's no cached item, execute the server function
-                response = await run()
-                  .then((d) => {
-                    return {
-                      ctx: d,
-                      error: null,
-                    }
-                  })
-                  .catch((e) => {
-                    return {
-                      ctx: undefined,
-                      error: e,
-                    }
-                  })
-
-                if (serverFnStaticCache?.setItem) {
-                  await serverFnStaticCache.setItem(ctx, response)
-                }
-              }
-
-              invariant(
-                response,
-                'No response from both server and static cache!',
-              )
-
-              if (response.error) {
-                throw response.error
-              }
-
-              return response.ctx
-            }
-
-            return run()
+            return executeMiddleware(resolvedMiddleware, 'server', ctx).then(
+              (d) => ({
+                // Only send the result and sendContext back to the client
+                result: d.result,
+                error: d.error,
+                context: d.sendContext,
+              }),
+            )
           },
         },
       ) as any
@@ -278,10 +229,6 @@ export async function executeMiddleware(
   })
 }
 
-export interface JsonResponse<TData> extends Response {
-  json: () => Promise<TData>
-}
-
 export type CompiledFetcherFnOptions = {
   method: Method
   data: unknown
@@ -289,6 +236,7 @@ export type CompiledFetcherFnOptions = {
   headers?: HeadersInit
   signal?: AbortSignal
   context?: any
+  // router?: AnyRouter
 }
 
 export type Fetcher<
@@ -357,12 +305,9 @@ export interface RequiredFetcher<
 
 export type FetcherBaseOptions = {
   headers?: HeadersInit
-  type?: ServerFnType
   signal?: AbortSignal
 }
 
-export type ServerFnType = 'static' | 'dynamic'
-
 export interface OptionalFetcherDataOptions<TMiddlewares, TValidator>
   extends FetcherBaseOptions {
   data?: Expand<IntersectAllValidatorInputs<TMiddlewares, TValidator>>
@@ -456,12 +401,6 @@ export type ServerFnBaseOptions<
     TResponse
   >
   functionId: string
-  type: ServerFnTypeOrTypeFn<
-    TMethod,
-    TServerFnResponseType,
-    TMiddlewares,
-    AnyValidator
-  >
 }
 
 export type ValidatorInputStringify<TValidator> = SerializerStringifyBy<
@@ -506,7 +445,6 @@ export interface ServerFnAfterMiddleware<
   TMiddlewares,
   TValidator,
 > extends ServerFnValidator<TMethod, TServerFnResponseType, TMiddlewares>,
-    ServerFnTyper<TMethod, TServerFnResponseType, TMiddlewares, TValidator>,
     ServerFnHandler<TMethod, TServerFnResponseType, TMiddlewares, TValidator> {}
 
 export type ValidatorFn<
@@ -536,47 +474,8 @@ export interface ServerFnAfterValidator<
   TMiddlewares,
   TValidator,
 > extends ServerFnMiddleware<TMethod, TServerFnResponseType, TValidator>,
-    ServerFnTyper<TMethod, TServerFnResponseType, TMiddlewares, TValidator>,
     ServerFnHandler<TMethod, TServerFnResponseType, TMiddlewares, TValidator> {}
 
-// Typer
-export interface ServerFnTyper<
-  TMethod extends Method,
-  TServerFnResponseType extends ServerFnResponseType,
-  TMiddlewares,
-  TValidator,
-> {
-  type: (
-    typer: ServerFnTypeOrTypeFn<
-      TMethod,
-      TServerFnResponseType,
-      TMiddlewares,
-      TValidator
-    >,
-  ) => ServerFnAfterTyper<
-    TMethod,
-    TServerFnResponseType,
-    TMiddlewares,
-    TValidator
-  >
-}
-
-export type ServerFnTypeOrTypeFn<
-  TMethod extends Method,
-  TServerFnResponseType extends ServerFnResponseType,
-  TMiddlewares,
-  TValidator,
-> =
-  | ServerFnType
-  | ((
-      ctx: ServerFnCtx<
-        TMethod,
-        TServerFnResponseType,
-        TMiddlewares,
-        TValidator
-      >,
-    ) => ServerFnType)
-
 export interface ServerFnAfterTyper<
   TMethod extends Method,
   TServerFnResponseType extends ServerFnResponseType,
@@ -612,7 +511,6 @@ export interface ServerFnBuilder<
   TServerFnResponseType extends ServerFnResponseType = 'data',
 > extends ServerFnMiddleware<TMethod, TServerFnResponseType, undefined>,
     ServerFnValidator<TMethod, TServerFnResponseType, undefined>,
-    ServerFnTyper<TMethod, TServerFnResponseType, undefined, undefined>,
     ServerFnHandler<TMethod, TServerFnResponseType, undefined, undefined> {
   options: ServerFnBaseOptions<
     TMethod,
@@ -623,176 +521,6 @@ export interface ServerFnBuilder<
   >
 }
 
-export type StaticCachedResult = {
-  ctx?: {
-    result: any
-    context: any
-  }
-  error?: any
-}
-
-export type ServerFnStaticCache = {
-  getItem: (
-    ctx: ServerFnMiddlewareResult,
-  ) => StaticCachedResult | Promise<StaticCachedResult | undefined>
-  setItem: (
-    ctx: ServerFnMiddlewareResult,
-    response: StaticCachedResult,
-  ) => Promise<void>
-  fetchItem: (
-    ctx: ServerFnMiddlewareResult,
-  ) => StaticCachedResult | Promise<StaticCachedResult | undefined>
-}
-
-export let serverFnStaticCache: ServerFnStaticCache | undefined
-
-export function setServerFnStaticCache(
-  cache?: ServerFnStaticCache | (() => ServerFnStaticCache | undefined),
-) {
-  const previousCache = serverFnStaticCache
-  serverFnStaticCache = typeof cache === 'function' ? cache() : cache
-
-  return () => {
-    serverFnStaticCache = previousCache
-  }
-}
-
-export function createServerFnStaticCache(
-  serverFnStaticCache: ServerFnStaticCache,
-) {
-  return serverFnStaticCache
-}
-
-/**
- * This is a simple hash function for generating a hash from a string to make the filenames shorter.
- *
- * It is not cryptographically secure (as its using SHA-1) and should not be used for any security purposes.
- *
- * It is only used to generate a hash for the static cache filenames.
- *
- * @param message - The input string to hash.
- * @returns A promise that resolves to the SHA-1 hash of the input string in hexadecimal format.
- *
- * @example
- * ```typescript
- * const hash = await sha1Hash("hello");
- * console.log(hash); // Outputs the SHA-1 hash of "hello" -> "aaf4c61ddcc5e8a2dabede0f3b482cd9aea9434d"
- * ```
- */
-async function sha1Hash(message: string): Promise<string> {
-  // Encode the string as UTF-8
-  const msgBuffer = new TextEncoder().encode(message)
-
-  // Hash the message
-  const hashBuffer = await crypto.subtle.digest('SHA-1', msgBuffer)
-
-  // Convert the ArrayBuffer to a string
-  const hashArray = Array.from(new Uint8Array(hashBuffer))
-  const hashHex = hashArray.map((b) => b.toString(16).padStart(2, '0')).join('')
-  return hashHex
-}
-
-setServerFnStaticCache(() => {
-  const getStaticCacheUrl = async (
-    options: ServerFnMiddlewareResult,
-    hash: string,
-  ) => {
-    const filename = await sha1Hash(`${options.functionId}__${hash}`)
-    return `/__tsr/staticServerFnCache/${filename}.json`
-  }
-
-  const jsonToFilenameSafeString = (json: any) => {
-    // Custom replacer to sort keys
-    const sortedKeysReplacer = (key: string, value: any) =>
-      value && typeof value === 'object' && !Array.isArray(value)
-        ? Object.keys(value)
-            .sort()
-            .reduce((acc: any, curr: string) => {
-              acc[curr] = value[curr]
-              return acc
-            }, {})
-        : value
-
-    // Convert JSON to string with sorted keys
-    const jsonString = JSON.stringify(json ?? '', sortedKeysReplacer)
-
-    // Replace characters invalid in filenames
-    return jsonString
-      .replace(/[/\\?%*:|"<>]/g, '-') // Replace invalid characters with a dash
-      .replace(/\s+/g, '_') // Optionally replace whitespace with underscores
-  }
-
-  const staticClientCache =
-    typeof document !== 'undefined' ? new Map<string, any>() : null
-
-  return createServerFnStaticCache({
-    getItem: async (ctx) => {
-      if (typeof document === 'undefined') {
-        const hash = jsonToFilenameSafeString(ctx.data)
-        const url = await getStaticCacheUrl(ctx, hash)
-        const publicUrl = process.env.TSS_OUTPUT_PUBLIC_DIR!
-
-        // Use fs instead of fetch to read from filesystem
-        const { promises: fs } = await import('node:fs')
-        const path = await import('node:path')
-        const filePath = path.join(publicUrl, url)
-
-        const [cachedResult, readError] = await fs
-          .readFile(filePath, 'utf-8')
-          .then((c) => [
-            startSerializer.parse(c) as {
-              ctx: unknown
-              error: any
-            },
-            null,
-          ])
-          .catch((e) => [null, e])
-
-        if (readError && readError.code !== 'ENOENT') {
-          throw readError
-        }
-
-        return cachedResult as StaticCachedResult
-      }
-
-      return undefined
-    },
-    setItem: async (ctx, response) => {
-      const { promises: fs } = await import('node:fs')
-      const path = await import('node:path')
-
-      const hash = jsonToFilenameSafeString(ctx.data)
-      const url = await getStaticCacheUrl(ctx, hash)
-      const publicUrl = process.env.TSS_OUTPUT_PUBLIC_DIR!
-      const filePath = path.join(publicUrl, url)
-
-      // Ensure the directory exists
-      await fs.mkdir(path.dirname(filePath), { recursive: true })
-
-      // Store the result with fs
-      await fs.writeFile(filePath, startSerializer.stringify(response))
-    },
-    fetchItem: async (ctx) => {
-      const hash = jsonToFilenameSafeString(ctx.data)
-      const url = await getStaticCacheUrl(ctx, hash)
-
-      let result: any = staticClientCache?.get(url)
-
-      if (!result) {
-        result = await fetch(url, {
-          method: 'GET',
-        })
-          .then((r) => r.text())
-          .then((d) => startSerializer.parse(d))
-
-        staticClientCache?.set(url, result)
-      }
-
-      return result
-    },
-  })
-})
-
 export function extractFormDataContext(formData: FormData) {
   const serializedContext = formData.get('__TSR_CONTEXT')
   formData.delete('__TSR_CONTEXT')
@@ -849,14 +577,13 @@ export type ServerFnMiddlewareOptions = {
   signal?: AbortSignal
   sendContext?: any
   context?: any
-  type: ServerFnTypeOrTypeFn<any, any, any, any>
   functionId: string
+  router?: AnyRouter
 }
 
 export type ServerFnMiddlewareResult = ServerFnMiddlewareOptions & {
   result?: unknown
   error?: unknown
-  type: ServerFnTypeOrTypeFn<any, any, any, any>
 }
 
 export type NextFn = (
@@ -946,35 +673,8 @@ export function serverFnBaseToMiddleware(
           ...ctx,
           // switch the sendContext over to context
           context: sendContext,
-          type: typeof ctx.type === 'function' ? ctx.type(ctx) : ctx.type,
         } as any
 
-        if (
-          ctx.type === 'static' &&
-          process.env.NODE_ENV === 'production' &&
-          typeof document !== 'undefined'
-        ) {
-          invariant(
-            serverFnStaticCache,
-            'serverFnStaticCache.fetchItem is not available!',
-          )
-
-          const result = await serverFnStaticCache.fetchItem(payload)
-
-          if (result) {
-            if (result.error) {
-              throw result.error
-            }
-
-            return next(result.ctx)
-          }
-
-          warning(
-            result,
-            `No static cache item found for ${payload.functionId}__${JSON.stringify(payload.data)}, falling back to server function...`,
-          )
-        }
-
         // Execute the extracted function
         // but not before serializing the context
         const res = await options.extractedFn?.(payload)

package/src/index.tsx

@@ -1,16 +1,22 @@
-export { mergeHeaders } from './headers'
+export type {
+  DehydratedRouter,
+  JsonResponse,
+} from '@tanstack/router-core/ssr/client'
+
+export { hydrate, json, mergeHeaders } from '@tanstack/router-core/ssr/client'
+
 export { startSerializer } from './serializer'
-export {
-  type DehydratedRouter,
-  type ClientExtractedBaseEntry,
-  type StartSsrGlobal,
-  type ClientExtractedEntry,
-  type SsrMatch,
-  type ClientExtractedPromise,
-  type ClientExtractedStream,
-  type ResolvePromiseState,
-  hydrate,
-} from './ssr-client'
+
+export type {
+  StartSerializer,
+  Serializable,
+  SerializerParse,
+  SerializerParseBy,
+  SerializerStringify,
+  SerializerStringifyBy,
+  SerializerExtensions,
+} from './serializer'
+
 export {
   createIsomorphicFn,
   type IsomorphicFn,
@@ -19,8 +25,7 @@ export {
   type IsomorphicFnBase,
 } from './createIsomorphicFn'
 export { serverOnly, clientOnly } from './envOnly'
-export { type JsonResponse, createServerFn } from './createServerFn'
-export { json } from './json'
+export { createServerFn } from './createServerFn'
 export {
   createMiddleware,
   type IntersectAllValidatorInputs,
@@ -55,8 +60,6 @@ export {
   globalMiddleware,
 } from './registerGlobalMiddleware'
 export type {
-  ServerFn as FetchFn,
-  ServerFnCtx as FetchFnCtx,
   CompiledFetcherFnOptions,
   CompiledFetcherFn,
   Fetcher,
@@ -70,11 +73,9 @@ export type {
   ServerFnMiddlewareOptions,
   ServerFnMiddlewareResult,
   ServerFnBuilder,
-  ServerFnType,
   ServerFnBaseOptions,
   NextFn,
   Method,
-  StaticCachedResult,
   OptionalFetcher,
   RequiredFetcher,
 } from './createServerFn'
@@ -84,6 +85,5 @@ export {
   serverFnBaseToMiddleware,
   extractFormDataContext,
   flattenMiddlewares,
-  serverFnStaticCache,
   executeMiddleware,
 } from './createServerFn'

package/src/serializer.ts

@@ -1,6 +1,37 @@
 import { isPlainObject } from '@tanstack/router-core'
-import type { StartSerializer } from '@tanstack/router-core'
 
+export interface StartSerializer {
+  stringify: (obj: unknown) => string
+  parse: (str: string) => unknown
+  encode: <T>(value: T) => T
+  decode: <T>(value: T) => T
+}
+
+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>
 export const startSerializer: StartSerializer = {
   stringify: (value: any) =>
     JSON.stringify(value, function replacer(key, val) {
@@ -73,7 +104,6 @@ export const startSerializer: StartSerializer = {
     return value
   },
 }
-
 const createSerializer = <TKey extends string, TInput, TSerialized>(
   key: TKey,
   check: (value: any) => value is TInput,
@@ -86,7 +116,6 @@ const createSerializer = <TKey extends string, TInput, TSerialized>(
   parseCondition: (value: any) => Object.hasOwn(value, `$${key}`),
   parse: (value: any) => fromValue(value[`$${key}`]),
 })
-
 // Keep these ordered by predicted frequency
 // Make sure to keep DefaultSerializable in sync with these serializers
 // Also, make sure that they are unit tested in serializer.test.tsx

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

@@ -52,7 +52,6 @@ test('createServerFn with validator', () => {
   expectTypeOf(fn).parameter(0).toEqualTypeOf<{
     data: { input: string }
     headers?: HeadersInit
-    type?: 'static' | 'dynamic'
     signal?: AbortSignal
   }>()
 
@@ -168,7 +167,6 @@ describe('createServerFn with middleware and validator', () => {
         readonly inputC: 'inputC'
       }
       headers?: HeadersInit
-      type?: 'static' | 'dynamic'
       signal?: AbortSignal
     }>()
 
@@ -212,7 +210,6 @@ describe('createServerFn with middleware and validator', () => {
         readonly inputC: 'inputC'
       }
       headers?: HeadersInit
-      type?: 'static' | 'dynamic'
       signal?: AbortSignal
     }>()
 
@@ -323,7 +320,6 @@ test('createServerFn where validator is optional if object is optional', () => {
     | {
         data?: 'c' | undefined
         headers?: HeadersInit
-        type?: 'static' | 'dynamic'
         signal?: AbortSignal
       }
     | undefined
@@ -347,7 +343,6 @@ test('createServerFn where data is optional if there is no validator', () => {
     | {
         data?: undefined
         headers?: HeadersInit
-        type?: 'static' | 'dynamic'
         signal?: AbortSignal
       }
     | undefined
@@ -509,7 +504,6 @@ test('createServerFn validator infers unknown for default input type', () => {
     | {
         data?: unknown | undefined
         headers?: HeadersInit
-        type?: 'static' | 'dynamic'
         signal?: AbortSignal
       }
     | undefined