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

useBaseQuery.ts

397 lines11.7 KB

1// Had to disable the lint rule because isServer type is defined as false
2// in solid-js/web package. I'll create a GitHub issue with them to see
3// why that happens.
4import { hydrate, notifyManager, shouldThrowError } from '@tanstack/query-core'
5import { isServer } from 'solid-js/web'
6import {
7 createComputed,
8 createMemo,
9 createResource,
10 createSignal,
11 on,
12 onCleanup,
13} from 'solid-js'
14import { createStore, reconcile, unwrap } from 'solid-js/store'
15import { useQueryClient } from './QueryClientProvider'
16import { useIsRestoring } from './isRestoring'
17import type { UseBaseQueryOptions } from './types'
18import type { Accessor, Signal } from 'solid-js'
19import type { QueryClient } from './QueryClient'
20import type {
21 Query,
22 QueryKey,
23 QueryObserver,
24 QueryObserverResult,
25} from '@tanstack/query-core'
26​
27function reconcileFn<TData, TError>(
28 store: QueryObserverResult<TData, TError>,
29 result: QueryObserverResult<TData, TError>,
30 reconcileOption:
31 | string
32 | false
33 | ((oldData: TData | undefined, newData: TData) => TData),
34 queryHash?: string,
35): QueryObserverResult<TData, TError> {
36 if (reconcileOption === false) return result
37 if (typeof reconcileOption === 'function') {
38 const newData = reconcileOption(store.data, result.data as TData)
39 return { ...result, data: newData } as typeof result
40 }
41 let data = result.data
42 if (store.data === undefined) {
43 try {
44 data = structuredClone(data)
45 } catch (error) {
46 if (process.env.NODE_ENV !== 'production') {
47 if (error instanceof Error) {
48 console.warn(
49 `Unable to correctly reconcile data for query key: ${queryHash}. ` +
50 `Possibly because the query data contains data structures that aren't supported ` +
51 `by the 'structuredClone' algorithm. Consider using a callback function instead ` +
52 `to manage the reconciliation manually.\n\n Error Received: ${error.name} - ${error.message}`,
53 )
54 }
55 }
56 }
57 }
58 const newData = reconcile(data, { key: reconcileOption })(store.data)
59 return { ...result, data: newData } as typeof result
61​
62/**
63 * Solid's `onHydrated` functionality will silently "fail" (hydrate with an empty object)
64 * if the resource data is not serializable.
65 */
66const hydratableObserverResult = <
67 TQueryFnData,
68 TError,
69 TData,
70 TQueryKey extends QueryKey,
71 TDataHydratable,
72>(
73 query: Query<TQueryFnData, TError, TData, TQueryKey>,
74 result: QueryObserverResult<TDataHydratable, TError>,
75) => {
76 if (!isServer) return result
77 const obj: any = {
78 ...unwrap(result),
79 // During SSR, functions cannot be serialized, so we need to remove them
80 // This is safe because we will add these functions back when the query is hydrated
81 refetch: undefined,
82 }
83​
84 // If the query is an infinite query, we need to remove additional properties
85 if ('fetchNextPage' in result) {
86 obj.fetchNextPage = undefined
87 obj.fetchPreviousPage = undefined
88 }
89​
90 // We will also attach the dehydrated state of the query to the result
91 // This will be removed on client after hydration
92 obj.hydrationData = {
93 state: query.state,
94 queryKey: query.queryKey,
95 queryHash: query.queryHash,
96 ...(query.meta && { meta: query.meta }),
97 }
98​
99 return obj
101​
102// Base Query Function that is used to create the query.
103export function useBaseQuery<
104 TQueryFnData,
105 TError,
106 TData,
107 TQueryData,
108 TQueryKey extends QueryKey,
109>(
110 options: Accessor<
111 UseBaseQueryOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>
112 >,
113 Observer: typeof QueryObserver,
114 queryClient?: Accessor<QueryClient>,
115) {
116 type ResourceData = QueryObserverResult<TData, TError>
117​
118 const client = createMemo(() => useQueryClient(queryClient?.()))
119 const isRestoring = useIsRestoring()
120 // There are times when we run a query on the server but the resource is never read
121 // This could lead to times when the queryObserver is unsubscribed before the resource has loaded
122 // Causing a time out error. To prevent this we will queue the unsubscribe if the cleanup is called
123 // before the resource has loaded
124 let unsubscribeQueued = false
125​
126 const defaultedOptions = createMemo(() => {
127 const defaultOptions = client().defaultQueryOptions(options())
128 defaultOptions._optimisticResults = isRestoring()
129 ? 'isRestoring'
130 : 'optimistic'
131 defaultOptions.structuralSharing = false
132 if (isServer) {
133 defaultOptions.retry = false
134 defaultOptions.throwOnError = true
135 // Enable prefetch during render for SSR - required for createResource to work
136 // Without this, queries wait for effects which never run on the server
137 defaultOptions.experimental_prefetchInRender = true
138 }
139 return defaultOptions
140 })
141 const initialOptions = defaultedOptions()
142​
143 const [observer, setObserver] = createSignal(
144 new Observer(client(), defaultedOptions()),
145 )
146​
147 let observerResult = observer().getOptimisticResult(defaultedOptions())
148 const [state, setState] =
149 createStore<QueryObserverResult<TData, TError>>(observerResult)
150​
151 const createServerSubscriber = (
152 resolve: (
153 data: ResourceData | PromiseLike<ResourceData | undefined> | undefined,
154 ) => void,
155 reject: (reason?: any) => void,
156 ) => {
157 return observer().subscribe((result) => {
158 notifyManager.batchCalls(() => {
159 const query = observer().getCurrentQuery()
160 const unwrappedResult = hydratableObserverResult(query, result)
161​
162 if (result.data !== undefined && unwrappedResult.isError) {
163 reject(unwrappedResult.error)
164 unsubscribeIfQueued()
165 } else {
166 resolve(unwrappedResult)
167 unsubscribeIfQueued()
168 }
169 })()
170 })
171 }
172​
173 const unsubscribeIfQueued = () => {
174 if (unsubscribeQueued) {
175 unsubscribe?.()
176 unsubscribeQueued = false
177 }
178 }
179​
180 const createClientSubscriber = () => {
181 const obs = observer()
182 return obs.subscribe((result) => {
183 observerResult = result
184 queueMicrotask(() => {
185 if (unsubscribe) {
186 refetch()
187 }
188 })
189 })
190 }
191​
192 function setStateWithReconciliation(res: typeof observerResult) {
193 const opts = observer().options
194 // @ts-expect-error - Reconcile option is not correctly typed internally
195 const reconcileOptions = opts.reconcile
196​
197 setState((store) => {
198 return reconcileFn(
199 store,
200 res,
201 reconcileOptions === undefined ? false : reconcileOptions,
202 opts.queryHash,
203 )
204 })
205 }
206​
207 function createDeepSignal<T>(): Signal<T> {
208 return [
209 () => state,
210 (v: any) => {
211 const unwrapped = unwrap(state)
212 if (typeof v === 'function') {
213 v = v(unwrapped)
214 }
215 // Hydration data exists on first load after SSR,
216 // and should be removed from the observer result
217 if (v?.hydrationData) {
218 const { hydrationData, ...rest } = v
219 v = rest
220 }
221 setStateWithReconciliation(v)
222 },
223 ] as Signal<T>
224 }
225​
226 /**
227 * Unsubscribe is set lazily, so that we can subscribe after hydration when needed.
228 */
229 let unsubscribe: (() => void) | null = null
230​
231 /*
232 Fixes #7275
233 In a few cases, the observer could unmount before the resource is loaded.
234 This leads to Suspense boundaries to be suspended indefinitely.
235 This resolver will be called when the observer is unmounting
236 but the resource is still in a loading state
237 */
238 let resolver: ((value: ResourceData) => void) | null = null
239 const [queryResource, { refetch }] = createResource<ResourceData | undefined>(
240 () => {
241 const obs = observer()
242 return new Promise((resolve, reject) => {
243 resolver = resolve
244 if (isServer) {
245 unsubscribe = createServerSubscriber(resolve, reject)
246 } else if (!unsubscribe && !isRestoring()) {
247 unsubscribe = createClientSubscriber()
248 }
249 obs.updateResult()
250​
251 if (
252 observerResult.isError &&
253 !observerResult.isFetching &&
254 !isRestoring() &&
255 shouldThrowError(obs.options.throwOnError, [
256 observerResult.error,
257 obs.getCurrentQuery(),
258 ])
259 ) {
260 setStateWithReconciliation(observerResult)
261 return reject(observerResult.error)
262 }
263 // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- data can be undefined at runtime despite type inference
264 if (!observerResult.isLoading || observerResult.data !== undefined) {
265 resolver = null
266 return resolve(
267 hydratableObserverResult(obs.getCurrentQuery(), observerResult),
268 )
269 }
270​
271 setStateWithReconciliation(observerResult)
272 })
273 },
274 {
275 storage: createDeepSignal,
276​
277 get deferStream() {
278 return options().deferStream
279 },
280​
281 /**
282 * If this resource was populated on the server (either sync render, or streamed in over time), onHydrated
283 * will be called. This is the point at which we can hydrate the query cache state, and setup the query subscriber.
284 *
285 * Leveraging onHydrated allows us to plug into the async and streaming support that solidjs resources already support.
286 *
287 * Note that this is only invoked on the client, for queries that were originally run on the server.
288 */
289 onHydrated(_k, info) {
290 if (info.value && 'hydrationData' in info.value) {
291 hydrate(client(), {
292 // @ts-expect-error - hydrationData is not correctly typed internally
293 queries: [{ ...info.value.hydrationData }],
294 })
295 }
296​
297 if (unsubscribe) return
298 /**
299 * Do not refetch query on mount if query was fetched on server,
300 * even if `staleTime` is not set.
301 */
302 const newOptions = { ...initialOptions }
303 if (
304 (initialOptions.staleTime || !initialOptions.initialData) &&
305 info.value
306 ) {
307 newOptions.refetchOnMount = false
308 }
309 // Setting the options as an immutable object to prevent
310 // wonky behavior with observer subscriptions
311 observer().setOptions(newOptions)
312 setStateWithReconciliation(observer().getOptimisticResult(newOptions))
313 unsubscribe = createClientSubscriber()
314 },
315 },
316 )
317​
318 createComputed(
319 on(
320 client,
321 (c) => {
322 if (unsubscribe) {
323 unsubscribe()
324 }
325 const newObserver = new Observer(c, defaultedOptions())
326 unsubscribe = createClientSubscriber()
327 setObserver(newObserver)
328 },
329 {
330 defer: true,
331 },
332 ),
333 )
334​
335 createComputed(
336 on(
337 isRestoring,
338 (restoring) => {
339 if (!restoring && !isServer) {
340 refetch()
341 }
342 },
343 { defer: true },
344 ),
345 )
346​
347 onCleanup(() => {
348 if (isServer && queryResource.loading) {
349 unsubscribeQueued = true
350 return
351 }
352 if (unsubscribe) {
353 unsubscribe()
354 unsubscribe = null
355 }
356 if (resolver && !isServer) {
357 resolver(observerResult)
358 resolver = null
359 }
360 })
361​
362 createComputed(
363 on(
364 [observer, defaultedOptions],
365 ([obs, opts]) => {
366 obs.setOptions(opts)
367 setStateWithReconciliation(obs.getOptimisticResult(opts))
368 refetch()
369 },
370 { defer: true },
371 ),
372 )
373​
374 const handler = {
375 get(
376 target: QueryObserverResult<TData, TError>,
377 prop: keyof QueryObserverResult<TData, TError>,
378 ): any {
379 if (prop === 'data') {
380 const stateData = state.data
381​
382 if (!observerResult.isFetching && stateData !== undefined) {
383 return stateData
384 }
385​
386 if (!observerResult.isFetching && observerResult.data !== undefined) {
387 return observerResult.data
388 }
389​
390 return queryResource()?.data
391 }
392 return Reflect.get(target, prop)
393 },
394 }
395​
396 return new Proxy(state, handler)