Function buildQueryFamily

packages/vue/src/atomQuery.ts:416–493

(
  rt: AtomClientRuntime,
  self: {
    readonly id: string
    readonly handler: (i: I) => Effect.Effect<A, E, any>
    readonly options?: ClientForOptions
    readonly queryKeyProjectionHash?: string
  }
)

  if (opts.refetchInterval) atom = Atom.withRefresh(Duration.millis(opts.refetchInterval))(atom)
  if (opts.structuralSharing ?? true) atom = structuralShare(atom)
  return atom
}

/** Constant atom for disabled / `mode:"optional"`-None queries: stays Initial, never fetches. */
export const disabledQueryAtom: Atom.Atom<AsyncResult.AsyncResult<any, any>> = Atom.readable(() =>
  AsyncResult.initial(false)
)

/**
 * Bumps when the browser regains connectivity (the `online` event) — the tanstack
 * `refetchOnReconnect` trigger. One shared listener (module-level). SSR-guarded.
 */
const onlineSignal: Atom.Atom<number> = Atom.readable((get) => {
  let count = 0
  if (typeof window === "undefined") return count
  const update = () => {
    if (navigator.onLine) get.setSelf(++count)
  }
  window.addEventListener("online", update)
  get.addFinalizer(() => window.removeEventListener("online", update))
  return count
})

/**
 * Focus OR reconnect, as a single signal for `swr` — both should stale-revalidate a query.
 * swr takes one `focusSignal`, so we fold window-focus + reconnect into one derived atom;
 * a bump from either triggers swr's stale check.
 */
const focusOrReconnectSignal: Atom.Atom<number> = Atom.make((get) => get(Atom.windowFocusSignal) + get(onlineSignal))

/**
 * Build the per-input atom family for a request handler — the query CACHE IDENTITY.
 *
 * This is the TanStack `queryKey = [handler, input]` equivalent and the piece that makes
 * caching cross-component: `Atom.family` memoizes one atom per structurally-distinct input
 * (v4 hashes the input via Hash/Equal), so every component querying the same handler+input
 * reads the SAME atom instance => one fetch, one shared result in the global registry,
 * ref-counted and GC'd on idle ttl. (The registry + ttl give lifetime; reactivity keys give
 * invalidation; the family gives identity/sharing — all three are needed.)
 *
 * The family is created once per handler (see query.ts's per-handler cache), so it is shared
 * process-wide via the registry.
 *
 * Invalidation is hierarchical: each atom registers under EVERY prefix of its full key
 * `[...makeQueryKey(self), input]`. Since reactivity matches keys by exact hash, registering
 * all prefixes means `invalidate(P)` refreshes every atom whose key starts with `P` — e.g.
 * `["$X"]` refreshes all inputs, `["$X","$List",input]` only that input. (`makeQueryKey`'s
 * collapsed form `getQueryKey` — what mutations invalidate by default — is one of the prefixes.)
 */
export const buildQueryFamily = <I, A, E>(
  rt: AtomClientRuntime,
  self: {
    readonly id: string
    readonly handler: (i: I) => Effect.Effect<A, E, any>
    readonly options?: ClientForOptions
    readonly queryKeyProjectionHash?: string
  }
) => {