[🌎 Feature] 타임 라인용 목표 조회 API 개발 - Pagination 방식 offset 기반으로 변경 (#243)

* delete: 유저 정보를 활용한 타임라인 조회 API 삭제

* refactor: PaginationResult.transform() 사용 방식 lamda 형태로 통일

* refactor: 메서드 로직에 따라 get, find 명칭 구분

* refactor: lamda body 내 생략 가능한 parameter 생략

* refactor: 메서드명 내 부정확한 단어 제거(findGoalTimelineCountMap -> findGoalCountMap)

* refactor: associateWith 메서드 활용

* refactor: PaginationResult total값 Long으로 다시 변경

* fix: 목표 피드 조회 API deadline 역순으로 정렬 조회

* chore: apply lint

* fix: goals 테이블의 index 수정

* refactor: pagination cusorId type Any -> Generic으로 변경

* fix: 타임 라인 목표 조회 API paging 처리 방식 offset으로 변경

* refactor: cursor 기반 pagination 공통 모듈 cursor type long으로 통일

* refactor: pagination 공통 모듈 cursor와 offset 구분

* refactor: 미사용 코드 및 의미 없는 중복 코드 삭제

backend/application/api/src/main/kotlin/io/raemian/api/cheer/controller/CheeringController.kt

@@ -6,7 +6,7 @@ import io.raemian.api.cheer.model.CheererResult
 import io.raemian.api.cheer.model.CheeringCountResult
 import io.raemian.api.cheer.service.CheeringService
 import io.raemian.api.support.response.ApiResponse
-import io.raemian.api.support.response.PaginationResult
+import io.raemian.api.support.response.CursorPaginationResult
 import org.springframework.http.ResponseEntity
 import org.springframework.web.bind.annotation.GetMapping
 import org.springframework.web.bind.annotation.PathVariable
@@ -25,7 +25,7 @@ class CheeringController(
     fun findCheeringSquad(
         @PathVariable("lifeMapId") lifeMapId: Long,
         request: CheeringSquadPageRequest,
-    ): ResponseEntity<ApiResponse<PaginationResult<Long, CheererResult>>> =
+    ): ResponseEntity<ApiResponse<CursorPaginationResult<CheererResult>>> =
         ResponseEntity.ok().body(ApiResponse.success(cheeringService.findCheeringSquad(lifeMapId, request)))
 
     @GetMapping("/count/{userName}")

backend/application/api/src/main/kotlin/io/raemian/api/cheer/service/CheeringService.kt

@@ -8,15 +8,15 @@ import io.raemian.api.event.model.CheeredEvent
 import io.raemian.api.support.exception.CoreApiException
 import io.raemian.api.support.exception.ErrorInfo
 import io.raemian.api.support.limiter.CheeringLimiter
-import io.raemian.api.support.response.PaginationResult
+import io.raemian.api.support.response.CursorPaginationResult
 import io.raemian.storage.db.core.cheer.CheerJdbcQueryRepository
 import io.raemian.storage.db.core.cheer.Cheerer
 import io.raemian.storage.db.core.cheer.CheererRepository
 import io.raemian.storage.db.core.cheer.Cheering
 import io.raemian.storage.db.core.cheer.CheeringRepository
 import io.raemian.storage.db.core.cheer.model.CheererQueryResult
-import io.raemian.storage.db.core.common.pagination.CursorPaginationResult
 import io.raemian.storage.db.core.common.pagination.CursorPaginationTemplate
+import io.raemian.storage.db.core.common.pagination.PaginationResult
 import io.raemian.storage.db.core.lifemap.LifeMapRepository
 import io.raemian.storage.db.core.user.UserRepository
 import org.springframework.context.ApplicationEventPublisher
@@ -46,15 +46,15 @@ class CheeringService(
     }
 
     @Transactional(readOnly = true)
-    fun findCheeringSquad(lifeMapId: Long, request: CheeringSquadPageRequest): PaginationResult<Long, CheererResult> {
+    fun findCheeringSquad(lifeMapId: Long, request: CheeringSquadPageRequest): CursorPaginationResult<CheererResult> {
         val cheering = cheeringRepository.findByLifeMapId(lifeMapId)
             ?: Cheering(0, lifeMapId)
 
         val cheeringSquad = findCheeringSquadWithCursor(lifeMapId, request)
 
         val filteredCheeringSquad = cheeringSquad.transform { CheererResult.from(it) }
 
-        return PaginationResult.from(cheering.count, filteredCheeringSquad)
+        return CursorPaginationResult.from(cheering.count, filteredCheeringSquad)
     }
 
     @Transactional(readOnly = true)
@@ -89,7 +89,7 @@ class CheeringService(
         )
     }
 
-    private fun findCheeringSquadWithCursor(lifeMapId: Long, request: CheeringSquadPageRequest): CursorPaginationResult<Long, CheererQueryResult> {
+    private fun findCheeringSquadWithCursor(lifeMapId: Long, request: CheeringSquadPageRequest): PaginationResult<CheererQueryResult> {
         return CursorPaginationTemplate.execute(lifeMapId, request.cursor ?: Long.MAX_VALUE, request.size) {
                 id, cursor, size ->
             cheererJdbcQueryRepository.findAllByLifeMapWithCursor(id, cursor, size)

backend/application/api/src/main/kotlin/io/raemian/api/goal/controller/request/TimelinePageRequest.kt

@@ -1,8 +1,6 @@
 package io.raemian.api.goal.controller.request
 
-import java.time.LocalDateTime
-
 data class TimelinePageRequest(
-    val cursor: LocalDateTime?,
-    val size: Int,
+    val page: Int = 0,
+    val size: Int = 20,
 )

backend/application/api/src/main/kotlin/io/raemian/api/goal/service/GoalQueryService.kt

@@ -6,38 +6,38 @@ import io.raemian.api.goal.controller.request.TimelinePageRequest
 import io.raemian.api.goal.model.GoalTimelineCountSubset
 import io.raemian.api.goal.model.GoalTimelinePageResult
 import io.raemian.api.lifemap.service.LifeMapService
-import io.raemian.api.support.constant.LocalDateTimeConstant
-import io.raemian.api.support.response.PaginationResult
+import io.raemian.api.support.response.OffsetPaginationResult
 import io.raemian.api.task.service.TaskService
-import io.raemian.storage.db.core.common.pagination.CursorPaginationResult
-import io.raemian.storage.db.core.common.pagination.CursorPaginationTemplate
 import io.raemian.storage.db.core.goal.GoalJdbcQueryRepository
-import io.raemian.storage.db.core.goal.model.GoalQueryResult
+import io.raemian.storage.db.core.goal.GoalRepository
 import org.springframework.stereotype.Service
 import org.springframework.transaction.annotation.Transactional
-import java.time.LocalDateTime
 
 @Service
 class GoalQueryService(
     private val lifeMapService: LifeMapService,
     private val goalJdbcQueryRepository: GoalJdbcQueryRepository,
+    private val goalRepository: GoalRepository,
     private val emojiService: EmojiService,
     private val taskService: TaskService,
     private val commentService: CommentService,
 ) {
     @Transactional(readOnly = true)
-    fun findAllByUsernameWithCursor(username: String, request: TimelinePageRequest): PaginationResult<LocalDateTime, GoalTimelinePageResult> {
+    fun findAllByUsernameWithOffset(username: String, request: TimelinePageRequest): OffsetPaginationResult<GoalTimelinePageResult> {
         val lifeMap = lifeMapService.getFirstByUserName(username)
-        val goals = findAllByLifeMapIdWithCursor(lifeMap.lifeMapId, request)
+        val goals = goalJdbcQueryRepository.findAllByLifeMapWithOffset(lifeMap.lifeMapId, request.page, request.size)
+        val total = goalRepository.countByLifeMapId(lifeMap.lifeMapId)
 
-        val goalIds = goals.contents.map { it.goalId }
+        val goalIds = goals.map { it.goalId }
 
         val goalCountMap = findGoalCountMap(goalIds)
         val reactedEmojiMap = emojiService.findAllByGoalIds(goalIds, lifeMap.user.id)
 
-        return PaginationResult.from(
-            lifeMap.goals.size,
-            goals.transform {
+        return OffsetPaginationResult.of(
+            request.page,
+            request.size,
+            total,
+            goals.map {
                 GoalTimelinePageResult.from(
                     goal = it,
                     counts = goalCountMap[it.goalId],
@@ -58,11 +58,4 @@ class GoalQueryService(
             )
         }
     }
-
-    private fun findAllByLifeMapIdWithCursor(lifeMapId: Long, request: TimelinePageRequest): CursorPaginationResult<LocalDateTime, GoalQueryResult> {
-        return CursorPaginationTemplate.execute(lifeMapId, request.cursor ?: LocalDateTimeConstant.MAX, request.size) {
-                id, cursor, size ->
-            goalJdbcQueryRepository.findAllByLifeMapWithCursor(id, cursor, size)
-        }
-    }
 }

backend/application/api/src/main/kotlin/io/raemian/api/lifemap/controller/LifeMapController.kt

@@ -2,7 +2,6 @@ package io.raemian.api.lifemap.controller
 
 import io.raemian.api.auth.model.CurrentUser
 import io.raemian.api.cheer.service.CheeringService
-import io.raemian.api.goal.service.GoalQueryService
 import io.raemian.api.lifemap.controller.request.UpdatePublicRequest
 import io.raemian.api.lifemap.model.LifeMapResponse
 import io.raemian.api.lifemap.service.LifeMapService
@@ -21,7 +20,6 @@ import org.springframework.web.bind.annotation.RestController
 class LifeMapController(
     private val lifeMapService: LifeMapService,
     private val cheeringService: CheeringService,
-    private val goalQueryService: GoalQueryService,
 ) {
 
     @Operation(summary = "로그인한 유저의 인생 지도 조회 API")

backend/application/api/src/main/kotlin/io/raemian/api/lifemap/controller/OpenLifeMapController.kt

@@ -8,15 +8,14 @@ import io.raemian.api.goal.service.GoalQueryService
 import io.raemian.api.lifemap.model.LifeMapResponse
 import io.raemian.api.lifemap.service.LifeMapService
 import io.raemian.api.support.response.ApiResponse
-import io.raemian.api.support.response.PaginationResult
+import io.raemian.api.support.response.OffsetPaginationResult
 import io.swagger.v3.oas.annotations.Operation
 import org.springframework.http.ResponseEntity
 import org.springframework.security.core.annotation.AuthenticationPrincipal
 import org.springframework.web.bind.annotation.GetMapping
 import org.springframework.web.bind.annotation.PathVariable
 import org.springframework.web.bind.annotation.RequestMapping
 import org.springframework.web.bind.annotation.RestController
-import java.time.LocalDateTime
 
 @RestController
 @RequestMapping("/open/life-map")
@@ -51,8 +50,8 @@ class OpenLifeMapController(
     fun getTimeline(
         @PathVariable("username") username: String,
         request: TimelinePageRequest,
-    ): ResponseEntity<ApiResponse<PaginationResult<LocalDateTime, GoalTimelinePageResult>>> {
-        val goalTimeline = goalQueryService.findAllByUsernameWithCursor(username, request)
+    ): ResponseEntity<ApiResponse<OffsetPaginationResult<GoalTimelinePageResult>>> {
+        val goalTimeline = goalQueryService.findAllByUsernameWithOffset(username, request)
         return ResponseEntity.ok(ApiResponse.success(goalTimeline))
     }
 }

backend/application/api/src/main/kotlin/io/raemian/api/support/response/PaginationResult.kt → backend/application/api/src/main/kotlin/io/raemian/api/support/response/CursorPaginationResult.kt

@@ -1,25 +1,25 @@
 package io.raemian.api.support.response
 
-import io.raemian.storage.db.core.common.pagination.CursorPaginationResult
+import io.raemian.storage.db.core.common.pagination.PaginationResult
 
-data class PaginationResult<CursorType, T>(
+data class CursorPaginationResult<T>(
     val total: Long,
     val contents: List<T>,
     val isLast: Boolean,
-    val nextCursor: CursorType?,
+    val nextCursor: Long?,
 ) {
     companion object {
-        fun <CursorType, T> from(total: Long, result: CursorPaginationResult<CursorType, T>): PaginationResult<CursorType, T> {
-            return PaginationResult(
+        fun <T> from(total: Long, result: PaginationResult<T>): CursorPaginationResult<T> {
+            return CursorPaginationResult(
                 total = total,
                 contents = result.contents,
                 isLast = result.isLast,
                 nextCursor = result.nextCursor,
             )
         }
 
-        fun <CursorType, T> from(total: Int, result: CursorPaginationResult<CursorType, T>): PaginationResult<CursorType, T> {
-            return PaginationResult(
+        fun <T> from(total: Int, result: PaginationResult<T>): CursorPaginationResult<T> {
+            return CursorPaginationResult(
                 total = total.toLong(),
                 contents = result.contents,
                 isLast = result.isLast,

backend/application/api/src/main/kotlin/io/raemian/api/support/response/OffsetPaginationResult.kt

@@ -0,0 +1,14 @@
+package io.raemian.api.support.response
+
+data class OffsetPaginationResult<T>(
+    val total: Long,
+    val page: Int,
+    val size: Int,
+    val contents: List<T>,
+) {
+    companion object {
+        fun <T> of(page: Int, size: Int, total: Long, contents: List<T>): OffsetPaginationResult<T> {
+            return OffsetPaginationResult(total, page, size, contents)
+        }
+    }
+}

backend/storage/db-core/src/main/kotlin/io/raemian/storage/db/core/cheer/model/CheererQueryResult.kt

@@ -10,6 +10,6 @@ data class CheererQueryResult(
     val userNickName: String?,
     val userImageUrl: String?,
     val cheeringAt: LocalDateTime,
-) : CursorExtractable<Long> {
+) : CursorExtractable {
     override fun cursorId(): Long = cheererId
 }

backend/storage/db-core/src/main/kotlin/io/raemian/storage/db/core/common/pagination/CursorExtractable.kt

@@ -1,5 +1,5 @@
 package io.raemian.storage.db.core.common.pagination
 
-interface CursorExtractable<CursorType> {
-    fun cursorId(): CursorType
+interface CursorExtractable {
+    fun cursorId(): Long
 }

backend/storage/db-core/src/main/kotlin/io/raemian/storage/db/core/common/pagination/CursorPaginationTemplate.kt

@@ -3,17 +3,17 @@ package io.raemian.storage.db.core.common.pagination
 import kotlin.math.min
 
 object CursorPaginationTemplate {
-    fun <CursorType, T : CursorExtractable<CursorType>> execute(
+    fun <T : CursorExtractable> execute(
         id: Long,
-        cursorId: CursorType,
+        cursorId: Long,
         size: Int,
-        query: TriFunction<Long, CursorType, Int, List<T>>,
-    ): CursorPaginationResult<CursorType, T> {
+        query: TriFunction<Long, Long, Int, List<T>>,
+    ): PaginationResult<T> {
         val data = query.apply(id, cursorId, size + 1)
         val isLast = data.size != size + 1
         val nextCursor = if (isLast) null else data[size].cursorId()
 
-        return CursorPaginationResult(
+        return PaginationResult(
             data.subList(0, min(data.size, size)),
             nextCursor,
             isLast,

backend/storage/db-core/src/main/kotlin/io/raemian/storage/db/core/common/pagination/CursorPaginationResult.kt → backend/storage/db-core/src/main/kotlin/io/raemian/storage/db/core/common/pagination/PaginationResult.kt

@@ -2,13 +2,13 @@ package io.raemian.storage.db.core.common.pagination
 
 import java.util.function.Function
 
-data class CursorPaginationResult<CursorType, T> internal constructor(
+data class PaginationResult<T> internal constructor(
     val contents: List<T>,
-    val nextCursor: CursorType?,
+    val nextCursor: Long?,
     val isLast: Boolean,
 ) {
-    fun <R> transform(transformer: Function<T, R>): CursorPaginationResult<CursorType, R> {
-        return CursorPaginationResult(
+    fun <R> transform(transformer: Function<T, R>): PaginationResult<R> {
+        return PaginationResult(
             contents.stream().map(transformer).toList(),
             nextCursor,
             isLast,

backend/storage/db-core/src/main/kotlin/io/raemian/storage/db/core/goal/GoalJdbcQueryRepository.kt

@@ -10,7 +10,7 @@ import java.time.LocalDateTime
 class GoalJdbcQueryRepository(
     private val jdbcTemplate: NamedParameterJdbcTemplate,
 ) {
-    fun findAllByLifeMapWithCursor(lifeMapId: Long, cursor: LocalDateTime, size: Int): List<GoalQueryResult> {
+    fun findAllByLifeMapWithOffset(lifeMapId: Long, page: Int, size: Int): List<GoalQueryResult> {
         val sql =
             """
            SELECT
@@ -26,14 +26,14 @@ class GoalJdbcQueryRepository(
            LEFT OUTER JOIN stickers s ON g.STICKER_ID = s.ID
            WHERE 1 = 1
                AND g.LIFE_MAP_ID = :lifeMapId
-               AND g.DEADLINE <= :cursor
            ORDER BY g.DEADLINE DESC
            LIMIT :size
+           OFFSET :page
             """.trimIndent()
 
         val namedParameter = MapSqlParameterSource()
             .addValue("lifeMapId", lifeMapId)
-            .addValue("cursor", cursor)
+            .addValue("page", page)
             .addValue("size", size)
 
         return jdbcTemplate.query(sql, namedParameter) {

backend/storage/db-core/src/main/kotlin/io/raemian/storage/db/core/goal/GoalRepository.kt

@@ -8,6 +8,9 @@ import org.springframework.data.repository.query.Param
 import java.time.LocalDateTime
 
 interface GoalRepository : JpaRepository<Goal, Long> {
+
+    fun countByLifeMapId(lifeMapId: Long): Long
+
     fun findUserByCreatedAtGreaterThanEqual(createdAt: LocalDateTime): List<Goal>
 
     override fun getById(id: Long): Goal =

backend/storage/db-core/src/main/kotlin/io/raemian/storage/db/core/goal/model/GoalQueryResult.kt

@@ -1,6 +1,5 @@
 package io.raemian.storage.db.core.goal.model
 
-import io.raemian.storage.db.core.common.pagination.CursorExtractable
 import java.time.LocalDateTime
 
 data class GoalQueryResult(
@@ -11,6 +10,4 @@ data class GoalQueryResult(
     val stickerUrl: String,
     val tag: String,
     val createdAt: LocalDateTime,
-) : CursorExtractable<LocalDateTime> {
-    override fun cursorId(): LocalDateTime = deadline
-}
+)