[Feature Request] Skip any caches if network emits first.

[pardom]

At present, fetcher emissions are locked until reader emits, in order to preserve emission order. This presents a problem in the case that you do not want to emit from reader for a given condition, but instead return an emptyFlow. In this case, fetcher will never emit because reader never emits.

A potential solution would be to add some sort of "disk required" property to StoreRequest in order to either enforce current the fetcher lock behavior or skip the reader emission in the case that fetcher emits first.

To work around this, I have moved the conditional logic in fetcher to a map on stream(). However, it would be ideal to instead provide this behavior as part of the library.

Here's an example of the above:

sealed class GetItemError {
  data class Missing(val itemId: ItemId): GetItemError()
  data class Failure(val error: Exception): GetItemError()
}

typealias GetItemResult = Either<GetItemError, Item>
typealias GetItem = (ItemId) -> Flow<GetItemResult>

val fetcher: GetItem =
  { itemId ->
    try {
      val item = itemApiService.getItemById(itemId)
      if (item != null) {
        flowOf(Right(item))
      } else {
        flowOf(Left(GetItemError.Missing(itemId)))
      }
    } catch(e: Exception) {
      flowOf(Left(GetItemError.Failure(e)))
    }
  }

val reader: GetItem =
  { itemId ->
    val item = itemDao.getItemById(itemId)
    if (item != null) {
      flowOf(Right(item))
    } else {
      // Return empty Flow instead of `GetItemError.Missing` because DB 
      // isn't populated yet and this is not an error case.
      emptyFlow()
    }
  }

[pardom]

After exploring a bit more and becoming aware of the (Key) -> Flow<Output?> type of reader, I've discovered another workaround:

val dbGetItem: GetItem =
  { itemId ->
    val item = itemDao.getItemById(itemId)
    if (item != null) {
      flowOf(Right(item))
    } else {
      flowOf(Left(GetItemError.Missing(itemId))
    }
  }

val reader: (ItemId) -> Flow<GetItemResult?> =
  { itemId ->
    dbGetItem(itemId).map { result ->
      when (result) {
        is Either.Left -> when (result.a) {
          // Map GetItemError.Missing to null to skip disk
          is GetItemError.Missing -> null
          else -> result
        }
        is Either.Right -> result
      }
    }    
  }

Perhaps documentation is all that is needed to resolve this issue.

[digitalbuddha]

Thanks for reporting, we will indeed add this to the upcoming docs.