Spring Integration

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

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

<!-- 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); }

dmx.fun.tx-result.enabled=false          # disable TxResult
dmx.fun.tx-try.enabled=false             # disable TxTry
dmx.fun.tx-validated.enabled=false       # disable TxValidated
dmx.fun.aspect.enabled=false             # disable DmxTransactionalAspect
dmx.fun.tracing.enabled=false            # disable DmxTracing (requires fun-tracing on classpath)
dmx.fun.mvc.option-handler.enabled=false # disable Option MVC handler
dmx.fun.mvc.result-handler.enabled=false # disable Result/Try/Validated MVC handler

import dmx.fun.spring.TxResult;
import dmx.fun.spring.TxTry;
import dmx.fun.spring.TxValidated;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.transaction.PlatformTransactionManager;

@Configuration
public class MyTxConfig {

    // Override TxResult to use a specific (non-primary) transaction manager.
    // @ConditionalOnMissingBean in the auto-config backs off when this bean is present.
    @Bean
    public TxResult txResult(
            @Qualifier("myTxManager") PlatformTransactionManager txManager) {
        return new TxResult(txManager);
    }

    // TxTry and TxValidated are left to the auto-config — no override needed.
}

@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);
}

import dmx.fun.spring.DmxTransactionalAspect;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
import org.springframework.transaction.PlatformTransactionManager;

@Configuration
@EnableAspectJAutoProxy
public class AppConfig {

    @Bean
    public DmxTransactionalAspect dmxTransactionalAspect(
            PlatformTransactionManager txManager, BeanFactory beanFactory) {
        return new DmxTransactionalAspect(txManager, beanFactory);
    }
}

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

@Service
public class ReportService {
    private final AuditRepository repo;

    @TransactionalTry(propagation = Propagation.REQUIRES_NEW)
    public Try<AuditLog> auditEvent(Event event) {
        return Try.of(() -> repo.save(event));
        // • Success(log) → transaction commits
        // • Failure(ex)  → transaction rolls back; the Try is returned to the caller
    }
}

@Service
public class RegistrationService {
    private final UserRepository repo;

    @TransactionalValidated
    public Validated<NonEmptyList<String>, User> register(RegistrationRequest req) {
        return validateName(req)
            .combine(validateEmail(req), UserDraft::new)
            .map(repo::save);
        // • Valid(user)    → transaction commits
        // • Invalid(errors) → transaction rolls back; all writes undone
    }
}

@Service
public class PaymentService {

    // Custom propagation, isolation, and timeout
    @TransactionalResult(
        propagation = Propagation.REQUIRES_NEW,
        isolation   = Isolation.SERIALIZABLE,
        timeout     = 10
    )
    public Result<Receipt, PaymentError> charge(PaymentRequest req) { ... }

    // Read-only hint — lets the driver/ORM skip dirty checks or route to a replica
    @TransactionalResult(readOnly = true)
    public Result<List<Receipt>, String> listReceipts(CustomerId id) { ... }

    // Named transaction manager (multiple DataSources)
    @TransactionalResult(transactionManager = "ledgerTxManager")
    public Result<LedgerEntry, LedgerError> record(Receipt receipt) { ... }
}

// ---- Programmatic (TxResult) ----
// Explicit control, no AOP, works with JPMS without aspectjweaver at runtime.

@Service
public class OrderServiceProgrammatic {
    private final TxResult tx;

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

// ---- Declarative (@TransactionalResult) ----
// Less boilerplate, familiar @Transactional style.
// Requires DmxTransactionalAspect bean + @EnableAspectJAutoProxy.

@Service
public class OrderServiceDeclarative {

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

import dmx.fun.Option;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/items")
public class ItemController {

    private final ItemService service;

    // Option<V> — some maps to 200 with V as body; none maps to 404 with empty body
    @GetMapping("/{id}")
    public Option<Item> findById(@PathVariable long id) {
        return service.findById(id);
    }
}

import dmx.fun.Result;
import dmx.fun.Try;
import dmx.fun.Validated;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/items")
public class ItemController {

    private final ItemService service;

    // Result<V, E> — ok maps to 200 with V as body; err maps to 500 with E as body
    @PostMapping
    public Result<Item, String> create(@RequestBody CreateItemRequest request) {
        return service.create(request.name(), request.description());
    }

    // Try<V> — success maps to 200 with V as body; failure maps to 500 with cause as body
    @GetMapping("/{id}/summary")
    public Try<ItemSummary> summary(@PathVariable long id) {
        return service.summarize(id);
    }

    // Validated<E, A> — valid maps to 200 with A as body; invalid maps to 500 with E as body
    @PutMapping("/{id}/validate")
    public Validated<String, Item> validate(@PathVariable long id,
                                            @RequestBody UpdateItemRequest req) {
        return service.validate(id, req);
    }
}

# Disable the Result/Try/Validated MVC handler (enabled by default)
dmx.fun.mvc.result-handler.enabled=false

# Disable the Option MVC handler (enabled by default)
dmx.fun.mvc.option-handler.enabled=false