Open History to see the last commit
1/* eslint-disable @typescript-eslint/no-unnecessary-condition */
2// Had to disable the lint rule because isServer type is defined as false
3// in solid-js/web package. I'll create a GitHub issue with them to see
4// why that happens.
5import { hydrate, notifyManager } from '@tanstack/query-core'
6import { isServer } from 'solid-js/web'
7import {
8 createComputed,
9 createMemo,
10 createResource,
11 createSignal,
12 mergeProps,
13 on,
14 onCleanup,
15 untrack,
16} from 'solid-js'
17import { createStore, reconcile, unwrap } from 'solid-js/store'
18import { useQueryClient } from './QueryClientProvider'
19import { shouldThrowError } from './utils'
20import { useIsRestoring } from './isRestoring'
21import type { CreateBaseQueryOptions } from './types'
22import type { Accessor } from 'solid-js'
23import type { QueryClient } from './QueryClient'
24import type {
25 Query,
26 QueryKey,
27 QueryObserver,
28 QueryObserverResult,
29 QueryState,
30} from '@tanstack/query-core'
31β
32function reconcileFn<TData, TError>(
33 store: QueryObserverResult<TData, TError>,
34 result: QueryObserverResult<TData, TError>,
35 reconcileOption:
36 | string
37 | false
38 | ((oldData: TData | undefined, newData: TData) => TData),
39): QueryObserverResult<TData, TError> {
40 if (reconcileOption === false) return result
41 if (typeof reconcileOption === 'function') {
42 const newData = reconcileOption(store.data, result.data as TData)
43 return { ...result, data: newData } as typeof result
44 }
45 const newData = reconcile(result.data, { key: reconcileOption })(store.data)
46 return { ...result, data: newData } as typeof result
47}
48β
49type HydratableQueryState<TData, TError> = QueryObserverResult<TData, TError> &
50 QueryState<TData, TError>
51β
52/**
53 * Solid's `onHydrated` functionality will silently "fail" (hydrate with an empty object)
54 * if the resource data is not serializable.
55 */
56const hydratableObserverResult = <
57 TQueryFnData,
58 TError,
59 TData,
60 TQueryKey extends QueryKey,
61 TDataHydratable,
62>(
63 query: Query<TQueryFnData, TError, TData, TQueryKey>,
64 result: QueryObserverResult<TDataHydratable, TError>,
65): HydratableQueryState<TDataHydratable, TError> => {
66 // Including the extra properties is only relevant on the server
67 if (!isServer) return result as HydratableQueryState<TDataHydratable, TError>
68β
69 return {
70 ...unwrap(result),
71β
72 // cast to refetch function should be safe, since we only remove it on the server,
73 // and refetch is not relevant on the server
74 refetch: undefined as unknown as HydratableQueryState<
75 TDataHydratable,
76 TError
77 >['refetch'],
78β
79 // hydrate() expects a QueryState object, which is similar but not
80 // quite the same as a QueryObserverResult object. Thus, for now, we're
81 // copying over the missing properties from state in order to support hydration
82 dataUpdateCount: query.state.dataUpdateCount,
83 fetchFailureCount: query.state.fetchFailureCount,
84 isInvalidated: query.state.isInvalidated,
85β
86 // Unsetting these properties on the server since they might not be serializable
87 fetchFailureReason: null,
88 fetchMeta: null,
89 }
90}
91β
92// Base Query Function that is used to create the query.
93export function createBaseQuery<
94 TQueryFnData,
95 TError,
96 TData,
97 TQueryData,
98 TQueryKey extends QueryKey,
99>(
100 options: Accessor<
101 CreateBaseQueryOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>
102 >,
103 Observer: typeof QueryObserver,
104 queryClient?: Accessor<QueryClient>,
105) {
106 type ResourceData =
107 | HydratableQueryState<TData, TError>
108 | QueryObserverResult<TData, TError>
109β
110 const client = createMemo(() => useQueryClient(queryClient?.()))
111 const isRestoring = useIsRestoring()
112β
113 const defaultedOptions = createMemo(() =>
114 mergeProps(client()?.defaultQueryOptions(options()) || {}, {
115 get _optimisticResults() {
116 return isRestoring() ? 'isRestoring' : 'optimistic'
117 },
118 structuralSharing: false,
119 ...(isServer && { retry: false, throwOnError: true }),
120 }),
121 )
122β
123 const [observer, setObserver] = createSignal(
124 new Observer(client(), untrack(defaultedOptions)),
125 )
126 // we set the value in a computed because `createMemo`
127 // returns undefined during transitions
128 createComputed(
129 on(client, (c) => setObserver(new Observer(c, defaultedOptions())), {
130 defer: true,
131 }),
132 )
133β
134 const [state, setState] = createStore<QueryObserverResult<TData, TError>>(
135 observer().getOptimisticResult(defaultedOptions()),
136 )
137β
138 const createServerSubscriber = (
139 resolve: (
140 data: ResourceData | PromiseLike<ResourceData | undefined> | undefined,
141 ) => void,
142 reject: (reason?: any) => void,
143 ) => {
144 return observer().subscribe((result) => {
145 notifyManager.batchCalls(() => {
146 const query = observer().getCurrentQuery()
147 const unwrappedResult = hydratableObserverResult(query, result)
148β
149 if (unwrappedResult.isError) {
150 reject(unwrappedResult.error)
151 } else {
152 resolve(unwrappedResult)
153 }
154 })()
155 })
156 }
157β
158 const createClientSubscriber = () => {
159 const obs = observer()
160 return obs.subscribe((result) => {
161 notifyManager.batchCalls(() => {
162 // @ts-expect-error - This will error because the reconcile option does not
163 // exist on the query-core QueryObserverResult type
164 const reconcileOptions = obs.options.reconcile
165β
166 setState((store) => {
167 return reconcileFn(
168 store,
169 result,
170 reconcileOptions === undefined ? false : reconcileOptions,
171 )
172 })
173 // If the query has data we don't suspend but instead mutate the resource
174 // This could happen when placeholderData/initialData is defined
175 if (
176 queryResource()?.data &&
177 result.data &&
178 !queryResource.loading &&
179 isRestoring()
180 )
181 mutate(state)
182 else refetch()
183 })()
184 })
185 }
186β
187 /**
188 * Unsubscribe is set lazily, so that we can subscribe after hydration when needed.
189 */
190 let unsubscribe: (() => void) | null = null
191β
192 const [queryResource, { refetch, mutate }] = createResource<
193 ResourceData | undefined
194 >(
195 () => {
196 const obs = observer()
197 return new Promise((resolve, reject) => {
198 if (isServer) unsubscribe = createServerSubscriber(resolve, reject)
199 else if (!unsubscribe && !isRestoring())
200 unsubscribe = createClientSubscriber()
201β
202 obs.updateResult()
203β
204 if (!state.isLoading && !isRestoring()) {
205 const query = obs.getCurrentQuery()
206 resolve(hydratableObserverResult(query, state))
207 }
208 })
209 },
210 {
211 initialValue: state,
212β
213 // If initialData is provided, we resolve the resource immediately
214 get ssrLoadFrom() {
215 return options().initialData ? 'initial' : 'server'
216 },
217β
218 get deferStream() {
219 return options().deferStream
220 },
221β
222 /**
223 * If this resource was populated on the server (either sync render, or streamed in over time), onHydrated
224 * will be called. This is the point at which we can hydrate the query cache state, and setup the query subscriber.
225 *
226 * Leveraging onHydrated allows us to plug into the async and streaming support that solidjs resources already support.
227 *
228 * Note that this is only invoked on the client, for queries that were originally run on the server.
229 */
230 onHydrated(_k, info) {
231 const defaultOptions = defaultedOptions()
232 if (info.value) {
233 hydrate(client(), {
234 queries: [
235 {
236 queryKey: defaultOptions.queryKey,
237 queryHash: defaultOptions.queryHash,
238 state: info.value,
239 },
240 ],
241 })
242 }
243β
244 if (unsubscribe) return
245 /**
246 * Do not refetch query on mount if query was fetched on server,
247 * even if `staleTime` is not set.
248 */
249 const newOptions = { ...defaultOptions }
250 if (defaultOptions.staleTime || !defaultOptions.initialData) {
251 newOptions.refetchOnMount = false
252 }
253 // Setting the options as an immutable object to prevent
254 // wonky behavior with observer subscriptions
255 observer().setOptions(newOptions)
256 setState(observer().getOptimisticResult(newOptions))
257 unsubscribe = createClientSubscriber()
258 },
259 },
260 )
261β
262 createComputed(
263 on(
264 [isRestoring, observer],
265 ([restoring]) => {
266 const _unsubscribe = unsubscribe
267 queueMicrotask(() => _unsubscribe?.())
268 unsubscribe = null
269 if (!restoring) refetch()
270 },
271 { defer: true },
272 ),
273 )
274β
275 onCleanup(() => {
276 if (unsubscribe) {
277 unsubscribe()
278 unsubscribe = null
279 }
280 })
281β
282 createComputed(
283 on(
284 [observer, defaultedOptions],
285 ([obs, opts]) => {
286 obs.setOptions(opts)
287 setState(obs.getOptimisticResult(opts))
288 },
289 {
290 // Defer because we don't need to trigger on first render
291 // This only cares about changes to options after the observer is created
292 defer: true,
293 },
294 ),
295 )
296β
297 createComputed(
298 on(
299 () => state.status,
300 () => {
301 const obs = observer()
302 if (
303 state.isError &&
304 !state.isFetching &&
305 !isRestoring() &&
306 shouldThrowError(obs.options.throwOnError, [
307 state.error,
308 obs.getCurrentQuery(),
309 ])
310 ) {
311 throw state.error
312 }
313 },
314 ),
315 )
316β
317 const handler = {
318 get(
319 target: QueryObserverResult<TData, TError>,
320 prop: keyof QueryObserverResult<TData, TError>,
321 ): any {
322 const val = queryResource()?.[prop]
323 return val !== undefined ? val : Reflect.get(target, prop)
324 },
325 }
326β
327 return new Proxy(state, handler)
328}