refactor: extract shared repository transaction wrapper

Add DatabaseManager.suspendedTransaction() extension function that wraps
newSuspendedTransaction + try/catch into a single call. Apply across all
33 suspend repository methods in SQLiteNoteRepository (7),
SQLiteRoleTransitionRepository (5), and SQLiteWorkItemRepository (21).

Net reduction of ~80 lines of boilerplate. Consolidates the deprecated
newSuspendedTransaction call to a single site for future Exposed migration.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: jpicklyk

current/src/main/kotlin/io/github/jpicklyk/mcptask/current/infrastructure/repository/SQLiteNoteRepository.kt

@@ -14,7 +14,6 @@ import org.jetbrains.exposed.v1.jdbc.deleteWhere
 import org.jetbrains.exposed.v1.jdbc.insert
 import org.jetbrains.exposed.v1.jdbc.selectAll
 import org.jetbrains.exposed.v1.jdbc.update
-import org.jetbrains.exposed.v1.jdbc.transactions.experimental.newSuspendedTransaction
 import java.time.Instant
 import java.util.UUID
 
@@ -23,22 +22,19 @@ import java.util.UUID
  */
 class SQLiteNoteRepository(private val databaseManager: DatabaseManager) : NoteRepository {
 
-    override suspend fun getById(id: UUID): Result<Note> = try {
-        newSuspendedTransaction(db = databaseManager.getDatabase()) {
+    override suspend fun getById(id: UUID): Result<Note> =
+        databaseManager.suspendedTransaction("Failed to get Note by id") {
             val row = NotesTable.selectAll().where { NotesTable.id eq id }.singleOrNull()
             if (row != null) {
                 Result.Success(mapRowToNote(row))
             } else {
                 Result.Error(RepositoryError.NotFound(id, "Note not found with id: $id"))
             }
         }
-    } catch (e: Exception) {
-        Result.Error(RepositoryError.DatabaseError("Failed to get Note by id: ${e.message}", e))
-    }
 
-    override suspend fun upsert(note: Note): Result<Note> = try {
-        note.validate()
-        newSuspendedTransaction(db = databaseManager.getDatabase()) {
+    override suspend fun upsert(note: Note): Result<Note> =
+        databaseManager.suspendedTransaction("Failed to upsert Note") {
+            note.validate()
             // Check if a note with the same (itemId, key) already exists
             val existing = NotesTable.selectAll()
                 .where { (NotesTable.itemId eq note.itemId) and (NotesTable.key eq note.key) }
@@ -69,30 +65,21 @@ class SQLiteNoteRepository(private val databaseManager: DatabaseManager) : NoteR
                 Result.Success(note)
             }
         }
-    } catch (e: Exception) {
-        Result.Error(RepositoryError.DatabaseError("Failed to upsert Note: ${e.message}", e))
-    }
 
-    override suspend fun delete(id: UUID): Result<Boolean> = try {
-        newSuspendedTransaction(db = databaseManager.getDatabase()) {
+    override suspend fun delete(id: UUID): Result<Boolean> =
+        databaseManager.suspendedTransaction("Failed to delete Note") {
             val deletedCount = NotesTable.deleteWhere { NotesTable.id eq id }
             Result.Success(deletedCount > 0)
         }
-    } catch (e: Exception) {
-        Result.Error(RepositoryError.DatabaseError("Failed to delete Note: ${e.message}", e))
-    }
 
-    override suspend fun deleteByItemId(itemId: UUID): Result<Int> = try {
-        newSuspendedTransaction(db = databaseManager.getDatabase()) {
+    override suspend fun deleteByItemId(itemId: UUID): Result<Int> =
+        databaseManager.suspendedTransaction("Failed to delete Notes by itemId") {
             val deletedCount = NotesTable.deleteWhere { NotesTable.itemId eq itemId }
             Result.Success(deletedCount)
         }
-    } catch (e: Exception) {
-        Result.Error(RepositoryError.DatabaseError("Failed to delete Notes by itemId: ${e.message}", e))
-    }
 
-    override suspend fun findByItemId(itemId: UUID, role: String?): Result<List<Note>> = try {
-        newSuspendedTransaction(db = databaseManager.getDatabase()) {
+    override suspend fun findByItemId(itemId: UUID, role: String?): Result<List<Note>> =
+        databaseManager.suspendedTransaction("Failed to find Notes by itemId") {
             val notes = if (role != null) {
                 NotesTable.selectAll()
                     .where { (NotesTable.itemId eq itemId) and (NotesTable.role eq role) }
@@ -102,34 +89,24 @@ class SQLiteNoteRepository(private val databaseManager: DatabaseManager) : NoteR
             }.map { mapRowToNote(it) }
             Result.Success(notes)
         }
-    } catch (e: Exception) {
-        Result.Error(RepositoryError.DatabaseError("Failed to find Notes by itemId: ${e.message}", e))
-    }
 
     override suspend fun findByItemIds(itemIds: Set<UUID>): Result<Map<UUID, List<Note>>> {
         if (itemIds.isEmpty()) return Result.Success(emptyMap())
-        return try {
-            newSuspendedTransaction(db = databaseManager.getDatabase()) {
-                val notes = NotesTable.selectAll()
-                    .where { NotesTable.itemId inList itemIds }
-                    .map { mapRowToNote(it) }
-                Result.Success(notes.groupBy { it.itemId })
-            }
-        } catch (e: Exception) {
-            Result.Error(RepositoryError.DatabaseError("Failed to find Notes by itemIds: ${e.message}", e))
+        return databaseManager.suspendedTransaction("Failed to find Notes by itemIds") {
+            val notes = NotesTable.selectAll()
+                .where { NotesTable.itemId inList itemIds }
+                .map { mapRowToNote(it) }
+            Result.Success(notes.groupBy { it.itemId })
         }
     }
 
-    override suspend fun findByItemIdAndKey(itemId: UUID, key: String): Result<Note?> = try {
-        newSuspendedTransaction(db = databaseManager.getDatabase()) {
+    override suspend fun findByItemIdAndKey(itemId: UUID, key: String): Result<Note?> =
+        databaseManager.suspendedTransaction("Failed to find Note by itemId and key") {
             val row = NotesTable.selectAll()
                 .where { (NotesTable.itemId eq itemId) and (NotesTable.key eq key) }
                 .singleOrNull()
             Result.Success(row?.let { mapRowToNote(it) })
         }
-    } catch (e: Exception) {
-        Result.Error(RepositoryError.DatabaseError("Failed to find Note by itemId and key: ${e.message}", e))
-    }
 
     private fun mapRowToNote(row: ResultRow): Note {
         return Note(

current/src/main/kotlin/io/github/jpicklyk/mcptask/current/infrastructure/repository/SQLiteRoleTransitionRepository.kt

@@ -1,7 +1,6 @@
 package io.github.jpicklyk.mcptask.current.infrastructure.repository
 
 import io.github.jpicklyk.mcptask.current.domain.model.RoleTransition
-import io.github.jpicklyk.mcptask.current.domain.repository.RepositoryError
 import io.github.jpicklyk.mcptask.current.domain.repository.Result
 import io.github.jpicklyk.mcptask.current.domain.repository.RoleTransitionRepository
 import io.github.jpicklyk.mcptask.current.infrastructure.database.DatabaseManager
@@ -15,7 +14,6 @@ import org.jetbrains.exposed.v1.jdbc.andWhere
 import org.jetbrains.exposed.v1.jdbc.deleteWhere
 import org.jetbrains.exposed.v1.jdbc.insert
 import org.jetbrains.exposed.v1.jdbc.selectAll
-import org.jetbrains.exposed.v1.jdbc.transactions.experimental.newSuspendedTransaction
 import java.time.Instant
 import java.util.UUID
 
@@ -24,8 +22,8 @@ import java.util.UUID
  */
 class SQLiteRoleTransitionRepository(private val databaseManager: DatabaseManager) : RoleTransitionRepository {
 
-    override suspend fun create(transition: RoleTransition): Result<RoleTransition> = try {
-        newSuspendedTransaction(db = databaseManager.getDatabase()) {
+    override suspend fun create(transition: RoleTransition): Result<RoleTransition> =
+        databaseManager.suspendedTransaction("Failed to create RoleTransition") {
             RoleTransitionsTable.insert {
                 it[id] = transition.id
                 it[itemId] = transition.itemId
@@ -39,30 +37,24 @@ class SQLiteRoleTransitionRepository(private val databaseManager: DatabaseManage
             }
             Result.Success(transition)
         }
-    } catch (e: Exception) {
-        Result.Error(RepositoryError.DatabaseError("Failed to create RoleTransition: ${e.message}", e))
-    }
 
-    override suspend fun findByItemId(itemId: UUID, limit: Int): Result<List<RoleTransition>> = try {
-        newSuspendedTransaction(db = databaseManager.getDatabase()) {
+    override suspend fun findByItemId(itemId: UUID, limit: Int): Result<List<RoleTransition>> =
+        databaseManager.suspendedTransaction("Failed to find RoleTransitions by itemId") {
             val transitions = RoleTransitionsTable.selectAll()
                 .where { RoleTransitionsTable.itemId eq itemId }
                 .orderBy(RoleTransitionsTable.transitionedAt, SortOrder.DESC)
                 .limit(limit)
                 .map { mapRowToRoleTransition(it) }
             Result.Success(transitions)
         }
-    } catch (e: Exception) {
-        Result.Error(RepositoryError.DatabaseError("Failed to find RoleTransitions by itemId: ${e.message}", e))
-    }
 
     override suspend fun findByTimeRange(
         startTime: Instant,
         endTime: Instant,
         role: String?,
         limit: Int
-    ): Result<List<RoleTransition>> = try {
-        newSuspendedTransaction(db = databaseManager.getDatabase()) {
+    ): Result<List<RoleTransition>> =
+        databaseManager.suspendedTransaction("Failed to find RoleTransitions by time range") {
             var query = RoleTransitionsTable.selectAll().where {
                 (RoleTransitionsTable.transitionedAt greaterEq startTime) and
                         (RoleTransitionsTable.transitionedAt lessEq endTime)
@@ -80,31 +72,22 @@ class SQLiteRoleTransitionRepository(private val databaseManager: DatabaseManage
                 .map { mapRowToRoleTransition(it) }
             Result.Success(transitions)
         }
-    } catch (e: Exception) {
-        Result.Error(RepositoryError.DatabaseError("Failed to find RoleTransitions by time range: ${e.message}", e))
-    }
 
-    override suspend fun findSince(since: Instant, limit: Int): Result<List<RoleTransition>> = try {
-        newSuspendedTransaction(db = databaseManager.getDatabase()) {
+    override suspend fun findSince(since: Instant, limit: Int): Result<List<RoleTransition>> =
+        databaseManager.suspendedTransaction("Failed to find transitions since $since") {
             val results = RoleTransitionsTable.selectAll()
                 .where { RoleTransitionsTable.transitionedAt greaterEq since }
                 .orderBy(RoleTransitionsTable.transitionedAt, SortOrder.DESC)
                 .limit(limit)
                 .map { mapRowToRoleTransition(it) }
             Result.Success(results)
         }
-    } catch (e: Exception) {
-        Result.Error(RepositoryError.DatabaseError("Failed to find transitions since $since: ${e.message}", e))
-    }
 
-    override suspend fun deleteByItemId(itemId: UUID): Result<Int> = try {
-        newSuspendedTransaction(db = databaseManager.getDatabase()) {
+    override suspend fun deleteByItemId(itemId: UUID): Result<Int> =
+        databaseManager.suspendedTransaction("Failed to delete RoleTransitions by itemId") {
             val deletedCount = RoleTransitionsTable.deleteWhere { RoleTransitionsTable.itemId eq itemId }
             Result.Success(deletedCount)
         }
-    } catch (e: Exception) {
-        Result.Error(RepositoryError.DatabaseError("Failed to delete RoleTransitions by itemId: ${e.message}", e))
-    }
 
     private fun mapRowToRoleTransition(row: ResultRow): RoleTransition {
         return RoleTransition(