[feat/#137] 기록에 좋아요한 유저 목록을 조회

clokey-api/src/main/java/org/clokey/domain/like/controller/LikeController.java

@@ -6,6 +6,7 @@
 import lombok.RequiredArgsConstructor;
 import org.clokey.code.GlobalBaseSuccessCode;
 import org.clokey.domain.like.dto.response.LikedHistoriesResponse;
+import org.clokey.domain.like.dto.response.LikedMembersResponse;
 import org.clokey.domain.like.service.LikeService;
 import org.clokey.global.annotation.PageSize;
 import org.clokey.response.BaseResponse;
@@ -26,8 +27,27 @@ public class LikeController {
 
     private final LikeService likeService;
 
+    @GetMapping("/users")
+    @Operation(
+            operationId = "Like_getLikedMembers",
+            summary = "좋아요한 유저 조회",
+            description = "내 기록을 좋아요한 유저를 조회합니다")
+    public BaseResponse<SliceResponse<LikedMembersResponse.LikedMemberPreview>> getLikedMembers(
+            @Parameter(description = "기록 ID") @RequestParam Long historyId,
+            @Parameter(description = "이전 페이지의 좋아요 ID (첫 요청 시 생략)") @RequestParam(required = false)
+                    Long lastLikeId,
+            @Parameter(description = "페이지당 조회할 개수") @RequestParam @PageSize Integer size) {
+        SliceResponse<LikedMembersResponse.LikedMemberPreview> response =
+                likeService.getLikedMembers(historyId, lastLikeId, size);
+
+        return BaseResponse.onSuccess(GlobalBaseSuccessCode.OK, response);
+    }
+
     @GetMapping("/histories")
-    @Operation(summary = "좋아요한 기록 조회", description = "사용자가 좋아요한 기록을 조회합니다.")
+    @Operation(
+            operationId = "Like_getLikedHistories",
+            summary = "좋아요한 기록 조회",
+            description = "사용자가 좋아요한 기록을 조회합니다.")
     public BaseResponse<SliceResponse<LikedHistoriesResponse.LikedHistoryPreview>>
             getLikedHistories(
                     @Parameter(description = "이전 페이지의 좋아요 ID (첫 요청 시 생략)")

clokey-api/src/main/java/org/clokey/domain/like/dto/response/LikedHistoriesResponse.java

@@ -9,11 +9,40 @@ public record LikedHistoriesResponse(
         @Schema(description = "마지막 페이지 여부", example = "false") boolean isLast) {
 
     @Schema(description = "히스토리 미리보기 DTO")
-    public record LikedHistoryPreview(
-            @Schema(description = "히스토리 ID", example = "30") Long id,
-            @Schema(
-                            description = "히스토리 대표 이미지 URL",
-                            example =
-                                    "https://clokeybucket.s3.ap-northeast-2.amazonaws.com/example.jpg")
-                    String imageUrl) {}
+    public static class LikedHistoryPreview {
+        @Schema(description = "히스토리 ID", example = "30")
+        private final Long id;
+
+        @Schema(
+                description = "히스토리 대표 이미지 URL",
+                example = "https://clokeybucket.s3.ap-northeast-2.amazonaws.com/example.jpg")
+        private String imageUrl;
+
+        @Schema(description = "다음 페이지 조회를 위한 커서 ID (MemberLike ID)", example = "100")
+        private final Long lastLikeId;
+
+        public LikedHistoryPreview(Long id, Long lastLikeId) {
+            this.id = id;
+            this.lastLikeId = lastLikeId;
+            this.imageUrl = null;
+        }
+
+        public LikedHistoryPreview(Long id, String imageUrl) {
+            this.id = id;
+            this.imageUrl = imageUrl;
+            this.lastLikeId = null;
+        }
+
+        public Long getId() {
+            return id;
+        }
+
+        public String getImageUrl() {
+            return imageUrl;
+        }
+
+        public Long getLastLikeId() {
+            return lastLikeId;
+        }
+    }
 }

clokey-api/src/main/java/org/clokey/domain/like/dto/response/LikedMembersResponse.java

@@ -0,0 +1,53 @@
+package org.clokey.domain.like.dto.response;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import java.util.List;
+import lombok.Getter;
+
+@Schema(description = "좋아요 유저 조회 결과")
+public record LikedMembersResponse(
+        @Schema(description = "유저 미리보기 목록") List<LikedMemberPreview> memberPreviews,
+        @Schema(description = "마지막 페이지 여부", example = "false") boolean isLast) {
+
+    @Schema(description = "유저 미리보기 DTO")
+    @Getter
+    public static class LikedMemberPreview {
+        @Schema(description = "유저 ID", example = "30")
+        private final Long id;
+
+        @Schema(description = "클로키 ID", example = "@Clokey_USER1")
+        private final String codiveId;
+
+        @Schema(description = "프로필 이미지 URL")
+        private final String imageUrl;
+
+        @Schema(description = "닉네임")
+        private final String nickname;
+
+        @Schema(description = "팔로우 여부")
+        private final boolean followStatus;
+
+        @Schema(description = "다음 페이지 조회를 위한 커서 ID (MemberLike ID)", example = "100")
+        private final Long lastLikeId;
+
+        public LikedMemberPreview(
+                Long id, String codiveId, String imageUrl, String nickname, Long lastLikeId) {
+            this.id = id;
+            this.codiveId = codiveId;
+            this.imageUrl = imageUrl;
+            this.nickname = nickname;
+            this.lastLikeId = lastLikeId;
+            this.followStatus = false;
+        }
+
+        public LikedMemberPreview(
+                Long id, String codiveId, String imageUrl, String nickname, boolean followStatus) {
+            this.id = id;
+            this.codiveId = codiveId;
+            this.imageUrl = imageUrl;
+            this.nickname = nickname;
+            this.followStatus = followStatus;
+            this.lastLikeId = null;
+        }
+    }
+}

clokey-api/src/main/java/org/clokey/domain/like/repository/MemberLikeRepositoryCustom.java

@@ -0,0 +1,14 @@
+package org.clokey.domain.like.repository;
+
+import org.clokey.domain.like.dto.response.LikedHistoriesResponse;
+import org.clokey.domain.like.dto.response.LikedMembersResponse;
+import org.springframework.data.domain.Slice;
+
+public interface MemberLikeRepositoryCustom {
+
+    Slice<LikedHistoriesResponse.LikedHistoryPreview> findLikedHistoriesSliceByMemberId(
+            Long memberId, Long lastLikeId, Integer size);
+
+    Slice<LikedMembersResponse.LikedMemberPreview> findLikedMembersSliceByHistoryId(
+            Long historyId, Long lastLikeId, Integer size);
+}

clokey-api/src/main/java/org/clokey/domain/like/repository/MemberLikeRepositoryImpl.java

@@ -0,0 +1,92 @@
+package org.clokey.domain.like.repository;
+
+import static org.clokey.like.entity.QMemberLike.memberLike;
+import static org.clokey.member.entity.QMember.member;
+
+import com.querydsl.core.types.Projections;
+import com.querydsl.core.types.dsl.BooleanExpression;
+import com.querydsl.jpa.impl.JPAQueryFactory;
+import java.util.List;
+import lombok.RequiredArgsConstructor;
+import org.clokey.domain.like.dto.response.LikedHistoriesResponse;
+import org.clokey.domain.like.dto.response.LikedMembersResponse;
+import org.clokey.global.paging.SortDirection;
+import org.springframework.data.domain.PageRequest;
+import org.springframework.data.domain.Slice;
+import org.springframework.data.domain.SliceImpl;
+import org.springframework.stereotype.Repository;
+
+@Repository
+@RequiredArgsConstructor
+public class MemberLikeRepositoryImpl implements MemberLikeRepositoryCustom {
+
+    private final JPAQueryFactory queryFactory;
+
+    private final SortDirection DEFAULT_SORT = SortDirection.DESC;
+
+    @Override
+    public Slice<LikedHistoriesResponse.LikedHistoryPreview> findLikedHistoriesSliceByMemberId(
+            Long memberId, Long lastLikeId, Integer size) {
+
+        List<LikedHistoriesResponse.LikedHistoryPreview> results =
+                queryFactory
+                        .select(
+                                Projections.constructor(
+                                        LikedHistoriesResponse.LikedHistoryPreview.class,
+                                        memberLike.history.id,
+                                        memberLike.id))
+                        .from(memberLike)
+                        .where(
+                                memberLike.member.id.eq(memberId),
+                                lastLikeIdCondition(lastLikeId, DEFAULT_SORT))
+                        .limit(size + 1)
+                        .orderBy(memberLike.id.desc())
+                        .fetch();
+
+        return checkLastPage(size, results);
+    }
+
+    @Override
+    public Slice<LikedMembersResponse.LikedMemberPreview> findLikedMembersSliceByHistoryId(
+            Long historyId, Long lastLikeId, Integer size) {
+
+        List<LikedMembersResponse.LikedMemberPreview> results =
+                queryFactory
+                        .select(
+                                Projections.constructor(
+                                        LikedMembersResponse.LikedMemberPreview.class,
+                                        member.id,
+                                        member.clokeyId,
+                                        member.profileImageUrl,
+                                        member.nickname,
+                                        memberLike.id))
+                        .from(memberLike)
+                        .join(memberLike.member, member)
+                        .where(
+                                memberLike.history.id.eq(historyId),
+                                lastLikeIdCondition(lastLikeId, DEFAULT_SORT))
+                        .limit(size + 1)
+                        .orderBy(memberLike.id.desc())
+                        .fetch();
+
+        return checkLastPage(size, results);
+    }
+
+    private BooleanExpression lastLikeIdCondition(Long likeId, SortDirection direction) {
+        if (likeId == null) {
+            return null;
+        }
+        return memberLike.id.lt(likeId);
+    }
+
+    private <T> Slice<T> checkLastPage(int pageSize, List<T> results) {
+        boolean hasNext = false;
+
+        if (results.size() > pageSize) {
+            hasNext = true;
+            results.remove(pageSize);
+        }
+
+        return new SliceImpl<>(results, PageRequest.of(0, pageSize), hasNext);
+    }
+}

clokey-api/src/main/java/org/clokey/domain/like/service/LikeService.java

@@ -1,9 +1,13 @@
 package org.clokey.domain.like.service;
 
 import org.clokey.domain.like.dto.response.LikedHistoriesResponse;
+import org.clokey.domain.like.dto.response.LikedMembersResponse;
 import org.clokey.response.SliceResponse;
 
 public interface LikeService {
+    SliceResponse<LikedMembersResponse.LikedMemberPreview> getLikedMembers(
+            Long historyId, Long lastLikedId, Integer size);
+
     SliceResponse<LikedHistoriesResponse.LikedHistoryPreview> getLikedHistories(
             Long lastLikedId, Integer size);
 

clokey-api/src/main/java/org/clokey/domain/like/service/LikeServiceImpl.java

@@ -1,24 +1,28 @@
 package org.clokey.domain.like.service;
 
+import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
+import java.util.Set;
 import java.util.stream.Collectors;
 import lombok.RequiredArgsConstructor;
 import org.clokey.domain.history.exception.HistoryErrorCode;
 import org.clokey.domain.history.repository.HistoryImageRepository;
 import org.clokey.domain.history.repository.HistoryRepository;
 import org.clokey.domain.like.dto.response.LikedHistoriesResponse;
+import org.clokey.domain.like.dto.response.LikedMembersResponse;
 import org.clokey.domain.like.repository.MemberLikeRepository;
+import org.clokey.domain.like.repository.MemberLikeRepositoryCustom;
 import org.clokey.domain.member.repository.BlockRepository;
+import org.clokey.domain.member.repository.FollowRepository;
 import org.clokey.exception.BaseCustomException;
 import org.clokey.global.util.MemberUtil;
 import org.clokey.history.entity.History;
 import org.clokey.like.entity.MemberLike;
 import org.clokey.member.entity.Member;
 import org.clokey.response.SliceResponse;
-import org.springframework.data.domain.PageRequest;
-import org.springframework.data.domain.Pageable;
+import org.springframework.data.domain.Slice;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
@@ -32,44 +36,39 @@ public class LikeServiceImpl implements LikeService {
     private final HistoryImageRepository historyImageRepository;
     private final HistoryRepository historyRepository;
     private final BlockRepository blockRepository;
+    private final FollowRepository followRepository;
+    private final MemberLikeRepositoryCustom memberLikeRepositoryCustom;
 
     @Override
     public SliceResponse<LikedHistoriesResponse.LikedHistoryPreview> getLikedHistories(
             Long lastLikeId, Integer size) {
 
         Member currentMember = memberUtil.getCurrentMember();
 
-        // limit + 1 조회
-        Pageable pageable = PageRequest.of(0, size + 1);
+        Slice<LikedHistoriesResponse.LikedHistoryPreview> likedHistoriesSlice =
+                memberLikeRepositoryCustom.findLikedHistoriesSliceByMemberId(
+                        currentMember.getId(), lastLikeId, size);
 
-        List<MemberLike> likes =
-                memberLikeRepository.findLikedHistoriesByMemberId(
-                        currentMember.getId(), lastLikeId, pageable);
-
-        boolean isLast = likes.size() <= size;
-
-        if (!isLast) {
-            likes = likes.subList(0, size);
-        }
-
-        if (likes.isEmpty()) {
+        if (likedHistoriesSlice.isEmpty()) {
             return new SliceResponse<>(List.of(), true);
         }
 
-        List<Long> historyIds = likes.stream().map(like -> like.getHistory().getId()).toList();
+        List<Long> historyIds =
+                likedHistoriesSlice.getContent().stream()
+                        .map(LikedHistoriesResponse.LikedHistoryPreview::getId)
+                        .toList();
 
         Map<Long, String> imageMap = findFirstImagesByHistoryIds(historyIds);
 
         List<LikedHistoriesResponse.LikedHistoryPreview> previews =
-                likes.stream()
+                likedHistoriesSlice.getContent().stream()
                         .map(
-                                like ->
+                                preview ->
                                         new LikedHistoriesResponse.LikedHistoryPreview(
-                                                like.getHistory().getId(),
-                                                imageMap.get(like.getHistory().getId())))
+                                                preview.getId(), imageMap.get(preview.getId())))
                         .toList();
 
-        return new SliceResponse<>(previews, isLast);
+        return new SliceResponse<>(previews, likedHistoriesSlice.isLast());
     }
 
     private Map<Long, String> findFirstImagesByHistoryIds(List<Long> historyIds) {
@@ -115,4 +114,42 @@ private boolean isBlockedByOrBlocking(Long fromId, Long toId) {
                 fromId, toId,
                 toId, fromId);
     }
+
+    @Override
+    public SliceResponse<LikedMembersResponse.LikedMemberPreview> getLikedMembers(
+            Long historyId, Long lastLikeId, Integer size) {
+
+        Member currentMember = memberUtil.getCurrentMember();
+
+        Slice<LikedMembersResponse.LikedMemberPreview> likedMembersSlice =
+                memberLikeRepositoryCustom.findLikedMembersSliceByHistoryId(
+                        historyId, lastLikeId, size);
+
+        if (likedMembersSlice.isEmpty()) {
+            return new SliceResponse<>(List.of(), true);
+        }
+
+        List<Long> memberIds =
+                likedMembersSlice.getContent().stream()
+                        .map(LikedMembersResponse.LikedMemberPreview::getId)
+                        .toList();
+
+        Set<Long> followedIdSet =
+                new HashSet<>(
+                        followRepository.findFollowedMemberIds(currentMember.getId(), memberIds));
+
+        List<LikedMembersResponse.LikedMemberPreview> previews =
+                likedMembersSlice.getContent().stream()
+                        .map(
+                                preview ->
+                                        new LikedMembersResponse.LikedMemberPreview(
+                                                preview.getId(),
+                                                preview.getCodiveId(),
+                                                preview.getImageUrl(),
+                                                preview.getNickname(),
+                                                followedIdSet.contains(preview.getId())))
+                        .toList();
+
+        return new SliceResponse<>(previews, likedMembersSlice.isLast());
+    }
 }