Spring Integration

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

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

// Plain Spring — explicit registration (only needed without component scanning)
@Bean public TxResult txResult(PlatformTransactionManager tm) { return new TxResult(tm); }
@Bean public TxTry txTry(PlatformTransactionManager tm)       { return new TxTry(tm); }
@Bean public TxValidated txValidated(PlatformTransactionManager tm) { return new TxValidated(tm); }

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

    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
    }
}

@Service
public class ReportService {
    private final TxTry tx;
    private final ReportRepository repo;
    private final AuditLog audit;

    public ReportService(TxTry tx, ReportRepository repo, AuditLog audit) {
        this.tx = tx; this.repo = repo; this.audit = audit;
    }

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

@Service
public class RegistrationService {
    private final TxValidated tx;
    private final UserRepository repo;

    public RegistrationService(TxValidated tx, UserRepository repo) {
        this.tx = tx; this.repo = repo;
    }

    public Validated<NonEmptyList<String>, User> register(RegistrationRequest req) {
        return tx.execute(() ->
            validateName(req)
                .combine(validateEmail(req), (name, email) -> new UserDraft(name, email))
                .map(repo::save)
        );
        // • Valid(user)     → transaction commits
        // • Invalid(errors) → transaction rolls back; no partial writes persisted
    }
}

// Read-only transaction — hint to the JDBC driver and database optimizer
var readOnly = new DefaultTransactionDefinition();
readOnly.setReadOnly(true);

Result<List<Order>, String> orders = tx.execute(readOnly, orderRepo::findAll);

// Explicit isolation level — e.g. SERIALIZABLE for critical financial operations
var serializable = new DefaultTransactionDefinition();
serializable.setIsolationLevel(TransactionDefinition.ISOLATION_SERIALIZABLE);

Result<Transfer, TransferError> transfer = tx.execute(serializable, () ->
    debit(source, amount).flatMap(__ -> credit(target, amount))
);

// Custom timeout — rolls back automatically if the action exceeds 5 seconds
var withTimeout = new DefaultTransactionDefinition();
withTimeout.setTimeout(5);

Result<Report, String> report = tx.execute(withTimeout, () ->
    Result.ok(reportEngine.generate(params))
);

// ---- @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 Spring commits the transaction.
    //    In a longer pipeline (preAuth → save → ledger.record), writes
    //    from 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 marks the transaction
    //   rollback-only before Spring commits. 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);
}