feat: repositoryにtransactionを追加

src/main/kotlin/dev/usbharu/hideout/repository/IJwtRefreshTokenRepository.kt

@@ -3,6 +3,8 @@ package dev.usbharu.hideout.repository
 import dev.usbharu.hideout.domain.model.hideout.entity.JwtRefreshToken
 
 interface IJwtRefreshTokenRepository {
+    suspend fun <T> transaction(block: suspend () -> T):T
+
     suspend fun generateId(): Long
 
     suspend fun save(token: JwtRefreshToken)

src/main/kotlin/dev/usbharu/hideout/repository/IMetaRepository.kt

@@ -4,6 +4,8 @@ import dev.usbharu.hideout.domain.model.hideout.entity.Meta
 
 interface IMetaRepository {
 
+    suspend fun <T> transaction(block: suspend () -> T):T
+
     suspend fun save(meta: Meta)
 
     suspend fun get(): Meta?

src/main/kotlin/dev/usbharu/hideout/repository/IPostRepository.kt

@@ -7,4 +7,6 @@ interface IPostRepository {
     suspend fun insert(post: Post): PostEntity
     suspend fun findOneById(id: Long): PostEntity
     suspend fun delete(id: Long)
+    @Suppress("InjectDispatcher")
+    suspend fun <T> transaction(block: suspend () -> T): T
 }

src/main/kotlin/dev/usbharu/hideout/repository/IUserRepository.kt

@@ -36,4 +36,6 @@ interface IUserRepository {
     suspend fun findFollowersById(id: Long): List<User>
 
     suspend fun nextId(): Long
+    @Suppress("InjectDispatcher")
+    suspend fun <T> transaction(block: suspend () -> T): T
 }

src/main/kotlin/dev/usbharu/hideout/repository/JwtRefreshTokenRepositoryImpl.kt

@@ -1,6 +1,8 @@
 package dev.usbharu.hideout.repository
 
 import dev.usbharu.hideout.domain.model.hideout.entity.JwtRefreshToken
+import dev.usbharu.hideout.repository.JwtRefreshTokens.id
+import dev.usbharu.hideout.repository.JwtRefreshTokens.refreshToken
 import dev.usbharu.hideout.service.IdGenerateService
 import kotlinx.coroutines.Dispatchers
 import org.jetbrains.exposed.sql.*
@@ -25,14 +27,13 @@ class JwtRefreshTokenRepositoryImpl(
     }
 
     @Suppress("InjectDispatcher")
-    suspend fun <T> query(block: suspend () -> T): T =
+    override suspend fun <T> transaction(block: suspend () -> T): T =
         newSuspendedTransaction(Dispatchers.IO) { block() }
 
     override suspend fun generateId(): Long = idGenerateService.generateId()
 
     override suspend fun save(token: JwtRefreshToken) {
-        query {
+        if (JwtRefreshTokens.select { id.eq(token.id) }.empty()) {
-            if (JwtRefreshTokens.select { JwtRefreshTokens.id.eq(token.id) }.empty()) {
             JwtRefreshTokens.insert {
                 it[id] = token.id
                 it[userId] = token.userId
@@ -41,7 +42,7 @@ class JwtRefreshTokenRepositoryImpl(
                 it[expiresAt] = token.expiresAt.toEpochMilli()
             }
         } else {
-                JwtRefreshTokens.update({ JwtRefreshTokens.id eq token.id }) {
+            JwtRefreshTokens.update({ id eq token.id }) {
                 it[userId] = token.userId
                 it[refreshToken] = token.refreshToken
                 it[createdAt] = token.createdAt.toEpochMilli()
@@ -49,55 +50,38 @@ class JwtRefreshTokenRepositoryImpl(
             }
         }
     }
-    }
 
     override suspend fun findById(id: Long): JwtRefreshToken? {
-        return query {
+        return JwtRefreshTokens.select { JwtRefreshTokens.id.eq(id) }.singleOrNull()?.toJwtRefreshToken()
-            JwtRefreshTokens.select { JwtRefreshTokens.id.eq(id) }.singleOrNull()?.toJwtRefreshToken()
-        }
     }
 
     override suspend fun findByToken(token: String): JwtRefreshToken? {
-        return query {
+        return JwtRefreshTokens.select { refreshToken.eq(token) }.singleOrNull()?.toJwtRefreshToken()
-            JwtRefreshTokens.select { JwtRefreshTokens.refreshToken.eq(token) }.singleOrNull()?.toJwtRefreshToken()
-        }
     }
 
     override suspend fun findByUserId(userId: Long): JwtRefreshToken? {
-        return query {
+        return JwtRefreshTokens.select { JwtRefreshTokens.userId.eq(userId) }.singleOrNull()?.toJwtRefreshToken()
-            JwtRefreshTokens.select { JwtRefreshTokens.userId.eq(userId) }.singleOrNull()?.toJwtRefreshToken()
-        }
     }
 
     override suspend fun delete(token: JwtRefreshToken) {
-        return query {
+        JwtRefreshTokens.deleteWhere { id eq token.id }
-            JwtRefreshTokens.deleteWhere { JwtRefreshTokens.id eq token.id }
-        }
     }
 
     override suspend fun deleteById(id: Long) {
-        return query {
         JwtRefreshTokens.deleteWhere { JwtRefreshTokens.id eq id }
     }
-    }
 
     override suspend fun deleteByToken(token: String) {
-        return query {
+        JwtRefreshTokens.deleteWhere { refreshToken eq token }
-            JwtRefreshTokens.deleteWhere { JwtRefreshTokens.refreshToken eq token }
-        }
     }
 
     override suspend fun deleteByUserId(userId: Long) {
-        return query {
         JwtRefreshTokens.deleteWhere { JwtRefreshTokens.userId eq userId }
     }
-    }
 
     override suspend fun deleteAll() {
-        return query {
         JwtRefreshTokens.deleteAll()
     }
-    }
 }
 
 fun ResultRow.toJwtRefreshToken(): JwtRefreshToken {

src/main/kotlin/dev/usbharu/hideout/repository/MetaRepositoryImpl.kt

@@ -1,6 +1,8 @@
 package dev.usbharu.hideout.repository
 
 import dev.usbharu.hideout.domain.model.hideout.entity.Jwt
+import dev.usbharu.hideout.repository.Meta.id
+import dev.usbharu.hideout.repository.Meta.kid
 import kotlinx.coroutines.Dispatchers
 import org.jetbrains.exposed.sql.*
 import org.jetbrains.exposed.sql.transactions.experimental.newSuspendedTransaction
@@ -19,40 +21,36 @@ class MetaRepositoryImpl(private val database: Database) : IMetaRepository {
     }
 
     @Suppress("InjectDispatcher")
-    suspend fun <T> query(block: suspend () -> T): T =
+    override suspend fun <T> transaction(block: suspend () -> T): T =
         newSuspendedTransaction(Dispatchers.IO) { block() }
 
     override suspend fun save(meta: dev.usbharu.hideout.domain.model.hideout.entity.Meta) {
-        return query {
+        if (Meta.select { id eq 1 }.empty()) {
-            if (Meta.select { Meta.id eq 1 }.empty()) {
             Meta.insert {
                 it[id] = 1
-                    it[this.version] = meta.version
+                it[version] = meta.version
                 it[kid] = UUID.randomUUID().toString()
-                    it[this.jwtPrivateKey] = meta.jwt.privateKey
+                it[jwtPrivateKey] = meta.jwt.privateKey
-                    it[this.jwtPublicKey] = meta.jwt.publicKey
+                it[jwtPublicKey] = meta.jwt.publicKey
             }
         } else {
-                Meta.update({ Meta.id eq 1 }) {
+            Meta.update({ id eq 1 }) {
-                    it[this.version] = meta.version
+                it[version] = meta.version
                 it[kid] = UUID.randomUUID().toString()
-                    it[this.jwtPrivateKey] = meta.jwt.privateKey
+                it[jwtPrivateKey] = meta.jwt.privateKey
-                    it[this.jwtPublicKey] = meta.jwt.publicKey
+                it[jwtPublicKey] = meta.jwt.publicKey
-                }
             }
         }
     }
 
     override suspend fun get(): dev.usbharu.hideout.domain.model.hideout.entity.Meta? {
-        return query {
+        return Meta.select { id eq 1 }.singleOrNull()?.let {
-            Meta.select { Meta.id eq 1 }.singleOrNull()?.let {
             dev.usbharu.hideout.domain.model.hideout.entity.Meta(
                 it[Meta.version],
-                    Jwt(UUID.fromString(it[Meta.kid]), it[Meta.jwtPrivateKey], it[Meta.jwtPublicKey])
+                Jwt(UUID.fromString(it[kid]), it[Meta.jwtPrivateKey], it[Meta.jwtPublicKey])
             )
         }
     }
-    }
 }
 
 object Meta : Table("meta_info") {

src/main/kotlin/dev/usbharu/hideout/repository/PostRepositoryImpl.kt

@@ -23,11 +23,10 @@ class PostRepositoryImpl(database: Database, private val idGenerateService: IdGe
     }
 
     @Suppress("InjectDispatcher")
-    suspend fun <T> query(block: suspend () -> T): T =
+    override suspend fun <T> transaction(block: suspend () -> T): T =
         newSuspendedTransaction(Dispatchers.IO) { block() }
 
     override suspend fun insert(post: Post): PostEntity {
-        return query {
         val generateId = idGenerateService.generateId()
         val name = Users.select { Users.id eq post.userId }.single().toUser().name
         val postUrl = Config.configData.url + "/users/$name/posts/$generateId"
@@ -42,7 +41,7 @@ class PostRepositoryImpl(database: Database, private val idGenerateService: IdGe
             it[repostId] = post.repostId
             it[replyId] = post.replyId
         }
-            return@query PostEntity(
+        return PostEntity(
             id = generateId,
             userId = post.userId,
             overview = post.overview,
@@ -54,17 +53,10 @@ class PostRepositoryImpl(database: Database, private val idGenerateService: IdGe
             replyId = post.replyId
         )
     }
-    }
 
-    override suspend fun findOneById(id: Long): PostEntity {
+    override suspend fun findOneById(id: Long): PostEntity = Posts.select { Posts.id eq id }.single().toPost()
-        return query {
-            Posts.select { Posts.id eq id }.single().toPost()
-        }
-    }
 
     override suspend fun delete(id: Long) {
-        return query {
         Posts.deleteWhere { Posts.id eq id }
     }
-    }
 }

src/main/kotlin/dev/usbharu/hideout/repository/UserRepository.kt

@@ -1,6 +1,19 @@
 package dev.usbharu.hideout.repository
 
 import dev.usbharu.hideout.domain.model.hideout.entity.User
+import dev.usbharu.hideout.repository.Users.createdAt
+import dev.usbharu.hideout.repository.Users.description
+import dev.usbharu.hideout.repository.Users.domain
+import dev.usbharu.hideout.repository.Users.id
+import dev.usbharu.hideout.repository.Users.inbox
+import dev.usbharu.hideout.repository.Users.name
+import dev.usbharu.hideout.repository.Users.outbox
+import dev.usbharu.hideout.repository.Users.password
+import dev.usbharu.hideout.repository.Users.privateKey
+import dev.usbharu.hideout.repository.Users.publicKey
+import dev.usbharu.hideout.repository.Users.screenName
+import dev.usbharu.hideout.repository.Users.url
+import dev.usbharu.hideout.repository.UsersFollowers.followerId
 import dev.usbharu.hideout.service.IdGenerateService
 import kotlinx.coroutines.Dispatchers
 import org.jetbrains.exposed.dao.id.LongIdTable
@@ -24,12 +37,11 @@ class UserRepository(private val database: Database, private val idGenerateServi
     }
 
     @Suppress("InjectDispatcher")
-    suspend fun <T> query(block: suspend () -> T): T =
+    override suspend fun <T> transaction(block: suspend () -> T): T =
         newSuspendedTransaction(Dispatchers.IO) { block() }
 
     override suspend fun save(user: User): User {
-        return query {
+        val singleOrNull = Users.select { id eq user.id }.singleOrNull()
-            val singleOrNull = Users.select { Users.id eq user.id }.singleOrNull()
         if (singleOrNull == null) {
             Users.insert {
                 it[id] = user.id
@@ -46,7 +58,7 @@ class UserRepository(private val database: Database, private val idGenerateServi
                 it[privateKey] = user.privateKey
             }
         } else {
-                Users.update({ Users.id eq user.id }) {
+            Users.update({ id eq user.id }) {
                 it[name] = user.name
                 it[domain] = user.domain
                 it[screenName] = user.screenName
@@ -60,149 +72,113 @@ class UserRepository(private val database: Database, private val idGenerateServi
                 it[privateKey] = user.privateKey
             }
         }
-            return@query user
+        return user
-        }
     }
 
     override suspend fun createFollower(id: Long, follower: Long) {
-        return query {
         UsersFollowers.insert {
             it[userId] = id
             it[followerId] = follower
         }
     }
-    }
 
     override suspend fun findById(id: Long): User? {
-        return query {
+        return Users.select { Users.id eq id }.map {
-            Users.select { Users.id eq id }.map {
             it.toUser()
         }.singleOrNull()
     }
-    }
 
     override suspend fun findByIds(ids: List<Long>): List<User> {
-        return query {
+        return Users.select { id inList ids }.map {
-            Users.select { Users.id inList ids }.map {
             it.toUser()
         }
     }
-    }
 
     override suspend fun findByName(name: String): List<User> {
-        return query {
+        return Users.select { Users.name eq name }.map {
-            Users.select { Users.name eq name }.map {
             it.toUser()
         }
     }
-    }
 
-    override suspend fun findByNameAndDomain(name: String, domain: String): User? {
+    override suspend fun findByNameAndDomain(name: String, domain: String): User? =
-        return query {
         Users.select { Users.name eq name and (Users.domain eq domain) }.singleOrNull()?.toUser()
-        }
-    }
 
     override suspend fun findByDomain(domain: String): List<User> {
-        return query {
+        return Users.select { Users.domain eq domain }.map {
-            Users.select { Users.domain eq domain }.map {
             it.toUser()
         }
     }
-    }
 
     override suspend fun findByNameAndDomains(names: List<Pair<String, String>>): List<User> {
-        return query {
         val selectAll = Users.selectAll()
         names.forEach { (name, domain) ->
             selectAll.orWhere { Users.name eq name and (Users.domain eq domain) }
         }
-            selectAll.map { it.toUser() }
+        return selectAll.map { it.toUser() }
-        }
     }
 
-    override suspend fun findByUrl(url: String): User? {
+    override suspend fun findByUrl(url: String): User? = Users.select { Users.url eq url }.singleOrNull()?.toUser()
-        return query {
-            Users.select { Users.url eq url }.singleOrNull()?.toUser()
-        }
-    }
 
-    override suspend fun findByUrls(urls: List<String>): List<User> {
+    override suspend fun findByUrls(urls: List<String>): List<User> =
-        return query {
+        Users.select { url inList urls }.map { it.toUser() }
-            Users.select { Users.url inList urls }.map { it.toUser() }
-        }
-    }
 
     override suspend fun findFollowersById(id: Long): List<User> {
-        return query {
         val followers = Users.alias("FOLLOWERS")
-            Users.innerJoin(
+        return Users.innerJoin(
             otherTable = UsersFollowers,
             onColumn = { Users.id },
             otherColumn = { userId }
         )
             .innerJoin(
                 otherTable = followers,
-                    onColumn = { UsersFollowers.followerId },
+                onColumn = { followerId },
                 otherColumn = { followers[Users.id] }
             )
             .slice(
                 followers.get(Users.id),
-                    followers.get(Users.name),
+                followers.get(name),
-                    followers.get(Users.domain),
+                followers.get(domain),
-                    followers.get(Users.screenName),
+                followers.get(screenName),
-                    followers.get(Users.description),
+                followers.get(description),
-                    followers.get(Users.password),
+                followers.get(password),
-                    followers.get(Users.inbox),
+                followers.get(inbox),
-                    followers.get(Users.outbox),
+                followers.get(outbox),
-                    followers.get(Users.url),
+                followers.get(url),
-                    followers.get(Users.publicKey),
+                followers.get(publicKey),
-                    followers.get(Users.privateKey),
+                followers.get(privateKey),
-                    followers.get(Users.createdAt)
+                followers.get(createdAt)
             )
             .select { Users.id eq id }
             .map {
                 User(
                     id = it[followers[Users.id]],
-                        name = it[followers[Users.name]],
+                    name = it[followers[name]],
-                        domain = it[followers[Users.domain]],
+                    domain = it[followers[domain]],
-                        screenName = it[followers[Users.screenName]],
+                    screenName = it[followers[screenName]],
-                        description = it[followers[Users.description]],
+                    description = it[followers[description]],
-                        password = it[followers[Users.password]],
+                    password = it[followers[password]],
-                        inbox = it[followers[Users.inbox]],
+                    inbox = it[followers[inbox]],
-                        outbox = it[followers[Users.outbox]],
+                    outbox = it[followers[outbox]],
-                        url = it[followers[Users.url]],
+                    url = it[followers[url]],
-                        publicKey = it[followers[Users.publicKey]],
+                    publicKey = it[followers[publicKey]],
-                        privateKey = it[followers[Users.privateKey]],
+                    privateKey = it[followers[privateKey]],
-                        createdAt = Instant.ofEpochMilli(it[followers[Users.createdAt]])
+                    createdAt = Instant.ofEpochMilli(it[followers[createdAt]])
                 )
             }
     }
-    }
 
     override suspend fun delete(id: Long) {
-        query {
         Users.deleteWhere { Users.id.eq(id) }
     }
-    }
 
     override suspend fun deleteFollower(id: Long, follower: Long) {
-        query {
         UsersFollowers.deleteWhere { (userId eq id).and(followerId eq follower) }
     }
-    }
 
-    override suspend fun findAll(): List<User> {
+    override suspend fun findAll(): List<User> = Users.selectAll().map { it.toUser() }
-        return query {
-            Users.selectAll().map { it.toUser() }
-        }
-    }
 
-    override suspend fun findAllByLimitAndByOffset(limit: Int, offset: Long): List<User> {
+    override suspend fun findAllByLimitAndByOffset(limit: Int, offset: Long): List<User> =
-        return query {
         Users.selectAll().limit(limit, offset).map { it.toUser() }
-        }
-    }
 
     override suspend fun nextId(): Long = idGenerateService.generateId()
 }

src/main/kotlin/dev/usbharu/hideout/service/ServerInitialiseServiceImpl.kt

@@ -16,21 +16,24 @@ class ServerInitialiseServiceImpl(private val metaRepository: IMetaRepository) :
     val logger: Logger = LoggerFactory.getLogger(ServerInitialiseServiceImpl::class.java)
 
     override suspend fun init() {
+        metaRepository.transaction {
+
             val savedMeta = metaRepository.get()
             val implementationVersion = ServerUtil.getImplementationVersion()
             if (wasInitialised(savedMeta).not()) {
                 logger.info("Start Initialise")
                 initialise(implementationVersion)
                 logger.info("Finish Initialise")
-            return
+                return@transaction
             }
-
             if (isVersionChanged(savedMeta!!)) {
                 logger.info("Version changed!! (${savedMeta.version} -> $implementationVersion)")
                 updateVersion(savedMeta, implementationVersion)
             }
         }
 
+    }
+
     private fun wasInitialised(meta: Meta?): Boolean {
         logger.debug("Initialise checking...")
         return meta != null

src/test/kotlin/dev/usbharu/hideout/repository/UserRepositoryTest.kt

@@ -9,6 +9,7 @@ import kotlinx.coroutines.test.runTest
 import org.jetbrains.exposed.sql.Database
 import org.jetbrains.exposed.sql.SchemaUtils
 import org.jetbrains.exposed.sql.select
+import org.jetbrains.exposed.sql.transactions.experimental.newSuspendedTransaction
 import org.jetbrains.exposed.sql.transactions.transaction
 import org.junit.jupiter.api.AfterEach
 import org.junit.jupiter.api.Assertions.assertIterableEquals
@@ -41,6 +42,7 @@ class UserRepositoryTest {
 
     @Test
     fun `findFollowersById フォロワー一覧を取得`() = runTest {
+        newSuspendedTransaction {
             val userRepository = UserRepository(
                 db,
                 object : IdGenerateService {
@@ -100,9 +102,11 @@ class UserRepositoryTest {
                 assertIterableEquals(listOf(follower, follower2), it)
             }
         }
+    }
 
     @Test
     fun `createFollower フォロワー追加`() = runTest {
+        newSuspendedTransaction {
             val userRepository = UserRepository(
                 db,
                 object : IdGenerateService {
@@ -142,10 +146,11 @@ class UserRepositoryTest {
                 )
             )
             userRepository.createFollower(user.id, follower.id)
-        transaction {
+
             val followerIds =
                 UsersFollowers.select { UsersFollowers.userId eq user.id }.map { it[UsersFollowers.followerId] }
             assertIterableEquals(listOf(follower.id), followerIds)
+
         }
     }
 }

src/test/kotlin/dev/usbharu/hideout/service/ServerInitialiseServiceImplTest.kt

@@ -19,38 +19,48 @@ class ServerInitialiseServiceImplTest {
         val metaRepository = mock<IMetaRepository> {
             onBlocking { get() } doReturn null
             onBlocking { save(any()) } doReturn Unit
+            onBlocking {
+                transaction(any<suspend () -> Unit>())
+            } doSuspendableAnswer {
+                (it.arguments[0] as suspend () -> Unit).invoke()
+            }
         }
         val serverInitialiseServiceImpl = ServerInitialiseServiceImpl(metaRepository)
 
         serverInitialiseServiceImpl.init()
-        verify(metaRepository,times(1)).save(any())
+        verify(metaRepository, times(1)).save(any())
     }
 
     @Test
     fun `init メタデータが存在して同じバージョンのときは何もしない`() = runTest {
-        val meta = Meta(ServerUtil.getImplementationVersion(), Jwt(UUID.randomUUID(),"aaafafd","afafasdf"))
+        val meta = Meta(ServerUtil.getImplementationVersion(), Jwt(UUID.randomUUID(), "aaafafd", "afafasdf"))
         val metaRepository = mock<IMetaRepository> {
             onBlocking { get() } doReturn meta
         }
         val serverInitialiseServiceImpl = ServerInitialiseServiceImpl(metaRepository)
         serverInitialiseServiceImpl.init()
-        verify(metaRepository,times(0)).save(any())
+        verify(metaRepository, times(0)).save(any())
     }
 
     @Test
     fun `init メタデータが存在して違うバージョンのときはバージョンを変更する`() = runTest {
-        val meta = Meta("1.0.0", Jwt(UUID.randomUUID(),"aaafafd","afafasdf"))
+        val meta = Meta("1.0.0", Jwt(UUID.randomUUID(), "aaafafd", "afafasdf"))
         val metaRepository = mock<IMetaRepository> {
             onBlocking { get() } doReturn meta
             onBlocking { save(any()) } doReturn Unit
+            onBlocking {
+                transaction(any<suspend () -> Unit>())
+            } doSuspendableAnswer {
+                (it.arguments[0] as suspend () -> Unit).invoke()
+            }
         }
 
         val serverInitialiseServiceImpl = ServerInitialiseServiceImpl(metaRepository)
         serverInitialiseServiceImpl.init()
-        verify(metaRepository,times(1)).save(any())
+        verify(metaRepository, times(1)).save(any())
         argumentCaptor<Meta> {
-            verify(metaRepository,times(1)).save(capture())
+            verify(metaRepository, times(1)).save(capture())
-            assertEquals(ServerUtil.getImplementationVersion(),firstValue.version)
+            assertEquals(ServerUtil.getImplementationVersion(), firstValue.version)
         }
     }
 }