functional domain modeling

.editorconfig

@@ -8,4 +8,4 @@ trim_trailing_whitespace=true
 insert_final_newline=true
 
 [*.{kt,kts}]
-kotlin_imports_layout=ascii
+ij_kotlin_imports_layout=*

.github/workflows/unit-test.yml

@@ -7,6 +7,7 @@ on:
   pull_request:
     branches: [ master ]
     paths-ignore: [ '**.md', '**.MD' ]
+  workflow_dispatch:
 
 env:
   CI: true

app/src/test/java/com/hoc/flowmvi/ExampleUnitTest.kt → app/src/test/java/com/hoc/flowmvi/CheckModulesTest.kt

@@ -6,6 +6,7 @@ import io.mockk.mockkClass
 import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.FlowPreview
 import org.junit.Rule
+import org.koin.test.AutoCloseKoinTest
 import org.koin.test.check.checkKoinModules
 import org.koin.test.mock.MockProviderRule
 import kotlin.test.Test
@@ -15,7 +16,7 @@ import kotlin.time.ExperimentalTime
 @FlowPreview
 @ExperimentalCoroutinesApi
 @ExperimentalTime
-class ExampleUnitTest {
+class CheckModulesTest : AutoCloseKoinTest() {
   @get:Rule
   val mockProvider = MockProviderRule.create { clazz ->
     mockkClass(clazz).also { o ->

build.gradle.kts

@@ -1,3 +1,6 @@
+import java.util.EnumSet
+import org.gradle.api.tasks.testing.logging.TestExceptionFormat
+import org.gradle.api.tasks.testing.logging.TestLogEvent
 import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 
 // Top-level build file where you can add configuration options common to all sub-projects/modules.
@@ -33,7 +36,9 @@ subprojects {
         // TODO this should all come from editorconfig https://github.com/diffplug/spotless/issues/142
         mapOf(
           "indent_size" to "2",
-          "kotlin_imports_layout" to "ascii"
+          "ij_kotlin_imports_layout" to "*",
+          "end_of_line" to "lf",
+          "charset" to "utf-8"
         )
       )
 
@@ -56,7 +61,9 @@ subprojects {
       ktlint(ktlintVersion).userData(
         mapOf(
           "indent_size" to "2",
-          "kotlin_imports_layout" to "ascii"
+          "ij_kotlin_imports_layout" to "*",
+          "end_of_line" to "lf",
+          "charset" to "utf-8"
         )
       )
 
@@ -83,6 +90,21 @@ subprojects {
           isIncludeNoLocationClasses = true
           excludes = listOf("jdk.internal.*")
         }
+
+      testLogging {
+        showExceptions = true
+        showCauses = true
+        showStackTraces = true
+        showStandardStreams = true
+        events = EnumSet.of(
+          TestLogEvent.PASSED,
+          TestLogEvent.FAILED,
+          TestLogEvent.SKIPPED,
+          TestLogEvent.STANDARD_OUT,
+          TestLogEvent.STANDARD_ERROR
+        )
+        exceptionFormat = TestExceptionFormat.FULL
+      }
     }
   }
 }

buildSrc/src/main/kotlin/deps.kt

@@ -6,7 +6,7 @@ import org.gradle.kotlin.dsl.project
 import org.gradle.plugin.use.PluginDependenciesSpec
 import org.gradle.plugin.use.PluginDependencySpec
 
-const val ktlintVersion = "0.41.0"
+const val ktlintVersion = "0.43.0"
 const val kotlinVersion = "1.5.31"
 
 object appConfig {

data/build.gradle.kts

@@ -56,4 +56,5 @@ dependencies {
 
   addUnitTest()
   testImplementation(testUtils)
+  testImplementation(deps.koin.testJunit4)
 }

data/src/main/java/com/hoc/flowmvi/data/UserRepositoryImpl.kt

@@ -1,17 +1,20 @@
 package com.hoc.flowmvi.data
 
-import arrow.core.Either
+import arrow.core.ValidatedNel
+import arrow.core.computations.either
 import arrow.core.left
 import arrow.core.leftWiden
 import arrow.core.right
+import arrow.core.valueOr
 import com.hoc.flowmvi.core.Mapper
 import com.hoc.flowmvi.core.dispatchers.CoroutineDispatchers
 import com.hoc.flowmvi.core.retrySuspend
 import com.hoc.flowmvi.data.remote.UserApiService
 import com.hoc.flowmvi.data.remote.UserBody
 import com.hoc.flowmvi.data.remote.UserResponse
-import com.hoc.flowmvi.domain.entity.User
-import com.hoc.flowmvi.domain.repository.UserError
+import com.hoc.flowmvi.domain.model.User
+import com.hoc.flowmvi.domain.model.UserError
+import com.hoc.flowmvi.domain.model.UserValidationError
 import com.hoc.flowmvi.domain.repository.UserRepository
 import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.delay
@@ -27,13 +30,14 @@ import timber.log.Timber
 import java.io.IOException
 import kotlin.time.Duration
 import kotlin.time.ExperimentalTime
+import arrow.core.Either.Companion.catch as catchEither
 
 @ExperimentalTime
 @ExperimentalCoroutinesApi
 internal class UserRepositoryImpl(
   private val userApiService: UserApiService,
   private val dispatchers: CoroutineDispatchers,
-  private val responseToDomain: Mapper<UserResponse, User>,
+  private val responseToDomain: Mapper<UserResponse, ValidatedNel<UserValidationError, User>>,
   private val domainToBody: Mapper<User, UserBody>,
   private val errorMapper: Mapper<Throwable, UserError>,
 ) : UserRepository {
@@ -44,18 +48,35 @@ internal class UserRepositoryImpl(
     class Added(val user: User) : Change()
   }
 
+  private val responseToDomainThrows: (UserResponse) -> User = { response ->
+    responseToDomain(response).let { validated ->
+      validated.valueOr {
+        val t = UserError.ValidationFailed(it.toSet())
+        logError(t, "Map $response to user")
+        throw t
+      }
+    }
+  }
+
   private val changesFlow = MutableSharedFlow<Change>(extraBufferCapacity = 64)
 
+  private suspend inline fun sendChange(change: Change) = changesFlow.emit(change)
+
+  @Suppress("NOTHING_TO_INLINE")
+  private inline fun logError(t: Throwable, message: String) = Timber.tag(TAG).e(t, message)
+
   private suspend fun getUsersFromRemote(): List<User> {
     return withContext(dispatchers.io) {
       retrySuspend(
         times = 3,
         initialDelay = Duration.milliseconds(500),
         factor = 2.0,
         shouldRetry = { it is IOException }
-      ) {
-        Timber.d("[USER_REPO] Retry times=$it")
-        userApiService.getUsers().map(responseToDomain)
+      ) { times ->
+        Timber.d("[USER_REPO] Retry times=$times")
+        userApiService
+          .getUsers()
+          .map(responseToDomainThrows)
       }
     }
   }
@@ -77,40 +98,57 @@ internal class UserRepositoryImpl(
   }
     .map { it.right().leftWiden<UserError, Nothing, List<User>>() }
     .catch {
-      Timber.tag("UserRepositoryImpl").e(it, "getUsers")
+      logError(it, "getUsers")
       emit(errorMapper(it).left())
     }
 
-  override suspend fun refresh() = Either.catch {
-    getUsersFromRemote().let { changesFlow.emit(Change.Refreshed(it)) }
-  }.tapLeft { Timber.tag("UserRepositoryImpl").e(it, "refresh") }
+  override suspend fun refresh() = catchEither { getUsersFromRemote() }
+    .tap { sendChange(Change.Refreshed(it)) }
+    .map { }
+    .tapLeft { logError(it, "refresh") }
     .mapLeft(errorMapper)
 
-  override suspend fun remove(user: User) = Either.catch {
+  override suspend fun remove(user: User) = either<UserError, Unit> {
     withContext(dispatchers.io) {
-      val response = userApiService.remove(user.id)
-      changesFlow.emit(Change.Removed(responseToDomain(response)))
-    }
-  }.tapLeft { Timber.tag("UserRepositoryImpl").e(it, "remove user=$user") }
-    .mapLeft(errorMapper)
+      val response = catchEither { userApiService.remove(user.id) }
+        .tapLeft { logError(it, "remove user=$user") }
+        .mapLeft(errorMapper)
+        .bind()
 
-  override suspend fun add(user: User) = Either.catch {
-    withContext(dispatchers.io) {
-      val body = domainToBody(user)
-      val response = userApiService.add(body)
-      changesFlow.emit(Change.Added(responseToDomain(response)))
-      extraDelay()
+      val deleted = responseToDomain(response)
+        .mapLeft { UserError.ValidationFailed(it.toSet()) }
+        .tapInvalid { logError(it, "remove user=$user") }
+        .bind()
+
+      sendChange(Change.Removed(deleted))
     }
-  }.tapLeft { Timber.tag("UserRepositoryImpl").e(it, "add user=$user") }
-    .mapLeft(errorMapper)
+  }
 
-  override suspend fun search(query: String) = Either.catch {
+  override suspend fun add(user: User) = either<UserError, Unit> {
     withContext(dispatchers.io) {
-      extraDelay()
-      userApiService.search(query).map(responseToDomain)
+      val response = catchEither { userApiService.add(domainToBody(user)) }
+        .tapLeft { logError(it, "add user=$user") }
+        .mapLeft(errorMapper)
+        .bind()
+
+      delay(400) // TODO
+
+      val added = responseToDomain(response)
+        .mapLeft { UserError.ValidationFailed(it.toSet()) }
+        .tapInvalid { logError(it, "add user=$user") }
+        .bind()
+
+      sendChange(Change.Added(added))
     }
-  }.tapLeft { Timber.tag("UserRepositoryImpl").e(it, "search query=$query") }
-    .mapLeft(errorMapper)
+  }
 
-  private suspend inline fun extraDelay() = delay(400)
+  override suspend fun search(query: String) = withContext(dispatchers.io) {
+    catchEither { userApiService.search(query).map(responseToDomainThrows) }
+      .tapLeft { logError(it, "search query=$query") }
+      .mapLeft(errorMapper)
+  }
+
+  private companion object {
+    private val TAG = UserRepositoryImpl::class.java.simpleName
+  }
 }

data/src/main/java/com/hoc/flowmvi/data/mapper/UserDomainToUserBodyMapper.kt

@@ -2,14 +2,14 @@ package com.hoc.flowmvi.data.mapper
 
 import com.hoc.flowmvi.core.Mapper
 import com.hoc.flowmvi.data.remote.UserBody
-import com.hoc.flowmvi.domain.entity.User
+import com.hoc.flowmvi.domain.model.User
 
 internal class UserDomainToUserBodyMapper : Mapper<User, UserBody> {
   override fun invoke(domain: User): UserBody {
     return UserBody(
-      email = domain.email,
-      firstName = domain.firstName,
-      lastName = domain.lastName
+      email = domain.email.value,
+      firstName = domain.firstName.value,
+      lastName = domain.lastName.value
     )
   }
 }

data/src/main/java/com/hoc/flowmvi/data/mapper/UserErrorMapper.kt

@@ -3,7 +3,7 @@ package com.hoc.flowmvi.data.mapper
 import arrow.core.nonFatalOrThrow
 import com.hoc.flowmvi.core.Mapper
 import com.hoc.flowmvi.data.remote.ErrorResponse
-import com.hoc.flowmvi.domain.repository.UserError
+import com.hoc.flowmvi.domain.model.UserError
 import com.squareup.moshi.JsonAdapter
 import okhttp3.ResponseBody
 import retrofit2.HttpException
@@ -19,6 +19,7 @@ internal class UserErrorMapper(private val errorResponseJsonAdapter: JsonAdapter
 
     return runCatching {
       when (throwable) {
+        is UserError -> throwable
         is IOException -> when (throwable) {
           is UnknownHostException -> UserError.NetworkError
           is SocketTimeoutException -> UserError.NetworkError
@@ -47,7 +48,7 @@ internal class UserErrorMapper(private val errorResponseJsonAdapter: JsonAdapter
       "internal-error" -> UserError.ServerError
       "invalid-id" -> UserError.InvalidId(id = errorResponse.data as String)
       "user-not-found" -> UserError.UserNotFound(id = errorResponse.data as String)
-      "validation-failed" -> UserError.ValidationFailed
+      "validation-failed" -> UserError.ValidationFailed(errors = emptySet())
       else -> UserError.Unexpected
     }
   }

data/src/main/java/com/hoc/flowmvi/data/mapper/UserResponseToUserDomainMapper.kt

@@ -1,12 +1,14 @@
 package com.hoc.flowmvi.data.mapper
 
+import arrow.core.ValidatedNel
 import com.hoc.flowmvi.core.Mapper
 import com.hoc.flowmvi.data.remote.UserResponse
-import com.hoc.flowmvi.domain.entity.User
+import com.hoc.flowmvi.domain.model.User
+import com.hoc.flowmvi.domain.model.UserValidationError
 
-internal class UserResponseToUserDomainMapper : Mapper<UserResponse, User> {
-  override fun invoke(response: UserResponse): User {
-    return User(
+internal class UserResponseToUserDomainMapper : Mapper<UserResponse, ValidatedNel<UserValidationError, User>> {
+  override fun invoke(response: UserResponse): ValidatedNel<UserValidationError, User> {
+    return User.create(
       id = response.id,
       avatar = response.avatar,
       email = response.email,