Package-level declarations

InfiniteQueryLoadingErrorObject

data class InfiniteQueryConfig

Configuration for the infinite query.

InfiniteQueryLoadingObject

data class InfiniteQueryLoadingErrorObject<T, S>(val reply: Reply<T>, val replyUpdatedAt: Long, val error: Throwable, val errorUpdatedAt: Long, val staleAt: Long, val fetchStatus: QueryFetchStatus, val isInvalidated: Boolean, val refresh: suspend () -> Unit, val loadMore: suspend (param: S) -> Unit, val loadMoreParam: S?) : InfiniteQueryObject<T, S>

A InfiniteQueryLoadingErrorObject represents the initial loading error state of the InfiniteQueryObject.

data class InfiniteQueryLoadingObject<T, S>(val reply: Reply<T>, val replyUpdatedAt: Long, val error: Throwable?, val errorUpdatedAt: Long, val staleAt: Long, val fetchStatus: QueryFetchStatus, val isInvalidated: Boolean, val refresh: suspend () -> Unit, val loadMore: suspend (param: S) -> Unit, val loadMoreParam: S?) : InfiniteQueryObject<T, S>

A InfiniteQueryLoadingObject represents the initial loading state of the InfiniteQueryObject.

InfiniteQueryObject

InfiniteQueryObjectMapper

sealed interface InfiniteQueryObject<out T, S> : QueryModel<T>

A InfiniteQueryObject represents QueryModels interface for infinite fetching data using a retrieval method known as "infinite scroll."

interface InfiniteQueryObjectMapper

A mapper that converts QueryState to InfiniteQueryObject.

InfiniteQueryRecompositionOptimizer

interface InfiniteQueryRecompositionOptimizer

A recomposition optimizer for QueryState with QueryChunks.

InfiniteQueryRefreshErrorObject

data class InfiniteQueryRefreshErrorObject<T, S>(val reply: Reply<T>, val replyUpdatedAt: Long, val error: Throwable, val errorUpdatedAt: Long, val staleAt: Long, val fetchStatus: QueryFetchStatus, val isInvalidated: Boolean, val refresh: suspend () -> Unit, val loadMore: suspend (param: S) -> Unit, val loadMoreParam: S?) : InfiniteQueryObject<T, S>

A InfiniteQueryRefreshErrorObject represents the refresh error state of the InfiniteQueryObject.

InfiniteQueryStrategy

InfiniteQuerySuccessObject

interface InfiniteQueryStrategy

A mechanism to finely adjust the behavior of the infinite-query on a component basis in Composable functions.

data class InfiniteQuerySuccessObject<T, S>(val reply: Reply<T>, val replyUpdatedAt: Long, val error: Throwable?, val errorUpdatedAt: Long, val staleAt: Long, val fetchStatus: QueryFetchStatus, val isInvalidated: Boolean, val refresh: suspend () -> Unit, val loadMore: suspend (param: S) -> Unit, val loadMoreParam: S?) : InfiniteQueryObject<T, S>

A InfiniteQuerySuccessObject represents the successful state of the InfiniteQueryObject.

MutationConfig

data class MutationConfig

Configuration for the mutation.

MutationErrorObject

data class MutationErrorObject<T, S>(val reply: Reply<T>, val replyUpdatedAt: Long, val error: Throwable, val errorUpdatedAt: Long, val mutatedCount: Int, val mutate: suspend (S) -> T, val mutateAsync: suspend (S) -> Unit, val reset: suspend () -> Unit) : MutationObject<T, S>

A MutationErrorObject represents the error state of the MutationObject.

MutationIdleObject

data class MutationIdleObject<T, S>(val reply: Reply<T>, val replyUpdatedAt: Long, val error: Throwable?, val errorUpdatedAt: Long, val mutatedCount: Int, val mutate: suspend (S) -> T, val mutateAsync: suspend (S) -> Unit, val reset: suspend () -> Unit) : MutationObject<T, S>

A MutationIdleObject represents the initial idle state of the MutationObject.

MutationLoadingObject

data class MutationLoadingObject<T, S>(val reply: Reply<T>, val replyUpdatedAt: Long, val error: Throwable?, val errorUpdatedAt: Long, val mutatedCount: Int, val mutate: suspend (S) -> T, val mutateAsync: suspend (S) -> Unit, val reset: suspend () -> Unit) : MutationObject<T, S>

A Mutation Loading Object represents the waiting execution result state of the Mutation Object.

MutationObject

MutationRecompositionOptimizer

sealed interface MutationObject<out T, S> : MutationModel<T>

A MutationObject represents MutationModels interface for mutating data.

MutationObjectMapper

interface MutationObjectMapper

A mapper that converts MutationState to MutationObject.

interface MutationRecompositionOptimizer

A recomposition optimizer for MutationState.

MutationStrategy

interface MutationStrategy

A mechanism to finely adjust the behavior of the mutation on a component basis in Composable functions.

MutationSuccessObject

data class MutationSuccessObject<T, S>(val reply: Reply<T>, val replyUpdatedAt: Long, val error: Throwable?, val errorUpdatedAt: Long, val mutatedCount: Int, val mutate: suspend (S) -> T, val mutateAsync: suspend (S) -> Unit, val reset: suspend () -> Unit) : MutationObject<T, S>

A MutationSuccessObject represents the successful state of the MutationObject.

QueryConfig

data class QueryConfig

Configuration for the query.

QueryLoadingErrorObject

data class QueryLoadingErrorObject<T>(val reply: Reply<T>, val replyUpdatedAt: Long, val error: Throwable, val errorUpdatedAt: Long, val staleAt: Long, val fetchStatus: QueryFetchStatus, val isInvalidated: Boolean, val refresh: suspend () -> Unit) : QueryObject<T>

A QueryLoadingErrorObject represents the initial loading error state of the QueryObject.

QueryLoadingObject

data class QueryLoadingObject<T>(val reply: Reply<T>, val replyUpdatedAt: Long, val error: Throwable?, val errorUpdatedAt: Long, val staleAt: Long, val fetchStatus: QueryFetchStatus, val isInvalidated: Boolean, val refresh: suspend () -> Unit) : QueryObject<T>

A QueryIdleObject represents the initial loading state of the QueryObject.

QueryObject

QueryRecompositionOptimizer

sealed interface QueryObject<out T> : QueryModel<T>

A QueryObject represents QueryModels interface for fetching data.

QueryObjectMapper

interface QueryObjectMapper

A mapper that converts QueryState to QueryObject.

interface QueryRecompositionOptimizer

A recomposition optimizer for QueryState.

QueryRefreshErrorObject

data class QueryRefreshErrorObject<T>(val reply: Reply<T>, val replyUpdatedAt: Long, val error: Throwable, val errorUpdatedAt: Long, val staleAt: Long, val fetchStatus: QueryFetchStatus, val isInvalidated: Boolean, val refresh: suspend () -> Unit) : QueryObject<T>

A QueryRefreshErrorObject represents the refresh error state of the QueryObject.

QueryStrategy

interface QueryStrategy

A mechanism to finely adjust the behavior of the query on a component basis in Composable functions.

QuerySuccessObject

data class QuerySuccessObject<T>(val reply: Reply<T>, val replyUpdatedAt: Long, val error: Throwable?, val errorUpdatedAt: Long, val staleAt: Long, val fetchStatus: QueryFetchStatus, val isInvalidated: Boolean, val refresh: suspend () -> Unit) : QueryObject<T>

A QuerySuccessObject represents the successful state of the QueryObject.

SubscriptionConfig

data class SubscriptionConfig

Configuration for the subscription.

SubscriptionErrorObject

SubscriptionLoadingObject

data class SubscriptionErrorObject<T>(val reply: Reply<T>, val replyUpdatedAt: Long, val error: Throwable, val errorUpdatedAt: Long, val restartedAt: Long, val reset: suspend () -> Unit) : SubscriptionObject<T>

A SubscriptionErrorObject represents the error state of the SubscriptionObject.

data class SubscriptionLoadingObject<T>(val reply: Reply<T>, val replyUpdatedAt: Long, val error: Throwable?, val errorUpdatedAt: Long, val restartedAt: Long, val reset: suspend () -> Unit) : SubscriptionObject<T>

A SubscriptionLoadingObject represents the initial loading state of the SubscriptionObject.

SubscriptionObject

SubscriptionRecompositionOptimizer

sealed interface SubscriptionObject<out T> : SubscriptionModel<T>

A SubscriptionObject represents SubscriptionModels interface for receiving data.

SubscriptionObjectMapper

interface SubscriptionObjectMapper

A mapper that converts SubscriptionState to SubscriptionObject.

interface SubscriptionRecompositionOptimizer

A recomposition optimizer for SubscriptionState.

SubscriptionStrategy

SubscriptionSuccessObject

interface SubscriptionStrategy

A mechanism to finely adjust the behavior of the subscription on a component basis in Composable functions.

val InfiniteQueryObjectMapper.Companion.Default: InfiniteQueryObjectMapper

data class SubscriptionSuccessObject<T>(val reply: Reply<T>, val replyUpdatedAt: Long, val error: Throwable?, val errorUpdatedAt: Long, val restartedAt: Long, val reset: suspend () -> Unit) : SubscriptionObject<T>

A SubscriptionSuccessObject represents the successful state of the SubscriptionObject.

Properties

Default

The default InfiniteQueryObjectMapper.

val InfiniteQueryStrategy.Companion.Default: InfiniteQueryStrategy

The default built-in strategy for Infinite Query built into the library.

val MutationObjectMapper.Companion.Default: MutationObjectMapper

The default MutationObjectMapper.

val MutationStrategy.Companion.Default: MutationStrategy

The default built-in strategy for Mutation built into the library.

val QueryObjectMapper.Companion.Default: QueryObjectMapper

The default QueryObjectMapper.

val QueryStrategy.Companion.Default: QueryStrategy

The default built-in strategy for Query built into the library.

val SubscriptionObjectMapper.Companion.Default: SubscriptionObjectMapper

The default SubscriptionObjectMapper.

val SubscriptionStrategy.Companion.Default: SubscriptionStrategy

The default built-in strategy for Subscription built into the library.

Disabled

val InfiniteQueryRecompositionOptimizer.Companion.Disabled: InfiniteQueryRecompositionOptimizer

val MutationRecompositionOptimizer.Companion.Disabled: MutationRecompositionOptimizer

val QueryRecompositionOptimizer.Companion.Disabled: QueryRecompositionOptimizer

val SubscriptionRecompositionOptimizer.Companion.Disabled: SubscriptionRecompositionOptimizer

Option that performs no optimization.

Enabled

val InfiniteQueryRecompositionOptimizer.Companion.Enabled: InfiniteQueryRecompositionOptimizer

Optimizer implementation for InfiniteQueryStrategy.Companion.Default.

val MutationRecompositionOptimizer.Companion.Enabled: MutationRecompositionOptimizer

Optimizer implementation for MutationStrategy.Companion.Default.

val QueryRecompositionOptimizer.Companion.Enabled: QueryRecompositionOptimizer

Optimizer implementation for QueryStrategy.Companion.Default.

val SubscriptionRecompositionOptimizer.Companion.Enabled: SubscriptionRecompositionOptimizer

Optimizer implementation for SubscriptionStrategy.Companion.Default.

LocalMutationClient

val LocalMutationClient: ProvidableCompositionLocal<MutationClient>

CompositionLocal for MutationClient.

LocalQueryClient

val LocalQueryClient: ProvidableCompositionLocal<QueryClient>

CompositionLocal for QueryClient.

LocalSubscriptionClient

val LocalSubscriptionClient: ProvidableCompositionLocal<SubscriptionClient>

CompositionLocal for SubscriptionClient.

LocalSwrClient

val LocalSwrClient: ProvidableCompositionLocal<SwrClient>

CompositionLocal for SwrClient.

Functions

InfiniteQueryConfig

fun InfiniteQueryConfig(initializer: InfiniteQueryConfig.Builder.() -> Unit): InfiniteQueryConfig

Creates a InfiniteQueryConfig with the provided initializer.

MutationConfig

fun MutationConfig(initializer: MutationConfig.Builder.() -> Unit): MutationConfig

Creates a MutationConfig with the provided initializer.

QueryConfig

fun QueryConfig(initializer: QueryConfig.Builder.() -> Unit): QueryConfig

Creates a QueryConfig with the provided initializer.

rememberInfiniteQuery

fun <T, S> rememberInfiniteQuery(key: InfiniteQueryKey<T, S>, config: InfiniteQueryConfig = InfiniteQueryConfig.Default, client: QueryClient = LocalQueryClient.current): InfiniteQueryObject<QueryChunks<T, S>, S>

fun <T, S, U> rememberInfiniteQuery(key: InfiniteQueryKey<T, S>, select: (QueryChunks<T, S>) -> U, config: InfiniteQueryConfig = InfiniteQueryConfig.Default, client: QueryClient = LocalQueryClient.current): InfiniteQueryObject<U, S>

Remember a InfiniteQueryObject and subscribes to the query state of key.

rememberInfiniteQueryIf

fun <T, S, V> rememberInfiniteQueryIf(value: V, keyFactory: (value: V) -> InfiniteQueryKey<T, S>?, config: InfiniteQueryConfig = InfiniteQueryConfig.Default, client: QueryClient = LocalQueryClient.current): InfiniteQueryObject<QueryChunks<T, S>, S>?

fun <T, S, U, V> rememberInfiniteQueryIf(value: V, keyFactory: (value: V) -> InfiniteQueryKey<T, S>?, select: (QueryChunks<T, S>) -> U, config: InfiniteQueryConfig = InfiniteQueryConfig.Default, client: QueryClient = LocalQueryClient.current): InfiniteQueryObject<U, S>?

Provides a conditional rememberInfiniteQuery.

rememberMutation

fun <T, S> rememberMutation(key: MutationKey<T, S>, config: MutationConfig = MutationConfig.Default, client: MutationClient = LocalMutationClient.current): MutationObject<T, S>

Remember a MutationObject and subscribes to the mutation state of key.

rememberMutationIf

fun <T, S, V> rememberMutationIf(value: V, keyFactory: (value: V) -> MutationKey<T, S>?, config: MutationConfig = MutationConfig.Default, client: MutationClient = LocalMutationClient.current): MutationObject<T, S>?

Provides a conditional rememberMutation.

rememberQuery

fun <T> rememberQuery(key: QueryKey<T>, config: QueryConfig = QueryConfig.Default, client: QueryClient = LocalQueryClient.current): QueryObject<T>

fun <T, U> rememberQuery(key: QueryKey<T>, select: (T) -> U, config: QueryConfig = QueryConfig.Default, client: QueryClient = LocalQueryClient.current): QueryObject<U>

Remember a QueryObject and subscribes to the query state of key.

fun <T, R> rememberQuery(keys: List<QueryKey<T>>, transform: (List<T>) -> R, config: QueryConfig = QueryConfig.Default, client: QueryClient = LocalQueryClient.current): QueryObject<R>

Remember a QueryObject and subscribes to the query state of keys.

fun <T1, T2, R> rememberQuery(key1: QueryKey<T1>, key2: QueryKey<T2>, transform: (T1, T2) -> R, config: QueryConfig = QueryConfig.Default, client: QueryClient = LocalQueryClient.current): QueryObject<R>

Remember a QueryObject and subscribes to the query state of key1 and key2.

fun <T1, T2, T3, R> rememberQuery(key1: QueryKey<T1>, key2: QueryKey<T2>, key3: QueryKey<T3>, transform: (T1, T2, T3) -> R, config: QueryConfig = QueryConfig.Default, client: QueryClient = LocalQueryClient.current): QueryObject<R>

Remember a QueryObject and subscribes to the query state of key1, key2, and key3.

rememberQueryIf

fun <T, V> rememberQueryIf(value: V, keyFactory: (value: V) -> QueryKey<T>?, config: QueryConfig = QueryConfig.Default, client: QueryClient = LocalQueryClient.current): QueryObject<T>?

@JvmName(name = "rememberQueryIfWithPair")

fun <T1, T2, R, V> rememberQueryIf(value: V, keyPairFactory: (value: V) -> Pair<QueryKey<T1>, QueryKey<T2>>?, transform: (T1, T2) -> R, config: QueryConfig = QueryConfig.Default, client: QueryClient = LocalQueryClient.current): QueryObject<R>?

@JvmName(name = "rememberQueryIfWithTriple")

fun <T1, T2, T3, R, V> rememberQueryIf(value: V, keyTripleFactory: (value: V) -> Triple<QueryKey<T1>, QueryKey<T2>, QueryKey<T3>>?, transform: (T1, T2, T3) -> R, config: QueryConfig = QueryConfig.Default, client: QueryClient = LocalQueryClient.current): QueryObject<R>?

@JvmName(name = "rememberQueryIfWithList")

fun <T, R, V> rememberQueryIf(value: V, keyListFactory: (value: V) -> List<QueryKey<T>>?, transform: (List<T>) -> R, config: QueryConfig = QueryConfig.Default, client: QueryClient = LocalQueryClient.current): QueryObject<R>?

fun <T, U, V> rememberQueryIf(value: V, keyFactory: (value: V) -> QueryKey<T>?, select: (T) -> U, config: QueryConfig = QueryConfig.Default, client: QueryClient = LocalQueryClient.current): QueryObject<U>?

Provides a conditional rememberQuery.

rememberSubscription

fun <T> rememberSubscription(key: SubscriptionKey<T>, config: SubscriptionConfig = SubscriptionConfig.Default, client: SubscriptionClient = LocalSubscriptionClient.current): SubscriptionObject<T>

fun <T, U> rememberSubscription(key: SubscriptionKey<T>, select: (T) -> U, config: SubscriptionConfig = SubscriptionConfig.Default, client: SubscriptionClient = LocalSubscriptionClient.current): SubscriptionObject<U>

Remember a SubscriptionObject and subscribes to the subscription state of key.

rememberSubscriptionIf

fun <T, V> rememberSubscriptionIf(value: V, keyFactory: (value: V) -> SubscriptionKey<T>?, config: SubscriptionConfig = SubscriptionConfig.Default, client: SubscriptionClient = LocalSubscriptionClient.current): SubscriptionObject<T>?

fun <T, U, V> rememberSubscriptionIf(value: V, keyFactory: (value: V) -> SubscriptionKey<T>?, select: (T) -> U, config: SubscriptionConfig = SubscriptionConfig.Default, client: SubscriptionClient = LocalSubscriptionClient.current): SubscriptionObject<U>?

Provides a conditional rememberSubscription.

SubscriptionConfig

fun SubscriptionConfig(initializer: SubscriptionConfig.Builder.() -> Unit): SubscriptionConfig

Creates a SubscriptionConfig with the provided initializer.

SwrClientProvider

fun SwrClientProvider(client: SwrClient, content: @Composable () -> Unit)

Provides a SwrClient to the content over LocalSwrClient