Move transactions to domain layer

simplenotes-domain/src/main/kotlin/be/simplenotes/domain/usecases/NoteService.kt

@@ -6,6 +6,7 @@ import be.simplenotes.domain.usecases.markdown.MarkdownConverter
 import be.simplenotes.domain.usecases.markdown.MarkdownParsingError
 import be.simplenotes.persistance.repositories.NoteRepository
 import be.simplenotes.persistance.repositories.UserRepository
+import be.simplenotes.persistance.transactions.TransactionService
 import be.simplenotes.search.NoteSearcher
 import be.simplenotes.search.SearchTerms
 import be.simplenotes.types.LoggedInUser
@@ -24,30 +25,35 @@ class NoteService(
     private val userRepository: UserRepository,
     private val searcher: NoteSearcher,
     private val htmlSanitizer: HtmlSanitizer,
+    private val transaction: TransactionService,
 ) {
 
-    fun create(user: LoggedInUser, markdownText: String) = either.eager<MarkdownParsingError, PersistedNote> {
-        val persistedNote = !markdownConverter.renderDocument(markdownText)
-            .map { it.copy(html = htmlSanitizer.sanitize(user, it.html)) }
-            .map { Note(it.metadata, markdown = markdownText, html = it.html) }
-            .map { noteRepository.create(user.userId, it) }
+    fun create(user: LoggedInUser, markdownText: String) = transaction.use {
+        either.eager<MarkdownParsingError, PersistedNote> {
+            val persistedNote = !markdownConverter.renderDocument(markdownText)
+                .map { it.copy(html = htmlSanitizer.sanitize(user, it.html)) }
+                .map { Note(it.metadata, markdown = markdownText, html = it.html) }
+                .map { noteRepository.create(user.userId, it) }
 
-        searcher.indexNote(user.userId, persistedNote)
-        persistedNote
+            searcher.indexNote(user.userId, persistedNote)
+            persistedNote
+        }
     }
 
     fun update(
         user: LoggedInUser,
         uuid: UUID,
         markdownText: String,
-    ) = either.eager<MarkdownParsingError, PersistedNote?> {
-        val persistedNote = !markdownConverter.renderDocument(markdownText)
-            .map { it.copy(html = htmlSanitizer.sanitize(user, it.html)) }
-            .map { Note(it.metadata, markdown = markdownText, html = it.html) }
-            .map { noteRepository.update(user.userId, uuid, it) }
+    ) = transaction.use {
+        either.eager<MarkdownParsingError, PersistedNote?> {
+            val persistedNote = !markdownConverter.renderDocument(markdownText)
+                .map { it.copy(html = htmlSanitizer.sanitize(user, it.html)) }
+                .map { Note(it.metadata, markdown = markdownText, html = it.html) }
+                .map { noteRepository.update(user.userId, uuid, it) }
 
-        persistedNote?.let { searcher.updateIndex(user.userId, it) }
-        persistedNote
+            persistedNote?.let { searcher.updateIndex(user.userId, it) }
+            persistedNote
+        }
     }
 
     fun paginatedNotes(
@@ -66,22 +72,22 @@ class NoteService(
 
     fun find(userId: Int, uuid: UUID) = noteRepository.find(userId, uuid)
 
-    fun trash(userId: Int, uuid: UUID): Boolean {
+    fun trash(userId: Int, uuid: UUID): Boolean = transaction.use {
         val res = noteRepository.delete(userId, uuid, permanent = false)
         if (res) searcher.deleteIndex(userId, uuid)
-        return res
+        res
     }
 
-    fun restore(userId: Int, uuid: UUID): Boolean {
+    fun restore(userId: Int, uuid: UUID): Boolean = transaction.use {
         val res = noteRepository.restore(userId, uuid)
         if (res) find(userId, uuid)?.let { note -> searcher.indexNote(userId, note) }
-        return res
+        res
     }
 
-    fun delete(userId: Int, uuid: UUID): Boolean {
+    fun delete(userId: Int, uuid: UUID): Boolean = transaction.use {
         val res = noteRepository.delete(userId, uuid, permanent = true)
         if (res) searcher.deleteIndex(userId, uuid)
-        return res
+        res
     }
 
     fun countDeleted(userId: Int) = noteRepository.count(userId, deleted = true)
@@ -101,8 +107,8 @@ class NoteService(
     @PreDestroy
     fun dropAllIndexes() = searcher.dropAll()
 
-    fun makePublic(userId: Int, uuid: UUID) = noteRepository.makePublic(userId, uuid)
-    fun makePrivate(userId: Int, uuid: UUID) = noteRepository.makePrivate(userId, uuid)
+    fun makePublic(userId: Int, uuid: UUID) = transaction.use { noteRepository.makePublic(userId, uuid) }
+    fun makePrivate(userId: Int, uuid: UUID) = transaction.use { noteRepository.makePrivate(userId, uuid) }
     fun findPublic(uuid: UUID) = noteRepository.findPublic(uuid)
 }
 

simplenotes-domain/src/main/kotlin/be/simplenotes/domain/usecases/users/delete/DeleteUseCaseImpl.kt

@@ -6,6 +6,7 @@ import arrow.core.rightIfNotNull
 import be.simplenotes.domain.security.PasswordHash
 import be.simplenotes.domain.validation.UserValidations
 import be.simplenotes.persistance.repositories.UserRepository
+import be.simplenotes.persistance.transactions.TransactionService
 import be.simplenotes.search.NoteSearcher
 import io.micronaut.context.annotation.Primary
 import javax.inject.Singleton
@@ -16,16 +17,19 @@ internal class DeleteUseCaseImpl(
     private val userRepository: UserRepository,
     private val passwordHash: PasswordHash,
     private val searcher: NoteSearcher,
+    private val transactionService: TransactionService,
 ) : DeleteUseCase {
-    override fun delete(form: DeleteForm) = either.eager<DeleteError, Unit> {
-        val user = !UserValidations.validateDelete(form)
-        val persistedUser = !userRepository.find(user.username).rightIfNotNull { DeleteError.Unregistered }
-        !Either.conditionally(
-            passwordHash.verify(user.password, persistedUser.password),
-            { DeleteError.WrongPassword },
-            { Unit }
-        )
-        !Either.conditionally(userRepository.delete(persistedUser.id), { DeleteError.Unregistered }, { Unit })
-        searcher.dropIndex(persistedUser.id)
+    override fun delete(form: DeleteForm) = transactionService.use {
+        either.eager<DeleteError, Unit> {
+            val user = !UserValidations.validateDelete(form)
+            val persistedUser = !userRepository.find(user.username).rightIfNotNull { DeleteError.Unregistered }
+            !Either.conditionally(
+                passwordHash.verify(user.password, persistedUser.password),
+                { DeleteError.WrongPassword },
+                { Unit }
+            )
+            !Either.conditionally(userRepository.delete(persistedUser.id), { DeleteError.Unregistered }, { Unit })
+            searcher.dropIndex(persistedUser.id)
+        }
     }
 }

simplenotes-domain/src/main/kotlin/be/simplenotes/domain/usecases/users/register/RegisterUseCaseImpl.kt

@@ -6,6 +6,7 @@ import arrow.core.leftIfNull
 import be.simplenotes.domain.security.PasswordHash
 import be.simplenotes.domain.validation.UserValidations
 import be.simplenotes.persistance.repositories.UserRepository
+import be.simplenotes.persistance.transactions.TransactionService
 import be.simplenotes.types.PersistedUser
 import io.micronaut.context.annotation.Primary
 import javax.inject.Singleton
@@ -14,10 +15,11 @@ import javax.inject.Singleton
 @Singleton
 internal class RegisterUseCaseImpl(
     private val userRepository: UserRepository,
-    private val passwordHash: PasswordHash
+    private val passwordHash: PasswordHash,
+    private val transactionService: TransactionService,
 ) : RegisterUseCase {
-    override fun register(form: RegisterForm): Either<RegisterError, PersistedUser> {
-        return UserValidations.validateRegister(form)
+    override fun register(form: RegisterForm): Either<RegisterError, PersistedUser> = transactionService.use {
+        UserValidations.validateRegister(form)
             .filterOrElse({ !userRepository.exists(it.username) }, { UserExists })
             .map { it.copy(password = passwordHash.crypt(it.password)) }
             .map { userRepository.create(it) }

simplenotes-domain/src/test/kotlin/be/simplenotes/domain/usecases/users/register/RegisterUseCaseImplTest.kt

@@ -4,6 +4,7 @@ import be.simplenotes.domain.security.BcryptPasswordHash
 import be.simplenotes.domain.testutils.isLeftOfType
 import be.simplenotes.domain.testutils.isRight
 import be.simplenotes.persistance.repositories.UserRepository
+import be.simplenotes.persistance.transactions.TransactionService
 import be.simplenotes.types.PersistedUser
 import com.natpryce.hamkrest.assertion.assertThat
 import com.natpryce.hamkrest.equalTo
@@ -16,7 +17,10 @@ internal class RegisterUseCaseImplTest {
     // region setup
     private val mockUserRepository = mockk<UserRepository>()
     private val passwordHash = BcryptPasswordHash(test = true)
-    private val registerUseCase = RegisterUseCaseImpl(mockUserRepository, passwordHash)
+    private val noopTransactionService = object : TransactionService {
+        override fun <T> use(block: () -> T) = block()
+    }
+    private val registerUseCase = RegisterUseCaseImpl(mockUserRepository, passwordHash, noopTransactionService)
 
     @BeforeEach
     fun resetMocks() {