react-query

react-query

Version 3.39.3
Published 2 years ago
2.26 MB
3 dependencies
MIT license

Install

npm i react-query

yarn add react-query

pnpm add react-query

Overview

Hooks for managing, caching and syncing asynchronous and remote data in React

Index

Variables

variable focusManager

const focusManager: FocusManager;

variable notifyManager

const notifyManager: NotifyManager;

variable onlineManager

const onlineManager: OnlineManager;

Functions

function dehydrate

dehydrate: (client: QueryClient, options?: DehydrateOptions) => DehydratedState;

function hashQueryKey

hashQueryKey: (queryKey: QueryKey) => string;

Default query keys hash function.

function hydrate

hydrate: (
    client: QueryClient,
    dehydratedState: unknown,
    options?: HydrateOptions
) => void;

function Hydrate

Hydrate: ({
    children,
    options,
    state,
}: HydrateProps) => React.ReactElement<
    any,
    | string
    | ((props: any) => React.ReactElement<any, any> | null)
    | (new (props: any) => React.Component<any, any, any>)
>;

function isCancelledError

isCancelledError: (value: any) => value is CancelledError;

function isError

isError: (value: any) => value is Error;

function QueryClientProvider

QueryClientProvider: ({
    client,
    contextSharing,
    children,
}: QueryClientProviderProps) => JSX.Element;

function QueryErrorResetBoundary

QueryErrorResetBoundary: ({
    children,
}: QueryErrorResetBoundaryProps) => JSX.Element;

function setLogger

setLogger: (newLogger: Logger) => void;

function useHydrate

useHydrate: (state: unknown, options?: HydrateOptions) => void;

function useInfiniteQuery

useInfiniteQuery: {
    <
        TQueryFnData = unknown,
        TError = unknown,
        TData = TQueryFnData,
        TQueryKey extends QueryKey = QueryKey
    >(
        options: UseInfiniteQueryOptions<
            TQueryFnData,
            TError,
            TData,
            TQueryFnData,
            TQueryKey
        >
    ): UseInfiniteQueryResult<TData, TError>;
    <
        TQueryFnData = unknown,
        TError = unknown,
        TData = TQueryFnData,
        TQueryKey extends QueryKey = QueryKey
    >(
        queryKey: TQueryKey,
        options?: Omit<
            UseInfiniteQueryOptions<
                TQueryFnData,
                TError,
                TData,
                TQueryFnData,
                TQueryKey
            >,
            'queryKey'
        >
    ): UseInfiniteQueryResult<TData, TError>;
    <
        TQueryFnData = unknown,
        TError = unknown,
        TData = TQueryFnData,
        TQueryKey extends QueryKey = QueryKey
    >(
        queryKey: TQueryKey,
        queryFn: QueryFunction<TQueryFnData, TQueryKey>,
        options?: Omit<
            UseInfiniteQueryOptions<
                TQueryFnData,
                TError,
                TData,
                TQueryFnData,
                TQueryKey
            >,
            'queryKey' | 'queryFn'
        >
    ): UseInfiniteQueryResult<TData, TError>;
};

function useIsFetching

useIsFetching: {
    (filters?: QueryFilters): number;
    (queryKey?: QueryKey, filters?: QueryFilters): number;
};

function useIsMutating

useIsMutating: {
    (filters?: MutationFilters): number;
    (
        mutationKey?: MutationKey,
        filters?: Omit<MutationFilters, 'mutationKey'>
    ): number;
};

function useMutation

useMutation: {
    <TData = unknown, TError = unknown, TVariables = void, TContext = unknown>(
        options: UseMutationOptions<TData, TError, TVariables, TContext>
    ): UseMutationResult<TData, TError, TVariables, TContext>;
    <TData = unknown, TError = unknown, TVariables = void, TContext = unknown>(
        mutationFn: MutationFunction<TData, TVariables>,
        options?: Omit<
            UseMutationOptions<TData, TError, TVariables, TContext>,
            'mutationFn'
        >
    ): UseMutationResult<TData, TError, TVariables, TContext>;
    <TData = unknown, TError = unknown, TVariables = void, TContext = unknown>(
        mutationKey: MutationKey,
        options?: Omit<
            UseMutationOptions<TData, TError, TVariables, TContext>,
            'mutationKey'
        >
    ): UseMutationResult<TData, TError, TVariables, TContext>;
    <TData = unknown, TError = unknown, TVariables = void, TContext = unknown>(
        mutationKey: MutationKey,
        mutationFn?: MutationFunction<TData, TVariables>,
        options?: Omit<
            UseMutationOptions<TData, TError, TVariables, TContext>,
            'mutationKey' | 'mutationFn'
        >
    ): UseMutationResult<TData, TError, TVariables, TContext>;
};

function useQueries

useQueries: <T extends any[]>(
    queries: readonly [...QueriesOptions<T>]
) => QueriesResults<T>;

function useQuery

useQuery: {
    <
        TQueryFnData = unknown,
        TError = unknown,
        TData = TQueryFnData,
        TQueryKey extends QueryKey = QueryKey
    >(
        options: UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>
    ): UseQueryResult<TData, TError>;
    <
        TQueryFnData = unknown,
        TError = unknown,
        TData = TQueryFnData,
        TQueryKey extends QueryKey = QueryKey
    >(
        queryKey: TQueryKey,
        options?: Omit<
            UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>,
            'queryKey'
        >
    ): UseQueryResult<TData, TError>;
    <
        TQueryFnData = unknown,
        TError = unknown,
        TData = TQueryFnData,
        TQueryKey extends QueryKey = QueryKey
    >(
        queryKey: TQueryKey,
        queryFn: QueryFunction<TQueryFnData, TQueryKey>,
        options?: Omit<
            UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>,
            'queryKey' | 'queryFn'
        >
    ): UseQueryResult<TData, TError>;
};

function useQueryClient

useQueryClient: () => QueryClient;

function useQueryErrorResetBoundary

useQueryErrorResetBoundary: () => QueryErrorResetBoundaryValue;

Classes

class CancelledError

class CancelledError {}

constructor

constructor(options?: CancelOptions);

property revert

revert?: boolean;

property silent

silent?: boolean;

class InfiniteQueryObserver

class InfiniteQueryObserver<
    TQueryFnData = unknown,
    TError = unknown,
    TData = TQueryFnData,
    TQueryData = TQueryFnData
> extends QueryObserver<
    TQueryFnData,
    TError,
    InfiniteData<TData>,
    InfiniteData<TQueryData>
> {}

constructor

constructor(
    client: QueryClient,
    options: InfiniteQueryObserverOptions<
        TQueryFnData,
        TError,
        TData,
        TQueryData,
        QueryKey
    >
);

property fetch

protected fetch: (
    fetchOptions?: ObserverFetchOptions
) => Promise<InfiniteQueryObserverResult<TData, TError>>;

property getCurrentResult

getCurrentResult: () => InfiniteQueryObserverResult<TData, TError>;

subscribe: (
    listener?: InfiniteQueryObserverListener<TData, TError>
) => () => void;

method bindMethods

protected bindMethods: () => void;

method createResult

protected createResult: (
    query: Query<TQueryFnData, TError, InfiniteData<TQueryData>>,
    options: InfiniteQueryObserverOptions<
        TQueryFnData,
        TError,
        TData,
        TQueryData
    >
) => InfiniteQueryObserverResult<TData, TError>;

method fetchNextPage

fetchNextPage: (
    options?: FetchNextPageOptions
) => Promise<InfiniteQueryObserverResult<TData, TError>>;

method fetchPreviousPage

fetchPreviousPage: (
    options?: FetchPreviousPageOptions
) => Promise<InfiniteQueryObserverResult<TData, TError>>;

method getOptimisticResult

getOptimisticResult: (
    options: InfiniteQueryObserverOptions<
        TQueryFnData,
        TError,
        TData,
        TQueryData
    >
) => InfiniteQueryObserverResult<TData, TError>;

method setOptions

setOptions: (
    options?: InfiniteQueryObserverOptions<
        TQueryFnData,
        TError,
        TData,
        TQueryData
    >,
    notifyOptions?: NotifyOptions
) => void;

class Mutation

class Mutation<
    TData = unknown,
    TError = unknown,
    TVariables = void,
    TContext = unknown
> {}

constructor

constructor(config: MutationConfig<TData, TError, TVariables, TContext>);

property meta

meta: MutationMeta;

property mutationId

mutationId: number;

property options

options: MutationOptions<TData, TError, TVariables, TContext>;

property state

state: MutationState<TData, TError, TVariables, TContext>;

method addObserver

addObserver: (observer: MutationObserver<any, any, any, any>) => void;

method cancel

cancel: () => Promise<void>;

method continue

continue: () => Promise<TData>;

method execute

execute: () => Promise<TData>;

method removeObserver

removeObserver: (observer: MutationObserver<any, any, any, any>) => void;

method setState

setState: (state: MutationState<TData, TError, TVariables, TContext>) => void;

class MutationCache

class MutationCache extends Subscribable<MutationCacheListener> {}

constructor

constructor(config?: MutationCacheConfig);

property config

config: MutationCacheConfig;

method add

add: (mutation: Mutation<any, any, any, any>) => void;

method build

build: <TData, TError, TVariables, TContext>(
    client: QueryClient,
    options: MutationOptions<TData, TError, TVariables, TContext>,
    state?: MutationState<TData, TError, TVariables, TContext>
) => Mutation<TData, TError, TVariables, TContext>;

method clear

clear: () => void;

method find

find: <TData = unknown, TError = unknown, TVariables = any, TContext = unknown>(
    filters: MutationFilters
) => Mutation<TData, TError, TVariables, TContext> | undefined;

method findAll

findAll: (filters: MutationFilters) => Mutation[];

method getAll

getAll: () => Mutation[];

method notify

notify: (mutation?: Mutation<any, any, any, any>) => void;

method onFocus

onFocus: () => void;

method onOnline

onOnline: () => void;

method remove

remove: (mutation: Mutation<any, any, any, any>) => void;

method resumePausedMutations

resumePausedMutations: () => Promise<void>;

class MutationObserver

class MutationObserver<
    TData = unknown,
    TError = unknown,
    TVariables = void,
    TContext = unknown
> extends Subscribable<
    MutationObserverListener<TData, TError, TVariables, TContext>
> {}

constructor

constructor(
    client: QueryClient,
    options: MutationObserverOptions<TData, TError, TVariables, TContext>
);

property options

options: MutationObserverOptions<TData, TError, TVariables, TContext>;

method bindMethods

protected bindMethods: () => void;

method getCurrentResult

getCurrentResult: () => MutationObserverResult<
    TData,
    TError,
    TVariables,
    TContext
>;

method mutate

mutate: (
    variables?: TVariables,
    options?: MutateOptions<TData, TError, TVariables, TContext>
) => Promise<TData>;

method onMutationUpdate

onMutationUpdate: (action: Action<TData, TError, TVariables, TContext>) => void;

method onUnsubscribe

protected onUnsubscribe: () => void;

method reset

reset: () => void;

method setOptions

setOptions: (
    options?: MutationObserverOptions<TData, TError, TVariables, TContext>
) => void;

class QueriesObserver

class QueriesObserver extends Subscribable<QueriesObserverListener> {}

constructor

constructor(
    client: QueryClient,
    queries?: QueryObserverOptions<
        unknown,
        unknown,
        unknown,
        unknown,
        QueryKey
    >[]
);

method destroy

destroy: () => void;

method getCurrentResult

getCurrentResult: () => QueryObserverResult[];

method getOptimisticResult

getOptimisticResult: (queries: QueryObserverOptions[]) => QueryObserverResult[];

method onSubscribe

protected onSubscribe: () => void;

method onUnsubscribe

protected onUnsubscribe: () => void;

method setQueries

setQueries: (
    queries: QueryObserverOptions[],
    notifyOptions?: NotifyOptions
) => void;

class Query

class Query<
    TQueryFnData = unknown,
    TError = unknown,
    TData = TQueryFnData,
    TQueryKey extends QueryKey = QueryKey
> {}

constructor

constructor(config: QueryConfig<TQueryFnData, TError, TData, TQueryKey>);

property cacheTime

cacheTime: number;

property initialState

initialState: QueryState<TData, TError>;

property meta

meta: QueryMeta;

property options

options: QueryOptions<TQueryFnData, TError, TData, TQueryKey>;

property queryHash

queryHash: string;

property queryKey

queryKey: QueryKey;

property revertState

revertState?: QueryState<TData, TError>;

property state

state: QueryState<TData, TError>;

method addObserver

addObserver: (observer: QueryObserver<any, any, any, any, any>) => void;

method cancel

cancel: (options?: CancelOptions) => Promise<void>;

method destroy

destroy: () => void;

method fetch

fetch: (
    options?: QueryOptions<TQueryFnData, TError, TData, TQueryKey>,
    fetchOptions?: FetchOptions
) => Promise<TData>;

method getDefaultState

protected getDefaultState: (
    options: QueryOptions<TQueryFnData, TError, TData, TQueryKey>
) => QueryState<TData, TError>;

method getObserversCount

getObserversCount: () => number;

method invalidate

invalidate: () => void;

method isActive

isActive: () => boolean;

method isFetching

isFetching: () => boolean;

method isStale

isStale: () => boolean;

method isStaleByTime

isStaleByTime: (staleTime?: number) => boolean;

method onFocus

onFocus: () => void;

method onOnline

onOnline: () => void;

method reducer

protected reducer: (
    state: QueryState<TData, TError>,
    action: Action<TData, TError>
) => QueryState<TData, TError>;

method removeObserver

removeObserver: (observer: QueryObserver<any, any, any, any, any>) => void;

method reset

reset: () => void;

method setData

setData: (
    updater: Updater<TData | undefined, TData>,
    options?: SetDataOptions
) => TData;

method setDefaultOptions

setDefaultOptions: (
    options: QueryOptions<TQueryFnData, TError, TData, TQueryKey>
) => void;

method setState

setState: (
    state: QueryState<TData, TError>,
    setStateOptions?: SetStateOptions
) => void;

class QueryCache

class QueryCache extends Subscribable<QueryCacheListener> {}

constructor

constructor(config?: QueryCacheConfig);

property config

config: QueryCacheConfig;

method add

add: (query: Query<any, any, any, any>) => void;

method build

build: <TQueryFnData, TError, TData, TQueryKey extends QueryKey>(
    client: QueryClient,
    options: QueryOptions<TQueryFnData, TError, TData, TQueryKey>,
    state?: QueryState<TData, TError>
) => Query<TQueryFnData, TError, TData, TQueryKey>;

method clear

clear: () => void;

method find

find: <TQueryFnData = unknown, TError = unknown, TData = TQueryFnData>(
    arg1: QueryKey,
    arg2?: QueryFilters
) => Query<TQueryFnData, TError, TData> | undefined;

method findAll

findAll: {
    (queryKey?: QueryKey, filters?: QueryFilters): Query[];
    (filters?: QueryFilters): Query<unknown, unknown, unknown, QueryKey>[];
    (arg1?: QueryKey | QueryFilters, arg2?: QueryFilters): Query<
        unknown,
        unknown,
        unknown,
        QueryKey
    >[];
};

method get

get: <
    TQueryFnData = unknown,
    TError = unknown,
    TData = TQueryFnData,
    TQueyKey extends QueryKey = QueryKey
>(
    queryHash: string
) => Query<TQueryFnData, TError, TData, TQueyKey> | undefined;

method getAll

getAll: () => Query[];

method notify

notify: (event: QueryCacheNotifyEvent) => void;

method onFocus

onFocus: () => void;

method onOnline

onOnline: () => void;

method remove

remove: (query: Query<any, any, any, any>) => void;

class QueryClient

class QueryClient {}

constructor

constructor(config?: QueryClientConfig);

method cancelMutations

cancelMutations: () => Promise<void>;

method cancelQueries

cancelQueries: {
    (filters?: QueryFilters, options?: CancelOptions): Promise<void>;
    (
        queryKey?: QueryKey,
        filters?: QueryFilters,
        options?: CancelOptions
    ): Promise<void>;
};

method clear

clear: () => void;

method defaultMutationOptions

defaultMutationOptions: <T extends MutationOptions<any, any, any, any>>(
    options?: T
) => T;

method defaultQueryObserverOptions

defaultQueryObserverOptions: <
    TQueryFnData,
    TError,
    TData,
    TQueryData,
    TQueryKey extends QueryKey
>(
    options?: QueryObserverOptions<
        TQueryFnData,
        TError,
        TData,
        TQueryData,
        TQueryKey
    >
) => QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>;

method defaultQueryOptions

defaultQueryOptions: <
    TQueryFnData,
    TError,
    TData,
    TQueryData,
    TQueryKey extends QueryKey
>(
    options?: QueryObserverOptions<
        TQueryFnData,
        TError,
        TData,
        TQueryData,
        TQueryKey
    >
) => QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>;

method executeMutation

executeMutation: <
    TData = unknown,
    TError = unknown,
    TVariables = void,
    TContext = unknown
>(
    options: MutationOptions<TData, TError, TVariables, TContext>
) => Promise<TData>;

method fetchInfiniteQuery

fetchInfiniteQuery: {
    <
        TQueryFnData = unknown,
        TError = unknown,
        TData = TQueryFnData,
        TQueryKey extends QueryKey = QueryKey
    >(
        options: FetchInfiniteQueryOptions<
            TQueryFnData,
            TError,
            TData,
            TQueryKey
        >
    ): Promise<InfiniteData<TData>>;
    <
        TQueryFnData = unknown,
        TError = unknown,
        TData = TQueryFnData,
        TQueryKey extends QueryKey = QueryKey
    >(
        queryKey: TQueryKey,
        options?: FetchInfiniteQueryOptions<
            TQueryFnData,
            TError,
            TData,
            TQueryKey
        >
    ): Promise<InfiniteData<TData>>;
    <
        TQueryFnData = unknown,
        TError = unknown,
        TData = TQueryFnData,
        TQueryKey extends QueryKey = QueryKey
    >(
        queryKey: TQueryKey,
        queryFn: QueryFunction<TQueryFnData, TQueryKey>,
        options?: FetchInfiniteQueryOptions<
            TQueryFnData,
            TError,
            TData,
            TQueryKey
        >
    ): Promise<InfiniteData<TData>>;
};

method fetchQuery

fetchQuery: {
    <
        TQueryFnData = unknown,
        TError = unknown,
        TData = TQueryFnData,
        TQueryKey extends QueryKey = QueryKey
    >(
        options: FetchQueryOptions<TQueryFnData, TError, TData, TQueryKey>
    ): Promise<TData>;
    <
        TQueryFnData = unknown,
        TError = unknown,
        TData = TQueryFnData,
        TQueryKey extends QueryKey = QueryKey
    >(
        queryKey: TQueryKey,
        options?: FetchQueryOptions<TQueryFnData, TError, TData, TQueryKey>
    ): Promise<TData>;
    <
        TQueryFnData = unknown,
        TError = unknown,
        TData = TQueryFnData,
        TQueryKey extends QueryKey = QueryKey
    >(
        queryKey: TQueryKey,
        queryFn: QueryFunction<TQueryFnData, TQueryKey>,
        options?: FetchQueryOptions<TQueryFnData, TError, TData, TQueryKey>
    ): Promise<TData>;
};

method getDefaultOptions

getDefaultOptions: () => DefaultOptions;

method getMutationCache

getMutationCache: () => MutationCache;

method getMutationDefaults

getMutationDefaults: (
    mutationKey?: MutationKey
) => MutationObserverOptions<any, any, any, any> | undefined;

method getQueriesData

getQueriesData: {
    <TData = unknown>(queryKey: QueryKey): [QueryKey, TData][];
    <TData = unknown>(filters: QueryFilters): [QueryKey, TData][];
};

method getQueryCache

getQueryCache: () => QueryCache;

method getQueryData

getQueryData: <TData = unknown>(
    queryKey: QueryKey,
    filters?: QueryFilters
) => TData | undefined;

method getQueryDefaults

getQueryDefaults: (
    queryKey?: QueryKey
) => QueryObserverOptions<any, any, any, any, any> | undefined;

method getQueryState

getQueryState: <TData = unknown, TError = undefined>(
    queryKey: QueryKey,
    filters?: QueryFilters
) => QueryState<TData, TError> | undefined;

method invalidateQueries

invalidateQueries: {
    <TPageData = unknown>(
        filters?: InvalidateQueryFilters<TPageData>,
        options?: InvalidateOptions
    ): Promise<void>;
    <TPageData = unknown>(
        queryKey?: QueryKey,
        filters?: InvalidateQueryFilters<TPageData>,
        options?: InvalidateOptions
    ): Promise<void>;
};

method isFetching

isFetching: {
    (filters?: QueryFilters): number;
    (queryKey?: QueryKey, filters?: QueryFilters): number;
};

method isMutating

isMutating: (filters?: MutationFilters) => number;

method mount

mount: () => void;

method prefetchInfiniteQuery

prefetchInfiniteQuery: {
    <
        TQueryFnData = unknown,
        TError = unknown,
        TData = TQueryFnData,
        TQueryKey extends QueryKey = QueryKey
    >(
        options: FetchInfiniteQueryOptions<
            TQueryFnData,
            TError,
            TData,
            TQueryKey
        >
    ): Promise<void>;
    <
        TQueryFnData = unknown,
        TError = unknown,
        TData = TQueryFnData,
        TQueryKey extends QueryKey = QueryKey
    >(
        queryKey: TQueryKey,
        options?: FetchInfiniteQueryOptions<
            TQueryFnData,
            TError,
            TData,
            TQueryKey
        >
    ): Promise<void>;
    <
        TQueryFnData = unknown,
        TError = unknown,
        TData = TQueryFnData,
        TQueryKey extends QueryKey = QueryKey
    >(
        queryKey: TQueryKey,
        queryFn: QueryFunction<TQueryFnData, TQueryKey>,
        options?: FetchInfiniteQueryOptions<
            TQueryFnData,
            TError,
            TData,
            TQueryKey
        >
    ): Promise<void>;
};

method prefetchQuery

prefetchQuery: {
    <
        TQueryFnData = unknown,
        TError = unknown,
        TData = TQueryFnData,
        TQueryKey extends QueryKey = QueryKey
    >(
        options: FetchQueryOptions<TQueryFnData, TError, TData, TQueryKey>
    ): Promise<void>;
    <
        TQueryFnData = unknown,
        TError = unknown,
        TData = TQueryFnData,
        TQueryKey extends QueryKey = QueryKey
    >(
        queryKey: TQueryKey,
        options?: FetchQueryOptions<TQueryFnData, TError, TData, TQueryKey>
    ): Promise<void>;
    <
        TQueryFnData = unknown,
        TError = unknown,
        TData = TQueryFnData,
        TQueryKey extends QueryKey = QueryKey
    >(
        queryKey: TQueryKey,
        queryFn: QueryFunction<TQueryFnData, TQueryKey>,
        options?: FetchQueryOptions<TQueryFnData, TError, TData, TQueryKey>
    ): Promise<void>;
};

method refetchQueries

refetchQueries: {
    <TPageData = unknown>(
        filters?: RefetchQueryFilters<TPageData>,
        options?: RefetchOptions
    ): Promise<void>;
    <TPageData = unknown>(
        queryKey?: QueryKey,
        filters?: RefetchQueryFilters<TPageData>,
        options?: RefetchOptions
    ): Promise<void>;
};

method removeQueries

removeQueries: {
    (filters?: QueryFilters): void;
    (queryKey?: QueryKey, filters?: QueryFilters): void;
};

method resetQueries

resetQueries: {
    <TPageData = unknown>(
        filters?: ResetQueryFilters<TPageData>,
        options?: ResetOptions
    ): Promise<void>;
    <TPageData = unknown>(
        queryKey?: QueryKey,
        filters?: ResetQueryFilters<TPageData>,
        options?: ResetOptions
    ): Promise<void>;
};

method resumePausedMutations

resumePausedMutations: () => Promise<void>;

method setDefaultOptions

setDefaultOptions: (options: DefaultOptions) => void;

method setMutationDefaults

setMutationDefaults: (
    mutationKey: MutationKey,
    options: MutationObserverOptions<any, any, any, any>
) => void;

method setQueriesData

setQueriesData: {
    <TData>(
        queryKey: QueryKey,
        updater: Updater<TData | undefined, TData>,
        options?: SetDataOptions
    ): [QueryKey, TData][];
    <TData>(
        filters: QueryFilters,
        updater: Updater<TData, TData>,
        options?: SetDataOptions
    ): [QueryKey, TData][];
};

method setQueryData

setQueryData: <TData>(
    queryKey: QueryKey,
    updater: Updater<TData | undefined, TData>,
    options?: SetDataOptions
) => TData;

method setQueryDefaults

setQueryDefaults: (
    queryKey: QueryKey,
    options: QueryObserverOptions<any, any, any, any>
) => void;

method unmount

unmount: () => void;

class QueryObserver

class QueryObserver<
    TQueryFnData = unknown,
    TError = unknown,
    TData = TQueryFnData,
    TQueryData = TQueryFnData,
    TQueryKey extends QueryKey = QueryKey
> extends Subscribable<QueryObserverListener<TData, TError>> {}

constructor

constructor(
    client: QueryClient,
    options: QueryObserverOptions<
        TQueryFnData,
        TError,
        TData,
        TQueryData,
        TQueryKey
    >
);

property options

options: QueryObserverOptions<
    TQueryFnData,
    TError,
    TData,
    TQueryData,
    TQueryKey
>;

method bindMethods

protected bindMethods: () => void;

method createResult

protected createResult: (
    query: Query<TQueryFnData, TError, TQueryData, TQueryKey>,
    options: QueryObserverOptions<
        TQueryFnData,
        TError,
        TData,
        TQueryData,
        TQueryKey
    >
) => QueryObserverResult<TData, TError>;

method destroy

destroy: () => void;

method fetch

protected fetch: (
    fetchOptions?: ObserverFetchOptions
) => Promise<QueryObserverResult<TData, TError>>;

method fetchOptimistic

fetchOptimistic: (
    options: QueryObserverOptions<
        TQueryFnData,
        TError,
        TData,
        TQueryData,
        TQueryKey
    >
) => Promise<QueryObserverResult<TData, TError>>;

method getCurrentQuery

getCurrentQuery: () => Query<TQueryFnData, TError, TQueryData, TQueryKey>;

method getCurrentResult

getCurrentResult: () => QueryObserverResult<TData, TError>;

method getNextResult

getNextResult: (
    options?: ResultOptions
) => Promise<QueryObserverResult<TData, TError>>;

method getOptimisticResult

getOptimisticResult: (
    options: QueryObserverOptions<
        TQueryFnData,
        TError,
        TData,
        TQueryData,
        TQueryKey
    >
) => QueryObserverResult<TData, TError>;

method onQueryUpdate

onQueryUpdate: (action: Action<TData, TError>) => void;

method onSubscribe

protected onSubscribe: () => void;

method onUnsubscribe

protected onUnsubscribe: () => void;

method refetch

refetch: <TPageData>(
    options?: RefetchOptions & RefetchQueryFilters<TPageData>
) => Promise<QueryObserverResult<TData, TError>>;

method remove

remove: () => void;

method setOptions

setOptions: (
    options?: QueryObserverOptions<
        TQueryFnData,
        TError,
        TData,
        TQueryData,
        TQueryKey
    >,
    notifyOptions?: NotifyOptions
) => void;

method shouldFetchOnReconnect

shouldFetchOnReconnect: () => boolean;

method shouldFetchOnWindowFocus

shouldFetchOnWindowFocus: () => boolean;

method trackResult

trackResult: (
    result: QueryObserverResult<TData, TError>,
    defaultedOptions: QueryObserverOptions<
        TQueryFnData,
        TError,
        TData,
        TQueryData,
        TQueryKey
    >
) => QueryObserverResult<TData, TError>;

method updateResult

updateResult: (notifyOptions?: NotifyOptions) => void;

Interfaces

interface CancelOptions

interface CancelOptions {}

property revert

revert?: boolean;

property silent

silent?: boolean;

interface DefaultOptions

interface DefaultOptions<TError = unknown> {}

property mutations

mutations?: MutationObserverOptions<unknown, TError, unknown, unknown>;

property queries

queries?: QueryObserverOptions<unknown, TError>;

interface DehydratedState

interface DehydratedState {}

property mutations

mutations: DehydratedMutation[];

property queries

queries: DehydratedQuery[];

interface DehydrateOptions

interface DehydrateOptions {}

property dehydrateMutations

dehydrateMutations?: boolean;

property dehydrateQueries

dehydrateQueries?: boolean;

property shouldDehydrateMutation

shouldDehydrateMutation?: ShouldDehydrateMutationFunction;

property shouldDehydrateQuery

shouldDehydrateQuery?: ShouldDehydrateQueryFunction;

interface FetchInfiniteQueryOptions

interface FetchInfiniteQueryOptions<
    TQueryFnData = unknown,
    TError = unknown,
    TData = TQueryFnData,
    TQueryKey extends QueryKey = QueryKey
> extends FetchQueryOptions<TQueryFnData, TError, InfiniteData<TData>, TQueryKey> {}

interface FetchNextPageOptions

interface FetchNextPageOptions extends ResultOptions {}

property cancelRefetch

cancelRefetch?: boolean;

property pageParam

pageParam?: unknown;

interface FetchPreviousPageOptions

interface FetchPreviousPageOptions extends ResultOptions {}

property cancelRefetch

cancelRefetch?: boolean;

property pageParam

pageParam?: unknown;

interface FetchQueryOptions

interface FetchQueryOptions<
    TQueryFnData = unknown,
    TError = unknown,
    TData = TQueryFnData,
    TQueryKey extends QueryKey = QueryKey
> extends QueryOptions<TQueryFnData, TError, TData, TQueryKey> {}

property staleTime

staleTime?: number;

The time in milliseconds after data is considered stale. If the data is fresh it will be returned from the cache.

interface HydrateOptions

interface HydrateOptions {}

property defaultOptions

defaultOptions?: {
    queries?: QueryOptions;
    mutations?: MutationOptions;
};

interface HydrateProps

interface HydrateProps {}

property children

children?: React.ReactNode;

property options

options?: HydrateOptions;

property state

state?: unknown;

interface InfiniteData

interface InfiniteData<TData> {}

property pageParams

pageParams: unknown[];

property pages

pages: TData[];

interface InfiniteQueryObserverBaseResult

interface InfiniteQueryObserverBaseResult<TData = unknown, TError = unknown>
    extends QueryObserverBaseResult<InfiniteData<TData>, TError> {}

property fetchNextPage

fetchNextPage: (
    options?: FetchNextPageOptions
) => Promise<InfiniteQueryObserverResult<TData, TError>>;

property fetchPreviousPage

fetchPreviousPage: (
    options?: FetchPreviousPageOptions
) => Promise<InfiniteQueryObserverResult<TData, TError>>;

property hasNextPage

hasNextPage?: boolean;

property hasPreviousPage

hasPreviousPage?: boolean;

property isFetchingNextPage

isFetchingNextPage: boolean;

property isFetchingPreviousPage

isFetchingPreviousPage: boolean;

interface InfiniteQueryObserverIdleResult

interface InfiniteQueryObserverIdleResult<TData = unknown, TError = unknown>
    extends InfiniteQueryObserverBaseResult<TData, TError> {}

property data

data: undefined;

property error

error: null;

property isError

isError: false;

property isIdle

isIdle: true;

property isLoading

isLoading: false;

property isLoadingError

isLoadingError: false;

property isRefetchError

isRefetchError: false;

property isSuccess

isSuccess: false;

property status

status: 'idle';

interface InfiniteQueryObserverLoadingErrorResult

interface InfiniteQueryObserverLoadingErrorResult<TData = unknown, TError = unknown>
    extends InfiniteQueryObserverBaseResult<TData, TError> {}

property data

data: undefined;

property error

error: TError;

property isError

isError: true;

property isIdle

isIdle: false;

property isLoading

isLoading: false;

property isLoadingError

isLoadingError: true;

property isRefetchError

isRefetchError: false;

property isSuccess

isSuccess: false;

property status

status: 'error';

interface InfiniteQueryObserverLoadingResult

interface InfiniteQueryObserverLoadingResult<TData = unknown, TError = unknown>
    extends InfiniteQueryObserverBaseResult<TData, TError> {}

property data

data: undefined;

property error

error: null;

property isError

isError: false;

property isIdle

isIdle: false;

property isLoading

isLoading: true;

property isLoadingError

isLoadingError: false;

property isRefetchError

isRefetchError: false;

property isSuccess

isSuccess: false;

property status

status: 'loading';

interface InfiniteQueryObserverOptions

interface InfiniteQueryObserverOptions<
    TQueryFnData = unknown,
    TError = unknown,
    TData = TQueryFnData,
    TQueryData = TQueryFnData,
    TQueryKey extends QueryKey = QueryKey
> extends QueryObserverOptions<
        TQueryFnData,
        TError,
        InfiniteData<TData>,
        InfiniteData<TQueryData>,
        TQueryKey
    > {}

interface InfiniteQueryObserverRefetchErrorResult

interface InfiniteQueryObserverRefetchErrorResult<TData = unknown, TError = unknown>
    extends InfiniteQueryObserverBaseResult<TData, TError> {}

property data

data: InfiniteData<TData>;

property error

error: TError;

property isError

isError: true;

property isIdle

isIdle: false;

property isLoading

isLoading: false;

property isLoadingError

isLoadingError: false;

property isRefetchError

isRefetchError: true;

property isSuccess

isSuccess: false;

property status

status: 'error';

interface InfiniteQueryObserverSuccessResult

interface InfiniteQueryObserverSuccessResult<TData = unknown, TError = unknown>
    extends InfiniteQueryObserverBaseResult<TData, TError> {}

property data

data: InfiniteData<TData>;

property error

error: null;

property isError

isError: false;

property isIdle

isIdle: false;

property isLoading

isLoading: false;

property isLoadingError

isLoadingError: false;

property isRefetchError

isRefetchError: false;

property isSuccess

isSuccess: true;

property status

status: 'success';

interface InvalidateOptions

interface InvalidateOptions extends RefetchOptions {}

interface InvalidateQueryFilters

interface InvalidateQueryFilters<TPageData = unknown>
    extends QueryFilters,
        RefetchPageFilters<TPageData> {}

property refetchActive

refetchActive?: boolean;

property refetchInactive

refetchInactive?: boolean;

interface Logger

interface Logger {}

property error

error: LogFunction;

property log

log: LogFunction;

property warn

warn: LogFunction;

interface MutateOptions

interface MutateOptions<
    TData = unknown,
    TError = unknown,
    TVariables = void,
    TContext = unknown
> {}

property onError

onError?: (
    error: TError,
    variables: TVariables,
    context: TContext | undefined
) => Promise<unknown> | void;

property onSettled

onSettled?: (
    data: TData | undefined,
    error: TError | null,
    variables: TVariables,
    context: TContext | undefined
) => Promise<unknown> | void;

property onSuccess

onSuccess?: (
    data: TData,
    variables: TVariables,
    context: TContext
) => Promise<unknown> | void;

interface MutationObserverBaseResult

interface MutationObserverBaseResult<
    TData = unknown,
    TError = unknown,
    TVariables = void,
    TContext = unknown
> extends MutationState<TData, TError, TVariables, TContext> {}

property isError

isError: boolean;

property isIdle

isIdle: boolean;

property isLoading

isLoading: boolean;

property isSuccess

isSuccess: boolean;

property mutate

mutate: MutateFunction<TData, TError, TVariables, TContext>;

property reset

reset: () => void;

interface MutationObserverErrorResult

interface MutationObserverErrorResult<
    TData = unknown,
    TError = unknown,
    TVariables = void,
    TContext = unknown
> extends MutationObserverBaseResult<TData, TError, TVariables, TContext> {}

property data

data: undefined;

property error

error: TError;

property isError

isError: true;

property isIdle

isIdle: false;

property isLoading

isLoading: false;

property isSuccess

isSuccess: false;

property status

status: 'error';

interface MutationObserverIdleResult

interface MutationObserverIdleResult<
    TData = unknown,
    TError = unknown,
    TVariables = void,
    TContext = unknown
> extends MutationObserverBaseResult<TData, TError, TVariables, TContext> {}

property data

data: undefined;

property error

error: null;

property isError

isError: false;

property isIdle

isIdle: true;

property isLoading

isLoading: false;

property isSuccess

isSuccess: false;

property status

status: 'idle';

interface MutationObserverLoadingResult

interface MutationObserverLoadingResult<
    TData = unknown,
    TError = unknown,
    TVariables = void,
    TContext = unknown
> extends MutationObserverBaseResult<TData, TError, TVariables, TContext> {}

property data

data: undefined;

property error

error: null;

property isError

isError: false;

property isIdle

isIdle: false;

property isLoading

isLoading: true;

property isSuccess

isSuccess: false;

property status

status: 'loading';

interface MutationObserverOptions

interface MutationObserverOptions<
    TData = unknown,
    TError = unknown,
    TVariables = void,
    TContext = unknown
> extends MutationOptions<TData, TError, TVariables, TContext> {}

property useErrorBoundary

useErrorBoundary?: boolean | ((error: TError) => boolean);

interface MutationObserverSuccessResult

interface MutationObserverSuccessResult<
    TData = unknown,
    TError = unknown,
    TVariables = void,
    TContext = unknown
> extends MutationObserverBaseResult<TData, TError, TVariables, TContext> {}

property data

data: TData;

property error

error: null;

property isError

isError: false;

property isIdle

isIdle: false;

property isLoading

isLoading: false;

property isSuccess

isSuccess: true;

property status

status: 'success';

interface MutationOptions

interface MutationOptions<
    TData = unknown,
    TError = unknown,
    TVariables = void,
    TContext = unknown
> {}

property meta

meta?: MutationMeta;

property mutationFn

mutationFn?: MutationFunction<TData, TVariables>;

property mutationKey

mutationKey?: MutationKey;

property onError

onError?: (
    error: TError,
    variables: TVariables,
    context: TContext | undefined
) => Promise<unknown> | void;

property onMutate

onMutate?: (
    variables: TVariables
) => Promise<TContext | undefined> | TContext | undefined;

property onSettled

onSettled?: (
    data: TData | undefined,
    error: TError | null,
    variables: TVariables,
    context: TContext | undefined
) => Promise<unknown> | void;

property onSuccess

onSuccess?: (
    data: TData,
    variables: TVariables,
    context: TContext | undefined
) => Promise<unknown> | void;

property retry

retry?: RetryValue<TError>;

property retryDelay

retryDelay?: RetryDelayValue<TError>;

property variables

variables?: TVariables;

interface QueryClientConfig

interface QueryClientConfig {}

property defaultOptions

defaultOptions?: DefaultOptions;

property mutationCache

mutationCache?: MutationCache;

property queryCache

queryCache?: QueryCache;

interface QueryClientProviderProps

interface QueryClientProviderProps {}

property children

children?: React.ReactNode;

property client

client: QueryClient;

property contextSharing

contextSharing?: boolean;

interface QueryErrorResetBoundaryProps

interface QueryErrorResetBoundaryProps {}

property children

children:
    | ((value: QueryErrorResetBoundaryValue) => React.ReactNode)
    | React.ReactNode;

interface QueryFunctionContext

interface QueryFunctionContext<
    TQueryKey extends QueryKey = QueryKey,
    TPageParam = any
> {}

property meta

meta: QueryMeta | undefined;

property pageParam

pageParam?: TPageParam;

property queryKey

queryKey: EnsuredQueryKey<TQueryKey>;

property signal

signal?: AbortSignal;

interface QueryObserverBaseResult

interface QueryObserverBaseResult<TData = unknown, TError = unknown> {}

property data

data: TData | undefined;

property dataUpdatedAt

dataUpdatedAt: number;

property error

error: TError | null;

property errorUpdateCount

errorUpdateCount: number;

property errorUpdatedAt

errorUpdatedAt: number;

property failureCount

failureCount: number;

property isError

isError: boolean;

property isFetched

isFetched: boolean;

property isFetchedAfterMount

isFetchedAfterMount: boolean;

property isFetching

isFetching: boolean;

property isIdle

isIdle: boolean;

property isLoading

isLoading: boolean;

property isLoadingError

isLoadingError: boolean;

property isPlaceholderData

isPlaceholderData: boolean;

property isPreviousData

isPreviousData: boolean;

property isRefetchError

isRefetchError: boolean;

property isRefetching

isRefetching: boolean;

property isStale

isStale: boolean;

property isSuccess

isSuccess: boolean;

property refetch

refetch: <TPageData>(
    options?: RefetchOptions & RefetchQueryFilters<TPageData>
) => Promise<QueryObserverResult<TData, TError>>;

property remove

remove: () => void;

property status

status: QueryStatus;

interface QueryObserverIdleResult

interface QueryObserverIdleResult<TData = unknown, TError = unknown>
    extends QueryObserverBaseResult<TData, TError> {}

property data

data: undefined;

property error

error: null;

property isError

isError: false;

property isIdle

isIdle: true;

property isLoading

isLoading: false;

property isLoadingError

isLoadingError: false;

property isRefetchError

isRefetchError: false;

property isSuccess

isSuccess: false;

property status

status: 'idle';

interface QueryObserverLoadingErrorResult

interface QueryObserverLoadingErrorResult<TData = unknown, TError = unknown>
    extends QueryObserverBaseResult<TData, TError> {}

property data

data: undefined;

property error

error: TError;

property isError

isError: true;

property isIdle

isIdle: false;

property isLoading

isLoading: false;

property isLoadingError

isLoadingError: true;

property isRefetchError

isRefetchError: false;

property isSuccess

isSuccess: false;

property status

status: 'error';

interface QueryObserverLoadingResult

interface QueryObserverLoadingResult<TData = unknown, TError = unknown>
    extends QueryObserverBaseResult<TData, TError> {}

property data

data: undefined;

property error

error: null;

property isError

isError: false;

property isIdle

isIdle: false;

property isLoading

isLoading: true;

property isLoadingError

isLoadingError: false;

property isRefetchError

isRefetchError: false;

property isSuccess

isSuccess: false;

property status

status: 'loading';

interface QueryObserverOptions

interface QueryObserverOptions<
    TQueryFnData = unknown,
    TError = unknown,
    TData = TQueryFnData,
    TQueryData = TQueryFnData,
    TQueryKey extends QueryKey = QueryKey
> extends QueryOptions<TQueryFnData, TError, TQueryData, TQueryKey> {}

property enabled

enabled?: boolean;

Set this to false to disable automatic refetching when the query mounts or changes query keys. To refetch the query, use the refetch method returned from the useQuery instance. Defaults to true.

property keepPreviousData

keepPreviousData?: boolean;

Set this to true to keep the previous data when fetching based on a new query key. Defaults to false.

property notifyOnChangeProps

notifyOnChangeProps?: Array<keyof InfiniteQueryObserverResult> | 'tracked';

If set, the component will only re-render if any of the listed properties change. When set to ['data', 'error'], the component will only re-render when the data or error properties change. When set to tracked, access to properties will be tracked, and the component will only re-render when one of the tracked properties change.

property notifyOnChangePropsExclusions

notifyOnChangePropsExclusions?: Array<keyof InfiniteQueryObserverResult>;

If set, the component will not re-render if any of the listed properties change.

property onError

onError?: (err: TError) => void;

This callback will fire if the query encounters an error and will be passed the error.

property onSettled

onSettled?: (data: TData | undefined, error: TError | null) => void;

This callback will fire any time the query is either successfully fetched or errors and be passed either the data or error.

property onSuccess

onSuccess?: (data: TData) => void;

This callback will fire any time the query successfully fetches new data or the cache is updated via setQueryData.

property optimisticResults

optimisticResults?: boolean;

If set, the observer will optimistically set the result in fetching state before the query has actually started fetching. This is to make sure the results are not lagging behind. Defaults to true.

property placeholderData

placeholderData?: TQueryData | PlaceholderDataFunction<TQueryData>;

If set, this value will be used as the placeholder data for this particular query observer while the query is still in the loading data and no initialData has been provided.

property refetchInterval

refetchInterval?:
    | number
    | false
    | ((
          data: TData | undefined,
          query: Query<TQueryFnData, TError, TQueryData, TQueryKey>
      ) => number | false);

If set to a number, the query will continuously refetch at this frequency in milliseconds. If set to a function, the function will be executed with the latest data and query to compute a frequency Defaults to false.

property refetchIntervalInBackground

refetchIntervalInBackground?: boolean;

If set to true, the query will continue to refetch while their tab/window is in the background. Defaults to false.

property refetchOnMount

refetchOnMount?:
    | boolean
    | 'always'
    | ((
          query: Query<TQueryFnData, TError, TQueryData, TQueryKey>
      ) => boolean | 'always');

If set to true, the query will refetch on mount if the data is stale. If set to false, will disable additional instances of a query to trigger background refetches. If set to 'always', the query will always refetch on mount. If set to a function, the function will be executed with the latest data and query to compute the value Defaults to true.

property refetchOnReconnect

refetchOnReconnect?:
    | boolean
    | 'always'
    | ((
          query: Query<TQueryFnData, TError, TQueryData, TQueryKey>
      ) => boolean | 'always');

If set to true, the query will refetch on reconnect if the data is stale. If set to false, the query will not refetch on reconnect. If set to 'always', the query will always refetch on reconnect. If set to a function, the function will be executed with the latest data and query to compute the value. Defaults to true.

property refetchOnWindowFocus

refetchOnWindowFocus?:
    | boolean
    | 'always'
    | ((
          query: Query<TQueryFnData, TError, TQueryData, TQueryKey>
      ) => boolean | 'always');

If set to true, the query will refetch on window focus if the data is stale. If set to false, the query will not refetch on window focus. If set to 'always', the query will always refetch on window focus. If set to a function, the function will be executed with the latest data and query to compute the value. Defaults to true.

property retryOnMount

retryOnMount?: boolean;

If set to false, the query will not be retried on mount if it contains an error. Defaults to true.

property select

select?: (data: TQueryData) => TData;

This option can be used to transform or select a part of the data returned by the query function.

property staleTime

staleTime?: number;

The time in milliseconds after data is considered stale. If set to Infinity, the data will never be considered stale.

property suspense

suspense?: boolean;

If set to true, the query will suspend when status === 'loading' and throw errors when status === 'error'. Defaults to false.

property useErrorBoundary

useErrorBoundary?:
    | boolean
    | ((
          error: TError,
          query: Query<TQueryFnData, TError, TQueryData, TQueryKey>
      ) => boolean);

Whether errors should be thrown instead of setting the error property. If set to true or suspense is true, all errors will be thrown to the error boundary. If set to false and suspense is false, errors are returned as state. If set to a function, it will be passed the error and the query, and it should return a boolean indicating whether to show the error in an error boundary (true) or return the error as state (false). Defaults to false.

interface QueryObserverRefetchErrorResult

interface QueryObserverRefetchErrorResult<TData = unknown, TError = unknown>
    extends QueryObserverBaseResult<TData, TError> {}

property data

data: TData;

property error

error: TError;

property isError

isError: true;

property isIdle

isIdle: false;

property isLoading

isLoading: false;

property isLoadingError

isLoadingError: false;

property isRefetchError

isRefetchError: true;

property isSuccess

isSuccess: false;

property status

status: 'error';

interface QueryObserverSuccessResult

interface QueryObserverSuccessResult<TData = unknown, TError = unknown>
    extends QueryObserverBaseResult<TData, TError> {}

property data

data: TData;

property error

error: null;

property isError

isError: false;

property isIdle

isIdle: false;

property isLoading

isLoading: false;

property isLoadingError

isLoadingError: false;

property isRefetchError

isRefetchError: false;

property isSuccess

isSuccess: true;

property status

status: 'success';

interface QueryOptions

interface QueryOptions<
    TQueryFnData = unknown,
    TError = unknown,
    TData = TQueryFnData,
    TQueryKey extends QueryKey = QueryKey
> {}

property behavior

behavior?: QueryBehavior<TQueryFnData, TError, TData>;

property cacheTime

cacheTime?: number;

property getNextPageParam

getNextPageParam?: GetNextPageParamFunction<TQueryFnData>;

This function can be set to automatically get the next cursor for infinite queries. The result will also be used to determine the value of hasNextPage.

property getPreviousPageParam

getPreviousPageParam?: GetPreviousPageParamFunction<TQueryFnData>;

This function can be set to automatically get the previous cursor for infinite queries. The result will also be used to determine the value of hasPreviousPage.

property initialData

initialData?: TData | InitialDataFunction<TData>;

property initialDataUpdatedAt

initialDataUpdatedAt?: number | (() => number | undefined);

property isDataEqual

isDataEqual?: (oldData: TData | undefined, newData: TData) => boolean;

property meta

meta?: QueryMeta;

Additional payload to be stored on each query. Use this property to pass information that can be used in other places.

property queryFn

queryFn?: QueryFunction<TQueryFnData, TQueryKey>;

property queryHash

queryHash?: string;

property queryKey

queryKey?: TQueryKey;

property queryKeyHashFn

queryKeyHashFn?: QueryKeyHashFunction<TQueryKey>;

property retry

retry?: RetryValue<TError>;

If false, failed queries will not retry by default. If true, failed queries will retry infinitely., failureCount: num If set to an integer number, e.g. 3, failed queries will retry until the failed query count meets that number. If set to a function (failureCount, error) => boolean failed queries will retry until the function returns false.

property retryDelay

retryDelay?: RetryDelayValue<TError>;

property structuralSharing

structuralSharing?: boolean;

Set this to false to disable structural sharing between query results. Defaults to true.

interface RefetchOptions

interface RefetchOptions extends ResultOptions {}

property cancelRefetch

cancelRefetch?: boolean;

interface RefetchPageFilters

interface RefetchPageFilters<TPageData = unknown> {}

property refetchPage

refetchPage?: (
    lastPage: TPageData,
    index: number,
    allPages: TPageData[]
) => boolean;

interface RefetchQueryFilters

interface RefetchQueryFilters<TPageData = unknown>
    extends QueryFilters,
        RefetchPageFilters<TPageData> {}

interface ResetOptions

interface ResetOptions extends RefetchOptions {}

interface ResetQueryFilters

interface ResetQueryFilters<TPageData = unknown>
    extends QueryFilters,
        RefetchPageFilters<TPageData> {}

interface ResultOptions

interface ResultOptions {}

property throwOnError

throwOnError?: boolean;

interface SetDataOptions

interface SetDataOptions {}

property updatedAt

updatedAt?: number;

interface UseBaseQueryOptions

interface UseBaseQueryOptions<
    TQueryFnData = unknown,
    TError = unknown,
    TData = TQueryFnData,
    TQueryData = TQueryFnData,
    TQueryKey extends QueryKey = QueryKey
> extends QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey> {}

interface UseInfiniteQueryOptions

interface UseInfiniteQueryOptions<
    TQueryFnData = unknown,
    TError = unknown,
    TData = TQueryFnData,
    TQueryData = TQueryFnData,
    TQueryKey extends QueryKey = QueryKey
> extends InfiniteQueryObserverOptions<
        TQueryFnData,
        TError,
        TData,
        TQueryData,
        TQueryKey
    > {}

interface UseMutationOptions

interface UseMutationOptions<
    TData = unknown,
    TError = unknown,
    TVariables = void,
    TContext = unknown
> extends Omit<
        MutationObserverOptions<TData, TError, TVariables, TContext>,
        '_defaulted' | 'variables'
    > {}

interface UseQueryOptions

interface UseQueryOptions<
    TQueryFnData = unknown,
    TError = unknown,
    TData = TQueryFnData,
    TQueryKey extends QueryKey = QueryKey
> extends UseBaseQueryOptions<
        TQueryFnData,
        TError,
        TData,
        TQueryFnData,
        TQueryKey
    > {}

Type Aliases

type EnsuredQueryKey

type EnsuredQueryKey<T extends QueryKey> = T extends string
    ? [T]
    : Exclude<T, string>;

type GetNextPageParamFunction

type GetNextPageParamFunction<TQueryFnData = unknown> = (
    lastPage: TQueryFnData,
    allPages: TQueryFnData[]
) => unknown;

type GetPreviousPageParamFunction

type GetPreviousPageParamFunction<TQueryFnData = unknown> = (
    firstPage: TQueryFnData,
    allPages: TQueryFnData[]
) => unknown;

type InfiniteQueryObserverResult

type InfiniteQueryObserverResult<TData = unknown, TError = unknown> =
    | InfiniteQueryObserverIdleResult<TData, TError>
    | InfiniteQueryObserverLoadingErrorResult<TData, TError>
    | InfiniteQueryObserverLoadingResult<TData, TError>
    | InfiniteQueryObserverRefetchErrorResult<TData, TError>
    | InfiniteQueryObserverSuccessResult<TData, TError>;

type InitialDataFunction

type InitialDataFunction<T> = () => T | undefined;

type MutateFunction

type MutateFunction<
    TData = unknown,
    TError = unknown,
    TVariables = void,
    TContext = unknown
> = (
    variables: TVariables,
    options?: MutateOptions<TData, TError, TVariables, TContext>
) => Promise<TData>;

type MutationFunction

type MutationFunction<TData = unknown, TVariables = unknown> = (
    variables: TVariables
) => Promise<TData>;

type MutationKey

type MutationKey = string | readonly unknown[];

type MutationMeta

type MutationMeta = Record<string, unknown>;

type MutationObserverResult

type MutationObserverResult<
    TData = unknown,
    TError = unknown,
    TVariables = void,
    TContext = unknown
> =
    | MutationObserverIdleResult<TData, TError, TVariables, TContext>
    | MutationObserverLoadingResult<TData, TError, TVariables, TContext>
    | MutationObserverErrorResult<TData, TError, TVariables, TContext>
    | MutationObserverSuccessResult<TData, TError, TVariables, TContext>;

type MutationStatus

type MutationStatus = 'idle' | 'loading' | 'success' | 'error';

type PlaceholderDataFunction

type PlaceholderDataFunction<TResult> = () => TResult | undefined;

type QueriesOptions

type QueriesOptions<
    T extends any[],
    Result extends any[] = [],
    Depth extends ReadonlyArray<number> = []
> = Depth['length'] extends MAXIMUM_DEPTH
    ? UseQueryOptions[]
    : T extends []
    ? []
    : T extends [infer Head]
    ? [...Result, GetOptions<Head>]
    : T extends [infer Head, ...infer Tail]
    ? QueriesOptions<[...Tail], [...Result, GetOptions<Head>], [...Depth, 1]>
    : unknown[] extends T
    ? T
    : T extends UseQueryOptions<
          infer TQueryFnData,
          infer TError,
          infer TData,
          infer TQueryKey
      >[]
    ? UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>[]
    : UseQueryOptions[];

QueriesOptions reducer recursively unwraps function arguments to infer/enforce type param

type QueriesResults

type QueriesResults<
    T extends any[],
    Result extends any[] = [],
    Depth extends ReadonlyArray<number> = []
> = Depth['length'] extends MAXIMUM_DEPTH
    ? UseQueryResult[]
    : T extends []
    ? []
    : T extends [infer Head]
    ? [...Result, GetResults<Head>]
    : T extends [infer Head, ...infer Tail]
    ? QueriesResults<[...Tail], [...Result, GetResults<Head>], [...Depth, 1]>
    : T extends UseQueryOptions<infer TQueryFnData, infer TError, infer TData, any>[]
    ? UseQueryResult<unknown extends TData ? TQueryFnData : TData, TError>[]
    : UseQueryResult[];

QueriesResults reducer recursively maps type param to results

type QueryFunction

type QueryFunction<T = unknown, TQueryKey extends QueryKey = QueryKey> = (
    context: QueryFunctionContext<TQueryKey>
) => T | Promise<T>;

type QueryKey

type QueryKey = string | readonly unknown[];

type QueryKeyHashFunction

type QueryKeyHashFunction<TQueryKey extends QueryKey> = (
    queryKey: TQueryKey
) => string;

type QueryMeta

type QueryMeta = Record<string, unknown>;

type QueryObserverResult

type QueryObserverResult<TData = unknown, TError = unknown> =
    | QueryObserverIdleResult<TData, TError>
    | QueryObserverLoadingErrorResult<TData, TError>
    | QueryObserverLoadingResult<TData, TError>
    | QueryObserverRefetchErrorResult<TData, TError>
    | QueryObserverSuccessResult<TData, TError>;

type QueryStatus

type QueryStatus = 'idle' | 'loading' | 'error' | 'success';

type ShouldDehydrateMutationFunction

type ShouldDehydrateMutationFunction = (mutation: Mutation) => boolean;

type ShouldDehydrateQueryFunction

type ShouldDehydrateQueryFunction = (query: Query) => boolean;

type UseBaseMutationResult

type UseBaseMutationResult<
    TData = unknown,
    TError = unknown,
    TVariables = unknown,
    TContext = unknown
> = Override<
    MutationObserverResult<TData, TError, TVariables, TContext>,
    {
        mutate: UseMutateFunction<TData, TError, TVariables, TContext>;
    }
> & {
    mutateAsync: UseMutateAsyncFunction<TData, TError, TVariables, TContext>;
};

type UseBaseQueryResult

type UseBaseQueryResult<TData = unknown, TError = unknown> = QueryObserverResult<
    TData,
    TError
>;

type UseInfiniteQueryResult

type UseInfiniteQueryResult<
    TData = unknown,
    TError = unknown
> = InfiniteQueryObserverResult<TData, TError>;

type UseMutateAsyncFunction

type UseMutateAsyncFunction<
    TData = unknown,
    TError = unknown,
    TVariables = void,
    TContext = unknown
> = MutateFunction<TData, TError, TVariables, TContext>;

type UseMutateFunction

type UseMutateFunction<
    TData = unknown,
    TError = unknown,
    TVariables = void,
    TContext = unknown
> = (
    ...args: Parameters<MutateFunction<TData, TError, TVariables, TContext>>
) => void;

type UseMutationResult

type UseMutationResult<
    TData = unknown,
    TError = unknown,
    TVariables = unknown,
    TContext = unknown
> = UseBaseMutationResult<TData, TError, TVariables, TContext>;

type UseQueryResult

type UseQueryResult<TData = unknown, TError = unknown> = UseBaseQueryResult<
    TData,
    TError
>;

Dependencies (3)

Dev Dependencies (55)

Peer Dependencies (1)

react

Badge

To add a badge like this oneto your package's README, use the codes available below.

You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/react-query.

Markdown

[![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/react-query)

HTML

<a href="https://www.jsdocs.io/package/react-query"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>

Updated 2 years ago.
Package analyzed in 8343 ms.
Missing or incorrect documentation? Open an issue for this package.

react-query

Install

Overview

Index

Variables

Functions

Classes

Interfaces

Type Aliases

Variables

variable focusManager

variable notifyManager

variable onlineManager

Functions

function dehydrate

function hashQueryKey

function hydrate

function Hydrate

function isCancelledError

function isError

function QueryClientProvider

function QueryErrorResetBoundary

function setLogger

function useHydrate

function useInfiniteQuery

function useIsFetching

function useIsMutating

function useMutation

function useQueries

function useQuery

function useQueryClient

function useQueryErrorResetBoundary

Classes

class CancelledError

property revert

property silent

class InfiniteQueryObserver

property fetch

property getCurrentResult

property subscribe

method bindMethods

method createResult

method fetchNextPage

method fetchPreviousPage

method getOptimisticResult

method setOptions

class Mutation

property meta

property mutationId

property options

property state

method addObserver

method cancel

method continue

method execute

method removeObserver

method setState

class MutationCache

property config

method add

method build

method clear

method find

method findAll

method getAll

method notify

method onFocus

method onOnline

method remove

method resumePausedMutations

class MutationObserver

property options

method bindMethods

method getCurrentResult

method mutate

method onMutationUpdate

method onUnsubscribe

method reset

method setOptions

class QueriesObserver