Patrones JPA/Hibernate para Spring Boot

@Entity
@Table(name = "tenants", indexes = {
  @Index(name = "idx_tenants_slug",
         columnList = "slug", unique = true),
  @Index(name = "idx_tenants_status",
         columnList = "status")
})
@EntityListeners(AuditingEntityListener.class)
public class TenantEntity {

  @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
  private Long id;

  @Column(nullable = false, length = 200)
  private String name;

  @Column(nullable = false, unique = true, length = 120)
  private String slug;

  @Enumerated(EnumType.STRING)
  @Column(nullable = false, length = 20)
  private TenantStatus status = TenantStatus.ACTIVE;

  // 1:N lazy (no EAGER) — cargado solo con JOIN FETCH
  @OneToMany(mappedBy = "tenant",
    cascade = CascadeType.ALL, orphanRemoval = true)
  private List<OrderEntity> orders = new ArrayList<>();

  @CreatedDate private Instant createdAt;
  @LastModifiedDate private Instant updatedAt;
}

@Entity
@Table(name = "orders", indexes = {
  // Cubre el filtro más frecuente: tenant + estado + fecha
  @Index(name = "idx_orders_tenant_status_date",
         columnList = "tenant_id, status, created_at DESC")
})
@EntityListeners(AuditingEntityListener.class)
public class OrderEntity {

  @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
  private Long id;

  @ManyToOne(fetch = FetchType.LAZY, optional = false)
  @JoinColumn(name = "tenant_id", nullable = false)
  private TenantEntity tenant;

  @Enumerated(EnumType.STRING)
  private OrderStatus status = OrderStatus.DRAFT;

  // LAZY en colecciones — evita el N+1
  @OneToMany(mappedBy = "order",
    cascade = CascadeType.ALL, orphanRemoval = true)
  private List<OrderLineEntity> lines = new ArrayList<>();

  @Column(precision = 12, scale = 2)
  private BigDecimal totalAmount;

  @CreatedDate private Instant createdAt;
  @LastModifiedDate private Instant updatedAt;
}

public interface OrderRepository
    extends JpaRepository<OrderEntity, Long> {

  // Carga Order + lines en 1 sola query
  @Query("select o from OrderEntity o " +
         "left join fetch o.lines " +
         "where o.id = :id")
  Optional<OrderEntity> findWithLines(
      @Param("id") Long id);

  // Listado paginado por tenant + estado (usa el índice compuesto)
  @Query("select o from OrderEntity o " +
         "where o.tenant.id = :tenantId " +
         "and o.status = :status")
  Page<OrderEntity> findByTenantAndStatus(
      @Param("tenantId") Long tenantId,
      @Param("status") OrderStatus status,
      Pageable pageable);

  // Cursor-pagination (evita OFFSET en tablas grandes)
  @Query("select o from OrderEntity o " +
         "where o.tenant.id = :tenantId " +
         "and o.id > :lastId " +
         "order by o.id asc")
  List<OrderEntity> findNextPage(
      @Param("tenantId") Long tenantId,
      @Param("lastId") Long lastId,
      Pageable pageable);
}

// Proyección para listado (select solo id, status, total, fecha)
public interface OrderSummary {
  Long getId();
  OrderStatus getStatus();
  BigDecimal getTotalAmount();
  Instant getCreatedAt();
  // Expresión derivada con @Value (SpEL)
  @Value("#{target.tenant.name}")
  String getTenantName();
}

// En el repositorio:
Page<OrderSummary> findAllBy(Pageable pageable);

// Hibernate genera SELECT optimizado:
// SELECT o.id, o.status, o.total_amount,
//        o.created_at, t.name
// FROM orders o JOIN tenants t ON o.tenant_id = t.id
// → Sin cargar entidad completa ni listas


// DTO record para API response (Java 17)
public record OrderListItem(
  Long id,
  String tenantName,
  OrderStatus status,
  BigDecimal total,
  Instant createdAt
) {
  public static OrderListItem from(OrderSummary s) {
    return new OrderListItem(
      s.getId(), s.getTenantName(),
      s.getStatus(), s.getTotalAmount(),
      s.getCreatedAt());
  }
}

@Service
@RequiredArgsConstructor
public class OrderService {

  private final OrderRepository orderRepo;
  private final TenantRepository tenantRepo;

  // ✅ readOnly = true → Hibernate omite dirty checking
  //    + PostgreSQL puede enrutar a réplica de lectura
  @Transactional(readOnly = true)
  public Page<OrderListItem> listOrders(
      Long tenantId, OrderStatus status,
      int page, int size) {

    Pageable pageable = PageRequest.of(
      page, size,
      Sort.by("createdAt").descending());

    return orderRepo
      .findByTenantAndStatus(tenantId, status, pageable)
      .map(OrderListItem::from);
  }

  // ✅ Escritura: transacción completa con rollback automático
  @Transactional
  public OrderListItem confirmOrder(Long orderId) {
    OrderEntity order = orderRepo
      .findWithLines(orderId)
      .orElseThrow(() -> new EntityNotFoundException(
        "Order not found: " + orderId));

    // Validación de negocio dentro de la misma tx
    if (order.getLines().isEmpty()) {
      throw new IllegalStateException(
        "Cannot confirm empty order");
    }

    order.setStatus(OrderStatus.CONFIRMED);
    order.setTotalAmount(calculateTotal(order));
    // Sin save() explícito — dirty checking lo persiste
    return OrderListItem.from(order);
  }
}

// Bueno para: panel con control de página, exportaciones
// Malo para: tablas > 100k filas (OFFSET es costoso)

@GetMapping("/orders")
@Transactional(readOnly = true)
public ResponseEntity<Page<OrderListItem>> list(
    @RequestParam(defaultValue = "0") int page,
    @RequestParam(defaultValue = "20") int size,
    @RequestParam(defaultValue = "CONFIRMED")
        OrderStatus status) {

  Pageable p = PageRequest.of(
    page, size,
    Sort.by("createdAt").descending());

  return ResponseEntity.ok(
    orderService.listOrders(
      currentTenantId(), status, page, size));
}

// Bueno para: scroll infinito, sync incremental, APIs públicas
// Sin OFFSET → rendimiento estable en tablas grandes

@GetMapping("/orders/stream")
@Transactional(readOnly = true)
public CursorPage<OrderListItem> stream(
    @RequestParam(defaultValue = "0") Long lastId,
    @RequestParam(defaultValue = "20") int size) {

  List<OrderListItem> items = orderRepo
    .findNextPage(
      currentTenantId(), lastId,
      PageRequest.ofSize(size))
    .stream()
    .map(OrderListItem::from)
    .toList();

  Long nextCursor = items.isEmpty()
    ? null
    : items.getLast().id();

  return new CursorPage<>(items, nextCursor);
}
// SQL generado: WHERE id > :lastId ORDER BY id ASC LIMIT 20
// → usa Primary Key index → O(1) sin importar volumen