an attempt at UseCase error handling with Flow extensions

Author: johsoe

app/src/main/java/com/monstarlab/arch/data/RepositoryExtensions.kt renamed to app/src/main/java/com/monstarlab/arch/extensions/RepositoryExtensions.kt

@@ -1,4 +1,4 @@
-package com.monstarlab.arch.data
+package com.monstarlab.arch.extensions
 
 import com.monstarlab.core.domain.error.ErrorModel
 import com.monstarlab.core.domain.error.toError

app/src/main/java/com/monstarlab/arch/extensions/UseCaseExtensions.kt

@@ -0,0 +1,51 @@
+package com.monstarlab.arch.extensions
+
+import com.monstarlab.core.domain.error.ErrorModel
+import com.monstarlab.core.domain.error.toError
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.flow
+import kotlinx.coroutines.flow.transform
+
+
+sealed class UseCaseResult<out T> {
+    data class Success<T>(val value: T) : UseCaseResult<T>()
+    data class Error(val error: ErrorModel) : UseCaseResult<Nothing>()
+}
+
+suspend inline fun <T> safeUseCase(
+        crossinline block: suspend () -> RepositoryResult<T>
+): UseCaseResult<T> = try {
+    when (val repoResult = block()) {
+        is RepositoryResult.Success -> UseCaseResult.Success(repoResult.value)
+        is RepositoryResult.Error -> UseCaseResult.Error(repoResult.error)
+    }
+} catch (e: Exception) {
+    UseCaseResult.Error(e.toError())
+}
+
+inline fun <T> safeFlow(
+        crossinline block: suspend () -> RepositoryResult<T>
+): Flow<UseCaseResult<T>> = flow {
+    try {
+        when (val repoResult = block()) {
+            is RepositoryResult.Success -> UseCaseResult.Success(repoResult.value)
+            is RepositoryResult.Error -> UseCaseResult.Error(repoResult.error)
+        }
+    } catch (e: Exception) {
+        UseCaseResult.Error(e.toError())
+    }
+}
+
+fun <T> Flow<UseCaseResult<T>>.onSuccess(action: suspend (T) -> Unit): Flow<UseCaseResult<T>> = transform { result ->
+    if(result is UseCaseResult.Success<T>) {
+        action(result.value)
+    }
+    return@transform emit(result)
+}
+
+fun <T> Flow<UseCaseResult<T>>.onError(action: suspend (ErrorModel) -> Unit): Flow<UseCaseResult<T>> = transform { result ->
+    if(result is UseCaseResult.Error) {
+        action(result.error)
+    }
+    return@transform emit(result)
+}

app/src/main/java/com/monstarlab/core/domain/error/ErrorMapping.kt

@@ -26,6 +26,6 @@ fun Throwable.toError(): ErrorModel {
         is SocketTimeoutException -> ErrorModel.Connection.Timeout
         is UnknownHostException -> ErrorModel.Connection.UnknownHost
         is IOException -> ErrorModel.Connection.IOError
-        else -> ErrorModel.Unknown
+        else -> ErrorModel.Unknown(this)
     }
 }

app/src/main/java/com/monstarlab/core/domain/error/ErrorModel.kt

@@ -24,6 +24,6 @@ sealed class ErrorModel {
         object UnknownHost: Connection()
     }
 
-    object Unknown: ErrorModel()
+    data class Unknown(val throwable: Throwable): ErrorModel()
 
 }

app/src/main/java/com/monstarlab/core/usecases/blog/GetPostsUseCase.kt

@@ -1,5 +1,9 @@
 package com.monstarlab.core.usecases.blog
 
+import com.monstarlab.arch.extensions.UseCaseResult
+import com.monstarlab.arch.extensions.safeCall
+import com.monstarlab.arch.extensions.safeFlow
+import com.monstarlab.arch.extensions.safeUseCase
 import com.monstarlab.core.data.repositories.PostRepository
 import com.monstarlab.core.domain.model.Post
 import kotlinx.coroutines.flow.Flow
@@ -8,9 +12,7 @@ import javax.inject.Inject
 class GetPostsUseCase @Inject constructor(
     private val postRepository: PostRepository
 ){
-
-    fun getPosts(): Flow<List<Post>> {
-        return postRepository.getPosts()
+    fun getPosts(): Flow<UseCaseResult<List<Post>>> = safeFlow {
+        postRepository.getPosts()
     }
-
 }

app/src/main/java/com/monstarlab/features/sample/SampleViewModel.kt

@@ -4,9 +4,13 @@ import androidx.lifecycle.SavedStateHandle
 import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
 import com.monstarlab.arch.extensions.combineFlows
+import com.monstarlab.arch.extensions.onError
+import com.monstarlab.arch.extensions.onSuccess
 import com.monstarlab.core.data.repositories.PostRepository
+import com.monstarlab.core.domain.error.ErrorModel
 import com.monstarlab.core.domain.mock.MockFlows
 import com.monstarlab.core.domain.mock.MockSuspends
+import com.monstarlab.core.usecases.blog.GetPostsUseCase
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.flow.*
 import kotlinx.coroutines.launch
@@ -15,24 +19,33 @@ import java.io.IOException
 import javax.inject.Inject
 
 class SampleViewModel @Inject constructor(
-        private val postRepository: PostRepository
+        private val getPostsUseCase: GetPostsUseCase
 ): ViewModel() {
 
     val clickFlow: MutableStateFlow<Int> = MutableStateFlow(0)
     val textFlow: MutableStateFlow<String> = MutableStateFlow("Nothing yet")
-    val errorFlow = MutableSharedFlow<String>()
+    val errorFlow = MutableSharedFlow<ErrorModel>()
 
     fun clickedButton() {
         clickFlow.value++
     }
 
     fun fetchBlogPosts() {
-        postRepository
-            .getPosts()
+
+        getPostsUseCase.getPosts()
+                .onStart { /* start loading */  }
+                .onSuccess { textFlow.value = "Found ${it.size}" }
+                .onError { errorFlow.emit(it) }
+                .onCompletion { /* stop loading */ }
+                .launchIn(viewModelScope)
+
+        getPostsUseCase.getPosts()
             .onStart { /* start loading */  }
-            .onEach { blogEntries -> textFlow.value = "Found ${blogEntries.size}" }
-            .retryWhen { cause, attempt -> cause is IOException && attempt <= 2 }
-            .catch { _ -> errorFlow.emit("Something went wrong") }
+            .onSuccess { textFlow.value = "Found ${it.size}" }
+            .onError { errorFlow.emit(it) }
+            //.onEach { blogEntries -> textFlow.value = "Found ${blogEntries.size}" }
+            //.retryWhen { cause, attempt -> cause is IOException && attempt <= 2 }
+            //.catch { _ -> errorFlow.emit("Something went wrong") }
             .onCompletion { /* stop loading */ }
             .launchIn(viewModelScope)
     }