Refactor JPA entities to use proper associations.

Author: gunkim

core-impl/src/main/kotlin/io/github/gunkim/realworld/infrastructure/jpa/article/dao/ArticleDao.kt

@@ -42,8 +42,8 @@ interface ArticleDao : JpaRepository<ArticleEntity, Int>, JpaSpecificationExecut
         """
         SELECT a
         FROM users u
-             INNER JOIN user_follow uf ON uf.followerUserDatabaseId = u.databaseId
-             INNER JOIN article a ON a.authorEntity.databaseId = uf.followeeUserDatabaseId
+             INNER JOIN user_follow uf ON uf.followerEntity = u
+             INNER JOIN article a ON a.authorEntity = uf.followeeEntity
         WHERE u.id = :userId
         """
     )

core-impl/src/main/kotlin/io/github/gunkim/realworld/infrastructure/jpa/article/dao/ArticleFavoriteDao.kt

@@ -1,8 +1,10 @@
 package io.github.gunkim.realworld.infrastructure.jpa.article.dao
 
+import io.github.gunkim.realworld.infrastructure.jpa.article.model.ArticleEntity
 import io.github.gunkim.realworld.infrastructure.jpa.article.model.FavoriteEntity
+import io.github.gunkim.realworld.infrastructure.jpa.user.model.UserEntity
 import org.springframework.data.jpa.repository.JpaRepository
 
 interface ArticleFavoriteDao : JpaRepository<FavoriteEntity, Int> {
-    fun deleteByArticleEntityDatabaseIdAndUserEntityDatabaseId(articleDatabaseId: Int, userDatabaseId: Int)
+    fun deleteByArticleEntityAndUserEntity(articleEntity: ArticleEntity, userEntity: UserEntity)
 }

core-impl/src/main/kotlin/io/github/gunkim/realworld/infrastructure/jpa/article/model/ArticleEntity.kt

@@ -130,10 +130,6 @@ class ArticleEntity(
         return result
     }
 
-    override fun toString(): String {
-        return "ArticleJpaEntity(databaseId=$databaseId, id=$id, author=$authorEntity, articleTagJpaEntities=$tagEntities, createdAt=$createdAt, updatedAt=$updatedAt, slug=$slug, title='$title', description='$description', body='$body')"
-    }
-
     companion object {
         fun from(article: Article): ArticleEntity = with(article) {
             ArticleEntity(

core-impl/src/main/kotlin/io/github/gunkim/realworld/infrastructure/jpa/article/model/ArticleTagEntity.kt

@@ -53,11 +53,6 @@ class ArticleTagEntity(
         return result
     }
 
-    override fun toString(): String {
-        return "ArticleTagJpaEntity(databaseId=$databaseId, tag=$tagEntity, createdAt=$createdAt, updatedAt=$updatedAt)"
-    }
-
-
     companion object {
         fun fromTagEntity(tag: TagEntity) = ArticleTagEntity(
             tagEntity = tag,

core-impl/src/main/kotlin/io/github/gunkim/realworld/infrastructure/jpa/article/repository/ArticleRepositoryImpl.kt

@@ -25,37 +25,37 @@ class ArticleRepositoryImpl(
     private val articleFavoriteDao: ArticleFavoriteDao,
 ) : ArticleRepository, ArticleReadRepository by articleReadRepository {
     override fun save(article: Article): Article {
-        val articleJpaEntity = convertArticleToJpaEntity(article)
-        return articleDao.save(articleJpaEntity)
+        val articleEntity = convertArticleToEntity(article)
+        return articleDao.save(articleEntity)
     }
 
     override fun delete(article: Article) {
-        articleDao.delete(convertArticleToJpaEntity(article))
+        articleDao.delete(convertArticleToEntity(article))
     }
 
     override fun favorite(article: Article, user: User) {
-        val (articleJpaEntity, userJpaEntity) = mapToJpaEntities(article, user)
+        val (articleEntity, userEntity) = mapToEntities(article, user)
         articleFavoriteDao.save(
             FavoriteEntity.of(
-                articleJpaEntity,
-                userJpaEntity
+                articleEntity = articleEntity,
+                userEntity = userEntity
             )
         )
     }
 
     override fun unFavorite(article: Article, user: User) {
-        val (articleJpaEntity, userJpaEntity) = mapToJpaEntities(article, user)
-        articleFavoriteDao.deleteByArticleEntityDatabaseIdAndUserEntityDatabaseId(
-            articleJpaEntity.databaseId!!,
-            userJpaEntity.databaseId!!
+        val (articleEntity, userEntity) = mapToEntities(article, user)
+        articleFavoriteDao.deleteByArticleEntityAndUserEntity(
+            articleEntity = articleEntity,
+            userEntity = userEntity
         )
     }
 
-    private fun mapToJpaEntities(article: Article, user: User) =
-        convertArticleToJpaEntity(article) to UserEntity.from(user)
+    private fun mapToEntities(article: Article, user: User) =
+        convertArticleToEntity(article) to UserEntity.from(user)
 
-    private fun convertArticleToJpaEntity(article: Article) =
-        ArticleEntity.from(article, convertTagsToJpaEntities(article))
+    private fun convertArticleToEntity(article: Article) =
+        ArticleEntity.from(article, convertTagsToEntities(article))
 
     /**
      * Converts the `tags` associated with the provided `article` into a list of `ArticleTagJpaEntity`.
@@ -66,7 +66,7 @@ class ArticleRepositoryImpl(
      * @param article The article whose tags need to be converted to JPA entities.
      * @return A list of `ArticleTagJpaEntity` objects corresponding to the tags of the article.
      */
-    private fun convertTagsToJpaEntities(article: Article): List<ArticleTagEntity> {
+    private fun convertTagsToEntities(article: Article): List<ArticleTagEntity> {
         if (article is ArticleEntity) return article.tagEntities
 
         val tags = article.tags

core-impl/src/main/kotlin/io/github/gunkim/realworld/infrastructure/jpa/user/dao/FollowDao.kt

@@ -1,8 +1,9 @@
 package io.github.gunkim.realworld.infrastructure.jpa.user.dao
 
-import io.github.gunkim.realworld.infrastructure.jpa.user.model.FollowJpaEntity
+import io.github.gunkim.realworld.infrastructure.jpa.user.model.FollowEntity
+import io.github.gunkim.realworld.infrastructure.jpa.user.model.UserEntity
 import org.springframework.data.jpa.repository.JpaRepository
 
-interface FollowDao : JpaRepository<FollowJpaEntity, Long> {
-    fun deleteByFolloweeUserDatabaseIdAndFollowerUserDatabaseId(followingDatabaseId: Int, followerDatabaseId: Int)
+interface FollowDao : JpaRepository<FollowEntity, Long> {
+    fun deleteByFolloweeEntityAndFollowerEntity(followeeUserEntity: UserEntity, followerUserEntity: UserEntity)
 }

core-impl/src/main/kotlin/io/github/gunkim/realworld/infrastructure/jpa/user/dao/UserDao.kt

@@ -15,9 +15,9 @@ interface UserDao : JpaRepository<UserEntity, Long> {
         SELECT followee.id
         FROM users u
              INNER JOIN 
-             user_follow f ON f.followerUserDatabaseId = u.databaseId
+             user_follow f ON f.followerEntity = u
              INNER JOIN
-             users followee ON f.followeeUserDatabaseId = followee.databaseId
+             users followee ON f.followeeEntity = followee
         WHERE u.id = :userId
     """
     )

…ucture/jpa/user/model/FollowJpaEntity.kt …structure/jpa/user/model/FollowEntity.ktcore-impl/src/main/kotlin/io/github/gunkim/realworld/infrastructure/jpa/user/model/FollowJpaEntity.kt renamed to core-impl/src/main/kotlin/io/github/gunkim/realworld/infrastructure/jpa/user/model/FollowEntity.kt core-impl/src/main/kotlin/io/github/gunkim/realworld/infrastructure/jpa/user/model/FollowJpaEntity.kt renamed to core-impl/src/main/kotlin/io/github/gunkim/realworld/infrastructure/jpa/user/model/FollowEntity.kt

@@ -2,33 +2,38 @@ package io.github.gunkim.realworld.infrastructure.jpa.user.model
 
 import jakarta.persistence.Column
 import jakarta.persistence.Entity
+import jakarta.persistence.FetchType
 import jakarta.persistence.GeneratedValue
 import jakarta.persistence.GenerationType
 import jakarta.persistence.Id
+import jakarta.persistence.JoinColumn
+import jakarta.persistence.ManyToOne
 import java.time.Instant
 
 @Entity(name = "user_follow")
-class FollowJpaEntity(
+class FollowEntity(
     @Id
     @Column(name = "follow_id")
     @GeneratedValue(strategy = GenerationType.IDENTITY)
     val databaseId: Int?,
-    @Column(name = "followee_id")
-    val followeeUserDatabaseId: Int,
-    @Column(name = "follower_id")
-    val followerUserDatabaseId: Int,
+    @ManyToOne(fetch = FetchType.EAGER)
+    @JoinColumn(name = "followee_id")
+    val followeeEntity: UserEntity,
+    @ManyToOne(fetch = FetchType.EAGER)
+    @JoinColumn(name = "follower_id")
+    val followerEntity: UserEntity,
     val createdAt: Instant,
     val updatedAt: Instant = Instant.now(),
 ) {
     override fun equals(other: Any?): Boolean {
         if (this === other) return true
         if (javaClass != other?.javaClass) return false
 
-        other as FollowJpaEntity
+        other as FollowEntity
 
         if (databaseId != other.databaseId) return false
-        if (followeeUserDatabaseId != other.followeeUserDatabaseId) return false
-        if (followerUserDatabaseId != other.followerUserDatabaseId) return false
+        if (followeeEntity != other.followeeEntity) return false
+        if (followerEntity != other.followerEntity) return false
         if (createdAt != other.createdAt) return false
         if (updatedAt != other.updatedAt) return false
 
@@ -37,19 +42,19 @@ class FollowJpaEntity(
 
     override fun hashCode(): Int {
         var result = databaseId ?: 0
-        result = 31 * result + followeeUserDatabaseId
-        result = 31 * result + followerUserDatabaseId
+        result = 31 * result + followeeEntity.hashCode()
+        result = 31 * result + followerEntity.hashCode()
         result = 31 * result + createdAt.hashCode()
         result = 31 * result + updatedAt.hashCode()
         return result
     }
 
     companion object {
-        fun of(followeeId: Int, followerId: Int) =
-            FollowJpaEntity(
+        fun of(followeeUserEntity: UserEntity, followerUserEntity: UserEntity) =
+            FollowEntity(
                 databaseId = null,
-                followeeUserDatabaseId = followeeId,
-                followerUserDatabaseId = followerId,
+                followeeEntity = followeeUserEntity,
+                followerEntity = followerUserEntity,
                 createdAt = Instant.now()
             )
     }

core-impl/src/main/kotlin/io/github/gunkim/realworld/infrastructure/jpa/user/repository/UserRepositoryImpl.kt

@@ -7,7 +7,7 @@ import io.github.gunkim.realworld.domain.user.repository.UserReadRepository
 import io.github.gunkim.realworld.domain.user.repository.UserRepository
 import io.github.gunkim.realworld.infrastructure.jpa.user.dao.FollowDao
 import io.github.gunkim.realworld.infrastructure.jpa.user.dao.UserDao
-import io.github.gunkim.realworld.infrastructure.jpa.user.model.FollowJpaEntity
+import io.github.gunkim.realworld.infrastructure.jpa.user.model.FollowEntity
 import io.github.gunkim.realworld.infrastructure.jpa.user.model.UserEntity
 import org.springframework.beans.factory.annotation.Qualifier
 import org.springframework.stereotype.Repository
@@ -26,32 +26,32 @@ class UserRepositoryImpl(
     }
 
     override fun follow(followerId: UserId, followeeId: UserId) {
-        val (followerDatabaseId, followeeDatabaseId) = resolveUserDatabaseIds(followerId, followeeId)
+        val (follower, followee) = resolveUserEntity(followerId, followeeId)
         followDao.save(
-            FollowJpaEntity.of(
-                followeeId = followeeDatabaseId,
-                followerId = followerDatabaseId
+            FollowEntity.of(
+                followerUserEntity = follower,
+                followeeUserEntity = followee
             )
         )
     }
 
     override fun unfollow(followerId: UserId, followeeId: UserId) {
-        val (followerDatabaseId, followeeDatabaseId) = resolveUserDatabaseIds(followerId, followeeId)
-        followDao.deleteByFolloweeUserDatabaseIdAndFollowerUserDatabaseId(
-            followingDatabaseId = followeeDatabaseId,
-            followerDatabaseId = followerDatabaseId
+        val (follower, followee) = resolveUserEntity(followerId, followeeId)
+        followDao.deleteByFolloweeEntityAndFollowerEntity(
+            followeeUserEntity = followee,
+            followerUserEntity = follower
         )
     }
 
-    private fun resolveUserDatabaseIds(followerId: UserId, followeeId: UserId): Pair<Int, Int> {
-        val followerDatabaseId = getUserDatabaseIdOrThrow(followerId)
-        val followeeDatabaseId = getUserDatabaseIdOrThrow(followeeId)
+    private fun resolveUserEntity(followerId: UserId, followeeId: UserId): Pair<UserEntity, UserEntity> {
+        val follower = getUserEntityOrThrow(followerId)
+        val followee = getUserEntityOrThrow(followeeId)
 
-        return followerDatabaseId to followeeDatabaseId
+        return follower to followee
     }
 
-    private fun getUserDatabaseIdOrThrow(userId: UserId): Int {
-        return userDao.findById(userId)?.databaseId
+    private fun getUserEntityOrThrow(userId: UserId): UserEntity {
+        return userDao.findById(userId)
             ?: throw UserNotFoundException.fromId(userId)
     }
 }