diff --git a/.changeset/live-query-source-switch.md b/.changeset/live-query-source-switch.md new file mode 100644 index 000000000..03e72a161 --- /dev/null +++ b/.changeset/live-query-source-switch.md @@ -0,0 +1,14 @@ +--- +"@effect-app/vue": patch +--- + +Harden live-query invalidation: + +- a pending readiness wait follows a reconfigured source (including the same source, or one configured from `ready()`), ignores stale rejections, and stops when the fetch is interrupted +- writes are buffered per query while that query discovers its dependencies, so one slow fetch no longer blocks every live query +- live and invalidation-mode registrations last for the observer's lifetime, so publishing a result no longer cancels a delayed invalidation +- source resets and source switches invalidate queries that are still discovering, and newly observed live queries catch up on writes missed while unsubscribed +- failed fetches record their dependencies, projected query families keep separate dependency metadata, and keys whose hashes collide stay distinct +- re-entrant subscription during `subscribe` no longer leaks a subscription, and a stricter observer brings a pending delayed invalidation forward + +`acquireLiveQueryFetch` now returns a `LiveQueryFetch` handle to pass to `awaitLiveQueryFetch` and `releaseLiveQueryFetch`. `beginLiveQueryFetch`/`endLiveQueryFetch` remain as deprecated wrappers. diff --git a/packages/vue/src/atomQuery.ts b/packages/vue/src/atomQuery.ts index 40b15b72f..dfffbaca3 100644 --- a/packages/vue/src/atomQuery.ts +++ b/packages/vue/src/atomQuery.ts @@ -23,9 +23,11 @@ import * as S from "effect-app/Schema" import * as Cause from "effect/Cause" import * as Duration from "effect/Duration" import * as Equal from "effect/Equal" -import * as Hash from "effect/Hash" +import * as Exit from "effect/Exit" import { isHttpClientError } from "effect/http/HttpClientError" import type * as Layer from "effect/Layer" +import * as MutableHashMap from "effect/MutableHashMap" +import * as MutableHashSet from "effect/MutableHashSet" import * as AsyncResult from "effect/reactivity/AsyncResult" import * as Atom from "effect/reactivity/Atom" import * as AtomRegistry from "effect/reactivity/AtomRegistry" @@ -34,7 +36,7 @@ import * as Stream from "effect/Stream" import type * as Tracer from "effect/Tracer" import { clearQueryReadDependencies, getQueryReadDependencies, type QueryInvalidationMode, registerQueryInvalidationMode, setQueryReadDependencies } from "./dependencyMetadata.ts" import { reportRuntimeError } from "./lib.ts" -import { acquireLiveQueryFetch, endLiveQueryFetch, type LiveQueryOptions, liveQueryReady, registerLiveQuery } from "./liveQueryInvalidation.ts" +import { acquireLiveQueryFetch, awaitLiveQueryFetch, type LiveQueryOptions, registerLiveQuery, releaseLiveQueryFetch } from "./liveQueryInvalidation.ts" import { atomsToRefetch, observeQueryAtom } from "./queryLifetime.ts" /** All non-empty prefixes of a key, longest last. `[a,b,c]` -> `[[a],[a,b],[a,b,c]]`. */ @@ -43,11 +45,10 @@ const prefixesOf = (key: ReadonlyArray): ReadonlyArray>): ReadonlyArray> => { const out: Array> = [] - const seen = new Set() + const seen = MutableHashSet.empty>() for (const key of keys) { - const hash = Hash.hash(key) - if (seen.has(hash)) continue - seen.add(hash) + if (MutableHashSet.has(seen, key)) continue + MutableHashSet.add(seen, key) out.push(key) } return out @@ -58,20 +59,21 @@ const uniqueKeys = (keys: ReadonlyArray>): ReadonlyArray< // alive in the registry (mounted OR cached within idle-ttl). Invalidation *marks* every matching // atom stale; it only *refetches* atoms that currently have observers (TanStack refetchType: // "active"). Idle cache entries refetch on the next mount. -const keyAtoms = new Map>>>() +const keyAtoms = MutableHashMap.empty, Set>>>() const trackByKeys = (keys: ReadonlyArray>) => (atom: Atom.Atom>): Atom.Atom> => Atom.transform(atom, (get) => { for (const key of keys) { - const h = Hash.hash(key) - let set = keyAtoms.get(h) - if (!set) keyAtoms.set(h, set = new Set()) + let set = Option.getOrUndefined(MutableHashMap.get(keyAtoms, key)) + if (!set) MutableHashMap.set(keyAtoms, key, set = new Set()) set.add(atom) get.addFinalizer(() => { set.delete(atom) - if (set.size === 0) keyAtoms.delete(h) + if (set.size === 0 && Option.getOrUndefined(MutableHashMap.get(keyAtoms, key)) === set) { + MutableHashMap.remove(keyAtoms, key) + } }) } return get(atom) @@ -111,7 +113,7 @@ const trackReadDependencies = const atomsForKeys = (keys: ReadonlyArray): ReadonlyArray>> => { const atoms = new Set>>() for (const key of keys) { - const set = keyAtoms.get(Hash.hash(key)) + const set = Option.getOrUndefined(MutableHashMap.get(keyAtoms, key)) if (set) { for (const a of set) atoms.add(a) } } return [...atoms] @@ -377,6 +379,16 @@ const recoverStuckWaitingOnMount = return current }, { initialValueTarget: wrapped }) +/** Runs `setup` once per mount (not per result change) and forwards the wrapped atom's results. */ +const withMountLifetime = + (setup: (get: Atom.AtomContext) => void) => + (atom: Atom.Atom>): Atom.Atom> => + Atom.transform(atom, (get) => { + setup(get) + get.subscribe(atom, (value) => get.setSelf(value)) + return get.once(atom) + }, { initialValueTarget: atom }) + export const withQueryOptions = ( self: Atom.Atom>, opts: AtomQueryOptions = {}, @@ -386,24 +398,15 @@ export const withQueryOptions = ( const staleTime: Duration.Input = opts.staleTime ?? defaults.staleTime let atom = self if (liveKey !== undefined) { - atom = Atom.transform(atom, (get) => { - const unregister = registerQueryInvalidationMode(liveKey, opts.invalidation ?? "await") - get.addFinalizer(unregister) - return get(self) - }, { initialValueTarget: self }) + atom = withMountLifetime((get) => { + get.addFinalizer(registerQueryInvalidationMode(liveKey, opts.invalidation ?? "await")) + })(atom) } if (opts.live && liveKey !== undefined) { const liveOptions = opts.live === true ? {} : opts.live - const inner = atom - atom = Atom.transform(inner, (get) => { - const unregister = registerLiveQuery( - liveKey, - () => getQueryReadDependencies(liveKey), - liveOptions - ) - get.addFinalizer(unregister) - return get(inner) - }, { initialValueTarget: self }) + atom = withMountLifetime((get) => { + get.addFinalizer(registerLiveQuery(liveKey, () => getQueryReadDependencies(liveKey), liveOptions)) + })(atom) } const revalidateOnFocus = opts.revalidateOnFocus ?? true atom = Atom.swr({ @@ -476,6 +479,10 @@ export const buildQueryFamily = ( return Atom.family((input: I) => { const fullKey = [...baseKey, input] + // metadata/live identity: projections of one handler read different data + const projectedFullKey = self.queryKeyProjectionHash === undefined + ? fullKey + : [...baseKey, self.queryKeyProjectionHash, input] // Record the repository/server read-dependencies seen while fetching, keyed by `fullKey`, so a // later mutation whose writes intersect them can derive this query as an invalidation target. // The last recorded reads are retained on the (memoized) family atom so `trackReadDependencies` @@ -496,21 +503,32 @@ export const buildQueryFamily = ( const readsRef = yield* Ref.make(DataDependencies.empty()) const writesRef = yield* Ref.make(DataDependencies.empty()) const recorder = DataDependencies.makeDataDependencyRecorder(readsRef, writesRef) - const result = yield* self + return yield* self .handler(input) - .pipe(Effect.provideService(DataDependencies.DataDependencyRecorder, recorder)) - lastReads = yield* Ref.get(readsRef) - setQueryReadDependencies(fullKey, lastReads) - return result + .pipe( + Effect.provideService(DataDependencies.DataDependencyRecorder, recorder), + // a failure (e.g. not found) still depends on what it read; keep a displayed success's reads + Effect.onExit((exit) => + Exit.isFailure(exit) && Cause.hasInterruptsOnly(exit.cause) + ? Effect.void + : Ref.get(readsRef).pipe(Effect.map((reads) => { + lastReads = Exit.isSuccess(exit) ? reads : DataDependencies.merge(lastReads, reads) + setQueryReadDependencies(projectedFullKey, lastReads) + })) + ) + ) }) const effect = Effect .acquireUseRelease( - Effect.sync(() => acquireLiveQueryFetch(fullKey)), + Effect.sync(() => acquireLiveQueryFetch(projectedFullKey)), (live) => - (live ? Effect.promise(liveQueryReady) : Effect.void).pipe( + (live === undefined ? Effect.void : Effect.promise((signal) => awaitLiveQueryFetch(live, signal))).pipe( Effect.andThen(recordReads.pipe(Effect.retry({ times: 5, while: isRetryable }))) ), - (live) => Effect.sync(() => endLiveQueryFetch(live)) + (live) => + Effect.sync(() => { + if (live !== undefined) releaseLiveQueryFetch(live) + }) ) .pipe( Effect.tapCauseIf(Cause.hasDies, (cause) => reportRuntimeError(cause)), @@ -534,13 +552,10 @@ export const buildQueryFamily = ( // Register under every prefix of the full key => hierarchical (prefix) invalidation. Two roles: // - withReactivity: `Reactivity.invalidate(key)` refreshes this atom (the actual refetch). // - trackByKeys: records the atom in `keyAtoms` so the mutation can AWAIT its settle. - const projectedFullKey = self.queryKeyProjectionHash === undefined - ? fullKey - : [...baseKey, self.queryKeyProjectionHash, input] const reactivityKeys = uniqueKeys([...prefixesOf(fullKey), ...prefixesOf(projectedFullKey)]) atom = rt.factory.withReactivity(reactivityKeys)(atom) atom = trackByKeys(reactivityKeys)(atom) - atom = trackReadDependencies(fullKey, () => lastReads)(atom) + atom = trackReadDependencies(projectedFullKey, () => lastReads)(atom) // gcTime LAST so the whole chain (incl. the registration + tracking) stays alive through the // idle window. Invalidation still finds the cached atom and marks it stale; it does not // refetch until an observer remounts (TanStack refetchType: "active"). @@ -561,8 +576,8 @@ export const buildQueryFamily = ( const observed = observeQueryAtom(result) queryFetchStates.set(result, fetchState) queryFetchStates.set(observed, fetchState) - atomQueryKeys.set(result, fullKey) - atomQueryKeys.set(observed, fullKey) + atomQueryKeys.set(result, projectedFullKey) + atomQueryKeys.set(observed, projectedFullKey) return observed }) } diff --git a/packages/vue/src/dependencyMetadata.ts b/packages/vue/src/dependencyMetadata.ts index 277957815..37087a71e 100644 --- a/packages/vue/src/dependencyMetadata.ts +++ b/packages/vue/src/dependencyMetadata.ts @@ -1,37 +1,42 @@ import { DataDependencies } from "effect-app/client" -import * as Hash from "effect/Hash" +import * as MutableHashMap from "effect/MutableHashMap" +import * as Option from "effect/Option" // Maps a live query's reactivity key (its full `[...queryKey, input]` key) to the // data dependencies it read while fetching. Populated when the query handler resolves and // cleared when the query atom is GC'd, so the set mirrors the live query atoms (mounted or // cached-within-ttl) — the atom equivalent of the former tanstack query cache. type Entry = { readonly key: ReadonlyArray; readonly reads: DataDependencies.DataDependencies } -const readDependencies = new Map() +const readDependencies = MutableHashMap.empty, Entry>() export type QueryInvalidationMode = "await" | "soft" type InvalidationModeEntry = { awaitSubscribers: number; softSubscribers: number } -const invalidationModes = new Map() +const invalidationModes = MutableHashMap.empty, InvalidationModeEntry>() export const registerQueryInvalidationMode = ( key: ReadonlyArray, mode: QueryInvalidationMode ): () => void => { - const hash = Hash.hash(key) - const entry = invalidationModes.get(hash) ?? { awaitSubscribers: 0, softSubscribers: 0 } + const entry = Option.getOrUndefined(MutableHashMap.get(invalidationModes, key)) + ?? { awaitSubscribers: 0, softSubscribers: 0 } if (mode === "soft") entry.softSubscribers++ else entry.awaitSubscribers++ - invalidationModes.set(hash, entry) + MutableHashMap.set(invalidationModes, key, entry) let active = true return () => { if (!active) return active = false if (mode === "soft") entry.softSubscribers-- else entry.awaitSubscribers-- - if (entry.awaitSubscribers === 0 && entry.softSubscribers === 0) invalidationModes.delete(hash) + if ( + entry.awaitSubscribers === 0 + && entry.softSubscribers === 0 + && Option.getOrUndefined(MutableHashMap.get(invalidationModes, key)) === entry + ) MutableHashMap.remove(invalidationModes, key) } } export const getQueryInvalidationMode = (key: ReadonlyArray): QueryInvalidationMode => { - const entry = invalidationModes.get(Hash.hash(key)) + const entry = Option.getOrUndefined(MutableHashMap.get(invalidationModes, key)) return entry !== undefined && entry.awaitSubscribers === 0 && entry.softSubscribers > 0 ? "soft" : "await" } @@ -39,18 +44,18 @@ export const setQueryReadDependencies = ( key: ReadonlyArray, reads: DataDependencies.DataDependencies ) => { - const h = Hash.hash(key) - if (!DataDependencies.isNonEmpty(reads)) readDependencies.delete(h) - else readDependencies.set(h, { key, reads }) + if (!DataDependencies.isNonEmpty(reads)) MutableHashMap.remove(readDependencies, key) + else MutableHashMap.set(readDependencies, key, { key, reads }) } export const clearQueryReadDependencies = (key: ReadonlyArray) => { - readDependencies.delete(Hash.hash(key)) + MutableHashMap.remove(readDependencies, key) } export const getQueryReadDependencies = ( key: ReadonlyArray -): DataDependencies.DataDependencies => readDependencies.get(Hash.hash(key))?.reads ?? DataDependencies.empty() +): DataDependencies.DataDependencies => + Option.getOrUndefined(MutableHashMap.get(readDependencies, key))?.reads ?? DataDependencies.empty() /** * Reactivity keys of every live query whose recorded read-dependencies intersect this @@ -62,7 +67,7 @@ export const getDerivedInvalidationKeys = ( ): ReadonlyArray> => { if (!DataDependencies.isNonEmpty(writeDependencies)) return [] const keys: Array> = [] - for (const { key, reads } of readDependencies.values()) { + for (const { key, reads } of MutableHashMap.values(readDependencies)) { if (DataDependencies.intersects(reads, writeDependencies)) keys.push(key) } return keys diff --git a/packages/vue/src/liveQueryInvalidation.ts b/packages/vue/src/liveQueryInvalidation.ts index 7197963e3..b5e7de08d 100644 --- a/packages/vue/src/liveQueryInvalidation.ts +++ b/packages/vue/src/liveQueryInvalidation.ts @@ -1,5 +1,6 @@ import { DataDependencies } from "effect-app/client" -import * as Hash from "effect/Hash" +import * as MutableHashMap from "effect/MutableHashMap" +import * as Option from "effect/Option" export interface LiveQueryOptions { /** Fixed maximum delay from the first matching write. Zero reacts immediately. */ @@ -17,68 +18,232 @@ export interface LiveQueryInvalidationSource { } interface LiveQueryEntry { - readonly hash: number readonly key: ReadonlyArray readonly reads: () => DataDependencies.DataDependencies observers: number readonly delays: Map timer: ReturnType | undefined + firstWriteAt: number + deadline: number + /** live fetches between acquire and release; their writes are buffered until reads are known */ + discovering: number + /** live fetches still waiting for source readiness */ + awaitingReady: number + buffered: DataDependencies.DataDependencies + /** invalidate when discovery ends (reset, or a source epoch no fetch covered) */ + dirty: boolean + /** latest source epoch a fetch of this entry was ready for */ + coveredEpoch: number + /** pending check for writes missed before this subscription's epoch was covered */ + catchUp: AbortController | undefined } -const entries = new Map() +/** One live fetch: acquire before running, release on every exit. */ +export interface LiveQueryFetch { + readonly key: ReadonlyArray +} + +interface FetchState { + readonly entry: LiveQueryEntry + awaiting: boolean + released: boolean +} + +const entries = MutableHashMap.empty, LiveQueryEntry>() +const fetches = new WeakMap() +type ReadyOutcome = { readonly _tag: "ready" } | { readonly _tag: "switched" } | { + readonly _tag: "failed" + readonly error: unknown +} +/** One shared `ready()` call per epoch; waiters detach on abort so none accumulate on the promise. */ +let observation: { readonly epoch: number; readonly waiters: Set<(outcome: ReadyOutcome) => void> } | undefined let source: LiveQueryInvalidationSource | undefined let unsubscribe: (() => void) | undefined -let discovering = 0 -let bufferedWrites = DataDependencies.empty() +let subscribing = false +let epoch = 0 + +// a synchronous refresh can remove or replace registrations while dispatching +const isCurrent = (entry: LiveQueryEntry) => Option.getOrUndefined(MutableHashMap.get(entries, entry.key)) === entry + +const forEachCurrent = (f: (entry: LiveQueryEntry) => void) => { + for (const entry of Array.from(MutableHashMap.values(entries))) { + if (isCurrent(entry)) f(entry) + } +} const invalidateEntry = (entry: LiveQueryEntry) => { entry.timer = undefined - source?.invalidate([entry.key]) + if (isCurrent(entry)) source?.invalidate([entry.key]) +} + +// (re)arm for the strictest observer; a stricter observer or write can only bring the deadline forward +const arm = (entry: LiveQueryEntry) => { + const deadline = entry.firstWriteAt + Math.min(...entry.delays.keys()) + if (entry.timer !== undefined) { + if (entry.deadline <= deadline) return + clearTimeout(entry.timer) + entry.timer = undefined + } + entry.deadline = deadline + const wait = deadline - Date.now() + if (wait <= 0) return invalidateEntry(entry) + entry.timer = setTimeout(() => invalidateEntry(entry), wait) } const schedule = (entry: LiveQueryEntry) => { - if (entry.timer !== undefined) return - const maxDelayMs = Math.min(...entry.delays.keys()) - if (maxDelayMs <= 0) return invalidateEntry(entry) - entry.timer = setTimeout(() => invalidateEntry(entry), maxDelayMs) + if (entry.timer === undefined) entry.firstWriteAt = Date.now() + arm(entry) } -// a synchronous refresh can remove or replace registrations while dispatching -const isCurrent = (entry: LiveQueryEntry) => entries.get(entry.hash) === entry +// catch-up replaces a refetch, so it bypasses write coalescing; a running refetch makes SWR skip its own +const invalidateNow = (entry: LiveQueryEntry) => { + if (entry.discovering > 0) return void (entry.dirty = true) + if (entry.timer !== undefined) clearTimeout(entry.timer) + invalidateEntry(entry) +} -const dispatch = (writes: DataDependencies.DataDependencies) => { +const receive = (writes: DataDependencies.DataDependencies) => { if (!DataDependencies.isNonEmpty(writes)) return - for (const entry of Array.from(entries.values())) { - if (isCurrent(entry) && DataDependencies.intersects(entry.reads(), writes)) schedule(entry) - } + forEachCurrent((entry) => { + if (entry.discovering > 0) entry.buffered = DataDependencies.merge(entry.buffered, writes) + else if (DataDependencies.intersects(entry.reads(), writes)) schedule(entry) + }) } -const receive = (writes: DataDependencies.DataDependencies) => { - if (discovering > 0) { - bufferedWrites = DataDependencies.merge(bufferedWrites, writes) - return +const reset = () => { + forEachCurrent((entry) => { + if (entry.discovering > 0) entry.dirty = true + else if (DataDependencies.isNonEmpty(entry.reads())) schedule(entry) + }) +} + +const settle = (current: NonNullable, outcome: ReadyOutcome) => { + if (observation === current) observation = undefined + if (current.epoch !== epoch) return + const waiters = Array.from(current.waiters) + current.waiters.clear() + for (const f of waiters) f(outcome) +} + +const observeReady = (waiter: (outcome: ReadyOutcome) => void) => { + let current = observation + if (current === undefined || current.epoch !== epoch) { + const started = { epoch, waiters: new Set([waiter]) } + current = observation = started + // the waiter is attached first: `ready()` may reconfigure synchronously + let ready: Promise + try { + ready = source?.ready() ?? Promise.resolve() + } catch (error) { + ready = Promise.reject(error) + } + ready.then(() => settle(started, { _tag: "ready" }), (error) => settle(started, { _tag: "failed", error })) + } else { + current.waiters.add(waiter) } - dispatch(writes) + const observed = current + return () => observed.waiters.delete(waiter) } -const reset = () => { - bufferedWrites = DataDependencies.empty() - for (const entry of Array.from(entries.values())) { - if (isCurrent(entry) && DataDependencies.isNonEmpty(entry.reads())) schedule(entry) +/** Whether the current source became ready before being replaced; rejects with its error or on abort. */ +const readyOnce = (signal?: AbortSignal) => + new Promise((resolve, reject) => { + if (signal?.aborted === true) return reject(signal.reason) + if (source === undefined) return resolve(true) + let detach: (() => void) | undefined + let aborted = false + const onAbort = () => { + aborted = true + detach?.() + reject(signal?.reason) + } + signal?.addEventListener("abort", onAbort, { once: true }) + // `ready()` may abort synchronously, before `detach` exists + detach = observeReady((outcome) => { + signal?.removeEventListener("abort", onAbort) + if (outcome._tag === "failed") reject(outcome.error) + else resolve(outcome._tag === "ready") + }) + if (aborted) detach() + }) + +/** Resolves with the epoch whose readiness was observed; a reconfigured source supersedes the wait. */ +const waitReady = async (signal?: AbortSignal): Promise => { + const target = epoch + let ready: boolean + try { + ready = await readyOnce(signal) + } catch (error) { + // a reconfiguration can run between settlement and this continuation + if (epoch === target || signal?.aborted === true) throw error + return waitReady(signal) } + return ready && epoch === target ? target : waitReady(signal) +} + +const cancelCatchUp = (entry: LiveQueryEntry) => { + entry.catchUp?.abort() + entry.catchUp = undefined +} + +// a reconfigured source restarts it; a live fetch or unregistering cancels it +const catchUp = (entry: LiveQueryEntry) => { + cancelCatchUp(entry) + if (source === undefined) return + const target = epoch + const controller = new AbortController() + entry.catchUp = controller + readyOnce(controller.signal).then((ready) => { + if (entry.catchUp === controller) entry.catchUp = undefined + if (!ready || epoch !== target || !isCurrent(entry)) return + if (entry.awaitingReady === 0 && entry.coveredEpoch !== target) invalidateNow(entry) + }, () => {}) +} + +const unsubscribeNow = () => { + const current = unsubscribe + unsubscribe = undefined + current?.() } const ensureSubscribed = () => { - if (unsubscribe === undefined && source !== undefined && entries.size > 0) { - unsubscribe = source.subscribe(receive, reset) + if (unsubscribe !== undefined || subscribing || source === undefined || MutableHashMap.size(entries) === 0) return + const target = epoch + const active = () => epoch === target + subscribing = true + let handle: () => void + try { + handle = source.subscribe( + (writes) => { + if (active()) receive(writes) + }, + () => { + if (active()) reset() + } + ) + } finally { + subscribing = false } + if (!active() || MutableHashMap.size(entries) === 0) { + handle() + return ensureSubscribed() + } + unsubscribe = handle } export const configureLiveQueryInvalidation = (next: LiveQueryInvalidationSource) => { - unsubscribe?.() - unsubscribe = undefined + unsubscribeNow() source = next + epoch++ + const previous = observation + observation = undefined + if (previous !== undefined) { + const waiters = Array.from(previous.waiters) + previous.waiters.clear() + for (const f of waiters) f({ _tag: "switched" }) + } ensureSubscribed() + forEachCurrent(catchUp) } export const registerLiveQuery = ( @@ -86,67 +251,167 @@ export const registerLiveQuery = ( reads: () => DataDependencies.DataDependencies, options: LiveQueryOptions ) => { - const hash = Hash.hash(key) const delay = options.maxDelayMs ?? 0 - const current = entries.get(hash) - if (current !== undefined) { - current.observers++ - current.delays.set(delay, (current.delays.get(delay) ?? 0) + 1) + let entry = Option.getOrUndefined(MutableHashMap.get(entries, key)) + if (entry !== undefined) { + entry.observers++ + entry.delays.set(delay, (entry.delays.get(delay) ?? 0) + 1) + if (entry.timer !== undefined) arm(entry) } else { - entries.set(hash, { - hash, + entry = { key, reads, observers: 1, delays: new Map([[delay, 1]]), - timer: undefined - }) + timer: undefined, + firstWriteAt: 0, + deadline: 0, + discovering: 0, + awaitingReady: 0, + buffered: DataDependencies.empty(), + dirty: false, + coveredEpoch: -1, + catchUp: undefined + } + MutableHashMap.set(entries, key, entry) + ensureSubscribed() + // writes missed while unsubscribed (cached result, or a fetch that started before this registration) + catchUp(entry) } - ensureSubscribed() + const registered = entry + let active = true return () => { - const entry = entries.get(hash) - if (entry === undefined) return - const delayObservers = entry.delays.get(delay) ?? 0 - if (delayObservers <= 1) entry.delays.delete(delay) - else entry.delays.set(delay, delayObservers - 1) - if (--entry.observers > 0) return - if (entry.timer !== undefined) clearTimeout(entry.timer) - entries.delete(hash) - if (entries.size === 0) { - unsubscribe?.() - unsubscribe = undefined - bufferedWrites = DataDependencies.empty() + if (!active) return + active = false + const delayObservers = registered.delays.get(delay) ?? 0 + if (delayObservers <= 1) registered.delays.delete(delay) + else registered.delays.set(delay, delayObservers - 1) + if (--registered.observers > 0) return + if (registered.timer !== undefined) clearTimeout(registered.timer) + registered.timer = undefined + cancelCatchUp(registered) + if (isCurrent(registered)) MutableHashMap.remove(entries, key) + if (MutableHashMap.size(entries) === 0) unsubscribeNow() + } +} + +/** Synchronously starts a live fetch for a registered key; release it with `releaseLiveQueryFetch` on every exit. */ +export const acquireLiveQueryFetch = (key: ReadonlyArray): LiveQueryFetch | undefined => { + const entry = Option.getOrUndefined(MutableHashMap.get(entries, key)) + if (entry === undefined || source === undefined) return undefined + entry.discovering++ + entry.awaitingReady++ + // this fetch awaits readiness itself, covering the epoch the catch-up was waiting for + cancelCatchUp(entry) + const fetch: LiveQueryFetch = { key } + fetches.set(fetch, { entry, awaiting: true, released: false }) + return fetch +} + +const stopAwaiting = (state: FetchState) => { + if (!state.awaiting) return + state.awaiting = false + state.entry.awaitingReady-- +} + +/** Waits until writes after this point reach the fetch; abort to stop waiting. */ +export const awaitLiveQueryFetch = async (fetch: LiveQueryFetch, signal?: AbortSignal) => { + const state = fetches.get(fetch) + if (state === undefined || state.released) return + try { + // every `await` is a gap in which the source can be switched: only settle for a still-current epoch + for (;;) { + const target = epoch + let ready: number + try { + ready = await waitReady(signal) + } catch (error) { + if (signal?.aborted === true || epoch === target) throw error + continue + } + if (ready !== epoch) continue + state.entry.coveredEpoch = Math.max(state.entry.coveredEpoch, ready) + break } + } finally { + stopAwaiting(state) } } -/** Synchronously marks a live fetch as discovering; pair with `endLiveQueryFetch` even if interrupted. */ -export const acquireLiveQueryFetch = (key: ReadonlyArray) => { - if (!entries.has(Hash.hash(key)) || source === undefined) return false - discovering++ - return true +export const releaseLiveQueryFetch = (fetch: LiveQueryFetch) => { + const state = fetches.get(fetch) + if (state === undefined || state.released) return + state.released = true + stopAwaiting(state) + state.entry.discovering-- + finishDiscovery(state.entry) +} + +const finishDiscovery = (entry: LiveQueryEntry) => { + if (entry.discovering > 0 || !isCurrent(entry)) return + const { buffered, dirty } = entry + entry.buffered = DataDependencies.empty() + entry.dirty = false + if (dirty || DataDependencies.intersects(entry.reads(), buffered)) schedule(entry) +} + +/** Waits for the current source; a reconfigured source supersedes a pending wait on the previous one. */ +export const liveQueryReady = async (): Promise => { + for (;;) { + const target = epoch + try { + if (await waitReady() === epoch) return + } catch (error) { + if (epoch === target) throw error + } + } } -export const liveQueryReady = () => source?.ready() ?? Promise.resolve() +// Boolean callers cannot say which fetch ended: their entries keep buffering until every legacy fetch has +// ended. Other queries are unaffected; bookkeeping is per entry, not per call. +const legacyEntries = new Map() +let legacyDiscovering = 0 -/** @deprecated Interruptible between acquire and ready; use `acquireLiveQueryFetch` + `liveQueryReady`. */ +/** @deprecated Waits for all concurrent legacy fetches; use `acquireLiveQueryFetch` + `awaitLiveQueryFetch`. */ export const beginLiveQueryFetch = async (key: ReadonlyArray) => { - if (!acquireLiveQueryFetch(key)) return false + const fetch = acquireLiveQueryFetch(key) + const state = fetch && fetches.get(fetch) + if (fetch === undefined || state === undefined) return false + // hand the discovery count over to the legacy barrier + state.released = true + legacyDiscovering++ + legacyEntries.set(state.entry, (legacyEntries.get(state.entry) ?? 0) + 1) try { - await liveQueryReady() - return true + for (;;) { + const target = epoch + let ready: number + try { + ready = await waitReady() + } catch (error) { + if (epoch === target) throw error + continue + } + if (ready !== epoch) continue + state.entry.coveredEpoch = Math.max(state.entry.coveredEpoch, ready) + break + } } catch (error) { - discovering-- + endLiveQueryFetch(true) throw error + } finally { + stopAwaiting(state) } + return true } +/** @deprecated Pairs with `beginLiveQueryFetch`; use `releaseLiveQueryFetch`. */ export const endLiveQueryFetch = (wasLive: boolean) => { - if (!wasLive) return - discovering = Math.max(0, discovering - 1) - if (discovering > 0 || !DataDependencies.isNonEmpty(bufferedWrites)) return - const writes = bufferedWrites - bufferedWrites = DataDependencies.empty() - dispatch(writes) + if (!wasLive || legacyDiscovering === 0 || --legacyDiscovering > 0) return + const ended = Array.from(legacyEntries) + legacyEntries.clear() + for (const [entry, count] of ended) { + entry.discovering -= count + finishDiscovery(entry) + } } diff --git a/packages/vue/test/liveQueryInvalidation.test.ts b/packages/vue/test/liveQueryInvalidation.test.ts index 2f51a0665..68a5e4e29 100644 --- a/packages/vue/test/liveQueryInvalidation.test.ts +++ b/packages/vue/test/liveQueryInvalidation.test.ts @@ -6,11 +6,17 @@ import * as ManagedRuntime from "effect/ManagedRuntime" import { afterEach, describe, expect, it, vi } from "vitest" import { awaitAtomResult, buildQueryFamily, invalidateAndAwait, invalidateSoft, makeAtomClientRuntime, withQueryOptions } from "../src/atomQuery.js" import { getQueryInvalidationMode } from "../src/dependencyMetadata.js" -import { acquireLiveQueryFetch, configureLiveQueryInvalidation, endLiveQueryFetch, liveQueryReady, registerLiveQuery } from "../src/liveQueryInvalidation.js" +import { acquireLiveQueryFetch, awaitLiveQueryFetch, configureLiveQueryInvalidation, registerLiveQuery, releaseLiveQueryFetch } from "../src/liveQueryInvalidation.js" const repo = DataDependencies.repo("Inventory", ["item-1"]) const otherId = DataDependencies.repo("Inventory", ["item-2"]) +const acquire = (key: ReadonlyArray) => { + const fetch = acquireLiveQueryFetch(key) + if (fetch === undefined) throw new Error("expected a live fetch") + return fetch +} + describe("live query invalidation", () => { const cleanups: Array<() => void> = [] @@ -166,13 +172,13 @@ describe("live query invalidation", () => { let reads = DataDependencies.empty() cleanups.push(registerLiveQuery(key, () => reads, {})) - const wasLive = acquireLiveQueryFetch(key) - const starting = liveQueryReady() + const fetch = acquire(key) + const starting = awaitLiveQueryFetch(fetch) receive(new Set([repo])) open() await starting reads = new Set([repo]) - endLiveQueryFetch(wasLive) + releaseLiveQueryFetch(fetch) expect(invalidations).toEqual([[key]]) }) @@ -216,6 +222,39 @@ describe("live query invalidation", () => { } }) + it("moves a pending readiness wait to a newly configured source", async () => { + const invalidations: Array>> = [] + let receive = (_writes: DataDependencies.DataDependencies) => {} + configureLiveQueryInvalidation({ + ready: () => new Promise(() => {}), + subscribe: () => () => {}, + invalidate: () => {} + }) + const key = ["$Inventory", "Get", { id: "item-1" }] + let reads = DataDependencies.empty() + cleanups.push(registerLiveQuery(key, () => reads, {})) + const fetch = acquire(key) + const starting = awaitLiveQueryFetch(fetch) + + let open = () => {} + const ready = new Promise((resolve) => open = resolve) + configureLiveQueryInvalidation({ + ready: () => ready, + subscribe: (onWrites) => { + receive = onWrites + return () => {} + }, + invalidate: (keys) => invalidations.push(keys) + }) + receive(new Set([repo])) + open() + await starting + reads = new Set([repo]) + releaseLiveQueryFetch(fetch) + + expect(invalidations).toEqual([[key]]) + }) + it("coalesces matching writes using the query's maximum delay", () => { vi.useFakeTimers() const invalidations: Array>> = [] diff --git a/packages/vue/test/liveQueryLifecycle.test.ts b/packages/vue/test/liveQueryLifecycle.test.ts new file mode 100644 index 000000000..eb5fe7a55 --- /dev/null +++ b/packages/vue/test/liveQueryLifecycle.test.ts @@ -0,0 +1,507 @@ +import { defaultRegistry } from "@effect/atom-vue" +import { DataDependencies, makeQueryKey } from "effect-app/client" +import * as Effect from "effect-app/Effect" +import * as Layer from "effect-app/Layer" +import * as ManagedRuntime from "effect/ManagedRuntime" +import { afterEach, describe, expect, it, vi } from "vitest" +import { awaitAtomResult, buildQueryFamily, invalidateAndAwait, makeAtomClientRuntime, withQueryOptions } from "../src/atomQuery.js" +import { getQueryReadDependencies } from "../src/dependencyMetadata.js" +import { acquireLiveQueryFetch, awaitLiveQueryFetch, beginLiveQueryFetch, configureLiveQueryInvalidation, endLiveQueryFetch, type LiveQueryInvalidationSource, liveQueryReady, registerLiveQuery, releaseLiveQueryFetch } from "../src/liveQueryInvalidation.js" + +type Keys = Array>> + +const repo = DataDependencies.repo("Inventory", ["item-1"]) +const never = () => new Promise(() => {}) +const flush = () => new Promise((resolve) => setTimeout(resolve, 0)) + +const acquire = (key: ReadonlyArray) => { + const fetch = acquireLiveQueryFetch(key) + if (fetch === undefined) throw new Error("expected a live fetch") + return fetch +} + +const isRegistered = (key: ReadonlyArray) => { + const fetch = acquireLiveQueryFetch(key) + if (fetch !== undefined) releaseLiveQueryFetch(fetch) + return fetch !== undefined +} + +const makeSource = (ready: () => Promise = () => Promise.resolve()) => { + const invalidations: Keys = [] + const handlers = { receive: (_writes: DataDependencies.DataDependencies) => {}, reset: () => {} } + const source: LiveQueryInvalidationSource = { + ready, + subscribe: (onWrites, onReset) => { + handlers.receive = onWrites + handlers.reset = onReset + return () => {} + }, + invalidate: (keys) => invalidations.push(keys) + } + return { source, invalidations, handlers } +} + +describe("live query lifecycle", () => { + const cleanups: Array<() => void> = [] + + afterEach(async () => { + while (cleanups.length > 0) cleanups.pop()?.() + defaultRegistry.reset() + vi.useRealTimers() + await flush() + }) + + it("keeps a delayed invalidation when the replayed fetch publishes its result", async () => { + const dependency = DataDependencies.repo("DelayedOrders") + const { handlers, source } = makeSource() + let calls = 0 + configureLiveQueryInvalidation({ + ...source, + invalidate: (keys) => void Effect.runPromise(invalidateAndAwait(keys)) + }) + const mrt = ManagedRuntime.make(Layer.empty) + cleanups.push(() => void mrt.dispose()) + const rt = makeAtomClientRuntime(() => Layer.empty, mrt.memoMap) + const query = { + id: "DelayedOrders.List", + handler: () => + DataDependencies.read(dependency).pipe(Effect.andThen(Effect.sync(() => { + // the server changes while the initial fetch is still discovering + if (++calls === 1) handlers.receive(new Set([dependency])) + return calls + }))) + } + const atom = withQueryOptions( + buildQueryFamily(rt, query)(undefined), + { live: { maxDelayMs: 10 }, revalidateOnFocus: false }, + [...makeQueryKey(query), undefined] + ) + cleanups.push(defaultRegistry.mount(atom)) + await Effect.runPromise(awaitAtomResult(defaultRegistry, atom)) + await new Promise((resolve) => setTimeout(resolve, 30)) + await Effect.runPromise(awaitAtomResult(defaultRegistry, atom)) + expect(calls).toBe(2) + }) + + it("lets settled queries react while another query is still discovering", () => { + const { handlers, invalidations, source } = makeSource(never) + configureLiveQueryInvalidation(source) + const pending = ["$Inventory", "Get", { id: "pending" }] + const settled = ["$Inventory", "List", undefined] + cleanups.push(registerLiveQuery(pending, () => DataDependencies.empty(), {})) + cleanups.push(registerLiveQuery(settled, () => new Set([repo]), {})) + const fetch = acquire(pending) + cleanups.push(() => releaseLiveQueryFetch(fetch)) + + handlers.receive(new Set([repo])) + expect(invalidations).toEqual([[settled]]) + }) + + it("requests readiness again when the same source is configured again", async () => { + let calls = 0 + let open = () => {} + const { source } = makeSource(() => ++calls === 1 ? never() : new Promise((resolve) => open = resolve)) + configureLiveQueryInvalidation(source) + const key = ["$Inventory", "Get", { id: "same" }] + cleanups.push(registerLiveQuery(key, () => DataDependencies.empty(), {})) + const fetch = acquire(key) + cleanups.push(() => releaseLiveQueryFetch(fetch)) + let ready = false + void awaitLiveQueryFetch(fetch).then(() => ready = true) + + configureLiveQueryInvalidation(source) + await flush() + expect(ready).toBe(false) + open() + await flush() + expect(ready).toBe(true) + }) + + it("follows a source configured synchronously from ready()", async () => { + const next = makeSource() + const { source } = makeSource(() => { + configureLiveQueryInvalidation(next.source) + return never() + }) + configureLiveQueryInvalidation(source) + const key = ["$Inventory", "Get", { id: "sync" }] + cleanups.push(registerLiveQuery(key, () => DataDependencies.empty(), {})) + const fetch = acquire(key) + cleanups.push(() => releaseLiveQueryFetch(fetch)) + await awaitLiveQueryFetch(fetch) + }) + + it("ignores a stale rejection from a replaced source", async () => { + let reject = (_error: unknown) => {} + const { source } = makeSource(() => new Promise((_, rej) => reject = rej)) + configureLiveQueryInvalidation(source) + const key = ["$Inventory", "Get", { id: "stale" }] + cleanups.push(registerLiveQuery(key, () => DataDependencies.empty(), {})) + const fetch = acquire(key) + cleanups.push(() => releaseLiveQueryFetch(fetch)) + const waiting = awaitLiveQueryFetch(fetch) + reject(new Error("old source")) + configureLiveQueryInvalidation(makeSource().source) + await expect(waiting).resolves.toBeUndefined() + }) + + it("invalidates a discovering query when the source resets", async () => { + const { handlers, invalidations, source } = makeSource() + configureLiveQueryInvalidation(source) + const key = ["$Inventory", "Get", { id: "reset" }] + let reads = DataDependencies.empty() + cleanups.push(registerLiveQuery(key, () => reads, {})) + const fetch = acquire(key) + await awaitLiveQueryFetch(fetch) + handlers.receive(new Set([repo])) + handlers.reset() + reads = new Set([repo]) + releaseLiveQueryFetch(fetch) + expect(invalidations).toEqual([[key]]) + }) + + it("catches up a query registered without a covering fetch", async () => { + const { invalidations, source } = makeSource() + configureLiveQueryInvalidation(source) + const key = ["$Inventory", "List", "cached"] + cleanups.push(registerLiveQuery(key, () => new Set([repo]), {})) + expect(invalidations).toEqual([]) + await flush() + expect(invalidations).toEqual([[key]]) + }) + + it("does not catch up a query whose fetch covers the subscription", async () => { + const { invalidations, source } = makeSource() + configureLiveQueryInvalidation(source) + const key = ["$Inventory", "List", "fresh"] + cleanups.push(registerLiveQuery(key, () => new Set([repo]), {})) + const fetch = acquire(key) + await awaitLiveQueryFetch(fetch) + releaseLiveQueryFetch(fetch) + await flush() + expect(invalidations).toEqual([]) + }) + + it("refetches a query whose running fetch was only ready for a replaced source", async () => { + configureLiveQueryInvalidation(makeSource().source) + const key = ["$Inventory", "List", "switched"] + cleanups.push(registerLiveQuery(key, () => new Set([repo]), {})) + const fetch = acquire(key) + await awaitLiveQueryFetch(fetch) + const next = makeSource() + configureLiveQueryInvalidation(next.source) + await flush() + expect(next.invalidations).toEqual([]) + releaseLiveQueryFetch(fetch) + expect(next.invalidations).toEqual([[key]]) + }) + + it("stops waiting for readiness when the fetch is aborted", async () => { + configureLiveQueryInvalidation(makeSource(never).source) + const key = ["$Inventory", "Get", { id: "abort" }] + cleanups.push(registerLiveQuery(key, () => DataDependencies.empty(), {})) + const fetch = acquire(key) + const controller = new AbortController() + const waiting = awaitLiveQueryFetch(fetch, controller.signal) + controller.abort() + await expect(waiting).rejects.toBeDefined() + releaseLiveQueryFetch(fetch) + + const ready = vi.fn(() => Promise.resolve()) + configureLiveQueryInvalidation({ ...makeSource().source, ready }) + await flush() + // only the catch-up for the still-registered query asks the new source + expect(ready).toHaveBeenCalledTimes(1) + }) + + it("releases the deprecated fetch when readiness rejects", async () => { + const { handlers, invalidations, source } = makeSource(() => Promise.reject(new Error("offline"))) + configureLiveQueryInvalidation(source) + const key = ["$Inventory", "List", "legacy"] + cleanups.push(registerLiveQuery(key, () => new Set([repo]), {})) + await expect(beginLiveQueryFetch(key)).rejects.toThrow("offline") + handlers.receive(new Set([repo])) + expect(invalidations).toEqual([[key]]) + }) + + it("records dependencies of a failed fetch", async () => { + configureLiveQueryInvalidation(makeSource().source) + const dependency = DataDependencies.repo("MissingOrders") + const mrt = ManagedRuntime.make(Layer.empty) + cleanups.push(() => void mrt.dispose()) + const rt = makeAtomClientRuntime(() => Layer.empty, mrt.memoMap) + const query = { + id: "MissingOrders.Get", + handler: () => DataDependencies.read(dependency).pipe(Effect.andThen(Effect.fail("not found"))) + } + const key = [...makeQueryKey(query), undefined] + const atom = withQueryOptions(buildQueryFamily(rt, query)(undefined), { live: true, revalidateOnFocus: false }, key) + cleanups.push(defaultRegistry.mount(atom)) + await Effect.runPromise(Effect.exit(awaitAtomResult(defaultRegistry, atom))) + expect(getQueryReadDependencies(key)).toEqual(new Set([dependency])) + }) + + it("keeps dependencies of projected families apart", async () => { + const first = DataDependencies.repo("ProjectedA") + const second = DataDependencies.repo("ProjectedB") + const mrt = ManagedRuntime.make(Layer.empty) + cleanups.push(() => void mrt.dispose()) + const rt = makeAtomClientRuntime(() => Layer.empty, mrt.memoMap) + const make = (queryKeyProjectionHash: string, dependency: DataDependencies.DataDependency) => ({ + id: "Projected.Get", + queryKeyProjectionHash, + handler: () => DataDependencies.read(dependency) + }) + const a = buildQueryFamily(rt, make("a", first))(undefined) + const b = buildQueryFamily(rt, make("b", second))(undefined) + cleanups.push(defaultRegistry.mount(a), defaultRegistry.mount(b)) + await Effect.runPromise(awaitAtomResult(defaultRegistry, a)) + await Effect.runPromise(awaitAtomResult(defaultRegistry, b)) + const baseKey = makeQueryKey(make("a", first)) + expect(getQueryReadDependencies([...baseKey, "a", undefined])).toEqual(new Set([first])) + expect(getQueryReadDependencies([...baseKey, "b", undefined])).toEqual(new Set([second])) + }) + + it("keeps keys with colliding hashes apart", () => { + const { handlers, invalidations, source } = makeSource() + configureLiveQueryInvalidation(source) + const first = ["$Inventory", "Get", { id: "15019" }] + const second = ["$Inventory", "Get", { id: "66804" }] + cleanups.push(registerLiveQuery(first, () => new Set([repo]), {})) + cleanups.push(registerLiveQuery(second, () => new Set([repo]), {})) + handlers.receive(new Set([repo])) + expect(invalidations).toEqual([[first], [second]]) + }) + + it("subscribes once when a synchronous reset replaces the registration", () => { + configureLiveQueryInvalidation(makeSource().source) + const key = ["$Inventory", "List", "reentrant"] + let unregister = registerLiveQuery(key, () => new Set([repo]), {}) + let subscriptions = 0 + let unsubscriptions = 0 + configureLiveQueryInvalidation({ + ready: () => Promise.resolve(), + subscribe: (_onWrites, onReset) => { + subscriptions++ + onReset() + return () => unsubscriptions++ + }, + invalidate: () => { + unregister() + unregister = registerLiveQuery(key, () => new Set([repo]), {}) + } + }) + unregister() + expect([subscriptions, unsubscriptions]).toEqual([1, 1]) + }) + + it("brings a pending delayed invalidation forward for a stricter observer", () => { + vi.useFakeTimers() + const { handlers, invalidations, source } = makeSource() + configureLiveQueryInvalidation(source) + const key = ["$Inventory", "List", "strict"] + cleanups.push(registerLiveQuery(key, () => new Set([repo]), { maxDelayMs: 50 })) + handlers.receive(new Set([repo])) + vi.advanceTimersByTime(10) + cleanups.push(registerLiveQuery(key, () => new Set([repo]), { maxDelayMs: 0 })) + expect(invalidations).toEqual([[key]]) + }) + + it("releases deprecated fetches together when they end out of order", async () => { + const { handlers, invalidations, source } = makeSource() + configureLiveQueryInvalidation(source) + const first = ["$Inventory", "Get", { id: "legacy-a" }] + const second = ["$Inventory", "Get", { id: "legacy-b" }] + let firstReads = DataDependencies.empty() + cleanups.push(registerLiveQuery(first, () => firstReads, {})) + cleanups.push(registerLiveQuery(second, () => new Set([repo]), {})) + const [a, b] = await Promise.all([beginLiveQueryFetch(first), beginLiveQueryFetch(second)]) + handlers.receive(new Set([repo])) + endLiveQueryFetch(b) + expect(invalidations).toEqual([]) + firstReads = new Set([repo]) + endLiveQueryFetch(a) + expect(invalidations).toEqual([[first], [second]]) + }) + + it("rejects an already aborted readiness wait", async () => { + configureLiveQueryInvalidation(makeSource(never).source) + const key = ["$Inventory", "Get", { id: "pre-aborted" }] + cleanups.push(registerLiveQuery(key, () => DataDependencies.empty(), {})) + const fetch = acquire(key) + cleanups.push(() => releaseLiveQueryFetch(fetch)) + await expect(awaitLiveQueryFetch(fetch, AbortSignal.abort())).rejects.toBeDefined() + }) + + it("rejects an aborted wait after following a source switch", async () => { + configureLiveQueryInvalidation(makeSource(never).source) + const key = ["$Inventory", "Get", { id: "abort-after-switch" }] + cleanups.push(registerLiveQuery(key, () => DataDependencies.empty(), {})) + const fetch = acquire(key) + cleanups.push(() => releaseLiveQueryFetch(fetch)) + const controller = new AbortController() + const waiting = awaitLiveQueryFetch(fetch, controller.signal) + configureLiveQueryInvalidation(makeSource(never).source) + await flush() + controller.abort() + await expect(waiting).rejects.toBeDefined() + }) + + it("does not ask the source again after an unregistered query's catch-up is cancelled", async () => { + let open = () => {} + const ready = vi.fn(() => new Promise((resolve) => open = resolve)) + const { invalidations, source } = makeSource(ready) + configureLiveQueryInvalidation(source) + const key = ["$Inventory", "List", "cancelled-catch-up"] + registerLiveQuery(key, () => new Set([repo]), {})() + open() + await flush() + expect(invalidations).toEqual([]) + }) + + it.each([0, 60_000])("revalidates a remount once with staleTime %i", async (staleTime) => { + const dependency = DataDependencies.repo("RemountOrders") + configureLiveQueryInvalidation({ + ...makeSource().source, + invalidate: (keys) => void Effect.runPromise(invalidateAndAwait(keys)) + }) + const mrt = ManagedRuntime.make(Layer.empty) + cleanups.push(() => void mrt.dispose()) + const rt = makeAtomClientRuntime(() => Layer.empty, mrt.memoMap) + let calls = 0 + const query = { + id: "RemountOrders.List", + // network latency: SWR's mount task sees the catch-up refetch in flight + handler: () => + DataDependencies.read(dependency).pipe( + Effect.andThen(Effect.sleep("1 millis")), + Effect.andThen(Effect.sync(() => ++calls)) + ) + } + const key = [...makeQueryKey(query), undefined] + const atom = withQueryOptions( + buildQueryFamily(rt, query)(undefined), + { live: { maxDelayMs: 20 }, staleTime, revalidateOnFocus: false }, + key + ) + const unmount = defaultRegistry.mount(atom) + await Effect.runPromise(awaitAtomResult(defaultRegistry, atom)) + unmount() + // the registry disposes asynchronously; a remount before that keeps the registration (nothing missed) + await vi.waitFor(() => expect(isRegistered(key)).toBe(false)) + cleanups.push(defaultRegistry.mount(atom)) + await new Promise((resolve) => setTimeout(resolve, 50)) + await Effect.runPromise(awaitAtomResult(defaultRegistry, atom)) + expect(calls).toBe(2) + }) + + it("catches up a mounted stale query when the source is switched", async () => { + const dependency = DataDependencies.repo("SwitchedOrders") + const invalidate = (keys: ReadonlyArray>) => void Effect.runPromise(invalidateAndAwait(keys)) + configureLiveQueryInvalidation({ ...makeSource().source, invalidate }) + const mrt = ManagedRuntime.make(Layer.empty) + cleanups.push(() => void mrt.dispose()) + const rt = makeAtomClientRuntime(() => Layer.empty, mrt.memoMap) + let calls = 0 + const query = { + id: "SwitchedOrders.List", + handler: () => DataDependencies.read(dependency).pipe(Effect.andThen(Effect.sync(() => ++calls))) + } + const atom = withQueryOptions( + buildQueryFamily(rt, query)(undefined), + { live: true, staleTime: 0, revalidateOnFocus: false }, + [...makeQueryKey(query), undefined] + ) + cleanups.push(defaultRegistry.mount(atom)) + await Effect.runPromise(awaitAtomResult(defaultRegistry, atom)) + await flush() + expect(calls).toBe(1) + configureLiveQueryInvalidation({ ...makeSource().source, invalidate }) + await flush() + await Effect.runPromise(awaitAtomResult(defaultRegistry, atom)) + expect(calls).toBe(2) + }) + + it("keeps waiting when a switch runs between readiness settling and the wait resuming", async () => { + let open = () => {} + const ready = new Promise((resolve) => open = resolve) + configureLiveQueryInvalidation(makeSource(() => ready).source) + const key = ["$Inventory", "Get", { id: "overtaken" }] + cleanups.push(registerLiveQuery(key, () => DataDependencies.empty(), {})) + const fetch = acquire(key) + cleanups.push(() => releaseLiveQueryFetch(fetch)) + let settled = false + void awaitLiveQueryFetch(fetch).then(() => settled = true, () => settled = true) + void ready.then(() => configureLiveQueryInvalidation(makeSource(never).source)) + open() + await flush() + expect(settled).toBe(false) + }) + + it("rejects when ready() aborts the wait synchronously", async () => { + const controller = new AbortController() + configureLiveQueryInvalidation( + makeSource(() => { + controller.abort() + return never() + }) + .source + ) + const key = ["$Inventory", "Get", { id: "sync-abort" }] + cleanups.push(registerLiveQuery(key, () => DataDependencies.empty(), {})) + const fetch = acquire(key) + cleanups.push(() => releaseLiveQueryFetch(fetch)) + await expect(awaitLiveQueryFetch(fetch, controller.signal)).rejects.toBeDefined() + }) + + it.each(["modern", "legacy"] as const)( + "keeps a %s wait when a switch is queued right after readiness", + async (api) => { + let open = () => {} + const oldReady = new Promise((resolve) => open = resolve) + configureLiveQueryInvalidation(makeSource(() => oldReady).source) + const key = ["$Inventory", "Get", { id: `deferred-${api}` }] + cleanups.push(registerLiveQuery(key, () => DataDependencies.empty(), {})) + let settled = false + if (api === "modern") { + const fetch = acquire(key) + cleanups.push(() => releaseLiveQueryFetch(fetch)) + void awaitLiveQueryFetch(fetch).then(() => settled = true, () => settled = true) + } else { + cleanups.push(() => endLiveQueryFetch(true)) + void beginLiveQueryFetch(key).then(() => settled = true, () => settled = true) + } + void oldReady.then(() => queueMicrotask(() => configureLiveQueryInvalidation(makeSource(never).source))) + open() + await flush() + expect(settled).toBe(false) + } + ) + + it.each(["modern", "legacy", "ready"] as const)( + "ignores a %s rejection when a switch is queued right after it", + async (api) => { + let rejectOld = (_error: unknown) => {} + const oldReady = new Promise((_, reject) => rejectOld = reject) + configureLiveQueryInvalidation(makeSource(() => oldReady).source) + const key = ["$Inventory", "Get", { id: `deferred-rejection-${api}` }] + cleanups.push(registerLiveQuery(key, () => DataDependencies.empty(), {})) + let settled = false + const done = () => settled = true + if (api === "modern") { + const fetch = acquire(key) + cleanups.push(() => releaseLiveQueryFetch(fetch)) + void awaitLiveQueryFetch(fetch).then(done, done) + } else if (api === "legacy") { + cleanups.push(() => endLiveQueryFetch(true)) + void beginLiveQueryFetch(key).then(done, done) + } else { + void liveQueryReady().then(done, done) + } + void oldReady.catch(() => queueMicrotask(() => configureLiveQueryInvalidation(makeSource(never).source))) + rejectOld(new Error("departed source")) + await flush() + expect(settled).toBe(false) + } + ) +})