useQuery<T> function

QueryResult<T> useQuery<T>({
  1. required List queryKey,
  2. required QueryFetcher<T> fetcher,
  3. Duration? staleTime,
  4. Duration? cacheTime,
  5. bool enabled = true,
  6. int? retry,
  7. RetryDelayFn? retryDelay,
  8. RetryWhenFn? retryWhen,
  9. bool? refetchOnWindowFocus,
  10. bool? refetchOnReconnect,
  11. Duration? refetchInterval,
  12. void onSuccess(
    1. T data,
    2. List key
    )?,
  13. void onError(
    1. Object error,
    2. StackTrace st,
    3. List key
    )?,
  14. void onSettled(
    1. T? data,
    2. Object? error
    )?,
  15. T? initialData,
  16. T select(
    1. T data
    )?,
  17. bool keepPreviousData = false,
})

A hook that subscribes to a query and returns its current state.

Implementation

QueryResult<T> useQuery<T>({
  required List<dynamic> queryKey,
  required QueryFetcher<T> fetcher,
  Duration? staleTime,
  Duration? cacheTime,
  bool enabled = true,
  int? retry,
  RetryDelayFn? retryDelay,
  RetryWhenFn? retryWhen,
  bool? refetchOnWindowFocus,
  bool? refetchOnReconnect,
  Duration? refetchInterval,
  void Function(T data, List<dynamic> key)? onSuccess,
  void Function(Object error, StackTrace st, List<dynamic> key)? onError,
  void Function(T? data, Object? error)? onSettled,
  T? initialData,
  T Function(T data)? select,
  bool keepPreviousData = false,
}) {
  final context = useContext();
  final client = QueryClient.of(context);
  final defaults = client.defaultOptions;

  final options = useMemoized(
    () => QueryOptions<T>(
      key: queryKey,
      fetcher: fetcher,
      staleTime: staleTime ?? defaults.staleTime,
      cacheTime: cacheTime ?? defaults.cacheTime,
      enabled: enabled,
      retry: retry ?? defaults.retry,
      retryDelay: retryDelay ?? defaults.retryDelay,
      retryWhen: retryWhen ?? defaults.retryWhen,
      refetchOnWindowFocus:
          refetchOnWindowFocus ?? defaults.refetchOnWindowFocus,
      refetchOnReconnect: refetchOnReconnect ?? defaults.refetchOnReconnect,
      refetchInterval: refetchInterval ?? defaults.refetchInterval,
      onSuccess: onSuccess,
      onError: onError,
      onSettled: onSettled,
      initialData: initialData,
      select: select,
      keepPreviousData: keepPreviousData,
    ),
    [
      queryKey,
      staleTime,
      cacheTime,
      enabled,
      retry,
      refetchOnWindowFocus,
      refetchOnReconnect,
      refetchInterval,
      initialData,
      keepPreviousData,
    ],
  );

  return _useQueryObserver<T>(client, queryKey, options);
}