Function useQuery

packages/vue/src/internal/tanstackQuery.ts:149–286

(
    q: RequestHandlerWithInput<I, A, E, R, Request, Name>
  )

    }
    queryClient.setQueryData(queryKey, (data: A | undefined) => data === undefined ? data : updater(data))
  }
})

export const makeTanstackQuery = <R>(
  getRuntime: () => Context.Context<R>,
  queryClient: QueryClient
): MakeQuery2<R> => {
  // Drop a query's recorded read-dependencies when tanstack evicts it from the cache, so the
  // registry mirrors the live queries (mirrors the atom engine's `trackReadDependencies` finalizer).
  queryClient.getQueryCache().subscribe((event) => {
    if (event.type === "removed") clearQueryReadDependencies(event.query.queryKey)
  })

  const useQuery: MakeQuery2<R> = <I, A, E, Request extends Req, Name extends string>(
    q: RequestHandlerWithInput<I, A, E, R, Request, Name>
  ) =>
  <TData = A>(
    arg: I | WatchSource<I> | undefined | WatchSource<Option.Option<I>>,
    options?: LegacyTanstackOptions<A, CauseException<E>, TData>
  ) => {
    const runPromise = makeRunPromise(getRuntime())
    const queryKey = makeQueryKey(q)
    const enabled = resolveEnabled(arg, options)
    const structuralSharing = options?.structuralSharing === false ? false : replaceEqualDeep
    const tanstackOptions = {
      ...(options?.staleTime !== undefined ? { staleTime: options.staleTime } : {}),
      ...(typeof options?.gcTime === "number" ? { gcTime: options.gcTime } : {}),
      ...(options?.refetchOnWindowFocus !== undefined ? { refetchOnWindowFocus: options.refetchOnWindowFocus } : {}),
      structuralSharing,
      ...(options?.refetchInterval !== undefined ? { refetchInterval: options.refetchInterval } : {}),
      ...(options?.select !== undefined ? { select: options.select } : {})
    }
    const resolvedQueryKey = computed(() => {
      const input = resolveInput(arg, options?.mode)
      return fullQueryKey(q, queryKey, input)
    })
    watch(
      resolvedQueryKey,
      (key, _, onCleanup) => onCleanup(registerQueryInvalidationMode(key, options?.invalidation ?? "await")),
      { immediate: true }
    )
    const tanstack = useTanstackQuery<A, CauseException<E>, TData>({
      ...tanstackOptions,
      enabled,
      throwOnError: false,
      retry: (retryCount: number, error: unknown) => isRetryable(error) && retryCount < 5,
      queryKey: resolvedQueryKey,
      queryFn: (
        { meta, signal }: {
          readonly meta?: { readonly span?: Tracer.AnySpan | undefined } | undefined
          readonly signal: AbortSignal
        }
      ) =>
        runPromise(
          Effect.gen(function*() {
            const input = resolveInput(arg, options?.mode)!
            // Record the repository/server read-dependencies seen while fetching, keyed by the
            // tanstack queryKey, so a later mutation whose writes intersect them derives this query