[feat] 댓글 조회 api 개발

src/main/java/konkuk/thip/comment/adapter/in/web/CommentQueryController.java

@@ -1,10 +1,41 @@
 package konkuk.thip.comment.adapter.in.web;
 
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.Parameter;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import konkuk.thip.comment.adapter.in.web.response.CommentForSinglePostResponse;
+import konkuk.thip.comment.application.port.in.CommentShowAllUseCase;
+import konkuk.thip.comment.application.port.in.dto.CommentShowAllQuery;
+import konkuk.thip.common.dto.BaseResponse;
+import konkuk.thip.common.security.annotation.UserId;
 import lombok.RequiredArgsConstructor;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.RequestParam;
 import org.springframework.web.bind.annotation.RestController;
 
+@Tag(name = "Comment Query API", description = "댓글 조회 관련 API")
 @RestController
 @RequiredArgsConstructor
 public class CommentQueryController {
 
+    public final CommentShowAllUseCase commentShowAllUseCase;
+
+    @Operation(
+            summary = "댓글 전체 조회",
+            description = "특정 게시글(= 피드, 기록, 투표) 의 댓글과 대댓글들을 전체 조회합니다."
+    )
+    @GetMapping("/comments/{postId}")
+    public BaseResponse<CommentForSinglePostResponse> showAllCommentsOfPost(
+            @Parameter(hidden = true) @UserId final Long userId,
+            @Parameter(description = "댓글을 조회할 게시글(= FEED, RECORD, VOTE)의 id값")
+            @PathVariable("postId") final Long postId,
+            @Parameter(description = "게시물 타입 (RECORD, VOTE, FEED)", example = "RECORD")
+            @RequestParam(value = "postType") final String postType,
+            @Parameter(description = "커서 (첫번째 요청시 : null, 다음 요청시 : 이전 요청에서 반환받은 nextCursor 값)")
+            @RequestParam(value = "cursor", required = false) final String cursor) {
+        return BaseResponse.ok(commentShowAllUseCase.showAllCommentsOfPost(
+                CommentShowAllQuery.of(postId, userId, postType, cursor)
+        ));
+    }
 }

src/main/java/konkuk/thip/comment/adapter/in/web/response/CommentForSinglePostResponse.java

@@ -0,0 +1,58 @@
+package konkuk.thip.comment.adapter.in.web.response;
+
+import java.util.List;
+
+public record CommentForSinglePostResponse(
+        List<RootCommentDto> commentList,
+        String nextCursor,
+        boolean isLast
+) {
+    public record RootCommentDto(
+            Long commentId,
+            Long creatorId,
+            String creatorProfileImageUrl,
+            String creatorNickname,
+            String alias,
+            String aliasColor,
+            String postDate,        // 댓글 작성 시각 (~ 전 형식)
+            String content,
+            int likeCount,
+            boolean isLike,
+            boolean isDeleted,  // 삭제된 댓글인지 아닌지
+            List<ReplyDto> replyList
+    ) {
+        public record ReplyDto(
+                Long commentId,
+                String parentCommentCreatorNickname,
+                Long creatorId,
+                String creatorProfileImageUrl,
+                String creatorNickname,
+                String alias,
+                String aliasColor,
+                String postDate,        // 댓글 작성 시각 (~ 전 형식)
+                String content,
+                int likeCount,
+                boolean isLike
+        ) {}
+
+        /**
+         * 삭제된 루트 댓글에 매핑되는 response dto
+         * isDelete 제외 나머지 데이터는 모두 쓰레기 값으로
+         */
+        public static RootCommentDto createDeletedRootCommentDto(List<ReplyDto> replyList) {
+            return new RootCommentDto(
+                    null,
+                    null,
+                    null,
+                    null,
+                    null,
+                    null,
+                    null,
+                    null,
+                    0,
+                    false,
+                    true,       // true
+                    replyList);
+        }
+    }
+}

src/main/java/konkuk/thip/comment/adapter/out/persistence/CommentLikeQueryPersistenceAdapter.java

@@ -8,6 +8,8 @@
 import lombok.RequiredArgsConstructor;
 import org.springframework.stereotype.Repository;
 
+import java.util.Set;
+
 @Repository
 @RequiredArgsConstructor
 public class CommentLikeQueryPersistenceAdapter implements CommentLikeQueryPort {
@@ -21,4 +23,9 @@ public class CommentLikeQueryPersistenceAdapter implements CommentLikeQueryPort
     public boolean isLikedCommentByUser(Long userId, Long commentId) {
         return commentLikeJpaRepository.existsByUserIdAndCommentId(userId, commentId);
     }
+
+    @Override
+    public Set<Long> findCommentIdsLikedByUser(Set<Long> commentIds, Long userId) {
+        return commentLikeJpaRepository.findCommentIdsLikedByUser(commentIds, userId);
+    }
 }

src/main/java/konkuk/thip/comment/adapter/out/persistence/CommentQueryPersistenceAdapter.java

@@ -3,14 +3,44 @@
 import konkuk.thip.comment.adapter.out.mapper.CommentMapper;
 import konkuk.thip.comment.adapter.out.persistence.repository.CommentJpaRepository;
 import konkuk.thip.comment.application.port.out.CommentQueryPort;
+import konkuk.thip.comment.application.port.out.dto.CommentQueryDto;
+import konkuk.thip.common.util.Cursor;
+import konkuk.thip.common.util.CursorBasedList;
 import lombok.RequiredArgsConstructor;
 import org.springframework.stereotype.Repository;
 
+import java.time.LocalDateTime;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
 @Repository
 @RequiredArgsConstructor
 public class CommentQueryPersistenceAdapter implements CommentQueryPort {
 
-    private final CommentJpaRepository jpaRepository;
-    private final CommentMapper userMapper;
+    private final CommentJpaRepository commentJpaRepository;
+    private final CommentMapper commentMapper;
+
+    @Override
+    public CursorBasedList<CommentQueryDto> findLatestRootCommentsWithDeleted(Long postId, String postTypeStr, Cursor cursor) {
+        LocalDateTime lastCreatedAt = cursor.isFirstRequest() ? null : cursor.getLocalDateTime(0);
+        int size = cursor.getPageSize();
+
+        List<CommentQueryDto> commentQueryDtos = commentJpaRepository.findRootCommentsWithDeletedByCreatedAtDesc(postId, postTypeStr, lastCreatedAt, size);
+
+        return CursorBasedList.of(commentQueryDtos, size, commentQueryDto -> {
+            Cursor nextCursor = new Cursor(List.of(commentQueryDto.createdAt().toString()));
+            return nextCursor.toEncodedString();
+        });
+    }
+
+    @Override
+    public List<CommentQueryDto> findAllActiveChildCommentsOldestFirst(Long rootCommentId) {
+        return commentJpaRepository.findAllActiveChildCommentsByCreatedAtAsc(rootCommentId);
+    }
 
+    @Override
+    public Map<Long, List<CommentQueryDto>> findAllActiveChildCommentsOldestFirst(Set<Long> rootCommentIds) {
+        return commentJpaRepository.findAllActiveChildCommentsByCreatedAtAsc(rootCommentIds);
+    }
 }

src/main/java/konkuk/thip/comment/adapter/out/persistence/repository/CommentJpaRepository.java

@@ -6,6 +6,6 @@
 
 import java.util.Optional;
 
-public interface CommentJpaRepository extends JpaRepository<CommentJpaEntity, Long> {
+public interface CommentJpaRepository extends JpaRepository<CommentJpaEntity, Long>, CommentQueryRepository {
     Optional<CommentJpaEntity> findByCommentIdAndStatus(Long commentId, StatusType status);
 }

src/main/java/konkuk/thip/comment/adapter/out/persistence/repository/CommentLikeJpaRepository.java

@@ -7,6 +7,7 @@
 import org.springframework.data.repository.query.Param;
 
 import java.util.List;
+import java.util.Set;
 
 public interface CommentLikeJpaRepository extends JpaRepository<CommentLikeJpaEntity, Long> {
 
@@ -27,4 +28,6 @@ public interface CommentLikeJpaRepository extends JpaRepository<CommentLikeJpaEn
     @Query("DELETE FROM CommentLikeJpaEntity cl WHERE cl.commentJpaEntity.commentId = :commentId")
     void deleteAllByCommentId(@Param("commentId") Long commentId);
 
-}
+    @Query("SELECT c.commentJpaEntity.commentId FROM CommentLikeJpaEntity c WHERE c.userJpaEntity.userId = :userId AND c.commentJpaEntity.commentId IN :commentIds")
+    Set<Long> findCommentIdsLikedByUser(@Param("commentIds") Set<Long> commentIds, @Param("userId") Long userId);
+}

src/main/java/konkuk/thip/comment/adapter/out/persistence/repository/CommentQueryRepository.java

@@ -0,0 +1,17 @@
+package konkuk.thip.comment.adapter.out.persistence.repository;
+
+import konkuk.thip.comment.application.port.out.dto.CommentQueryDto;
+
+import java.time.LocalDateTime;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+public interface CommentQueryRepository {
+
+    List<CommentQueryDto> findRootCommentsWithDeletedByCreatedAtDesc(Long postId, String postTypeStr, LocalDateTime lastCreatedAt, int size);
+
+    List<CommentQueryDto> findAllActiveChildCommentsByCreatedAtAsc(Long rootCommentId);
+
+    Map<Long, List<CommentQueryDto>> findAllActiveChildCommentsByCreatedAtAsc(Set<Long> rootCommentIds);
+}

src/main/java/konkuk/thip/comment/adapter/out/persistence/repository/CommentQueryRepositoryImpl.java

@@ -0,0 +1,189 @@
+package konkuk.thip.comment.adapter.out.persistence.repository;
+
+import com.querydsl.core.types.dsl.BooleanExpression;
+import com.querydsl.core.types.dsl.Expressions;
+import com.querydsl.jpa.impl.JPAQueryFactory;
+import konkuk.thip.comment.adapter.out.jpa.QCommentJpaEntity;
+import konkuk.thip.comment.application.port.out.dto.CommentQueryDto;
+import konkuk.thip.comment.application.port.out.dto.QCommentQueryDto;
+import konkuk.thip.common.entity.StatusType;
+import konkuk.thip.user.adapter.out.jpa.QAliasJpaEntity;
+import konkuk.thip.user.adapter.out.jpa.QUserJpaEntity;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Repository;
+
+import java.time.LocalDateTime;
+import java.util.*;
+import java.util.stream.Collectors;
+
+@Repository
+@RequiredArgsConstructor
+public class CommentQueryRepositoryImpl implements CommentQueryRepository {
+
+    private final JPAQueryFactory queryFactory;
+
+    private final QCommentJpaEntity comment = QCommentJpaEntity.commentJpaEntity;
+    private final QUserJpaEntity commentCreator = QUserJpaEntity.userJpaEntity;
+    private final QAliasJpaEntity aliasOfCommentCreator = QAliasJpaEntity.aliasJpaEntity;
+    private final QCommentJpaEntity parentComment = new QCommentJpaEntity("parentComment");
+    private final QUserJpaEntity parentCommentCreator = new QUserJpaEntity("parentCommentCreator");
+
+    @Override
+    public List<CommentQueryDto> findRootCommentsWithDeletedByCreatedAtDesc(Long postId, String postTypeStr, LocalDateTime lastCreatedAt, int size) {
+        // 최상위 댓글(size+1) 프로젝션 생성
+        QCommentQueryDto proj = new QCommentQueryDto(
+                comment.commentId,
+                commentCreator.userId,
+                aliasOfCommentCreator.imageUrl,
+                commentCreator.nickname,
+                aliasOfCommentCreator.value,
+                aliasOfCommentCreator.color,
+                comment.createdAt,
+                comment.content,
+                comment.likeCount,
+                comment.status.eq(StatusType.INACTIVE)      // 루트 댓글이 삭제된 상태인지 아닌지
+        );
+
+        // WHERE 절 분리
+        BooleanExpression whereClause = comment.postJpaEntity.postId.eq(postId)
+                .and(comment.postJpaEntity.dtype.eq(postTypeStr))       // dType 필터링 추가
+                .and(comment.parent.isNull())       // 게시글의 최상위 댓글 조회
+                .and(lastCreatedAt != null      // 최신순 정렬
+                        ? comment.createdAt.lt(lastCreatedAt)
+                        : Expressions.TRUE
+                );
+
+        // 조회 및 반환
+        return queryFactory
+                .select(proj)
+                .from(comment)
+                .leftJoin(comment.userJpaEntity, commentCreator)
+                .leftJoin(commentCreator.aliasForUserJpaEntity, aliasOfCommentCreator)
+                .where(whereClause)
+                .orderBy(comment.createdAt.desc())
+                .limit(size + 1)        // size + 1 개 조회
+                .fetch();
+    }
+
+    @Override
+    public List<CommentQueryDto> findAllActiveChildCommentsByCreatedAtAsc(Long rootCommentId) {
+        List<CommentQueryDto> allDescendants = new ArrayList<>();       // 결과 누적용 리스트
+
+        // 1) 부모 ID 집합에 루트 댓글 ID 추가
+        Set<Long> parentIds = new HashSet<>();
+        parentIds.add(rootCommentId);
+
+        // 2) 자손 댓글용 프로젝션 (부모 댓글 ID·작성자 닉네임 포함)
+        QCommentQueryDto childProj = new QCommentQueryDto(
+                comment.commentId,
+                comment.parent.commentId,
+                parentCommentCreator.nickname,
+                commentCreator.userId,
+                aliasOfCommentCreator.imageUrl,
+                commentCreator.nickname,
+                aliasOfCommentCreator.value,
+                aliasOfCommentCreator.color,
+                comment.createdAt,
+                comment.content,
+                comment.likeCount,
+                comment.status.eq(StatusType.INACTIVE)
+        );
+
+        // 3) 단계별 자식 댓글 조회
+        while (!parentIds.isEmpty()) {
+            List<CommentQueryDto> children = queryFactory
+                    .select(childProj)
+                    .from(comment)
+                    .leftJoin(comment.parent, parentComment)
+                    .leftJoin(parentComment.userJpaEntity, parentCommentCreator)
+                    .leftJoin(comment.userJpaEntity, commentCreator)
+                    .leftJoin(commentCreator.aliasForUserJpaEntity, aliasOfCommentCreator)
+                    .where(
+                            comment.parent.commentId.in(parentIds),     // parentIds 하위의 모든 자식 댓글 조회
+                            comment.status.eq(StatusType.ACTIVE)        // 자식 댓글은 ACTIVE인 것만 조회
+                    )
+                    .fetch();
+
+            if (children.isEmpty()) break;
+
+            // 4) 누적 및 다음 단계 부모 ID 집합 갱신
+            allDescendants.addAll(children);
+            parentIds = children.stream()
+                    .map(CommentQueryDto::commentId)
+                    .collect(Collectors.toSet());
+        }
+
+        // 5) 전체 자손 댓글을 깊이와 상관없이 작성 순으로 재정렬
+        allDescendants.sort(Comparator.comparing(CommentQueryDto::createdAt));
+        return allDescendants;
+    }
+
+    @Override
+    public Map<Long, List<CommentQueryDto>> findAllActiveChildCommentsByCreatedAtAsc(Set<Long> rootCommentIds) {
+        // 1) 루트 ID별로 최상위 매핑 초기화
+        Map<Long, Long> idToRoot = new HashMap<>();
+        for (Long rootId : rootCommentIds) {
+            idToRoot.put(rootId, rootId);       // 초기화
+        }
+
+        // 2) 결과 맵 초기화
+        Map<Long, List<CommentQueryDto>> resultMap = new HashMap<>();
+        for (Long rootId : rootCommentIds) {
+            resultMap.put(rootId, new ArrayList<>());
+        }
+
+        // 3) 단계별 조회용 parentIds 초기화
+        Set<Long> parentIds = new HashSet<>(rootCommentIds);
+
+        // 4) 자손 댓글용 프로젝션 정의
+        QCommentQueryDto childProj = new QCommentQueryDto(
+                comment.commentId,
+                comment.parent.commentId,
+                parentCommentCreator.nickname,
+                commentCreator.userId,
+                aliasOfCommentCreator.imageUrl,
+                commentCreator.nickname,
+                aliasOfCommentCreator.value,
+                aliasOfCommentCreator.color,
+                comment.createdAt,
+                comment.content,
+                comment.likeCount,
+                comment.status.eq(StatusType.INACTIVE)
+        );
+
+        // 5) 루프를 돌며 모든 깊이의 자식 댓글 조회 및 매핑
+        while (!parentIds.isEmpty()) {
+            List<CommentQueryDto> children = queryFactory
+                    .select(childProj)
+                    .from(comment)
+                    .leftJoin(comment.parent, parentComment)
+                    .leftJoin(parentComment.userJpaEntity, parentCommentCreator)
+                    .leftJoin(comment.userJpaEntity, commentCreator)
+                    .leftJoin(commentCreator.aliasForUserJpaEntity, aliasOfCommentCreator)
+                    .where(
+                            comment.parent.commentId.in(parentIds),     // parentIds 하위의 모든 자식 댓글 조회
+                            comment.status.eq(StatusType.ACTIVE)        // 자식 댓글은 ACTIVE인 것만 조회
+                    )
+                    .fetch();
+
+            if (children.isEmpty()) break;
+
+            Set<Long> nextParentIds = new HashSet<>();
+            for (CommentQueryDto child : children) {    // 조회한 자식 댓글들에 대하여
+                Long rootId = idToRoot.get(child.parentCommentId());    // 현재 자식댓글의 루트 댓글(부모 아님, 루트임)
+
+                resultMap.get(rootId).add(child);   // 해당 루트 ID의 리스트에 자식 댓글 추가
+
+                // 현재 자식 댓글도 다음 단계의 parentIds로 사용하기 위해 매핑 저장
+                idToRoot.put(child.commentId(), rootId);
+                nextParentIds.add(child.commentId());
+            }
+            parentIds = nextParentIds;  // 한단계 아래 계층에서 활용할 부모 댓글들
+        }
+
+        // 6) 각 루트별 value 리스트를 작성시간순으로 정렬
+        resultMap.values().forEach(list -> list.sort(Comparator.comparing(CommentQueryDto::createdAt)));
+
+        return resultMap;
+    }
+}