[feat/CK-242] 로드맵 관련 부분 의존성 리팩토링을 한다

backend/kirikiri/src/main/java/co/kirikiri/persistence/goalroom/GoalRoomMemberQueryRepositoryImpl.java

@@ -38,7 +38,7 @@ public Optional<GoalRoomMember> findByRoadmapIdAndMemberIdentifierAndGoalRoomSta
                 .innerJoin(goalRoomMember.member, member)
                 .fetchJoin()
                 .where(
-                        goalRoom.roadmapContent.roadmap.id.eq(roadmapId),
+                        goalRoom.roadmapContent.roadmapId.eq(roadmapId),
                         member.identifier.eq(identifier),
                         goalRoom.status.eq(status))
                 .fetchOne());

backend/kirikiri/src/main/java/co/kirikiri/persistence/goalroom/GoalRoomQueryRepository.java

@@ -4,7 +4,6 @@
 import co.kirikiri.domain.goalroom.GoalRoomStatus;
 import co.kirikiri.domain.member.Member;
 import co.kirikiri.persistence.goalroom.dto.RoadmapGoalRoomsOrderType;
-import co.kirikiri.roadmap.domain.Roadmap;
 
 import java.time.LocalDate;
 import java.util.List;
@@ -18,10 +17,10 @@ public interface GoalRoomQueryRepository {
 
     Optional<GoalRoom> findByIdWithContentAndTodos(final Long goalRoomId);
 
-    List<GoalRoom> findGoalRoomsByRoadmapAndCond(final Roadmap roadmap,
-                                                 final RoadmapGoalRoomsOrderType filterType,
-                                                 final Long lastId,
-                                                 final int pageSize);
+    List<GoalRoom> findGoalRoomsByRoadmapIdAndCond(final Long roadmapId,
+                                                   final RoadmapGoalRoomsOrderType filterType,
+                                                   final Long lastId,
+                                                   final int pageSize);
 
     Optional<GoalRoom> findByIdWithTodos(final Long goalRoomId);
 
@@ -31,7 +30,7 @@ List<GoalRoom> findGoalRoomsByRoadmapAndCond(final Roadmap roadmap,
 
     Optional<GoalRoom> findByIdWithNodes(final Long goalRoomId);
 
-    List<GoalRoom> findByRoadmap(final Roadmap roadmap);
+    List<GoalRoom> findByRoadmapId(final Long roadmapId);
 
     List<GoalRoom> findAllRecruitingGoalRoomsByStartDateEarlierThan(final LocalDate startDate);
 }

backend/kirikiri/src/main/java/co/kirikiri/persistence/goalroom/GoalRoomQueryRepositoryImpl.java

@@ -5,7 +5,6 @@
 import co.kirikiri.domain.member.Member;
 import co.kirikiri.persistence.QuerydslRepositorySupporter;
 import co.kirikiri.persistence.goalroom.dto.RoadmapGoalRoomsOrderType;
-import co.kirikiri.roadmap.domain.Roadmap;
 import com.querydsl.core.types.OrderSpecifier;
 import com.querydsl.core.types.dsl.BooleanExpression;
 import jakarta.persistence.LockModeType;
@@ -60,17 +59,16 @@ public Optional<GoalRoom> findByIdWithContentAndTodos(final Long goalRoomId) {
     }
 
     @Override
-    public List<GoalRoom> findGoalRoomsByRoadmapAndCond(final Roadmap roadmap,
-                                                        final RoadmapGoalRoomsOrderType orderType,
-                                                        final Long lastId,
-                                                        final int pageSize) {
+    public List<GoalRoom> findGoalRoomsByRoadmapIdAndCond(final Long roadmapId,
+                                                          final RoadmapGoalRoomsOrderType orderType,
+                                                          final Long lastId,
+                                                          final int pageSize) {
         return selectFrom(goalRoom)
                 .innerJoin(goalRoom.roadmapContent, roadmapContent)
-                .on(roadmapContent.roadmap.eq(roadmap))
+                .on(roadmapContent.roadmapId.eq(roadmapId))
                 .where(
                         statusCond(orderType),
-                        lessThanLastId(lastId, orderType),
-                        roadmapCond(roadmap))
+                        lessThanLastId(lastId, orderType))
                 .limit(pageSize + LIMIT_OFFSET)
                 .orderBy(sortCond(orderType))
                 .fetch();
@@ -118,10 +116,10 @@ public Optional<GoalRoom> findByIdWithNodes(final Long goalRoomId) {
     }
 
     @Override
-    public List<GoalRoom> findByRoadmap(final Roadmap roadmap) {
+    public List<GoalRoom> findByRoadmapId(final Long roadmapId) {
         return selectFrom(goalRoom)
                 .innerJoin(goalRoom.roadmapContent, roadmapContent)
-                .where(roadmapContent.roadmap.eq(roadmap))
+                .where(roadmapContent.roadmapId.eq(roadmapId))
                 .fetch();
     }
 
@@ -174,10 +172,6 @@ private BooleanExpression lessThanLastId(final Long lastId, final RoadmapGoalRoo
         );
     }
 
-    private BooleanExpression roadmapCond(final Roadmap roadmap) {
-        return goalRoom.roadmapContent.roadmap.eq(roadmap);
-    }
-
     private BooleanExpression equalOrEarlierStartDateThan(final LocalDate date) {
         return goalRoom.startDate.loe(date);
     }

backend/kirikiri/src/main/java/co/kirikiri/roadmap/domain/Roadmap.java

@@ -15,7 +15,6 @@
 import lombok.NoArgsConstructor;
 
 import java.util.Objects;
-import java.util.Optional;
 
 @Entity
 @NoArgsConstructor(access = AccessLevel.PROTECTED)
@@ -52,15 +51,9 @@ public class Roadmap extends BaseCreatedTimeEntity {
     @JoinColumn(name = "category_id", nullable = false)
     private RoadmapCategory category;
 
-    @Embedded
-    private RoadmapContents contents = new RoadmapContents();
-
     @Embedded
     private RoadmapTags tags = new RoadmapTags();
 
-    @Embedded
-    private RoadmapReviews reviews = new RoadmapReviews();
-
     public Roadmap(final String title, final String introduction, final int requiredPeriod,
                    final RoadmapDifficulty difficulty, final Long creatorId, final RoadmapCategory category) {
         this(null, title, introduction, requiredPeriod, difficulty, RoadmapStatus.CREATED, creatorId, category);
@@ -123,13 +116,6 @@ private void validateRequiredPeriod(final int requiredPeriod) {
         }
     }
 
-    public void addContent(final RoadmapContent content) {
-        contents.add(content);
-        if (content.isNotSameRoadmap(this)) {
-            content.updateRoadmap(this);
-        }
-    }
-
     public void addTags(final RoadmapTags tags) {
         this.tags.addAll(tags);
     }
@@ -138,21 +124,10 @@ public boolean isCreator(final Long memberId) {
         return Objects.equals(creatorId, memberId);
     }
 
-    public void addReview(final RoadmapReview review) {
-        reviews.add(review);
-        if (review.isNotSameRoadmap(this)) {
-            review.updateRoadmap(this);
-        }
-    }
-
     public void delete() {
         this.status = RoadmapStatus.DELETED;
     }
 
-    public Optional<RoadmapContent> findLastRoadmapContent() {
-        return this.contents.findLastRoadmapContent();
-    }
-
     public boolean isDeleted() {
         return status == RoadmapStatus.DELETED;
     }
@@ -169,10 +144,6 @@ public RoadmapCategory getCategory() {
         return category;
     }
 
-    public RoadmapContents getContents() {
-        return contents;
-    }
-
     public String getIntroduction() {
         return introduction;
     }

backend/kirikiri/src/main/java/co/kirikiri/roadmap/domain/RoadmapContent.java

@@ -5,9 +5,6 @@
 import jakarta.persistence.Column;
 import jakarta.persistence.Embedded;
 import jakarta.persistence.Entity;
-import jakarta.persistence.FetchType;
-import jakarta.persistence.JoinColumn;
-import jakarta.persistence.ManyToOne;
 import lombok.AccessLevel;
 import lombok.Getter;
 import lombok.NoArgsConstructor;
@@ -24,21 +21,20 @@ public class RoadmapContent extends BaseUpdatedTimeEntity {
     @Column(length = 2200)
     private String content;
 
-    @ManyToOne(fetch = FetchType.LAZY)
-    @JoinColumn(name = "roadmap_id", nullable = false)
-    private Roadmap roadmap;
+    private Long roadmapId;
 
     @Embedded
     private final RoadmapNodes nodes = new RoadmapNodes();
 
-    public RoadmapContent(final String content) {
-        this(null, content);
+    public RoadmapContent(final String content, final Long roadmapId) {
+        this(null, content, roadmapId);
     }
 
-    public RoadmapContent(final Long id, final String content) {
+    public RoadmapContent(final Long id, final String content, final Long roadmapId) {
         validate(content);
         this.id = id;
         this.content = content;
+        this.roadmapId = roadmapId;
     }
 
     private void validate(final String content) {
@@ -58,16 +54,6 @@ public void addNodes(final RoadmapNodes nodes) {
         this.nodes.addAll(nodes);
     }
 
-    public boolean isNotSameRoadmap(final Roadmap roadmap) {
-        return this.roadmap == null || !this.roadmap.equals(roadmap);
-    }
-
-    public void updateRoadmap(final Roadmap roadmap) {
-        if (this.roadmap == null) {
-            this.roadmap = roadmap;
-        }
-    }
-
     public int nodesSize() {
         return nodes.size();
     }
@@ -84,11 +70,11 @@ public String getContent() {
         return content;
     }
 
-    public RoadmapNodes getNodes() {
-        return nodes;
+    public Long getRoadmapId() {
+        return roadmapId;
     }
 
-    public Roadmap getRoadmap() {
-        return roadmap;
+    public RoadmapNodes getNodes() {
+        return nodes;
     }
 }

backend/kirikiri/src/main/java/co/kirikiri/roadmap/domain/RoadmapContents.java

@@ -1,25 +1,15 @@
 package co.kirikiri.roadmap.domain;
 
-import jakarta.persistence.CascadeType;
-import jakarta.persistence.Column;
-import jakarta.persistence.Embeddable;
-import jakarta.persistence.FetchType;
-import jakarta.persistence.OneToMany;
 import lombok.AccessLevel;
 import lombok.NoArgsConstructor;
 
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Optional;
 
-@Embeddable
 @NoArgsConstructor(access = AccessLevel.PROTECTED)
 public class RoadmapContents {
 
-    @OneToMany(fetch = FetchType.LAZY,
-            cascade = {CascadeType.PERSIST, CascadeType.MERGE, CascadeType.REMOVE},
-            mappedBy = "roadmap")
-    @Column(nullable = false)
     private final List<RoadmapContent> values = new ArrayList<>();
 
     public RoadmapContents(final List<RoadmapContent> contents) {

backend/kirikiri/src/main/java/co/kirikiri/roadmap/domain/RoadmapReview.java

@@ -4,9 +4,6 @@
 import co.kirikiri.roadmap.domain.exception.RoadmapException;
 import jakarta.persistence.Column;
 import jakarta.persistence.Entity;
-import jakarta.persistence.FetchType;
-import jakarta.persistence.JoinColumn;
-import jakarta.persistence.ManyToOne;
 import lombok.AccessLevel;
 import lombok.NoArgsConstructor;
 
@@ -31,17 +28,16 @@ public class RoadmapReview extends BaseUpdatedTimeEntity {
 
     private Long memberId;
 
-    @ManyToOne(fetch = FetchType.LAZY)
-    @JoinColumn(name = "roadmap_id")
-    private Roadmap roadmap;
+    private Long roadmapId;
 
-    public RoadmapReview(final String content, final Double rate, final Long memberId) {
+    public RoadmapReview(final String content, final Double rate, final Long memberId, final Long roadmapId) {
         if (content != null) {
             validate(content, rate);
         }
         this.content = content;
         this.rate = rate;
         this.memberId = memberId;
+        this.roadmapId = roadmapId;
     }
 
     private void validate(final String content, final Double rate) {
@@ -62,16 +58,6 @@ private void validateRate(final Double rate) {
         }
     }
 
-    public void updateRoadmap(final Roadmap roadmap) {
-        if (this.roadmap == null) {
-            this.roadmap = roadmap;
-        }
-    }
-
-    public boolean isNotSameRoadmap(final Roadmap roadmap) {
-        return this.roadmap == null || !this.roadmap.equals(roadmap);
-    }
-
     public String getContent() {
         return content;
     }
@@ -83,4 +69,8 @@ public Double getRate() {
     public Long getMemberId() {
         return memberId;
     }
+
+    public Long getRoadmapId() {
+        return roadmapId;
+    }
 }

backend/kirikiri/src/main/java/co/kirikiri/roadmap/domain/RoadmapReviews.java

@@ -1,9 +1,6 @@
 package co.kirikiri.roadmap.domain;
 
-import jakarta.persistence.CascadeType;
 import jakarta.persistence.Embeddable;
-import jakarta.persistence.FetchType;
-import jakarta.persistence.OneToMany;
 import lombok.AccessLevel;
 import lombok.NoArgsConstructor;
 
@@ -14,9 +11,9 @@
 @NoArgsConstructor(access = AccessLevel.PROTECTED)
 public class RoadmapReviews {
 
-    @OneToMany(fetch = FetchType.LAZY,
-            cascade = {CascadeType.PERSIST, CascadeType.MERGE, CascadeType.REMOVE},
-            orphanRemoval = true, mappedBy = "roadmap")
+    //    @OneToMany(fetch = FetchType.LAZY,
+//            cascade = {CascadeType.PERSIST, CascadeType.MERGE, CascadeType.REMOVE},
+//            orphanRemoval = true, mappedBy = "roadmap")
     private List<RoadmapReview> values = new ArrayList<>();
 
     public void add(final RoadmapReview review) {

backend/kirikiri/src/main/java/co/kirikiri/roadmap/persistence/RoadmapContentRepository.java

@@ -1,21 +1,16 @@
 package co.kirikiri.roadmap.persistence;
 
-import co.kirikiri.roadmap.domain.Roadmap;
 import co.kirikiri.roadmap.domain.RoadmapContent;
 import org.springframework.data.jpa.repository.JpaRepository;
-import org.springframework.data.jpa.repository.Query;
-import org.springframework.data.repository.query.Param;
 
+import java.util.List;
 import java.util.Optional;
 
 public interface RoadmapContentRepository extends JpaRepository<RoadmapContent, Long> {
 
     Optional<RoadmapContent> findFirstByRoadmapIdOrderByCreatedAtDesc(final Long roadmapId);
 
-    Optional<RoadmapContent> findFirstByRoadmapOrderByCreatedAtDesc(final Roadmap roadmap);
+    List<RoadmapContent> findAllByRoadmapId(final Long roadmapId);
 
-    @Query("select rc from RoadmapContent rc "
-            + "join fetch rc.roadmap r "
-            + "where rc.id = :roadmapContentId")
-    Optional<RoadmapContent> findByIdWithRoadmap(@Param("roadmapContentId") final Long roadmapContentId);
+    void deleteAllByRoadmapId(final Long roadmapId);
 }

backend/kirikiri/src/main/java/co/kirikiri/roadmap/persistence/RoadmapQueryRepository.java

@@ -2,7 +2,6 @@
 
 import co.kirikiri.roadmap.domain.Roadmap;
 import co.kirikiri.roadmap.domain.RoadmapCategory;
-import co.kirikiri.roadmap.domain.RoadmapStatus;
 import co.kirikiri.roadmap.persistence.dto.RoadmapOrderType;
 import co.kirikiri.roadmap.persistence.dto.RoadmapSearchDto;
 
@@ -28,6 +27,4 @@ List<Roadmap> findRoadmapsWithCategoryByMemberIdOrderByLatest(final Long memberI
                                                                   final int pageSize);
 
     Optional<Roadmap> findByIdAndMemberIdentifier(final Long roadmapId, final String identifier);
-
-    List<Roadmap> findWithRoadmapContentByStatus(final RoadmapStatus status);
 }