Devops Monk

cascade = CascadeType.PERSIST   // propagate persist (save new entity)
cascade = CascadeType.MERGE     // propagate merge (re-attach detached entity)
cascade = CascadeType.REMOVE    // propagate remove (delete)
cascade = CascadeType.REFRESH   // propagate refresh (reload from DB)
cascade = CascadeType.DETACH    // propagate detach (remove from context)
cascade = CascadeType.ALL       // all of the above

@OneToMany(mappedBy = "order", cascade = CascadeType.PERSIST)
private List<OrderItem> items = new ArrayList<>();

Order order = new Order();       // transient
OrderItem item = new OrderItem(); // transient
order.addItem(item);

orderRepository.save(order);
// CascadeType.PERSIST: saves item too
// Without PERSIST: item stays transient → NOT saved → item.orderId is null

@OneToMany(mappedBy = "order", cascade = {CascadeType.PERSIST, CascadeType.MERGE})
private List<OrderItem> items = new ArrayList<>();

// order is detached (loaded in a previous transaction)
order.getItems().get(0).setQuantity(3);  // change on detached child

orderRepository.save(order);  // save() calls merge() for detached entities
// CascadeType.MERGE: also merges modified items

@OneToMany(mappedBy = "order", cascade = CascadeType.REMOVE)
private List<OrderItem> items = new ArrayList<>();

orderRepository.delete(order);
// CascadeType.REMOVE: deletes all order items first, then the order

DELETE FROM order_items WHERE order_id = ?   -- items deleted first
DELETE FROM orders WHERE id = ?              -- then the order

// DANGEROUS — deletes the Category when any Product is deleted
@ManyToOne(cascade = CascadeType.REMOVE)
private Category category;

@OneToMany(mappedBy = "order", cascade = CascadeType.ALL, orphanRemoval = true)
private List<OrderItem> items = new ArrayList<>();

@OneToOne(cascade = CascadeType.ALL, fetch = FetchType.LAZY)
@JoinColumn(name = "profile_id")
private CustomerProfile profile;

@OneToMany(mappedBy = "order", cascade = CascadeType.ALL, orphanRemoval = true)
private List<OrderItem> items = new ArrayList<>();

@Transactional
public void removeFirstItem(Long orderId) {
    Order order = orderRepository.findById(orderId).orElseThrow();
    OrderItem firstItem = order.getItems().get(0);

    order.removeItem(firstItem);
    // orphanRemoval = true: the item row is deleted from order_items on flush
    // No explicit itemRepository.delete() needed
}

@OneToMany(mappedBy = "order", cascade = CascadeType.ALL, orphanRemoval = true)

@Service
@RequiredArgsConstructor
public class OrderService {

    private final OrderRepository orderRepository;

    // Create — PERSIST cascades to items
    @Transactional
    public Order create(Customer customer, List<OrderItemRequest> requests) {
        Order order = new Order();
        order.setCustomer(customer);
        order.setOrderedAt(LocalDateTime.now());

        for (OrderItemRequest req : requests) {
            OrderItem item = new OrderItem();
            item.setProduct(req.product());
            item.setQuantity(req.quantity());
            item.setUnitPrice(req.product().getPrice());
            order.addItem(item);
        }

        return orderRepository.save(order);
        // PERSIST cascades: saves order + all items
    }

    // Update — MERGE cascades to items
    @Transactional
    public Order updateQuantity(Long orderId, Long itemId, int newQty) {
        Order order = orderRepository.findById(orderId).orElseThrow();
        order.getItems().stream()
            .filter(i -> i.getId().equals(itemId))
            .findFirst()
            .ifPresent(i -> i.setQuantity(newQty));
        // dirty checking detects the item change — no explicit save needed
        return order;
    }

    // Remove item — orphanRemoval deletes it
    @Transactional
    public void removeItem(Long orderId, Long itemId) {
        Order order = orderRepository.findById(orderId).orElseThrow();
        order.getItems().removeIf(i -> i.getId().equals(itemId));
        // orphanRemoval = true: DELETE FROM order_items WHERE id = ?
    }

    // Delete order — REMOVE cascades to items
    @Transactional
    public void cancel(Long orderId) {
        orderRepository.deleteById(orderId);
        // CascadeType.REMOVE: DELETE FROM order_items WHERE order_id = ?
        //                     DELETE FROM orders WHERE id = ?
    }
}

orderRepository.delete(order);
// Hibernate: SELECT * FROM order_items WHERE order_id = ?   ← loads all items
// Then: DELETE FROM order_items WHERE id = ?  (one per item)
// Then: DELETE FROM orders WHERE id = ?

@Modifying
@Query("DELETE FROM OrderItem i WHERE i.order.id = :orderId")
void deleteByOrderId(@Param("orderId") Long orderId);

itemRepository.deleteByOrderId(orderId);  // bulk delete in one SQL
orderRepository.deleteById(orderId);