Create RxJava artifact about store

[digitalbuddha]

Proposed design

Biggest issue I see is how to model persister read function. If we expect a Maybe<T> then we force user to return Maybe.empty() since rxjava will crash on Maybe.just(null). @yigit how does Room return when no values?

Builder

interface RxStoreBuilder<Key : Any, Output : Any> {

    companion object {
        /**
         * Creates a new [StoreBuilder] from a non-[Flow] fetcher.
         *
         * Use when creating a [Store] that fetches objects in an HTTP-like single response per
         * request protocol.
         *
         * @param fetcher a function for fetching network records.
         */
        fun <Key : Any, Output : Any> fromSingle(
            fetcher: (key: Key) -> Single<Output>
        ): BuilderImpl<Key, Output> = BuilderImpl { key: Key ->
            fetcher.invoke(key).toFlowable().asFlow()
        }

        /**
         * Creates a new [StoreBuilder] from a [Flow] fetcher.
         *
         * Use when creating a [Store] that fetches objects in an websocket-like multiple responses
         * per request protocol.
         *
         * @param fetcher a function for fetching a flow of network records.
         */
        fun <Key : Any, Output : Any> fromFlowable(
            fetcher: (key: Key) -> Flowable<Output>
        ): StoreBuilder<Key, Output> = BuilderImpl { key: Key ->
            fetcher.invoke(key).asFlow()
        }
    }
}

Extension Functions

fun <Key : Any, Output : Any> Store<Key, Output>.asRxStore(): RxStore<Key, Output> =
    object : RxStore<Key, Output> {
        override fun stream(request: StoreRequest<Key>): Flowable<StoreResponse<Output>> =
            [e-mail](request).asFlowable()

        override fun clear(key: Key): Single<Unit> =
            rxSingle { [e-mail](key) }

        @ExperimentalStoreApi
        override fun clearAll(): Single<Unit> = rxSingle { [e-mail]() }
    }

fun <Key : Any, Output : Any, NewOutput : Any> BuilderImpl<Key, Output>.withSinglePersister(
    reader: (Key) -> Maybe<NewOutput>,
    writer: (Key, Output) -> Single<Unit>,
    delete: ((Key) -> Unit)? = null,
    deleteAll: (() -> Unit)? = null
): BuilderWithSourceOfTruth<Key, Output, NewOutput> {
    return nonFlowingPersister(
        reader = { key -> reader.invoke(key).await() },
        writer = { key, output -> writer.invoke(key, output).await() },
        delete = { key -> delete?.invoke(key) },
        deleteAll = { deleteAll?.invoke() }
    )
}

fun <Key : Any, Output : Any, NewOutput : Any> BuilderImpl<Key, Output>.withFlowablePersister(
    reader: (Key) -> Flowable<NewOutput>,
    writer: (Key, Output) -> Single<Unit>,
    delete: ((Key) -> Unit)? = null,
    deleteAll: (() -> Unit)? = null
) {
    persister(
        reader = { key -> reader.invoke(key).asFlow() },
        writer = { key, output -> writer.invoke(key, output).await() },
        delete = { key -> delete?.invoke(key) },
        deleteAll = { deleteAll?.invoke() }
    )
}

Example

       val fetcher: (Int) -> Single<String> = { Single.just("three-1") }

       val persister=InMemoryRxPersister<Int,String>()
        val rxStore: RxStore<Int, String> = RxStoreBuilder.fromSingle(fetcher)
            .withSinglePersister(
                reader = {key->persister.read(key)},
                writer = {key,value->persister.write(key,value)}
            )
            .build()
            .asRxStore()

        val testObserver = rxStore.stream(StoreRequest.cached(3, refresh = false))
            .test()

        testObserver.assertValues(
            Loading(
                origin = Fetcher
            ), Data(
                value = "three-1",
                origin = Fetcher
            )
        )

[eyalgu]

Instead of RxStoreBuilder and RxStore can we just use extension functions on StoreBuilder and Store?

All we need is

fun StoreBuilder.fromSingle(...)
fun StoreBuilder.fromObservable(...)
fun StoreBuilder.fromFlow(...)
fun StoreBuilder.fromMaybe(...) // not sure if this makes sense
fun Store.observe(...)
fun Store.single(...)

[digitalbuddha]

Sure! I can move the top level ones to extensions, I think the rest are extensions right now

[digitalbuddha]

How do you feel about just having top level functions
fun rxSingleStore(...)
fun rxFlowableStore(...)

I can change other builders to this too

[eyalgu]

Can we avoid adding new types altogether? As in not have rxstore

…

On Sat, Feb 8, 2020, 2:30 PM Mike Nakhimovich ***@***.***> wrote: How do you feel about just having top level functions fun rxSingleStore(...) fun rxFlowableStore(...) I can change other builders to this too — You are receiving this because you commented. Reply to this email directly, view it on GitHub <#92>, or unsubscribe <https://github.com/notifications/unsubscribe-auth/AAMUYKI4PE7NUFHCHG6Q2I3RB4W63ANCNFSM4KRUMRGA> .

[digitalbuddha]

Yup, totally can, great suggestion!