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

createStart.ts

166 lines4.5 KB

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