TanStack.Query

data QueryKey

QueryKey

unsafeToQueryKey :: Array Foreign -> QueryKey

queryKey :: forall a. WriteForeign a => a -> QueryKey

startQueryKey :: forall a b. WriteForeign a => WriteForeign b => a -> b -> QueryKey

Operator alias for TanStack.Query.startQueryKey (left-associative / precedence 4)

appendQueryKey :: forall a. WriteForeign a => QueryKey -> a -> QueryKey

Operator alias for TanStack.Query.appendQueryKey (left-associative / precedence 4)

hashKeyImpl :: Fn2 (QueryKey -> String) QueryKey String

hashKey :: QueryKey -> String

data FetchStatus

FetchStatus / QueryStatus

Constructors

• Fetching
• Paused
• Idle

parseFetchStatus :: String -> FetchStatus

data QueryStatus

Constructors

• QueryPending
• QueryError
• QuerySuccess

parseQueryStatus :: String -> QueryStatus

data QueryClient

QueryClient

newQueryClient :: Effect QueryClient

newQueryClientWithConfigImpl :: forall config. EffectFn1 (Record config) QueryClient

type QueryClientConfig :: Row Typetype QueryClientConfig = (defaultOptions :: { mutations :: { retry :: Opt Int, retryDelay :: Opt Int }, queries :: { gcTime :: Opt Int, refetchOnMount :: Opt Boolean, refetchOnReconnect :: Opt Boolean, refetchOnWindowFocus :: Opt Boolean, retry :: Opt Int, staleTime :: Opt Int } })

newQueryClientWithConfig :: forall opts opts_. Union opts opts_ QueryClientConfig => Record opts -> Effect QueryClient

data UseQueryClient t0

useQueryClientImpl :: Effect QueryClient

useQueryClient :: Hook UseQueryClient QueryClient

queryClientProviderImpl :: forall a. ReactComponent (Record a)

queryClientProvider :: { client :: QueryClient } -> (Array JSX) -> JSX

invalidateQueries :: { queryKey :: QueryKey } -> QueryClient -> Effect Unit

QueryClient methods

invalidateAllQueries :: QueryClient -> Effect Unit

getQueryDataImpl :: QueryKey -> QueryClient -> Effect (Nullable Foreign)

getQueryData :: forall a. ReadForeign a => QueryKey -> QueryClient -> Effect (Maybe a)

setQueryDataImpl :: forall a. EffectFn3 QueryKey a QueryClient Unit

setQueryData :: forall a. WriteForeign a => QueryKey -> a -> QueryClient -> Effect Unit

removeQueriesImpl :: EffectFn2 { queryKey :: QueryKey } QueryClient Unit

removeQueries :: { queryKey :: QueryKey } -> QueryClient -> Effect Unit

prefetchQueryImpl :: forall a. EffectFn2 { queryFn :: Effect (Promise a), queryKey :: QueryKey } QueryClient (Promise Unit)

prefetchQuery :: forall @output. Flatten output output => { queryFn :: Aff output, queryKey :: QueryKey } -> QueryClient -> Aff Unit

fetchQueryImpl :: forall a. EffectFn2 { queryFn :: Effect (Promise a), queryKey :: QueryKey } QueryClient (Promise a)

fetchQuery :: forall @output. Flatten output output => { queryFn :: Aff output, queryKey :: QueryKey } -> QueryClient -> Aff output

cancelQueriesImpl :: EffectFn2 { queryKey :: QueryKey } QueryClient (Promise Unit)

cancelQueries :: { queryKey :: QueryKey } -> QueryClient -> Aff Unit

resetQueriesImpl :: EffectFn2 { queryKey :: QueryKey } QueryClient (Promise Unit)

resetQueries :: { queryKey :: QueryKey } -> QueryClient -> Aff Unit

refetchQueriesImpl :: EffectFn2 { queryKey :: QueryKey } QueryClient (Promise Unit)

refetchQueries :: { queryKey :: QueryKey } -> QueryClient -> Aff Unit

isFetchingImpl :: EffectFn2 { queryKey :: QueryKey } QueryClient Int

isFetching :: { queryKey :: QueryKey } -> QueryClient -> Effect Int

isMutatingImpl :: EffectFn2 { queryKey :: QueryKey } QueryClient Int

isMutating :: { queryKey :: QueryKey } -> QueryClient -> Effect Int

type QueryState output = { data :: Nullable output, dataUpdatedAt :: Nullable Number, error :: Nullable Error, errorUpdatedAt :: Nullable Number, fetchStatus :: String, status :: String }

getQueryStateImpl :: forall output. EffectFn2 QueryKey QueryClient (Nullable (QueryState output))

getQueryState :: forall output. QueryKey -> QueryClient -> Effect (Maybe (QueryState output))

data UseQuery t0

useQuery

type UseQueryArgs :: forall k. (Type -> k) -> Type -> Row ktype UseQueryArgs f output = (enabled :: f Boolean, gcTime :: f Int, initialData :: f output, initialDataUpdatedAt :: f Number, networkMode :: f String, placeholderData :: f output, queryFn :: f (Aff output), queryKey :: f QueryKey, refetchInterval :: f Int, refetchOnMount :: f Boolean, refetchOnReconnect :: f Boolean, refetchOnWindowFocus :: f Boolean, retry :: f Int, retryDelay :: f Int, select :: f (output -> output), staleTime :: f Int, structuralSharing :: f Boolean)

type UseQueryImplResult output = { data :: output, dataUpdatedAt :: Nullable Number, error :: Error, errorUpdatedAt :: Nullable Number, fetchStatus :: String, isError :: Boolean, isFetched :: Boolean, isPending :: Boolean, isPlaceholderData :: Boolean, isRefetchError :: Boolean, isRefetching :: Boolean, isStale :: Boolean, refetch :: Effect (Promise Unit), status :: String }

useQueryImpl :: forall input output. EffectFn1 input (UseQueryImplResult output)

type UseQueryResult output = { data :: RemoteData Error output, dataUpdatedAt :: Maybe Number, errorUpdatedAt :: Maybe Number, fetchStatus :: FetchStatus, isFetched :: Boolean, isPlaceholderData :: Boolean, isRefetchError :: Boolean, isRefetching :: Boolean, isStale :: Boolean, refetch :: Aff Unit, status :: QueryStatus }

useQuery :: forall opts opts_ @output. Flatten output output => Union opts opts_ (UseQueryArgs Id output) => Record opts -> Hook UseQuery (UseQueryResult output)

data UseMutation t0

useMutation

type UseMutationArgs :: forall k. (Type -> k) -> Type -> Type -> Type -> Row ktype UseMutationArgs f input output ctx = (mutationFn :: f (input -> Aff output), mutationKey :: f String, onError :: f (Error -> input -> ctx -> Aff Unit), onMutate :: f (input -> Effect (Maybe ctx)), onSettled :: f (Either Error output -> input -> ctx -> Aff Unit), onSuccess :: f (output -> input -> Effect Unit), retry :: f Int, retryDelay :: f Int)

type UseMutationImplResult input output = { data :: output, error :: Error, isError :: Boolean, isIdle :: Boolean, isPending :: Boolean, mutateAsync :: EffectFn1 input (Promise Unit), reset :: Effect Unit, submittedAt :: Nullable Instant, variables :: Nullable input }

useMutationImpl :: forall input output ctx. EffectFn1 { mutationFn :: Opt (EffectFn1 input (Promise output)), mutationKey :: Opt String, onError :: Opt (EffectFn3 Error input ctx (Promise Unit)), onMutate :: Opt (EffectFn1 input (Nullable ctx)), onSettled :: Opt (EffectFn4 output (Nullable Error) input ctx (Promise Unit)), onSuccess :: Opt (EffectFn2 output input Unit), retry :: Opt Int, retryDelay :: Opt Int } (UseMutationImplResult input output)

type UseMutationResult input output = { data :: RemoteData Error output, mutateAsync :: input -> Aff Unit, reset :: Effect Unit, submittedAt :: Maybe Instant, variables :: Maybe input }

useMutation :: forall opts opts_ input @output ctx. Flatten output output => Union opts opts_ (UseMutationArgs Id input output ctx) => Record opts -> Hook UseMutation (UseMutationResult input output)

data UseInfiniteQuery t0

useInfiniteQuery

type UseInfiniteQueryArgs :: forall k. (Type -> k) -> Type -> Type -> Row ktype UseInfiniteQueryArgs f output pageParam = (enabled :: f Boolean, gcTime :: f Int, getNextPageParam :: f (output -> Array output -> pageParam), getPreviousPageParam :: f (output -> Array output -> pageParam), initialPageParam :: f pageParam, maxPages :: f Int, queryFn :: f ({ pageParam :: pageParam } -> Aff output), queryKey :: f QueryKey, refetchInterval :: f Int, refetchOnWindowFocus :: f Boolean, retry :: f Int, staleTime :: f Int)

type UseInfiniteQueryImplResult output pageParam = { data :: { pageParams :: Array pageParam, pages :: Array output }, error :: Error, fetchNextPage :: Effect (Promise Unit), fetchPreviousPage :: Effect (Promise Unit), fetchStatus :: String, hasNextPage :: Boolean, hasPreviousPage :: Boolean, isError :: Boolean, isFetchingNextPage :: Boolean, isFetchingPreviousPage :: Boolean, isPending :: Boolean, isRefetching :: Boolean, refetch :: Effect (Promise Unit) }

useInfiniteQueryImpl :: forall input output pageParam. EffectFn1 input (UseInfiniteQueryImplResult output pageParam)

type InfiniteData output pageParam = { pageParams :: Array pageParam, pages :: Array output }

type UseInfiniteQueryResult output pageParam = { data :: RemoteData Error (InfiniteData output pageParam), fetchNextPage :: Aff Unit, fetchPreviousPage :: Aff Unit, fetchStatus :: FetchStatus, hasNextPage :: Boolean, hasPreviousPage :: Boolean, isFetchingNextPage :: Boolean, isFetchingPreviousPage :: Boolean, isRefetching :: Boolean, refetch :: Aff Unit }

useInfiniteQuery :: forall opts opts_ @output @pageParam. Flatten output output => Union opts opts_ (UseInfiniteQueryArgs Id output pageParam) => Record opts -> Hook UseInfiniteQuery (UseInfiniteQueryResult output pageParam)

data UseSuspenseQuery t0

useSuspenseQuery

type UseSuspenseQueryArgs :: forall k. (Type -> k) -> Type -> Row ktype UseSuspenseQueryArgs f output = (gcTime :: f Int, initialData :: f output, initialDataUpdatedAt :: f Number, networkMode :: f String, queryFn :: f (Aff output), queryKey :: f QueryKey, refetchInterval :: f Int, refetchOnMount :: f Boolean, refetchOnReconnect :: f Boolean, refetchOnWindowFocus :: f Boolean, retry :: f Int, retryDelay :: f Int, select :: f (output -> output), staleTime :: f Int, structuralSharing :: f Boolean)

type UseSuspenseQueryResult output = { data :: output, dataUpdatedAt :: Maybe Number, fetchStatus :: FetchStatus, isRefetching :: Boolean, refetch :: Aff Unit, status :: QueryStatus }

useSuspenseQueryImpl :: forall input output. EffectFn1 input { data :: output, dataUpdatedAt :: Nullable Number, fetchStatus :: String, isRefetching :: Boolean, refetch :: Effect (Promise Unit), status :: String }

useSuspenseQuery :: forall opts opts_ @output. Flatten output output => Union opts opts_ (UseSuspenseQueryArgs Id output) => Record opts -> Hook UseSuspenseQuery (UseSuspenseQueryResult output)

data UseSuspenseInfiniteQuery t0

useSuspenseInfiniteQuery

type UseSuspenseInfiniteQueryArgs :: forall k. (Type -> k) -> Type -> Type -> Row ktype UseSuspenseInfiniteQueryArgs f output pageParam = (gcTime :: f Int, getNextPageParam :: f (output -> Array output -> pageParam), getPreviousPageParam :: f (output -> Array output -> pageParam), initialPageParam :: f pageParam, maxPages :: f Int, queryFn :: f ({ pageParam :: pageParam } -> Aff output), queryKey :: f QueryKey, refetchInterval :: f Int, retry :: f Int, staleTime :: f Int)

type UseSuspenseInfiniteQueryResult output pageParam = { data :: InfiniteData output pageParam, fetchNextPage :: Aff Unit, fetchPreviousPage :: Aff Unit, fetchStatus :: FetchStatus, hasNextPage :: Boolean, hasPreviousPage :: Boolean, isFetchingNextPage :: Boolean, isFetchingPreviousPage :: Boolean, isRefetching :: Boolean, refetch :: Aff Unit }

useSuspenseInfiniteQueryImpl :: forall input output pageParam. EffectFn1 input { data :: { pageParams :: Array pageParam, pages :: Array output }, fetchNextPage :: Effect (Promise Unit), fetchPreviousPage :: Effect (Promise Unit), fetchStatus :: String, hasNextPage :: Boolean, hasPreviousPage :: Boolean, isFetchingNextPage :: Boolean, isFetchingPreviousPage :: Boolean, isRefetching :: Boolean, refetch :: Effect (Promise Unit) }

useSuspenseInfiniteQuery :: forall opts opts_ @output @pageParam. Flatten output output => Union opts opts_ (UseSuspenseInfiniteQueryArgs Id output pageParam) => Record opts -> Hook UseSuspenseInfiniteQuery (UseSuspenseInfiniteQueryResult output pageParam)

data UseQueries t0

useQueries

type UseQueryOptions output = { enabled :: Opt Boolean, gcTime :: Opt Int, queryFn :: Aff output, queryKey :: QueryKey, staleTime :: Opt Int }

type UseQueriesImplResult output = { data :: output, error :: Error, fetchStatus :: String, isError :: Boolean, isPending :: Boolean }

useQueriesImpl :: forall input output. EffectFn1 { queries :: input } (Array (UseQueriesImplResult output))

useQueries :: forall @output. Flatten output output => Array (UseQueryOptions output) -> Hook UseQueries (Array { data :: RemoteData Error output, fetchStatus :: FetchStatus })

data UseIsFetching t0

useIsFetching

useIsFetchingImpl :: forall input. EffectFn1 input Int

useIsFetching :: forall opts opts_. Union opts opts_ (queryKey :: QueryKey) => Record opts -> Hook UseIsFetching Int

useIsFetchingAll :: Hook UseIsFetching Int

data UseIsMutating t0

useIsMutating

useIsMutatingImpl :: forall input. EffectFn1 input Int

useIsMutating :: forall opts opts_. Union opts opts_ (mutationKey :: String) => Record opts -> Hook UseIsMutating Int

useIsMutatingAll :: Hook UseIsMutating Int

data UseMutationState t0

useMutationState

type MutationStateEntry = { data :: Nullable Foreign, error :: Nullable Error, status :: String, submittedAt :: Nullable Number, variables :: Nullable Foreign }

useMutationStateImpl :: forall input. EffectFn1 input (Array MutationStateEntry)

type UseMutationStateFilters :: Row Typetype UseMutationStateFilters = (filters :: { mutationKey :: Opt String, status :: Opt String })

useMutationState :: forall opts opts_. Union opts opts_ UseMutationStateFilters => Record opts -> Hook UseMutationState (Array MutationStateEntry)

data UseQueryErrorResetBoundary t0

QueryErrorResetBoundary

useQueryErrorResetBoundaryImpl :: Effect { reset :: Effect Unit }

useQueryErrorResetBoundary :: Hook UseQueryErrorResetBoundary { reset :: Effect Unit }

queryErrorResetBoundaryImpl :: forall a. ReactComponent (Record a)

queryErrorResetBoundary :: ({ reset :: Effect Unit } -> JSX) -> JSX

data DehydratedState

HydrationBoundary

hydrationBoundaryImpl :: forall a. ReactComponent (Record a)

hydrationBoundary :: { state :: DehydratedState } -> Array JSX -> JSX

dehydrateImpl :: EffectFn1 QueryClient DehydratedState

dehydrate :: QueryClient -> Effect DehydratedState

hydrateImpl :: EffectFn2 QueryClient DehydratedState Unit

hydrate :: QueryClient -> DehydratedState -> Effect Unit

skipTokenImpl :: forall a. a

Utilities

skipToken :: forall output. Aff output