Quarkus Integration

<!-- Maven -->
<dependency>
    <groupId>codes.domix</groupId>
    <artifactId>fun-quarkus</artifactId>
    <version>LATEST_VERSION</version>
</dependency>

// Gradle
implementation("codes.domix:fun-quarkus:LATEST_VERSION")

@ApplicationScoped
public class OrderService {
    private final TxResult tx;
    private final OrderRepository repo;
    private final InventoryClient inventory;

    @Inject
    public OrderService(TxResult tx, OrderRepository repo, InventoryClient inventory) {
        this.tx = tx; this.repo = repo; this.inventory = inventory;
    }

    public Result<Order, OrderError> createOrder(OrderRequest req) {
        return tx.execute(() ->
            validate(req)                     // Result<ValidOrder, OrderError>
                .flatMap(repo::save)          // Result<Order, OrderError>
                .flatMap(inventory::reserve)  // Result<Order, OrderError>
        );
        // • Ok(order)       → transaction commits
        // • Err(orderError) → transaction rolls back; partial writes undone
    }
}

@ApplicationScoped
public class OrderService {
    @Inject TxResult tx;
    @Inject AuditLog auditLog;
    @Inject OrderRepository repo;

    public Result<Order, OrderError> createOrder(OrderRequest req) {
        return tx.execute(() -> {
            // Inner call starts a brand-new independent transaction.
            // Even if the outer tx rolls back, the audit entry is already committed.
            tx.executeNew(() -> auditLog.record("createOrder attempted", req));

            return validate(req).flatMap(repo::save);
            // • Ok(order)       → outer tx commits
            // • Err(orderError) → outer tx rolls back, but audit entry persists
        });
    }
}

@ApplicationScoped
public class ReportService {
    private final TxTry tx;
    private final ReportRepository repo;

    @Inject
    public ReportService(TxTry tx, ReportRepository repo) {
        this.tx = tx; this.repo = repo;
    }

    public Try<Report> generate(ReportRequest req) {
        return tx.execute(() ->
            Try.of(() -> repo.save(build(req)))  // Try<Report>
        );
        // • Success(report) → transaction commits
        // • Failure(cause)  → transaction rolls back; partial writes undone
    }
}

// ---- @Transactional — commits even when Result is an error ----

@Transactional
public Result<Order, OrderError> createOrder(OrderRequest req) {
    return validate(req)
        .flatMap(repo::save);
    // ❌ If flatMap returns Err(orderError), the method returns normally —
    //    no exception escapes, so Narayana commits the transaction.
    //    Writes from the steps that succeeded before the Err are silently persisted.
}

// ---- TxResult — rolls back when Result is an error ----

public Result<Order, OrderError> createOrder(OrderRequest req) {
    return tx.execute(() ->
        validate(req)
            .flatMap(repo::save)
    );
    // ✓ If flatMap returns Err(orderError), TxResult rolls back the transaction.
    //   Partial writes are undone.
}

// ---- When @Transactional is still the right choice ----

@Transactional
public void deleteOrder(String id) {
    // No return value; rollback happens naturally on RuntimeException.
    // @Transactional is simpler and perfectly correct here.
    repo.delete(id);
}

@ApplicationScoped
public class OrderService {
    private final OrderRepository repo;
    private final InventoryClient inventory;

    @TransactionalResult
    public Result<Order, OrderError> createOrder(OrderRequest req) {
        return validate(req)             // Result<ValidOrder, OrderError>
            .flatMap(repo::save)         // Result<Order, OrderError>
            .flatMap(inventory::reserve);// Result<Order, OrderError>
        // • Ok(order)       → transaction commits
        // • Err(orderError) → transaction rolls back; partial writes undone
    }
}

@ApplicationScoped
public class ReportService {
    private final ReportRepository repo;

    @TransactionalTry
    public Try<Report> generate(ReportRequest req) {
        return Try.of(() -> repo.save(build(req)));
        // • Success(report) → transaction commits
        // • Failure(cause)  → transaction rolls back; partial writes undone
    }
}

@ApplicationScoped
public class OrderService {

    // REQUIRED (default) — join an existing tx or start a new one.
    // Most methods should use this.
    @TransactionalResult
    public Result<Order, OrderError> createOrder(OrderRequest req) { ... }

    // REQUIRES_NEW — always suspend any active tx and start a fresh one.
    // Use when the operation must commit/rollback independently of the caller.
    @TransactionalResult(Transactional.TxType.REQUIRES_NEW)
    public Result<AuditEntry, String> recordAudit(AuditEvent event) { ... }

    // MANDATORY — require an active transaction; throw if none is present.
    // Use for internal helpers that must only be called from within a tx.
    @TransactionalResult(Transactional.TxType.MANDATORY)
    public Result<Void, String> validateInTx(Order order) { ... }

    // SUPPORTS — join if a tx is active; otherwise run without one.
    // Use for read-only operations that are safe either way.
    @TransactionalResult(Transactional.TxType.SUPPORTS)
    public Result<Order, String> findOrder(String id) { ... }

    // NOT_SUPPORTED — suspend any active tx and run without one (auto-commit).
    // Use when the operation must not run inside a transaction at all.
    @TransactionalResult(Transactional.TxType.NOT_SUPPORTED)
    public Result<Report, String> generateReport(String id) { ... }

    // NEVER — throw if a transaction is active.
    // Use to assert that no caller holds an open transaction.
    @TransactionalResult(Transactional.TxType.NEVER)
    public Result<Stats, String> computeStats() { ... }
}

@TransactionalResult          // all Result-returning methods on the class are transactional
@ApplicationScoped
public class OrderService {
    public Result<Order, OrderError> createOrder(OrderRequest req) { ... }
    public Result<Void, OrderError>  cancelOrder(String id)        { ... }
}

// ── Programmatic (TxResult) ──────────────────────────────────────────────────

@ApplicationScoped
public class OrderService {
    private final TxResult tx;   // explicit dependency, easy to test without CDI
    private final OrderRepository repo;
    private final OrderValidator validator;

    @Inject
    public OrderService(TxResult tx, OrderRepository repo, OrderValidator validator) {
        this.tx = tx; this.repo = repo; this.validator = validator;
    }

    public Result<Order, OrderError> createOrder(OrderRequest req) {
        return tx.execute(() -> validator.validate(req).flatMap(repo::save));
    }
}

// ── Declarative (@TransactionalResult) ──────────────────────────────────────

@ApplicationScoped
public class OrderService {
    // no TxResult field — the interceptor wraps the method transparently
    private final OrderRepository repo;
    private final OrderValidator validator;

    @Inject
    public OrderService(OrderRepository repo, OrderValidator validator) {
        this.repo = repo; this.validator = validator;
    }

    @TransactionalResult
    public Result<Order, OrderError> createOrder(OrderRequest req) {
        return validator.validate(req).flatMap(repo::save);
    }
}