[volume-10] Collect, Stack, Zip

.github/workflows/main.yml

@@ -0,0 +1,13 @@
+name: PR Agent
+on:
+  pull_request:
+    types: [opened, synchronize]
+jobs:
+  pr_agent_job:
+    runs-on: ubuntu-latest
+    steps:
+      - name: PR Agent action step
+        uses: Codium-ai/pr-agent@main
+        env:
+          OPENAI_KEY: ${{ secrets.OPENAI_KEY }}
+          GITHUB_TOKEN: ${{ secrets.G_TOKEN }}

apps/commerce-api/src/main/java/com/loopers/application/like/LikeFacade.java

@@ -3,7 +3,6 @@
 import com.loopers.domain.like.LikeService;
 import lombok.RequiredArgsConstructor;
 import org.springframework.stereotype.Component;
-import org.springframework.transaction.annotation.Transactional;
 
 /**
  * packageName : com.loopers.application.like
@@ -18,7 +17,6 @@
  */
 @Component
 @RequiredArgsConstructor
-@Transactional
 public class LikeFacade {
 
     private final LikeService likeService;

apps/commerce-api/src/main/java/com/loopers/application/ranking/ProductRankSnapshot.java

@@ -0,0 +1,8 @@
+package com.loopers.application.ranking;
+
+public record ProductRankSnapshot(
+        long rank,
+        Long productId,
+        double score
+) {
+}

apps/commerce-api/src/main/java/com/loopers/application/ranking/RankingFacade.java

@@ -21,19 +21,30 @@ public class RankingFacade {
     private final RankingService rankingService;
     private final ProductService productService;
     private final BrandService brandService;
+    private final RankingMaterializedViewService rankingMaterializedViewService;
 
     @Transactional(readOnly = true)
-    public List<RankingInfo> getRankingItems(String date, int page, int size) {
-        return rankingService.getRankingRows(date, page, size)
+    public List<RankingInfo> getRankingItems(String date, RankingPeriod period, int page, int size) {
+        if (period.isDaily()) {
+            return rankingService.getRankingRows(date, page, size)
+                    .stream()
+                    .map(this::toDto)
+                    .filter(Objects::nonNull)
+                    .collect(Collectors.toList());
+        }
+        return rankingMaterializedViewService.getRankings(period, period.resolveKey(date), page, size)
                 .stream()
-                .map(this::toDto)
+                .map(this::toSnapshotDto)
                 .filter(Objects::nonNull)
                 .collect(Collectors.toList());
     }
 
     @Transactional(readOnly = true)
-    public long count(String date) {
-        return rankingService.count(date);
+    public long count(String date, RankingPeriod period) {
+        if (period.isDaily()) {
+            return rankingService.count(date);
+        }
+        return rankingMaterializedViewService.count(period, period.resolveKey(date));
     }
 
     @Transactional(readOnly = true)
@@ -53,8 +64,19 @@ private RankingInfo toDto(RankingRow row) {
             return null;
         }
 
-        Product product = productService.getProduct(row.productId());
+        return createRankingInfo(row.productId(), row.rank(), row.score());
+    }
+
+    private RankingInfo toSnapshotDto(ProductRankSnapshot snapshot) {
+        if (snapshot.productId() == null) {
+            return null;
+        }
+        return createRankingInfo(snapshot.productId(), snapshot.rank(), snapshot.score());
+    }
+
+    private RankingInfo createRankingInfo(Long productId, long rank, double score) {
+        Product product = productService.getProduct(productId);
         ProductInfo productInfo = ProductInfo.of(product, brandService.getBrand(product.getBrandId()));
-        return new RankingInfo(row.rank(), row.score(), productInfo);
+        return new RankingInfo(rank, score, productInfo);
     }
 }

apps/commerce-api/src/main/java/com/loopers/application/ranking/RankingMaterializedViewService.java

@@ -0,0 +1,53 @@
+package com.loopers.application.ranking;
+
+import com.loopers.domain.ranking.MvProductRankMonthly;
+import com.loopers.domain.ranking.MvProductRankWeekly;
+import com.loopers.infrastructure.ranking.MvProductRankMonthlyJpaRepository;
+import com.loopers.infrastructure.ranking.MvProductRankWeeklyJpaRepository;
+import java.util.List;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+
+@Service
+@RequiredArgsConstructor
+public class RankingMaterializedViewService {
+
+    private final MvProductRankWeeklyJpaRepository weeklyRepository;
+    private final MvProductRankMonthlyJpaRepository monthlyRepository;
+
+    public List<ProductRankSnapshot> getRankings(RankingPeriod period, String periodKey, int page, int size) {
+        List<ProductRankSnapshot> snapshots = fetch(period, periodKey);
+        int safeSize = Math.max(size, 1);
+        long skip = (long) Math.max(page, 0) * safeSize;
+        return snapshots.stream()
+                .skip(skip)
+                .limit(safeSize)
+                .toList();
+    }
+
+    public long count(RankingPeriod period, String periodKey) {
+        return fetch(period, periodKey).size();
+    }
+
+    private List<ProductRankSnapshot> fetch(RankingPeriod period, String periodKey) {
+        if (period == RankingPeriod.WEEKLY) {
+            return weeklyRepository.findByIdPeriodKeyOrderByRankAsc(periodKey).stream()
+                    .map(this::fromWeekly)
+                    .toList();
+        }
+        if (period == RankingPeriod.MONTHLY) {
+            return monthlyRepository.findByIdPeriodKeyOrderByRankAsc(periodKey).stream()
+                    .map(this::fromMonthly)
+                    .toList();
+        }
+        throw new IllegalArgumentException("Unsupported period for MV: " + period);
+    }
+
+    private ProductRankSnapshot fromWeekly(MvProductRankWeekly entity) {
+        return new ProductRankSnapshot(entity.getRank(), entity.getProductId(), entity.getScore());
+    }
+
+    private ProductRankSnapshot fromMonthly(MvProductRankMonthly entity) {
+        return new ProductRankSnapshot(entity.getRank(), entity.getProductId(), entity.getScore());
+    }
+}

apps/commerce-api/src/main/java/com/loopers/application/ranking/RankingPeriod.java

@@ -0,0 +1,93 @@
+package com.loopers.application.ranking;
+
+import java.time.DayOfWeek;
+import java.time.LocalDate;
+import java.time.ZoneId;
+import java.time.format.DateTimeFormatter;
+import java.time.temporal.TemporalAdjusters;
+import java.time.temporal.WeekFields;
+import java.util.Arrays;
+import java.util.Locale;
+
+public enum RankingPeriod {
+    DAILY("daily") {
+        @Override
+        public LocalDate resolveStartDate(String date) {
+            return parse(date);
+        }
+
+        @Override
+        public String resolveKey(String date) {
+            return parse(date).format(FORMATTER);
+        }
+    },
+    WEEKLY("weekly") {
+        @Override
+        public LocalDate resolveStartDate(String date) {
+            LocalDate target = parse(date);
+            return target.with(TemporalAdjusters.previousOrSame(DayOfWeek.MONDAY));
+        }
+
+        @Override
+        public String resolveKey(String date) {
+            return toYearMonthWeek(resolveStartDate(date));
+        }
+    },
+    MONTHLY("monthly") {
+        @Override
+        public LocalDate resolveStartDate(String date) {
+            LocalDate target = parse(date);
+            return target.withDayOfMonth(1);
+        }
+
+        @Override
+        public String resolveKey(String date) {
+            return toYearMonth(resolveStartDate(date));
+        }
+    };
+
+    private static final ZoneId ZONE_ID = ZoneId.of("Asia/Seoul");
+    private static final DateTimeFormatter FORMATTER = DateTimeFormatter.BASIC_ISO_DATE;
+
+    private final String value;
+
+    RankingPeriod(String value) {
+        this.value = value;
+    }
+
+    public static RankingPeriod from(String value) {
+        if (value == null) {
+            return DAILY;
+        }
+        return Arrays.stream(values())
+                .filter(period -> period.value.equalsIgnoreCase(value))
+                .findFirst()
+                .orElse(DAILY);
+    }
+
+    public abstract LocalDate resolveStartDate(String date);
+
+    public abstract String resolveKey(String date);
+
+    public boolean isDaily() {
+        return this == DAILY;
+    }
+
+    private static LocalDate parse(String date) {
+        if (date == null || date.isBlank()) {
+            return LocalDate.now(ZONE_ID);
+        }
+        return LocalDate.parse(date, FORMATTER);
+    }
+
+    private static String toYearMonthWeek(LocalDate target) {
+        WeekFields weekFields = WeekFields.of(Locale.KOREA);
+        int weekBasedYear = target.get(weekFields.weekBasedYear());
+        int week = target.get(weekFields.weekOfWeekBasedYear());
+        return String.format("%04d-W%02d", weekBasedYear, week);
+    }
+
+    private static String toYearMonth(LocalDate target) {
+        return String.format("%04d-%02d", target.getYear(), target.getMonthValue());
+    }
+}

apps/commerce-api/src/main/java/com/loopers/domain/brand/BrandService.java

@@ -23,7 +23,6 @@ public class BrandService {
 
     private final BrandRepository brandRepository;
 
-    @Transactional
     public void save(Brand brand) {
         brandRepository.save(brand);
     }

apps/commerce-api/src/main/java/com/loopers/domain/order/Order.java

@@ -55,6 +55,7 @@ public static Order create(String userId) {
     }
 
     public void addOrderItem(OrderItem orderItem) {
+        orderItem.setOrder(this);
         this.orderItems.add(orderItem);
     }
 

apps/commerce-api/src/main/java/com/loopers/domain/point/Point.java

@@ -42,7 +42,6 @@ public void charge(Long chargeAmount) {
             throw new CoreException(ErrorType.BAD_REQUEST, "0원 이하로 포인트를 충전 할수 없습니다.");
         }
         this.balance += chargeAmount;
-        new Point(this.userId, this.balance);
     }
 
     public void use(Long useAmount) {

apps/commerce-api/src/main/java/com/loopers/domain/point/PointService.java

@@ -36,11 +36,11 @@ public Point usePoint(String userId, Long useAmount) {
                 .orElseThrow(() -> new CoreException(ErrorType.NOT_FOUND, "포인트 정보를 찾을 수 없습니다."));
 
         if (useAmount == null || useAmount <= 0) {
-            throw new CoreException(ErrorType.NOT_FOUND, "차감할 포인트는 1 이상이어야 합니다.");
+            throw new CoreException(ErrorType.BAD_REQUEST, "차감할 포인트는 1 이상이어야 합니다.");
         }
 
         if (point.getBalance() < useAmount) {
-            throw new CoreException(ErrorType.NOT_FOUND, "포인트가 부족합니다.");
+            throw new CoreException(ErrorType.BAD_REQUEST, "포인트가 부족합니다.");
         }
 
         point.use(useAmount);

apps/commerce-api/src/main/java/com/loopers/domain/product/Product.java

@@ -85,14 +85,17 @@ private Long requireValidPrice(Long price) {
         return price;
     }
 
-    public Long requireValidLikeCount(Long likeCount) {
+    private Long requireValidLikeCount(Long likeCount) {
         if (likeCount == null || likeCount < 0) {
             throw new CoreException(ErrorType.BAD_REQUEST, "좋아요 개수는 0개 미만으로 설정할 수 없습니다.");
         }
         return likeCount;
     }
 
     private Long requireValidStock(Long stock) {
+        if (stock == null) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "상품 재고는 필수입니다.");
+        }
         if (stock < 0) {
             throw new CoreException(ErrorType.BAD_REQUEST, "상품 재고는 0 미만으로 설정할 수 없습니다.");
         }

apps/commerce-api/src/main/java/com/loopers/domain/product/ProductDomainService.java

@@ -7,6 +7,7 @@
 import com.loopers.support.error.ErrorType;
 import lombok.RequiredArgsConstructor;
 import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
 
 /**
  * packageName : com.loopers.domain.product
@@ -27,6 +28,7 @@ public class ProductDomainService {
     private final BrandRepository brandRepository;
     private final LikeRepository likeRepository;
 
+    @Transactional(readOnly = true)
     public ProductDetail getProductDetail(Long id) {
         Product product = productRepository.findById(id)
                 .orElseThrow(() -> new CoreException(ErrorType.NOT_FOUND, "상품을 찾을 수 없습니다."));

apps/commerce-api/src/main/java/com/loopers/domain/ranking/MvProductRankMonthly.java

@@ -0,0 +1,78 @@
+package com.loopers.domain.ranking;
+
+import jakarta.persistence.Column;
+import jakarta.persistence.EmbeddedId;
+import jakarta.persistence.Entity;
+import jakarta.persistence.Table;
+import java.time.LocalDateTime;
+import lombok.AccessLevel;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+
+@Getter
+@Entity
+@Table(name = "mv_product_rank_monthly")
+@NoArgsConstructor(access = AccessLevel.PROTECTED)
+public class MvProductRankMonthly {
+
+    @EmbeddedId
+    private ProductRankId id;
+
+    @Column(name = "like_count", nullable = false)
+    private long likeCount;
+
+    @Column(name = "sales_count", nullable = false)
+    private long salesCount;
+
+    @Column(name = "score", nullable = false)
+    private double score;
+
+    @Column(name = "rank", nullable = false)
+    private int rank;
+
+    @Column(name = "aggregated_at", nullable = false)
+    private LocalDateTime aggregatedAt;
+
+    private MvProductRankMonthly(
+            ProductRankId id,
+            long likeCount,
+            long salesCount,
+            double score,
+            int rank,
+            LocalDateTime aggregatedAt
+    ) {
+        this.id = id;
+        this.likeCount = likeCount;
+        this.salesCount = salesCount;
+        this.score = score;
+        this.rank = rank;
+        this.aggregatedAt = aggregatedAt;
+    }
+
+    public static MvProductRankMonthly create(
+            String yearMonth,
+            Long productId,
+            long likeCount,
+            long salesCount,
+            double score,
+            int rank,
+            LocalDateTime aggregatedAt
+    ) {
+        return new MvProductRankMonthly(
+                ProductRankId.of(yearMonth, productId),
+                likeCount,
+                salesCount,
+                score,
+                rank,
+                aggregatedAt
+        );
+    }
+
+    public String getPeriodKey() {
+        return id != null ? id.getPeriodKey() : null;
+    }
+
+    public Long getProductId() {
+        return id != null ? id.getProductId() : null;
+    }
+}