Function makeTanstackQuery

packages/vue/src/internal/tanstackQuery.ts:139–289

(
  getRuntime: () => Context.Context<R>,
  queryClient: QueryClient
)

  update: <I, A, E, R, Request extends Req, Name extends string>(
    _registry: ReturnType<typeof injectRegistry>,
    query: RequestHandlerWithInput<I, A, E, R, Request, Name>,
    input: I,
    updater: (data: NoInfer<A>) => NoInfer<A>
  ) => {
    const queryKey = fullQueryKey(query, makeQueryKey(query), input)
    if (queryClient.getQueryData(queryKey) === undefined) {
      console.warn(`Query ${query.id} has not been used yet; nothing to update`)
      return
    }
    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: (