Use transactions at the http layer

persistance/src/main/kotlin/notes/NoteRepositoryImpl.kt

@@ -1,6 +1,9 @@
 package be.simplenotes.persistance.notes
 
-import be.simplenotes.domain.model.*
+import be.simplenotes.domain.model.ExportedNote
+import be.simplenotes.domain.model.Note
+import be.simplenotes.domain.model.PersistedNote
+import be.simplenotes.domain.model.PersistedNoteMetadata
 import be.simplenotes.domain.usecases.repositories.NoteRepository
 import me.liuwj.ktorm.database.Database
 import me.liuwj.ktorm.dsl.*
@@ -59,14 +62,12 @@ internal class NoteRepositoryImpl(private val db: Database) : NoteRepository {
         val entity = note.toEntity(uuid, userId).apply {
             this.updatedAt = LocalDateTime.now()
         }
-        db.useTransaction {
-            db.notes.add(entity)
-            db.batchInsert(Tags) {
-                note.meta.tags.forEach { tagName ->
-                    item {
-                        it.noteUuid to uuid
-                        it.name to tagName
-                    }
+        db.notes.add(entity)
+        db.batchInsert(Tags) {
+            note.meta.tags.forEach { tagName ->
+                item {
+                    it.noteUuid to uuid
+                    it.name to tagName
                 }
             }
         }
@@ -90,64 +91,56 @@ internal class NoteRepositoryImpl(private val db: Database) : NoteRepository {
     }
 
     override fun update(userId: Int, uuid: UUID, note: Note): PersistedNote? {
-        db.useTransaction {
-
-            val now = LocalDateTime.now()
-            val count = db.update(Notes) {
-                it.title to note.meta.title
-                it.markdown to note.markdown
-                it.html to note.html
-                it.updatedAt to now
-                where { (it.uuid eq uuid) and (it.userId eq userId) and (it.deleted eq false) }
-            }
-
-            if (count == 0) return null
-
-            // delete all tags
-            db.delete(Tags) {
-                it.noteUuid eq uuid
-            }
-
-            // put new ones
-            note.meta.tags.forEach { tagName ->
-                db.insert(Tags) {
-                    it.name to tagName
-                    it.noteUuid to uuid
-                }
-            }
-
-            return PersistedNote(
-                meta = note.meta,
-                markdown = note.markdown,
-                html = note.html,
-                updatedAt = now,
-                uuid = uuid,
-                public = false, // TODO
-            )
+        val now = LocalDateTime.now()
+        val count = db.update(Notes) {
+            it.title to note.meta.title
+            it.markdown to note.markdown
+            it.html to note.html
+            it.updatedAt to now
+            where { (it.uuid eq uuid) and (it.userId eq userId) and (it.deleted eq false) }
         }
+
+        if (count == 0) return null
+
+        // delete all tags
+        db.delete(Tags) {
+            it.noteUuid eq uuid
+        }
+
+        // put new ones
+        note.meta.tags.forEach { tagName ->
+            db.insert(Tags) {
+                it.name to tagName
+                it.noteUuid to uuid
+            }
+        }
+
+        return PersistedNote(
+            meta = note.meta,
+            markdown = note.markdown,
+            html = note.html,
+            updatedAt = now,
+            uuid = uuid,
+            public = false, // TODO
+        )
     }
 
     override fun delete(userId: Int, uuid: UUID, permanent: Boolean): Boolean {
         return if (!permanent) {
-            db.useTransaction {
-                db.update(Notes) {
-                    it.deleted to true
-                    it.updatedAt to LocalDateTime.now()
-                    where { it.userId eq userId and (it.uuid eq uuid) }
-                }
+            db.update(Notes) {
+                it.deleted to true
+                it.updatedAt to LocalDateTime.now()
+                where { it.userId eq userId and (it.uuid eq uuid) }
             } == 1
-        } else db.useTransaction {
+        } else
             db.delete(Notes) { it.uuid eq uuid and (it.userId eq userId) } == 1
-        }
     }
 
     override fun restore(userId: Int, uuid: UUID): Boolean {
-        return db.useTransaction {
-            db.update(Notes) {
-                it.deleted to false
-                where { (it.userId eq userId) and (it.uuid eq uuid) }
-            } == 1
-        }
+        return db.update(Notes) {
+            it.deleted to false
+            where { (it.userId eq userId) and (it.uuid eq uuid) }
+        } == 1
     }
 
     override fun getTags(userId: Int): List<String> =

persistance/src/main/kotlin/users/UserRepositoryImpl.kt

@@ -3,21 +3,20 @@ package be.simplenotes.persistance.users
 import be.simplenotes.domain.model.PersistedUser
 import be.simplenotes.domain.model.User
 import be.simplenotes.domain.usecases.repositories.UserRepository
-import me.liuwj.ktorm.database.*
+import me.liuwj.ktorm.database.Database
 import me.liuwj.ktorm.dsl.*
-import me.liuwj.ktorm.entity.*
+import me.liuwj.ktorm.entity.any
+import me.liuwj.ktorm.entity.find
 import java.sql.SQLIntegrityConstraintViolationException
 
 internal class UserRepositoryImpl(private val db: Database) : UserRepository {
     override fun create(user: User): PersistedUser? {
         return try {
-            db.useTransaction {
-                val id = db.insertAndGenerateKey(Users) {
-                    it.username to user.username
-                    it.password to user.password
-                } as Int
-                PersistedUser(user.username, user.password, id)
-            }
+            val id = db.insertAndGenerateKey(Users) {
+                it.username to user.username
+                it.password to user.password
+            } as Int
+            PersistedUser(user.username, user.password, id)
         } catch (e: SQLIntegrityConstraintViolationException) {
             null
         }
@@ -27,6 +26,6 @@ internal class UserRepositoryImpl(private val db: Database) : UserRepository {
     override fun find(id: Int) = db.users.find { it.id eq id }?.toPersistedUser()
     override fun exists(username: String) = db.users.any { it.username eq username }
     override fun exists(id: Int) = db.users.any { it.id eq id }
-    override fun delete(id: Int) = db.useTransaction { db.delete(Users) { it.id eq id } == 1 }
+    override fun delete(id: Int) = db.delete(Users) { it.id eq id } == 1
     override fun findAll() = db.from(Users).select(Users.id).map { it[Users.id]!! }
 }