Open History to see the last commit
1import { notifyManager } from './notifyManager'
2import { QueryObserver } from './queryObserver'
3import { Subscribable } from './subscribable'
4import { replaceEqualDeep, shallowEqualObjects } from './utils'
5import type {
6 DefaultedQueryObserverOptions,
7 QueryObserverOptions,
8 QueryObserverResult,
9} from './types'
10import type { QueryClient } from './queryClient'
11β
12function difference<T>(array1: Array<T>, array2: Array<T>): Array<T> {
13 const excludeSet = new Set(array2)
14 return array1.filter((x) => !excludeSet.has(x))
15}
16β
17function replaceAt<T>(array: Array<T>, index: number, value: T): Array<T> {
18 const copy = array.slice(0)
19 copy[index] = value
20 return copy
21}
22β
23type QueriesObserverListener = (result: Array<QueryObserverResult>) => void
24β
25type CombineFn<TCombinedResult> = (
26 result: Array<QueryObserverResult>,
27) => TCombinedResult
28β
29export interface QueriesObserverOptions<
30 TCombinedResult = Array<QueryObserverResult>,
31> {
32 combine?: CombineFn<TCombinedResult>
33}
34β
35export class QueriesObserver<
36 TCombinedResult = Array<QueryObserverResult>,
37> extends Subscribable<QueriesObserverListener> {
38 #client: QueryClient
39 #result!: Array<QueryObserverResult>
40 #queries: Array<QueryObserverOptions>
41 #options?: QueriesObserverOptions<TCombinedResult>
42 #observers: Array<QueryObserver>
43 #combinedResult?: TCombinedResult
44 #lastCombine?: CombineFn<TCombinedResult>
45 #lastResult?: Array<QueryObserverResult>
46 #lastQueryHashes?: Array<string>
47 #observerMatches: Array<QueryObserverMatch> = []
48β
49 constructor(
50 client: QueryClient,
51 queries: Array<QueryObserverOptions<any, any, any, any, any>>,
52 options?: QueriesObserverOptions<TCombinedResult>,
53 ) {
54 super()
55β
56 this.#client = client
57 this.#options = options
58 this.#queries = []
59 this.#observers = []
60 this.#result = []
61β
62 this.setQueries(queries)
63 }
64β
65 protected onSubscribe(): void {
66 if (this.listeners.size === 1) {
67 this.#observers.forEach((observer) => {
68 observer.subscribe((result) => {
69 this.#onUpdate(observer, result)
70 })
71 })
72 }
73 }
74β
75 protected onUnsubscribe(): void {
76 if (!this.listeners.size) {
77 this.destroy()
78 }
79 }
80β
81 destroy(): void {
82 this.listeners = new Set()
83 this.#observers.forEach((observer) => {
84 observer.destroy()
85 })
86 }
87β
88 setQueries(
89 queries: Array<QueryObserverOptions>,
90 options?: QueriesObserverOptions<TCombinedResult>,
91 ): void {
92 this.#queries = queries
93 this.#options = options
94β
95 if (process.env.NODE_ENV !== 'production') {
96 const queryHashes = queries.map(
97 (query) => this.#client.defaultQueryOptions(query).queryHash,
98 )
99 if (new Set(queryHashes).size !== queryHashes.length) {
100 console.warn(
101 '[QueriesObserver]: Duplicate Queries found. This might result in unexpected behavior.',
102 )
103 }
104 }
105β
106 notifyManager.batch(() => {
107 const prevObservers = this.#observers
108β
109 const newObserverMatches = this.#findMatchingObservers(this.#queries)
110β
111 // set options for the new observers to notify of changes
112 newObserverMatches.forEach((match) =>
113 match.observer.setOptions(match.defaultedQueryOptions),
114 )
115β
116 const newObservers = newObserverMatches.map((match) => match.observer)
117 const newResult = newObservers.map((observer) =>
118 observer.getCurrentResult(),
119 )
120β
121 const hasLengthChange = prevObservers.length !== newObservers.length
122 const hasIndexChange = newObservers.some(
123 (observer, index) => observer !== prevObservers[index],
124 )
125 const hasStructuralChange = hasLengthChange || hasIndexChange
126β
127 const hasResultChange = hasStructuralChange
128 ? true
129 : newResult.some((result, index) => {
130 const prev = this.#result[index]
131 return !prev || !shallowEqualObjects(result, prev)
132 })
133β
134 if (!hasStructuralChange && !hasResultChange) return
135β
136 if (hasStructuralChange) {
137 this.#observerMatches = newObserverMatches
138 this.#observers = newObservers
139 }
140β
141 this.#result = newResult
142β
143 if (!this.hasListeners()) return
144β
145 if (hasStructuralChange) {
146 difference(prevObservers, newObservers).forEach((observer) => {
147 observer.destroy()
148 })
149 difference(newObservers, prevObservers).forEach((observer) => {
150 observer.subscribe((result) => {
151 this.#onUpdate(observer, result)
152 })
153 })
154 }
155β
156 this.#notify()
157 })
158 }
159β
160 getCurrentResult(): Array<QueryObserverResult> {
161 return this.#result
162 }
163β
164 getQueries() {
165 return this.#observers.map((observer) => observer.getCurrentQuery())
166 }
167β
168 getObservers() {
169 return this.#observers
170 }
171β
172 getOptimisticResult(
173 queries: Array<QueryObserverOptions>,
174 combine: CombineFn<TCombinedResult> | undefined,
175 ): [
176 rawResult: Array<QueryObserverResult>,
177 combineResult: (r?: Array<QueryObserverResult>) => TCombinedResult,
178 trackResult: () => Array<QueryObserverResult>,
179 ] {
180 const matches = this.#findMatchingObservers(queries)
181 const result = matches.map((match) =>
182 match.observer.getOptimisticResult(match.defaultedQueryOptions),
183 )
184 const queryHashes = matches.map(
185 (match) => match.defaultedQueryOptions.queryHash,
186 )
187β
188 return [
189 result,
190 (r?: Array<QueryObserverResult>) => {
191 return this.#combineResult(r ?? result, combine, queryHashes)
192 },
193 () => {
194 return this.#trackResult(result, matches)
195 },
196 ]
197 }
198β
199 #trackResult(
200 result: Array<QueryObserverResult>,
201 matches: Array<QueryObserverMatch>,
202 ) {
203 return matches.map((match, index) => {
204 const observerResult = result[index]!
205 return !match.defaultedQueryOptions.notifyOnChangeProps
206 ? match.observer.trackResult(observerResult, (accessedProp) => {
207 // track property on all observers to ensure proper (synchronized) tracking (#7000)
208 matches.forEach((m) => {
209 m.observer.trackProp(accessedProp)
210 })
211 })
212 : observerResult
213 })
214 }
215β
216 #combineResult(
217 input: Array<QueryObserverResult>,
218 combine: CombineFn<TCombinedResult> | undefined,
219 queryHashes?: Array<string>,
220 ): TCombinedResult {
221 if (combine) {
222 const lastHashes = this.#lastQueryHashes
223 const queryHashesChanged =
224 queryHashes !== undefined &&
225 lastHashes !== undefined &&
226 (lastHashes.length !== queryHashes.length ||
227 queryHashes.some((hash, i) => hash !== lastHashes[i]))
228β
229 if (
230 !this.#combinedResult ||
231 this.#result !== this.#lastResult ||
232 queryHashesChanged ||
233 combine !== this.#lastCombine
234 ) {
235 this.#lastCombine = combine
236 this.#lastResult = this.#result
237β
238 if (queryHashes !== undefined) {
239 this.#lastQueryHashes = queryHashes
240 }
241 this.#combinedResult = replaceEqualDeep(
242 this.#combinedResult,
243 combine(input),
244 )
245 }
246β
247 return this.#combinedResult
248 }
249 return input as any
250 }
251β
252 #findMatchingObservers(
253 queries: Array<QueryObserverOptions>,
254 ): Array<QueryObserverMatch> {
255 const prevObserversMap = new Map<string, Array<QueryObserver>>()
256β
257 this.#observers.forEach((observer) => {
258 const key = observer.options.queryHash
259 if (!key) return
260β
261 const previousObservers = prevObserversMap.get(key)
262β
263 if (previousObservers) {
264 previousObservers.push(observer)
265 } else {
266 prevObserversMap.set(key, [observer])
267 }
268 })
269β
270 const observers: Array<QueryObserverMatch> = []
271β
272 queries.forEach((options) => {
273 const defaultedOptions = this.#client.defaultQueryOptions(options)
274 const match = prevObserversMap.get(defaultedOptions.queryHash)?.shift()
275 const observer =
276 match ?? new QueryObserver(this.#client, defaultedOptions)
277β
278 observers.push({
279 defaultedQueryOptions: defaultedOptions,
280 observer,
281 })
282 })
283β
284 return observers
285 }
286β
287 #onUpdate(observer: QueryObserver, result: QueryObserverResult): void {
288 const index = this.#observers.indexOf(observer)
289 if (index !== -1) {
290 this.#result = replaceAt(this.#result, index, result)
291 this.#notify()
292 }
293 }
294β
295 #notify(): void {
296 if (this.hasListeners()) {
297 const previousResult = this.#combinedResult
298 const newTracked = this.#trackResult(this.#result, this.#observerMatches)
299 const newResult = this.#combineResult(newTracked, this.#options?.combine)
300β
301 if (previousResult !== newResult) {
302 notifyManager.batch(() => {
303 this.listeners.forEach((listener) => {
304 listener(this.#result)
305 })
306 })
307 }
308 }
309 }
310}
311β
312type QueryObserverMatch = {
313 defaultedQueryOptions: DefaultedQueryObserverOptions
314 observer: QueryObserver
315}