코틀린 서버 프로그래밍: 타임라인 API 설계

                                    🤵 클라이언트

상황1. 나는 팔로우 10명을 가진 A이다.

- 나는 오늘 "밥 뭐먹을지 추천해주세요"라는 글을 작성하였다.
- 이 게시글은 나를 팔로우한 10명에게 도잘해야한다.

상황2. 나는 A라는 유저를 팔로우하고 있는 B이다.
- 나는 오늘 A가 "밥 뭐먹을지 추천해주세요"라는 글을 보고, 내 주변의 맛집을 생각하게 되었다.

                                    👩‍🍳 서버
상황 1로부터...
- A로 부터 게시글 "밥 뭐먹을지 추천해주세요"를 저장해달라는 요청을 받았다.
- 게시글을 저장후, A의 팔로워들에게 전달하기 위해 팔로워 별 게시글 id별
   timeline table에 게시글 번호를 저장한다.

상황 2로부터...
- B로부터 자신이 팔로웆 중인 모든 유저의(A포함) 게시글을 달라는 요청을 받았다.
- timeline table을 참고하여, B에게 최신 timeline부터 10개씩 잘라서 전송한다.

                                    timelines 테이블 생성

id  receiver_id  board_id  created_at
1      10         12         ...
2      11         12         ...

                                    package com.example.frontServer.entity

import jakarta.persistence.*
import org.springframework.data.annotation.CreatedDate
import org.springframework.data.jpa.domain.support.AuditingEntityListener
import java.time.LocalDateTime

@Entity
@Table(name = "timelines")
@EntityListeners(AuditingEntityListener::class)
class Timeline(
    @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
    val id: Long? = null,

    val receiverId: Long,

    val boardId: Long,

    @CreatedDate
    var createdAt: LocalDateTime? = null
)

                                    package com.example.frontServer.service.board

import com.example.frontServer.dto.*
import com.example.frontServer.dto.board.BoardAllResult
import com.example.frontServer.dto.board.BoardCommentResult
import com.example.frontServer.dto.board.BoardResult
import com.example.frontServer.dto.board.BoardSaveRequest
import com.example.frontServer.dto.timeline.TimelineBoardResult
import com.example.frontServer.dto.timeline.TimelineRequest
import com.example.frontServer.entity.Board
import com.example.frontServer.repository.BoardRepository
import com.example.frontServer.repository.FollowRepository
import com.example.frontServer.service.FileService
import com.example.frontServer.service.LikeService
import com.example.frontServer.service.NotificationService
import jakarta.transaction.Transactional
import org.springframework.stereotype.Service
import java.util.*

@Service
class BoardService(
    private val boardRepository: BoardRepository,
    private val notificationService: NotificationService,
    private val fileService: FileService,
    private val followRepository: FollowRepository,
    private val likeService: LikeService,
    private val boardTimelineService: BoardTimelineService
) {
    // (중략)
    @Transactional
    fun save(request: BoardSaveRequest, userId: Long, username: String) {
        // (내부 중략)

        // 유저의 팔로워 목록
        val receivers = followRepository.findFollowersByUsername(username).map {it.id!!}
        saveTimeline(boardId, receivers)
    }

    private fun saveTimeline(boardId: Long, receivers: List<Long>) {
        boardTimelineService.saveTimeline(boardId, receivers)
    }
}

                                    package com.example.frontServer.service.board

import com.example.frontServer.dto.timeline.TimelineBoardResult
import com.example.frontServer.dto.timeline.TimelineRequest
import com.example.frontServer.repository.BoardRepository
import com.example.frontServer.service.TimelineService
import jakarta.transaction.Transactional
import org.springframework.stereotype.Service

@Service
class BoardTimelineService( // board-timeline rep or api connection
    private val timelineService: TimelineService,
    private val boardRepository: BoardRepository,
) {
    @Transactional
    fun findTimelineNext(timelineRequest: TimelineRequest): List<TimelineBoardResult> {
        val ids = findTimelineNextBoardIds(timelineRequest)
            return boardRepository.findAllWithCommentCountByIds(ids)
            .map { TimelineBoardResult.of(it) }
    }

    @Transactional
    fun findTimelineBefore(timelineRequest: TimelineRequest): List<TimelineBoardResult> {
        val ids = findTimelineBeforeBoardIds(timelineRequest)
        return boardRepository.findAllWithCommentCountByIds(ids)
            .map { TimelineBoardResult.of(it) }
    }

    private fun findTimelineNextBoardIds(timelineRequest: TimelineRequest): List<Long> {
        return timelineService.findAllNextBoardIds(timelineRequest)
    }

    private fun findTimelineBeforeBoardIds(timelineRequest: TimelineRequest): List<Long> {
        return timelineService.findAllBeforeBoardIds(timelineRequest)
    }

    fun saveTimeline(boardId: Long, followers: List<Long>) {
        timelineService.save(boardId, followers)
    }
}

                                    package com.example.frontServer.service

import com.example.frontServer.dto.timeline.TimelineRequest
import com.example.frontServer.entity.Timeline
import com.example.frontServer.repository.timeline.TimelineCursorRepository
import com.example.frontServer.repository.timeline.TimelineRepository
import org.springframework.stereotype.Service
import org.springframework.transaction.annotation.Transactional

@Service
class TimelineService(
    private val timelineRepository: TimelineRepository,
    private val timelinesCursorRepository: TimelineCursorRepository,
) {
    fun findAllNextBoardIds(timelineRequest: TimelineRequest): List<Long> {
        return timelineRepository.findAllNextBoardIds(timelineRequest)
            .map { it.boardId }
    }

    fun findAllBeforeBoardIds(timelineRequest: TimelineRequest): List<Long> {
        return timelineRepository.findAllBeforeBoardIds(timelineRequest)
            .map { it.boardId }
    }

    @Transactional
    fun save(boardId: Long, followersId: List<Long>) {
        followersId.map {
            timelineRepository.save(
                Timeline(
                    boardId = boardId,
                    receiverId = it
                )
            )
        }
    }

}

                                    * 양방향 스크롤 대응

1. 양방향 스크롤을 구현하려면, 이전과 이후에 대한 기준이 필요합니다.
2. timeline은 현재 구조상 id값이 낮을수록 오래된 timeline 높을수록 최신 timeline입니다.
3. client가 가지고 있는 board_id의 최소, 최대 값을 기준으로 이전 타임라인과, 이후 타임라인을
    가져올 수 있습니다.

                                    package com.example.frontServer.repository.timeline

import com.example.frontServer.dto.timeline.TimelineRequest
import com.example.frontServer.entity.QTimeline
import com.example.frontServer.entity.Timeline
import com.querydsl.jpa.impl.JPAQueryFactory

class TimelineQueryDslRepositoryImpl(
    private val jpaQueryFactory: JPAQueryFactory
): TimelineQueryDslRepository {
    private val timeline = QTimeline.timeline

    override fun findAllNextBoardIds(timelineRequest: TimelineRequest): List<Timeline> {
        return jpaQueryFactory
            .selectFrom(timeline)
            .where(timeline.receiverId.eq(timelineRequest.receiverId)
                .and(timeline.id.gt(timelineRequest.endBoardId))
            )
            .orderBy(timeline.createdAt.desc())
            .limit(15)
            .fetch()
    }

    override fun findAllBeforeBoardIds(timelineRequest: TimelineRequest): List<Timeline> {
        return jpaQueryFactory
            .selectFrom(timeline)
            .where(timeline.receiverId.eq(timelineRequest.receiverId)
                .and(timeline.id.lt(timelineRequest.startBoardId))
            )
            .orderBy(timeline.createdAt.desc())
            .limit(15)
            .fetch()
    }
}

                                    package com.example.frontServer.dto.timeline

data class TimelineRequest(
    val receiverId: Long,

    val startBoardId: Long,

    val endBoardId: Long,
)