@effect-app/vue 4.0.0-beta.307 → 4.0.0-beta.309

package/src/liveQueryInvalidation.ts

@@ -0,0 +1,138 @@
+import { DataDependencies } from "effect-app/client"
+import * as Hash from "effect/Hash"
+
+export interface LiveQueryOptions {
+  /** Fixed maximum delay from the first matching write. Zero reacts immediately. */
+  readonly maxDelayMs?: number
+}
+
+export interface LiveQueryInvalidationSource {
+  /** Resolve only after events received after this point can no longer be missed. */
+  readonly ready: () => Promise<void>
+  readonly subscribe: (
+    onWrites: (writes: DataDependencies.DataDependencies) => void,
+    onReset: () => void
+  ) => () => void
+  readonly invalidate: (keys: ReadonlyArray<ReadonlyArray<unknown>>) => void
+}
+
+interface LiveQueryEntry {
+  readonly key: ReadonlyArray<unknown>
+  readonly reads: () => DataDependencies.DataDependencies
+  observers: number
+  readonly delays: Map<number, number>
+  timer: ReturnType<typeof setTimeout> | undefined
+}
+
+const entries = new Map<number, LiveQueryEntry>()
+let source: LiveQueryInvalidationSource | undefined
+let unsubscribe: (() => void) | undefined
+let discovering = 0
+let bufferedWrites = DataDependencies.empty()
+
+const invalidateEntry = (entry: LiveQueryEntry) => {
+  entry.timer = undefined
+  source?.invalidate([entry.key])
+}
+
+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)
+}
+
+const dispatch = (writes: DataDependencies.DataDependencies) => {
+  if (!DataDependencies.isNonEmpty(writes)) return
+  for (const entry of entries.values()) {
+    if (DataDependencies.intersects(entry.reads(), writes)) schedule(entry)
+  }
+}
+
+const receive = (writes: DataDependencies.DataDependencies) => {
+  if (discovering > 0) {
+    bufferedWrites = DataDependencies.merge(bufferedWrites, writes)
+    return
+  }
+  dispatch(writes)
+}
+
+const reset = () => {
+  bufferedWrites = DataDependencies.empty()
+  for (const entry of entries.values()) {
+    if (DataDependencies.isNonEmpty(entry.reads())) schedule(entry)
+  }
+}
+
+const ensureSubscribed = () => {
+  if (unsubscribe === undefined && source !== undefined && entries.size > 0) {
+    unsubscribe = source.subscribe(receive, reset)
+  }
+}
+
+export const configureLiveQueryInvalidation = (next: LiveQueryInvalidationSource) => {
+  unsubscribe?.()
+  unsubscribe = undefined
+  source = next
+  ensureSubscribed()
+}
+
+export const registerLiveQuery = (
+  key: ReadonlyArray<unknown>,
+  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)
+  } else {
+    entries.set(hash, {
+      key,
+      reads,
+      observers: 1,
+      delays: new Map([[delay, 1]]),
+      timer: undefined
+    })
+  }
+  ensureSubscribed()
+
+  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()
+    }
+  }
+}
+
+export const beginLiveQueryFetch = async (key: ReadonlyArray<unknown>) => {
+  if (!entries.has(Hash.hash(key)) || source === undefined) return false
+  discovering++
+  try {
+    await source.ready()
+    return true
+  } catch (error) {
+    discovering--
+    throw error
+  }
+}
+
+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)
+}

package/src/makeClient.ts

@@ -1031,7 +1031,7 @@ export const makeClient = <RT_, RTHooks>(
             fromRequestConfig(
               defaultKey,
               queryResources as never,
-              input as never,
+              input,
               output as never
             ) as InvalidationEntry[])
           : undefined
@@ -1111,7 +1111,7 @@ export const makeClient = <RT_, RTHooks>(
                   fromRequestConfig(
                     defaultKey,
                     queryResources as never,
-                    input as never,
+                    input,
                     output as never
                   ) as InvalidationEntry[])
                 : undefined
@@ -1142,7 +1142,7 @@ export const makeClient = <RT_, RTHooks>(
                     fromRequestConfig(
                       defaultKey,
                       queryResources as never,
-                      input as never,
+                      input,
                       output as never
                     ) as InvalidationEntry[])
                   : undefined

package/src/mutate.ts

@@ -212,7 +212,7 @@ export const asResult = <Args extends readonly any[], A, E, R>(
         ))
       )
 
-  return tuple(computed(() => state.value), act) as any
+  return tuple(computed(() => state.value), act)
 }
 
 /**
@@ -259,7 +259,7 @@ export const asStreamResult = <Args extends readonly any[], A, E, R>(
 
   const act = (...args: Args) => runStream(handler(...args))
 
-  return tuple(computed(() => state.value), act) as any
+  return tuple(computed(() => state.value), act)
 }
 
 const buildInvalidateCache = <RInvalidator>(

package/src/query.ts

@@ -16,8 +16,9 @@ import * as Exit from "effect/Exit"
 import * as Stream from "effect/Stream"
 import * as AsyncResult from "effect/unstable/reactivity/AsyncResult"
 import * as Atom from "effect/unstable/reactivity/Atom"
-import { computed, type ComputedRef, effectScope, type MaybeRefOrGetter, onBeforeUnmount, onMounted, onScopeDispose, type Ref, ref, toValue, type WatchSource } from "vue"
-import { type AtomClientRuntime, type AtomQueryOptions, awaitAtomResult, buildQueryFamily, buildStreamQueryFamily, disabledQueryAtom, isStaleResult, refreshAtomWithCurrentSpan, staleTimeMsOf, withQueryOptions } from "./atomQuery.ts"
+import { computed, type ComputedRef, effectScope, type MaybeRefOrGetter, onBeforeUnmount, onMounted, onScopeDispose, ref, toValue, type WatchSource } from "vue"
+import { type AtomClientRuntime, type AtomQueryOptions, awaitAtomResult, buildQueryFamily, buildStreamQueryFamily, disabledQueryAtom, isStaleResult, queryKeyForAtom, refreshAtomWithCurrentSpan, staleTimeMsOf, withQueryOptions } from "./atomQuery.ts"
+import type { LiveQueryOptions } from "./liveQueryInvalidation.ts"
 import { latestDefined } from "./suspense.ts"
 
 // --- minimal local types (replacing the former @tanstack/vue-query type imports) ---
@@ -201,6 +202,7 @@ export interface CustomUseQueryOptions<
   readonly structuralSharing?: boolean
   /** poll: re-fetch every N ms (tanstack refetchInterval) */
   readonly refetchInterval?: number
+  readonly live?: boolean | LiveQueryOptions
   readonly select?: (data: TQueryFnData) => TData
   /** accepted for source compatibility; not used by the atom engine */
   readonly retry?: boolean | number
@@ -253,6 +255,7 @@ export interface AtomQueryNewOptions<TQueryFnData = unknown, TData = TQueryFnDat
   readonly structuralSharing?: boolean
   readonly refreshEvery?: number
   readonly refetchInterval?: number
+  readonly live?: boolean | LiveQueryOptions
   readonly select?: (data: TQueryFnData) => TData
 }
 
@@ -263,6 +266,7 @@ export interface AtomStreamQueryOptions {
   readonly revalidateOnFocus?: boolean
   readonly refetchOnWindowFocus?: boolean
   readonly refreshEvery?: number
+  readonly live?: boolean | LiveQueryOptions
   readonly refetchInterval?: number
 }
 
@@ -276,7 +280,8 @@ export interface AtomStreamQueryOptions {
  * option is set. Neither value is written to the atom cache.
  */
 export const withDataFallback = <A, E>(
-  rawResult: Ref<AsyncResult.AsyncResult<A, E>>,
+  // Structural read so both Ref and Readonly<Ref> from useAtomValue are accepted.
+  rawResult: { readonly value: AsyncResult.AsyncResult<A, E> },
   options?: unknown
 ): ComputedRef<AsyncResult.AsyncResult<A, E>> => {
   const opts = options as
@@ -285,6 +290,8 @@ export const withDataFallback = <A, E>(
   const initialData = opts?.initialData
   const placeholderData = opts?.placeholderData
   if (initialData === undefined && placeholderData === undefined) {
+    // Identity when no fallback options. Callers that need a real ComputedRef
+    // (e.g. useAtomValue's Readonly<Ref>) wrap before calling this helper.
     return rawResult as ComputedRef<AsyncResult.AsyncResult<A, E>>
   }
 
@@ -319,6 +326,7 @@ const normalizeQueryOptions = (options?: {
   readonly structuralSharing?: boolean
   readonly refetchInterval?: number
   readonly refreshEvery?: number
+  readonly live?: boolean | LiveQueryOptions
 }): AtomQueryOptions => {
   const out: {
     staleTime?: number
@@ -326,6 +334,7 @@ const normalizeQueryOptions = (options?: {
     revalidateOnFocus?: boolean
     structuralSharing?: boolean
     refetchInterval?: number
+    live?: boolean | LiveQueryOptions
   } = {}
   if (options?.staleTime !== undefined) out.staleTime = options.staleTime
   const gcTime = options?.idleTTL ?? options?.gcTime
@@ -335,6 +344,7 @@ const normalizeQueryOptions = (options?: {
   if (options?.structuralSharing !== undefined) out.structuralSharing = options.structuralSharing
   const refetchInterval = options?.refreshEvery ?? options?.refetchInterval
   if (refetchInterval !== undefined) out.refetchInterval = refetchInterval
+  if (options?.live !== undefined) out.live = options.live
   return out
 }
 
@@ -510,8 +520,10 @@ const observedAtom = <A, E>(
     readonly structuralSharing?: boolean
     readonly refetchInterval?: number
     readonly refreshEvery?: number
+    readonly live?: boolean | LiveQueryOptions
   }
-): Atom.Atom<AsyncResult.AsyncResult<A, E>> => withQueryOptions(atom, normalizeQueryOptions(options))
+): Atom.Atom<AsyncResult.AsyncResult<A, E>> =>
+  withQueryOptions(atom, normalizeQueryOptions(options), queryKeyForAtom(atom))
 
 const observedStreamAtom = <A, E>(
   atom: Atom.Writable<Atom.PullResult<A, E>, void>,
@@ -549,7 +561,9 @@ const makeQueryView = <I, A, E, TData>(
   const [req, enabledRef] = optionValue<I>(arg, options)
   const family = getQueryFamily(atomRt, q)
   const atomRef = computed(() => enabledRef.value ? observedAtom(family(req.value), options) : disabledQueryAtom)
-  const rawResult = useAtomValue(() => atomRef.value) as ComputedRef<AsyncResult.AsyncResult<A, E>>
+  // useAtomValue returns Readonly<Ref>, not ComputedRef — re-wrap before withDataFallback / QueryView.
+  const rawAtomResult = useAtomValue(() => atomRef.value)
+  const rawResult = computed(() => rawAtomResult.value)
   // `initialData` / `placeholderData` display fallback (old `.query()` API). Applied only while the
   // result is still Initial; Failures/Success pass through unmasked. Neither is written to cache
   // (the base atom stays Initial, so the mount-staleness check still triggers the real fetch). The

package/test/dist/liveQueryInvalidation.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"liveQueryInvalidation.test.d.ts","sourceRoot":"","sources":["../liveQueryInvalidation.test.ts"],"names":[],"mappings":""}

package/test/liveQueryInvalidation.test.ts

@@ -0,0 +1,108 @@
+import { DataDependencies } from "effect-app/client"
+import { afterEach, describe, expect, it, vi } from "vitest"
+import { beginLiveQueryFetch, configureLiveQueryInvalidation, endLiveQueryFetch, registerLiveQuery } from "../src/liveQueryInvalidation.js"
+
+const repo = DataDependencies.repo("Inventory", ["item-1"])
+const otherId = DataDependencies.repo("Inventory", ["item-2"])
+
+describe("live query invalidation", () => {
+  const cleanups: Array<() => void> = []
+
+  afterEach(() => {
+    while (cleanups.length > 0) cleanups.pop()?.()
+    vi.useRealTimers()
+  })
+
+  it("invalidates only live queries whose recorded reads intersect", () => {
+    const invalidations: Array<ReadonlyArray<ReadonlyArray<unknown>>> = []
+    let receive = (_writes: DataDependencies.DataDependencies) => {}
+    configureLiveQueryInvalidation({
+      ready: () => Promise.resolve(),
+      subscribe: (onWrites) => {
+        receive = onWrites
+        return () => {}
+      },
+      invalidate: (keys) => invalidations.push(keys)
+    })
+
+    const key = ["$Inventory", "List", undefined]
+    cleanups.push(registerLiveQuery(key, () => new Set([repo]), {}))
+    receive(new Set([otherId]))
+    expect(invalidations).toEqual([])
+
+    receive(new Set([repo]))
+    expect(invalidations).toEqual([[key]])
+  })
+
+  it("replays writes received while the initial query discovers its dependencies", async () => {
+    const invalidations: Array<ReadonlyArray<ReadonlyArray<unknown>>> = []
+    let receive = (_writes: DataDependencies.DataDependencies) => {}
+    let open = () => {}
+    const ready = new Promise<void>((resolve) => open = resolve)
+    configureLiveQueryInvalidation({
+      ready: () => ready,
+      subscribe: (onWrites) => {
+        receive = onWrites
+        return () => {}
+      },
+      invalidate: (keys) => invalidations.push(keys)
+    })
+
+    const key = ["$Inventory", "Get", { id: "item-1" }]
+    let reads = DataDependencies.empty()
+    cleanups.push(registerLiveQuery(key, () => reads, {}))
+
+    const starting = beginLiveQueryFetch(key)
+    receive(new Set([repo]))
+    open()
+    const wasLive = await starting
+    reads = new Set([repo])
+    endLiveQueryFetch(wasLive)
+
+    expect(invalidations).toEqual([[key]])
+  })
+
+  it("coalesces matching writes using the query's maximum delay", () => {
+    vi.useFakeTimers()
+    const invalidations: Array<ReadonlyArray<ReadonlyArray<unknown>>> = []
+    let receive = (_writes: DataDependencies.DataDependencies) => {}
+    configureLiveQueryInvalidation({
+      ready: () => Promise.resolve(),
+      subscribe: (onWrites) => {
+        receive = onWrites
+        return () => {}
+      },
+      invalidate: (keys) => invalidations.push(keys)
+    })
+
+    const key = ["$Inventory", "List", undefined]
+    cleanups.push(registerLiveQuery(key, () => new Set([repo]), { maxDelayMs: 2_000 }))
+    receive(new Set([repo]))
+    receive(new Set([repo]))
+    vi.advanceTimersByTime(1_999)
+    expect(invalidations).toEqual([])
+    vi.advanceTimersByTime(1)
+    expect(invalidations).toEqual([[key]])
+  })
+
+  it("fails safe by invalidating every live query when the source resets", () => {
+    const invalidations: Array<ReadonlyArray<ReadonlyArray<unknown>>> = []
+    let reset = () => {}
+    configureLiveQueryInvalidation({
+      ready: () => Promise.resolve(),
+      subscribe: (_onWrites, onReset) => {
+        reset = onReset
+        return () => {}
+      },
+      invalidate: (keys) => invalidations.push(keys)
+    })
+
+    const first = ["$Inventory", "List", undefined]
+    const second = ["$Orders", "List", undefined]
+    cleanups.push(registerLiveQuery(first, () => new Set([repo]), {}))
+    cleanups.push(registerLiveQuery(second, () => new Set([otherId]), {}))
+    reset()
+
+    expect(invalidations).toEqual([[first], [second]])
+  })
+})

package/tsconfig.json

@@ -14,7 +14,12 @@
     "isolatedModules": true,
     "esModuleInterop": true,
     "skipLibCheck": true,
-    "plugins": [],
+    "plugins": [
+      {
+        "name": "@effect/language-service",
+        "diagnostics": false
+      }
+    ],
     "module": "Node16",
     "lib": [
       "ES2023"