What's the best approach to manually append some data to a Store's contents?

[erawhctim]

This is better explained with an example:

I have a Store backed by some List<T>, with a fetcher that wraps some API that returns the list of data, and no source-of-truth (just an in-memory cache).
The API also has CRUD endpoints, and the Create/Update endpoints return a single T instance (either newly-created or recently updated with fresh data). What's the best way to take that T instance and add it into the cached List<T?

I think the obvious (and simple) solution is to just invalidate the cache and let the Store refresh itself with updated data from the API, which absolutely works fine. Since the Create/Update calls return the updated T record, it'd be nice if I could just send that single value into the Store's cache and keep everything else configured the same way.
Am I thinking about this the right way?

The other option is to use a MutableStore, but it's not really clear to me what my SourceOfTruth would be (since I don't need persistence here).

• Should I build a SourceOfTruth implementation that just holds data in memory?
• Can I build a MutableStore without a S.O.T?
• I saw this other discussion, which seems related to my question, but this part in the answer is tripping me up:

  Although we aren't making local writes only possible through MutableStoreBuilder, you can achieve it by providing a no-op Updater without a Bookkeeper

  • I'm not sure (yet) now Updater and BookKeeper relate to S.O.T (I need to keep digging into Store's internals)

[erawhctim]

Maybe MultiCache is what I need?

Just got access to the channel on kotlinlang Slack, so I'll continue to dig (and keep this discussion updated if I figure out the answer)

[matt-ramotar]

Can you share your Key and Fetcher?

[erawhctim]

Sure, maybe there's another way to accomplish the same goal in my current setup that you can spot (just recently discovered Store, so bear with me as I figure out all the pieces 🙂)

My key is a compound key, combined into a data class with two fields, similar to this:

data class CompoundKey(isLoggedIn: Boolean, key2: String?)

val key1Flow: Flow<Boolean> = ...
val key2Flow: Flow<String?> = ...

val storeFlow: Flow<ResponseModel> = 
  key1Flow.combine(key2Flow) { key1, key2 -> CompoundKey(key1, key2) }
    .flatMapLatest { key -> store.stream(StoreReadRequest.cached(key, false)) }
    ... // transform store response into ResponseModel

The key helps define what API call is hit in the Fetcher, and the Boolean part of the key helps clear the cache in response to login state changing:

val fetcher = Fetcher.of<CompoundKey, List<ResponseModel>> { key ->
  val (loggedIn, apiParam) = key
  if (!isLoggedIn) return@of emptyList()

  if (apiParam != null) {
    // call endpoint 1 without params, returns a List<ResponseModel>
  } else {
    // call endpoint 2 with `apiParam`, returns a List<ResponseModel>
  }
}

Assuming there's some CRUD endpoint on the same API that returns a single ResponseModel record, I'd like a way to essentially say store.setValue(store.currentValue + responseModel) (if that make sense)

[matt-ramotar]

Thanks for sharing. Here's one way you could approach this. Note that StoreKey, StoreData, and StoreMultiCache are experimental and will change.

@OptIn(ExperimentalStoreApi::class)
sealed class Key : StoreKey<String> {
    data class Collection(
        val isLoggedIn: Boolean, val key2: String?,
        override val insertionStrategy: InsertionStrategy = InsertionStrategy.APPEND
    ) : Key(), StoreKey.Collection<String>

    data class Single(val id: String) : Key(), StoreKey.Single<String>
}

@OptIn(ExperimentalStoreApi::class)
sealed class ResponseModel : StoreData<String> {
    data class Collection(
        override val items: List<Single>, override val itemsAfter: Int? = null,
        override val itemsBefore: Int? = null, override val nextKey: Key.Collection? = null,
        override val prevKey: Key.Collection = Key.Collection(true, ""),
    ) : StoreData.Collection<String, Key.Collection, Single>, ResponseModel() {
        override fun copyWith(items: List<Single>): StoreData.Collection<String, *, Single> {
            return copy(items = items)
        }

        override fun insertItems(
            strategy: InsertionStrategy,
            items: List<Single>
        ): StoreData.Collection<String, *, Single> {
            val updatedItems = when (strategy) {
                InsertionStrategy.APPEND -> this.items + items
                InsertionStrategy.PREPEND -> items + this.items
                InsertionStrategy.REPLACE -> items
            }
            return copy(items = updatedItems)
        }
    }

    data class Single(override val id: String) : StoreData.Single<String>, ResponseModel()
}

data class MyUpdaterResponse(
    val value: ResponseModel.Single
)

fun createSourceOfTruth(): SourceOfTruth<Key, ResponseModel, ResponseModel> {
    return object : SourceOfTruth<Key, ResponseModel, ResponseModel> {
        TODO(): Implement read and write operations for collection and single cases
    }
}

@OptIn(ExperimentalStoreApi::class)
fun createMemoryCache(): Cache<Key, ResponseModel> {
    return StoreMultiCache<String, Key, ResponseModel.Single, ResponseModel.Collection, ResponseModel>(
        keyProvider = object : KeyProvider<String, ResponseModel.Single> {
            override fun fromCollection(
                key: StoreKey.Collection<String>,
                value: ResponseModel.Single
            ): StoreKey.Single<String> {
                return Key.Single(value.id)
            }

            override fun fromSingle(
                key: StoreKey.Single<String>,
                value: ResponseModel.Single
            ): StoreKey.Collection<String> {
                TODO(): Implement the logic to create a collection key from a single key
            }
        },
    )
}

@OptIn(ExperimentalStoreApi::class)
fun createStore(): MutableStore<Key, ResponseModel> {
    val sourceOfTruth = createSourceOfTruth()
    val memoryCache = createMemoryCache()

    val store = StoreBuilder.from<Key, ResponseModel, ResponseModel>(
        fetcher = Fetcher.of<Key, ResponseModel> { key ->
            when (key) {
                is Key.Collection -> {
                    // Fetch data from API endpoint for collections
                }
                is Key.Single -> {
                    // Fetch data from API endpoint for singles, or no op if not needed
                }
            }
        },
        sourceOfTruth = sourceOfTruth,
        memoryCache = memoryCache,
    ).toMutableStoreBuilder(
        converter = object : Converter<ResponseModel, ResponseModel, ResponseModel> {
            override fun fromNetworkToLocal(network: ResponseModel): ResponseModel {
                TODO(): Implement the conversion logic from network to local model
            }

            override fun fromOutputToLocal(output: ResponseModel): ResponseModel {
                TODO(): Implement the conversion logic from output to local model
            }
        }
    ).build(
        updater = object : Updater<Key, ResponseModel, MyUpdaterResponse> {
            override suspend fun post(key: Key, value: ResponseModel): UpdaterResult {
                return when (key) {
                    is Key.Collection -> {
                        // If updating a collection is not supported, return success without any update
                        UpdaterResult.Success.Untyped(value)
                    }
                    is Key.Single -> {
                        try {
                            // Hit API with updated value and return updated object
                            val updatedObj = ResponseModel.Single("") // Replace with actual

                            // Update memory cache and source of truth with the updated object
                            memoryCache.put(key, updatedObj)
                            sourceOfTruth.write(key, updatedObj)

                            UpdaterResult.Success.Typed(updatedObj)
                        } catch (e: Exception) {
                            // Handle exceptions and return appropriate error result
                            UpdaterResult.Error.Exception(e)
                        }
                    }
                }
            }

            override val onCompletion: OnUpdaterCompletion<MyUpdaterResponse>? = null
        }
    )

    return store
}

[erawhctim]

Wow, this is incredibly helpful, thank you!

Right now, is there a way to build a MutableStore without using a SourceOfTruth (if I just want in-memory caching only)? Can I just supply a no-op S.O.T to achieve that, or does that cause any negative side-effects?

[matt-ramotar]

Sorry to be slow. It's not possible to build a MutableStore without a SourceOfTruth using the MutableStoreBuilder. However, it is possible to build one using StoreBuilder and StoreBuilder.toMutableStoreBuilder().

val store = StoreBuilder.from(fetcher).toMutableStoreBuilder(converter).build(updater, bookkeeper)

[matt-ramotar]

Just checking in - Let me know if you have any more questions. Will close otherwise

[erawhctim]

I need to do some more digging to see what the updater & bookkeeper responsibilities are, and if this would work for my use case, but I think you're good to go ahead and close; I can re-open if needed. Thanks again for the help