[volume-3] 도메인 & 객체 설계 및 아키텍처, 패키지 구성

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

@@ -0,0 +1,42 @@
+package com.loopers.application.like;
+
+import com.loopers.domain.like.Like;
+import com.loopers.domain.like.LikeService;
+import com.loopers.domain.product.ProductRepository;
+import com.loopers.support.error.CoreException;
+import com.loopers.support.error.ErrorType;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Component;
+
+import java.util.List;
+
+@RequiredArgsConstructor
+@Component
+public class LikeFacade {
+
+    private final LikeService likeService;
+    private final ProductRepository productRepository;
+
+    public LikeInfo like(Long userId, Long productId) {
+        validateProductExists(productId);
+        Like like = likeService.like(userId, productId);
+        return LikeInfo.from(like);
+    }
+
+    public void unlike(Long userId, Long productId) {
+        validateProductExists(productId);
+        likeService.unlike(userId, productId);
+    }
+
+    public List<LikeInfo> getLikesByUserId(Long userId) {
+        return likeService.findByUserId(userId).stream()
+            .map(LikeInfo::from)
+            .toList();
+    }
+
+    private void validateProductExists(Long productId) {
+        if (!productRepository.existsById(productId)) {
+            throw new CoreException(ErrorType.NOT_FOUND, "상품을 찾을 수 없습니다");
+        }
+    }
+}

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

@@ -0,0 +1,14 @@
+package com.loopers.application.like;
+
+import com.loopers.domain.like.Like;
+
+public record LikeInfo(Long likeId, Long userId, Long productId) {
+
+    public static LikeInfo from(Like like) {
+        return new LikeInfo(
+            like.getId(),
+            like.getUserId(),
+            like.getProductId()
+        );
+    }
+}

apps/commerce-api/src/main/java/com/loopers/application/order/OrderFacade.java

@@ -0,0 +1,57 @@
+package com.loopers.application.order;
+
+import com.loopers.domain.order.Order;
+import com.loopers.domain.order.OrderItem;
+import com.loopers.domain.order.OrderService;
+import com.loopers.domain.product.Product;
+import com.loopers.domain.product.ProductRepository;
+import com.loopers.domain.user.User;
+import com.loopers.domain.user.UserRepository;
+import com.loopers.support.error.CoreException;
+import com.loopers.support.error.ErrorType;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.ArrayList;
+import java.util.List;
+
+@RequiredArgsConstructor
+@Component
+public class OrderFacade {
+
+    private final OrderService orderService;
+    private final ProductRepository productRepository;
+    private final UserRepository userRepository;
+
+    @Transactional
+    public OrderInfo createOrder(Long userId, List<OrderItemRequest> itemRequests) {
+        User user = userRepository.findById(userId)
+            .orElseThrow(() -> new CoreException(ErrorType.NOT_FOUND, "사용자를 찾을 수 없습니다"));
+
+        List<OrderItem> orderItems = new ArrayList<>();
+        for (OrderItemRequest req : itemRequests) {
+            Product product = productRepository.findById(req.productId())
+                .orElseThrow(() -> new CoreException(ErrorType.NOT_FOUND, "상품을 찾을 수 없습니다"));
+
+            product.decreaseStock(req.quantity());
+            productRepository.save(product);
+
+            OrderItem orderItem = new OrderItem(
+                product.getId(),
+                product.getName(),
+                product.getPrice(),
+                req.quantity()
+            );
+            orderItems.add(orderItem);
+        }
+
+        Order order = new Order(userId, orderItems);
+        user.deductPoint(order.getTotalPrice());
+        userRepository.save(user);
+
+        return OrderInfo.from(orderService.createOrder(order));
+    }
+
+    public record OrderItemRequest(Long productId, Integer quantity) {}
+}

apps/commerce-api/src/main/java/com/loopers/application/order/OrderInfo.java

@@ -0,0 +1,33 @@
+package com.loopers.application.order;
+
+import com.loopers.domain.order.Order;
+import com.loopers.domain.order.OrderItem;
+
+import java.util.List;
+
+public record OrderInfo(Long orderId, Long userId, Long totalPrice, List<OrderItemInfo> items) {
+
+    public record OrderItemInfo(Long productId, String productName, Long productPrice, Integer quantity) {
+
+        public static OrderItemInfo from(OrderItem item) {
+            return new OrderItemInfo(
+                item.getProductId(),
+                item.getProductName(),
+                item.getProductPrice(),
+                item.getQuantity()
+            );
+        }
+    }
+
+    public static OrderInfo from(Order order) {
+        List<OrderItemInfo> items = order.getOrderItems().stream()
+            .map(OrderItemInfo::from)
+            .toList();
+        return new OrderInfo(
+            order.getId(),
+            order.getUserId(),
+            order.getTotalPrice(),
+            items
+        );
+    }
+}

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

@@ -0,0 +1,24 @@
+package com.loopers.domain.brand;
+
+import com.loopers.domain.BaseEntity;
+import jakarta.persistence.Column;
+import jakarta.persistence.Entity;
+import jakarta.persistence.Table;
+
+@Entity
+@Table(name = "brands")
+public class Brand extends BaseEntity {
+
+    @Column(name = "name", nullable = false, unique = true, length = 50)
+    private BrandName name;
+
+    protected Brand() {}
+
+    public Brand(String name) {
+        this.name = new BrandName(name);
+    }
+
+    public BrandName getName() {
+        return name;
+    }
+}

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

@@ -0,0 +1,16 @@
+package com.loopers.domain.brand;
+
+import com.loopers.support.error.CoreException;
+import com.loopers.support.error.ErrorType;
+
+public record BrandName(String value) {
+    public BrandName {
+        if (value == null || value.isBlank()) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "브랜드 이름은 비어 있을 수 없습니다");
+        }
+        value = value.trim();
+        if (value.length() > 50) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "브랜드 이름은 1~50자여야 합니다");
+        }
+    }
+}

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

@@ -0,0 +1,11 @@
+package com.loopers.domain.brand;
+
+import java.util.List;
+import java.util.Optional;
+
+public interface BrandRepository {
+    Brand save(Brand brand);
+    Optional<Brand> findById(Long id);
+    List<Brand> findAll();
+    boolean existsByName(BrandName name);
+}

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

@@ -0,0 +1,22 @@
+package com.loopers.domain.brand;
+
+import com.loopers.support.error.CoreException;
+import com.loopers.support.error.ErrorType;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Component;
+
+@RequiredArgsConstructor
+@Component
+public class BrandService {
+
+    private final BrandRepository brandRepository;
+
+    public Brand register(String name) {
+        BrandName brandName = new BrandName(name);
+        if (brandRepository.existsByName(brandName)) {
+            throw new CoreException(ErrorType.CONFLICT, "이미 등록된 브랜드 이름입니다");
+        }
+        Brand brand = new Brand(name);
+        return brandRepository.save(brand);
+    }
+}

apps/commerce-api/src/main/java/com/loopers/domain/like/Like.java

@@ -0,0 +1,40 @@
+package com.loopers.domain.like;
+
+import com.loopers.domain.BaseEntity;
+import com.loopers.support.error.CoreException;
+import com.loopers.support.error.ErrorType;
+import jakarta.persistence.Column;
+import jakarta.persistence.Entity;
+import jakarta.persistence.Table;
+
+@Entity
+@Table(name = "likes")
+public class Like extends BaseEntity {
+
+    @Column(name = "user_id", nullable = false)
+    private Long userId;
+
+    @Column(name = "product_id", nullable = false)
+    private Long productId;
+
+    protected Like() {}
+
+    public Like(Long userId, Long productId) {
+        if (userId == null) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "userId는 필수입니다");
+        }
+        if (productId == null) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "productId는 필수입니다");
+        }
+        this.userId = userId;
+        this.productId = productId;
+    }
+
+    public Long getUserId() {
+        return userId;
+    }
+
+    public Long getProductId() {
+        return productId;
+    }
+}

apps/commerce-api/src/main/java/com/loopers/domain/like/LikeRepository.java

@@ -0,0 +1,17 @@
+package com.loopers.domain.like;
+
+import java.util.List;
+import java.util.Optional;
+
+public interface LikeRepository {
+
+    Like save(Like like);
+
+    Optional<Like> findByUserIdAndProductId(Long userId, Long productId);
+
+    List<Like> findByUserId(Long userId);
+
+    void delete(Like like);
+
+    long countByProductId(Long productId);
+}

apps/commerce-api/src/main/java/com/loopers/domain/like/LikeService.java

@@ -0,0 +1,38 @@
+package com.loopers.domain.like;
+
+import java.util.List;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+
+@RequiredArgsConstructor
+@Component
+public class LikeService {
+
+    private final LikeRepository likeRepository;
+
+    @Transactional
+    public Like like(Long userId, Long productId) {
+        return likeRepository.findByUserIdAndProductId(userId, productId)
+            .orElseGet(() -> {
+                Like like = new Like(userId, productId);
+                return likeRepository.save(like);
+            });
+    }
+
+    @Transactional
+    public void unlike(Long userId, Long productId) {
+        likeRepository.findByUserIdAndProductId(userId, productId)
+            .ifPresent(likeRepository::delete);
+    }
+
+    @Transactional(readOnly = true)
+    public List<Like> findByUserId(Long userId) {
+        return likeRepository.findByUserId(userId);
+    }
+
+    @Transactional(readOnly = true)
+    public long countByProductId(Long productId) {
+        return likeRepository.countByProductId(productId);
+    }
+}

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

@@ -0,0 +1,59 @@
+package com.loopers.domain.order;
+
+import com.loopers.domain.BaseEntity;
+import com.loopers.support.error.CoreException;
+import com.loopers.support.error.ErrorType;
+import jakarta.persistence.Column;
+import jakarta.persistence.Entity;
+import jakarta.persistence.Table;
+import jakarta.persistence.Transient;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+@Entity
+@Table(name = "orders")
+public class Order extends BaseEntity {
+
+    @Column(name = "user_id", nullable = false)
+    private Long userId;
+
+    @Column(name = "total_price", nullable = false)
+    private Long totalPrice;
+
+    @Transient
+    private List<OrderItem> orderItems = new ArrayList<>();
+
+    protected Order() {}
+
+    public Order(Long userId, List<OrderItem> orderItems) {
+        if (userId == null) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "userId는 필수입니다");
+        }
+        if (orderItems == null || orderItems.isEmpty()) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "주문 항목은 1개 이상이어야 합니다");
+        }
+        this.userId = userId;
+        this.orderItems = new ArrayList<>(orderItems);
+        this.totalPrice = calculateTotalPrice();
+    }
+
+    private long calculateTotalPrice() {
+        return orderItems.stream()
+            .mapToLong(OrderItem::totalPrice)
+            .sum();
+    }
+
+    public Long getUserId() {
+        return userId;
+    }
+
+    public Long getTotalPrice() {
+        return totalPrice;
+    }
+
+    public List<OrderItem> getOrderItems() {
+        return Collections.unmodifiableList(orderItems);
+    }
+}