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

index.ts

293 lines8.7 KB

1import {
2 DestroyRef,
3 assertInInjectionContext,
4 computed,
5 effect,
6 inject,
7 signal,
8} from '@angular/core'
9import { BaseQueryBuilder, createLiveQueryCollection } from '@tanstack/db'
10import type {
11 ChangeMessage,
12 Collection,
13 CollectionConfigSingleRowOption,
14 CollectionStatus,
15 Context,
16 GetResult,
17 InferResultType,
18 InitialQueryBuilder,
19 LiveQueryCollectionConfig,
20 NonSingleResult,
21 QueryBuilder,
22 SingleResult,
23} from '@tanstack/db'
24import type { Signal } from '@angular/core'
25​
26export * from '@tanstack/db'
27​
28/**
29 * The result of calling `injectLiveQuery`.
30 * Contains reactive signals for the query state and data.
31 */
32export interface InjectLiveQueryResult<TContext extends Context> {
33 /** A signal containing the complete state map of results keyed by their ID */
34 state: Signal<Map<string | number, GetResult<TContext>>>
35 /** A signal containing the results as an array, or single result for findOne queries */
36 data: Signal<InferResultType<TContext>>
37 /** A signal containing the underlying collection instance (null for disabled queries) */
38 collection: Signal<Collection<
39 GetResult<TContext>,
40 string | number,
41 {}
42 > | null>
43 /** A signal containing the current status of the collection */
44 status: Signal<CollectionStatus | `disabled`>
45 /** A signal indicating whether the collection is currently loading */
46 isLoading: Signal<boolean>
47 /** A signal indicating whether the collection is ready */
48 isReady: Signal<boolean>
49 /** A signal indicating whether the collection is idle */
50 isIdle: Signal<boolean>
51 /** A signal indicating whether the collection has an error */
52 isError: Signal<boolean>
53 /** A signal indicating whether the collection has been cleaned up */
54 isCleanedUp: Signal<boolean>
56​
57export interface InjectLiveQueryResultWithCollection<
58 TResult extends object = any,
59 TKey extends string | number = string | number,
60 TUtils extends Record<string, any> = {},
61> {
62 state: Signal<Map<TKey, TResult>>
63 data: Signal<Array<TResult>>
64 collection: Signal<Collection<TResult, TKey, TUtils> | null>
65 status: Signal<CollectionStatus | `disabled`>
66 isLoading: Signal<boolean>
67 isReady: Signal<boolean>
68 isIdle: Signal<boolean>
69 isError: Signal<boolean>
70 isCleanedUp: Signal<boolean>
72​
73export interface InjectLiveQueryResultWithSingleResultCollection<
74 TResult extends object = any,
75 TKey extends string | number = string | number,
76 TUtils extends Record<string, any> = {},
77> {
78 state: Signal<Map<TKey, TResult>>
79 data: Signal<TResult | undefined>
80 collection: Signal<(Collection<TResult, TKey, TUtils> & SingleResult) | null>
81 status: Signal<CollectionStatus | `disabled`>
82 isLoading: Signal<boolean>
83 isReady: Signal<boolean>
84 isIdle: Signal<boolean>
85 isError: Signal<boolean>
86 isCleanedUp: Signal<boolean>
88​
89export function injectLiveQuery<
90 TContext extends Context,
91 TParams extends any,
92>(options: {
93 params: () => TParams
94 query: (args: {
95 params: TParams
96 q: InitialQueryBuilder
97 }) => QueryBuilder<TContext>
98}): InjectLiveQueryResult<TContext>
99export function injectLiveQuery<
100 TContext extends Context,
101 TParams extends any,
102>(options: {
103 params: () => TParams
104 query: (args: {
105 params: TParams
106 q: InitialQueryBuilder
107 }) => QueryBuilder<TContext> | undefined | null
108}): InjectLiveQueryResult<TContext>
109export function injectLiveQuery<TContext extends Context>(
110 queryFn: (q: InitialQueryBuilder) => QueryBuilder<TContext>,
111): InjectLiveQueryResult<TContext>
112export function injectLiveQuery<TContext extends Context>(
113 queryFn: (
114 q: InitialQueryBuilder,
115 ) => QueryBuilder<TContext> | undefined | null,
116): InjectLiveQueryResult<TContext>
117export function injectLiveQuery<TContext extends Context>(
118 config: LiveQueryCollectionConfig<TContext>,
119): InjectLiveQueryResult<TContext>
120// Pre-created collection without singleResult
121export function injectLiveQuery<
122 TResult extends object,
123 TKey extends string | number,
124 TUtils extends Record<string, any>,
125>(
126 liveQueryCollection: Collection<TResult, TKey, TUtils> & NonSingleResult,
127): InjectLiveQueryResultWithCollection<TResult, TKey, TUtils>
128// Pre-created collection with singleResult
129export function injectLiveQuery<
130 TResult extends object,
131 TKey extends string | number,
132 TUtils extends Record<string, any>,
133>(
134 liveQueryCollection: Collection<TResult, TKey, TUtils> & SingleResult,
135): InjectLiveQueryResultWithSingleResultCollection<TResult, TKey, TUtils>
136export function injectLiveQuery(opts: any) {
137 assertInInjectionContext(injectLiveQuery)
138 const destroyRef = inject(DestroyRef)
139​
140 const collection = computed(() => {
141 // Check if it's an existing collection
142 const isExistingCollection =
143 opts &&
144 typeof opts === `object` &&
145 typeof opts.subscribeChanges === `function` &&
146 typeof opts.startSyncImmediate === `function` &&
147 typeof opts.id === `string`
148​
149 if (isExistingCollection) {
150 return opts
151 }
152​
153 if (typeof opts === `function`) {
154 // Check if query function returns null/undefined (disabled query)
155 const queryBuilder = new BaseQueryBuilder() as InitialQueryBuilder
156 const result = opts(queryBuilder)
157​
158 if (result === undefined || result === null) {
159 // Disabled query - return null
160 return null
161 }
162​
163 return createLiveQueryCollection({
164 query: opts,
165 startSync: true,
166 gcTime: 0,
167 })
168 }
169​
170 // Check if it's reactive query options
171 const isReactiveQueryOptions =
172 opts &&
173 typeof opts === `object` &&
174 typeof opts.query === `function` &&
175 typeof opts.params === `function`
176​
177 if (isReactiveQueryOptions) {
178 const { params, query } = opts
179 const currentParams = params()
180​
181 // Check if query function returns null/undefined (disabled query)
182 const queryBuilder = new BaseQueryBuilder() as InitialQueryBuilder
183 const result = query({ params: currentParams, q: queryBuilder })
184​
185 if (result === undefined || result === null) {
186 // Disabled query - return null
187 return null
188 }
189​
190 return createLiveQueryCollection({
191 query: () => result,
192 startSync: true,
193 gcTime: 0,
194 })
195 }
196​
197 // Handle LiveQueryCollectionConfig objects
198 if (opts && typeof opts === `object` && typeof opts.query === `function`) {
199 return createLiveQueryCollection(opts)
200 }
201​
202 throw new Error(`Invalid options provided to injectLiveQuery`)
203 })
204​
205 const state = signal(new Map<string | number, any>())
206 const internalData = signal<Array<any>>([])
207 const status = signal<CollectionStatus | `disabled`>(
208 collection() ? `idle` : `disabled`,
209 )
210​
211 // Returns single item for singleResult collections, array otherwise
212 const data = computed(() => {
213 const currentCollection = collection()
214 if (!currentCollection) {
215 return internalData()
216 }
217 const config = currentCollection.config as
218 | CollectionConfigSingleRowOption<any, any, any>
219 | undefined
220 return config?.singleResult ? internalData()[0] : internalData()
221 })
222​
223 const syncDataFromCollection = (
224 currentCollection: Collection<any, any, any>,
225 ) => {
226 const newState = new Map(currentCollection.entries())
227 const newData = Array.from(currentCollection.values())
228​
229 state.set(newState)
230 internalData.set(newData)
231 status.set(currentCollection.status)
232 }
233​
234 let unsub: (() => void) | null = null
235 const cleanup = () => {
236 unsub?.()
237 unsub = null
238 }
239​
240 effect((onCleanup) => {
241 const currentCollection = collection()
242​
243 // Handle null collection (disabled query)
244 if (!currentCollection) {
245 status.set(`disabled` as const)
246 state.set(new Map())
247 internalData.set([])
248 cleanup()
249 return
250 }
251​
252 cleanup()
253​
254 // Initialize immediately with current state
255 syncDataFromCollection(currentCollection)
256​
257 // Start sync if idle
258 if (currentCollection.status === `idle`) {
259 currentCollection.startSyncImmediate()
260 // Update status after starting sync
261 status.set(currentCollection.status)
262 }
263​
264 // Subscribe to changes
265 const subscription = currentCollection.subscribeChanges(
266 (_: Array<ChangeMessage<any>>) => {
267 syncDataFromCollection(currentCollection)
268 },
269 )
270 unsub = subscription.unsubscribe.bind(subscription)
271​
272 // Handle ready state
273 currentCollection.onFirstReady(() => {
274 status.set(currentCollection.status)
275 })
276​
277 onCleanup(cleanup)
278 })
279​
280 destroyRef.onDestroy(cleanup)
281​
282 return {
283 state,
284 data,
285 collection,
286 status,
287 isLoading: computed(() => status() === `loading`),
288 isReady: computed(() => status() === `ready` || status() === `disabled`),
289 isIdle: computed(() => status() === `idle`),
290 isError: computed(() => status() === `error`),
291 isCleanedUp: computed(() => status() === `cleaned-up`),
292 }