[코틀린 스프링] 팔로우 API 설계

                                    follwers 테이블 생성

id, followingId, followerId
1      343       433
2      433       343

                                    CREATE TABLE followers(
    id BIGINT PRIMARY KEY,
    following_id BIGINT,
    follower_id BIGINT
)

                                    CREATE INDEX fidx_following_id
ON followers(following_id);

CREATE INDEX fidx_follower_id
ON followers(follwer_id);

ALTER TABLE followers
ADD CONSTRAINT uq_follow_cols UNIQUE (following, follower);

                                    🤵 클라이언트

- follow 버튼을 클릭하여 follow api를 호출한다.
  -> Post

- 팔로워, 팔로잉 보기 버튼을 클릭하여 follow api를 호출한다.
  -> GET

                                    👩‍🍳 서버

- client가 follow를 누르면 Post 요청이 들어온다
  - 이를 서버는 적절히 처리하여 데이터를 저장해야한다.

- client가 팔로워, 팔로잉 목록을 요청한다(GET).
  - 이때 서버는 적절히 처리하여 UserSummary(유저 요약 정보)를 클라이언트에게 제공한다.

                                    package com.example.frontServer.entity

import jakarta.persistence.*
import org.springframework.data.annotation.CreatedBy

@Entity
@Table(
    name = "followes",
)
class Follow(
    @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
    var id: Long? = null,

    @Column(name = "following_id")
    var followingId: Long,

    // @CreatedBy
    @Column(name = "follower_id")
    var followerId: Long? = null
)

                                    package com.example.frontServer.controller

import com.example.frontServer.dto.user.UserSummaryDto
import com.example.frontServer.security.AuthUserDetails
import com.example.frontServer.service.FollowService
import org.springframework.http.ResponseEntity
import org.springframework.security.core.annotation.AuthenticationPrincipal
import org.springframework.security.core.context.SecurityContextHolder
import org.springframework.web.bind.annotation.GetMapping
import org.springframework.web.bind.annotation.PostMapping
import org.springframework.web.bind.annotation.RequestParam
import org.springframework.web.bind.annotation.RestController

@RestController
class FollowController(
    private val followService: FollowService
) {

    @PostMapping("/follow")
    fun save(
        @RequestParam followingName: String,
        @AuthenticationPrincipal user: AuthUserDetails
    ): ResponseEntity<Void> {
        followService.save(followingName, user.getUserId())

        return ResponseEntity.ok().build()
    }

    @GetMapping("/following/users")
    fun findFollowingUsers(
        @RequestParam username: String
    ): ResponseEntity<List<UserSummaryDto>> {
        val followingSummaries: List<UserSummaryDto> =
            followService.findFollowings(username)

        return ResponseEntity.ok().body(followingSummaries)
    }

    @GetMapping("/follower/users")
    fun findFollowerUsers(
        @RequestParam username: String
    ): ResponseEntity<List<UserSummaryDto>> {

        val followerSummaries: List<UserSummaryDto>? =
            followService.findFollowers(username)
        if (followerSummaries == null) {
            return ResponseEntity.badRequest().body(null)
        }

        return ResponseEntity.ok().body(followerSummaries)
    }
}

                                    package com.example.frontServer.dto.user

import com.example.frontServer.entity.User

data class UserSummaryDto(
    val username: String,
    val userImg: String?,
) {
    companion object {
        fun of(user: User): UserSummaryDto {
            return UserSummaryDto(
                username = user.username,
                userImg = user.userImg,
            )
        }
    }
}

                                    package com.example.frontServer.service

import com.example.frontServer.dto.user.UserSummaryDto
import com.example.frontServer.entity.Follow
import com.example.frontServer.repository.FollowRepository
import com.example.frontServer.repository.UserRepository
import jakarta.transaction.Transactional
import org.springframework.stereotype.Service

@Service
class FollowService(
    private val followRepository: FollowRepository,
    private val userRepository: UserRepository
) {
    @Transactional
    fun save(followingName: String, followerId: Long): String {
        val userId = userRepository.findIdByUsername(followingName)
        if (userId != null) {
            followRepository.save(
                Follow(
                    followingId = userId,
                    followerId = followerId
                )
            )
            return "save success"
        }
        return "Invalid Username"
    }
}

                                     @Transactional
    fun save(followingName: String, followerId: Long) {
        // username(unique)를 통해 id를 찾늗다.
        val userId = userRepository.findIdByUsername(followingName)
        if (userId != null) {
            followRepository.save(
                Follow(
                    followingId = userId,
                    followerId = followerId
                )
            )
        } else {
            throw InvalidIdException("can't find the user")
        }
    }

                                     @Transactional
    fun findFollowers(
        username: String
    ): List<UserSummaryDto>? {
        return followRepository.findFollowersByUsername(username)
            .map { UserSummaryDto.of(it) }

        // exception? unknown username?
    }

@Transactional
fun findFollowings(
    username: String,
): List<UserSummaryDto> {
        return followRepository.findFollowingsByUserId(username)
        .map { UserSummaryDto.of(it) }
    }

                                    팔로워 로직 정리
1. usename을 parameter로 받는다.
2. username을 통해서 대상(id)을 찾는다.
3. 2번의 대상(id)를 팔로우 하고 있는 모든 id를 찾는다 = ids
4. 3번의 찾은 ids에 대한 user정보를 찾는다.
5. 최종적으로 List<User>을 반환한다.

                                    package com.example.frontServer.repository

import com.example.frontServer.entity.QFollow
import com.example.frontServer.entity.QUser
import com.example.frontServer.entity.User
import com.querydsl.jpa.JPAExpressions
import com.querydsl.jpa.impl.JPAQueryFactory
import org.springframework.stereotype.Repository

@Repository
class FollowQueryDslRepositoryImpl(
    private val queryFactory: JPAQueryFactory
): FollowQueryDslRepository {
    private val qFollow = QFollow.follow
    private val qUser = QUser.user
    // following Users
    override fun findFollowersByUsername(username: String): List<User> {
        return queryFactory
            .selectFrom(qUser)
            .where(
                qUser.id.`in` (
                        JPAExpressions
                            .select(qFollow.followerId)
                            .from(qFollow)
                            .where(
                                qFollow.followingId.eq(
                                    JPAExpressions
                                        .select(qUser.id)
                                        .from(qUser)
                                        .where(qUser.username.eq(username))
                                )
                            )
                        )
            )
            .fetch()
    }

    override fun findFollowingsByUserId(username: String): List<User> {
        return queryFactory
            .selectFrom(qUser)
            .where(
                qUser.id.`in` (
                    JPAExpressions
                        .select(qFollow.followingId)
                        .from(qFollow)
                        .where(qFollow.followerId.eq(
                            JPAExpressions
                                .select(qUser.id)
                                .from(qUser)
                                .where(qUser.username.eq(username))
                        ))
                )
            )
            .fetch()
    }
}