Skip to content
Source
Sign inSign up
TanStack/router
Open History to see the last commit

createStart.ts

178 lines4.9 KB

1import { isPromise } from '@tanstack/router-core'
2import { createMiddleware } from './createMiddleware'
3import type { TSS_SERVER_FUNCTION } from './constants'
4import type {
5 AnyFunctionMiddleware,
6 AnyRequestMiddleware,
7 CreateMiddlewareFn,
8} from './createMiddleware'
9import type { CustomFetch } from './createServerFn'
10import type {
11 AnySerializationAdapter,
12 Register,
13 SSROption,
14} from '@tanstack/router-core'
15​
16export interface StartInstanceOptions<
17 in out TSerializationAdapters,
18 in out TDefaultSsr,
19 in out TRequestMiddlewares,
20 in out TFunctionMiddlewares,
21> {
22 '~types': StartInstanceTypes<
23 TSerializationAdapters,
24 TDefaultSsr,
25 TRequestMiddlewares,
26 TFunctionMiddlewares
27 >
28 serializationAdapters?: TSerializationAdapters
29 defaultSsr?: TDefaultSsr
30 requestMiddleware?: TRequestMiddlewares
31 functionMiddleware?: TFunctionMiddlewares
32 /**
33 * Configuration options for server functions.
34 */
35 serverFns?: {
36 /**
37 * A custom fetch implementation to use for all server function calls.
38 * This can be overridden by middleware or at the call site.
39 *
40 * Precedence (highest to lowest):
41 * 1. Call site: `serverFn({ fetch: customFetch })`
42 * 2. Later middleware: Last middleware in chain that provides `fetch`
43 * 3. Earlier middleware: First middleware in chain that provides `fetch`
44 * 4. createStart: `createStart({ serverFns: { fetch: customFetch } })`
45 * 5. Default: Global `fetch` function
46 *
47 * @note Only applies on the client side. During SSR, server functions are called directly.
48 */
49 fetch?: CustomFetch
50 }
52​
53export interface StartInstance<
54 in out TSerializationAdapters,
55 in out TDefaultSsr,
56 in out TRequestMiddlewares,
57 in out TFunctionMiddlewares,
58> {
59 getOptions: () =>
60 | Promise<
61 StartInstanceOptions<
62 TSerializationAdapters,
63 TDefaultSsr,
64 TRequestMiddlewares,
65 TFunctionMiddlewares
66 >
67 >
68 | StartInstanceOptions<
69 TSerializationAdapters,
70 TDefaultSsr,
71 TRequestMiddlewares,
72 TFunctionMiddlewares
73 >
74 createMiddleware: CreateMiddlewareFn<Register>
76​
77export interface StartInstanceTypes<
78 in out TSerializationAdapters,
79 in out TDefaultSsr,
80 in out TRequestMiddlewares,
81 in out TFunctionMiddlewares,
82> {
83 serializationAdapters: TSerializationAdapters
84 defaultSsr: TDefaultSsr
85 requestMiddleware: TRequestMiddlewares
86 functionMiddleware: TFunctionMiddlewares
88​
89function dedupeSerializationAdapters(
90 deduped: Set<AnySerializationAdapter>,
91 serializationAdapters: Array<AnySerializationAdapter>,
92): void {
93 for (let i = 0, len = serializationAdapters.length; i < len; i++) {
94 const current = serializationAdapters[i]!
95 if (!deduped.has(current)) {
96 deduped.add(current)
97 if (current.extends) {
98 dedupeSerializationAdapters(deduped, current.extends)
99 }
100 }
101 }
103​
104function dedupeOptions<
105 T extends { serializationAdapters?: ReadonlyArray<AnySerializationAdapter> },
106>(options: T): T {
107 if (options.serializationAdapters) {
108 const deduped = new Set<AnySerializationAdapter>()
109 dedupeSerializationAdapters(
110 deduped,
111 options.serializationAdapters as Array<AnySerializationAdapter>,
112 )
113 options.serializationAdapters = Array.from(deduped)
114 }
115 return options
117​
118export const createStart = <
119 const TSerializationAdapters extends ReadonlyArray<AnySerializationAdapter> =
120 [],
121 TDefaultSsr extends SSROption = SSROption,
122 const TRequestMiddlewares extends ReadonlyArray<AnyRequestMiddleware> = [],
123 const TFunctionMiddlewares extends ReadonlyArray<AnyFunctionMiddleware> = [],
124>(
125 getOptions: () =>
126 | Promise<
127 Omit<
128 StartInstanceOptions<
129 TSerializationAdapters,
130 TDefaultSsr,
131 TRequestMiddlewares,
132 TFunctionMiddlewares
133 >,
134 '~types'
135 >
136 >
137 | Omit<
138 StartInstanceOptions<
139 TSerializationAdapters,
140 TDefaultSsr,
141 TRequestMiddlewares,
142 TFunctionMiddlewares
143 >,
144 '~types'
145 >,
146): StartInstance<
147 TSerializationAdapters,
148 TDefaultSsr,
149 TRequestMiddlewares,
150 TFunctionMiddlewares
151> => {
152 return {
153 // A synchronous factory returns synchronously so callers can skip a
154 // microtask per request.
155 getOptions: () => {
156 const options = getOptions()
157 // Promise.resolve adopts any thenable and returns a native promise as is.
158 return isPromise(options)
159 ? Promise.resolve(options).then(dedupeOptions)
160 : dedupeOptions(options)
161 },
162 createMiddleware: createMiddleware,
163 } as StartInstance<
164 TSerializationAdapters,
165 TDefaultSsr,
166 TRequestMiddlewares,
167 TFunctionMiddlewares
168 >
170​
171export type AnyStartInstance = StartInstance<any, any, any, any>
172export type AnyStartInstanceOptions = StartInstanceOptions<any, any, any, any>
173​
174declare module '@tanstack/router-core' {
175 interface SerializableExtensions {
176 serverFn: { [TSS_SERVER_FUNCTION]: true }
177 }