InvoiceFlow — Guía de Patrones Quarkus

@Path("/api/invoices")
@Produces(MediaType.APPLICATION_JSON)
@Consumes(MediaType.APPLICATION_JSON)
@RequiredArgsConstructor
public class InvoiceResource {
  private final InvoiceService invoiceService;

  @GET
  public Response list(
      @QueryParam("page") @DefaultValue("0") int page,
      @QueryParam("size") @DefaultValue("20") int size) {
    List<Invoice> invoices = invoiceService.list(page, size);
    return Response.ok(invoices).build();
  }

  @POST
  public Response create(
      @Valid CreateInvoiceRequest request,
      @Context UriInfo uriInfo) {
    Invoice invoice = invoiceService.create(request);
    URI location = uriInfo.getAbsolutePathBuilder()
        .path(String.valueOf(invoice.id)).build();
    return Response.created(location)
        .entity(InvoiceResponse.from(invoice)).build();
  }

  @GET
  @Path("/{id}")
  public Response getById(@PathParam("id") Long id) {
    return invoiceService.findById(id)
        .map(InvoiceResponse::from)
        .map(Response::ok)
        .orElse(Response.status(NOT_FOUND))
        .build();
  }
}

@Slf4j
@ApplicationScoped
@RequiredArgsConstructor
public class InvoiceService {
  private final InvoiceRepository repo;
  private final EventService eventService;
  private final InvoiceValidator validator;
  private final ProcessingPublisher publisher;

  @Transactional
  public Invoice create(CreateInvoiceRequest request) {
    ValidationResult v = validator.validate(request);
    if (!v.valid()) {
      eventService.createErrorEvent(
          request, "INVOICE_REJECTED", v.message());
      throw new WebApplicationException(
          v.message(), BAD_REQUEST);
    }
    Invoice inv = Invoice.from(request);
    repo.persist(inv);

    InvoiceReceipt receipt = InvoiceReceipt.from(inv);
    publisher.publishAsync(receipt);
    eventService.createSuccessEvent(
        receipt, "INVOICE_CREATED");

    log.info("Invoice {} created", inv.id);
    return inv;
  }

  public Optional<Invoice> findById(Long id) {
    return repo.findByIdOptional(id);
  }

  public List<Invoice> list(int page, int size) {
    return repo.findAll()
        .page(page, size).list();
  }
}

@ApplicationScoped
public class InvoiceRepository
    implements PanacheRepository<Invoice> {

  // Buscar por estado con paginación
  public List<Invoice> findByStatus(
      InvoiceStatus status, int page, int size) {
    return find("status = ?1 order by createdAt desc",
        status).page(page, size).list();
  }

  // Buscar por número de referencia único
  public Optional<Invoice> findByReference(
      String ref) {
    return find("referenceNumber", ref)
        .firstResultOptional();
  }

  // Contar facturas pendientes del día
  public long countPendingToday(LocalDate date) {
    return count(
        "status = ?1 and createdAt >= ?2",
        InvoiceStatus.PENDING,
        date.atStartOfDay());
  }

  // Facturas por cliente con importe > umbral
  public List<Invoice> findHighValue(
      String clientId, BigDecimal minAmount) {
    return list(
        "clientId = ?1 and amount >= ?2 " +
        "order by amount desc",
        clientId, minAmount);
  }
}

// DTO de entrada con validaciones
public record CreateInvoiceRequest(
    @NotBlank @Size(max = 50)  String referenceNumber,
    @NotNull                     String clientId,
    @NotNull @Positive           BigDecimal amount,
    @NotNull @FutureOrPresent    Instant dueDate,
    @NotEmpty                    List<@NotBlank String> lines) {}

// DTO de respuesta con factory method
public record InvoiceResponse(
    Long id, String referenceNumber,
    BigDecimal amount, InvoiceStatus status) {
  public static InvoiceResponse from(Invoice inv) {
    return new InvoiceResponse(
        inv.getId(), inv.getReferenceNumber(),
        inv.getAmount(), inv.getStatus());
  }
}

// Mapper de violaciones de validación → 400
@Provider
public class ValidationExceptionMapper
    implements ExceptionMapper<ConstraintViolationException> {
  @Override
  public Response toResponse(ConstraintViolationException ex) {
    String msg = ex.getConstraintViolations().stream()
        .map(cv -> cv.getPropertyPath() +
                 ": " + cv.getMessage())
        .collect(Collectors.joining(", "));
    return Response.status(BAD_REQUEST)
        .entity(Map.of("error", "validation_error",
                       "message", msg)).build();
  }
}