// CardTransaction.php — an event-sourced aggregate as a plain final class

use Ecotone\Modelling\Attribute\Aggregate;
use Ecotone\Modelling\Attribute\Identifier;
use Ecotone\Modelling\Attribute\EventSourcingHandler;
use Ecotone\EventSourcing\Attribute\EventSourcingAggregate;

#[EventSourcingAggregate]
final class CardTransaction
{
    #[Identifier] public string $transactionId;
    private int $authorizedAmount;
    private int $capturedAmount;
    private TransactionStatus $status;

    #[CommandHandler]
    public static function authorize(AuthorizeTransaction $cmd): array
    {
        return [new TransactionAuthorized($cmd->transactionId, $cmd->amount)];
    }

    #[CommandHandler]
    public function capture(CaptureTransaction $cmd): array
    {
        if ($cmd->amount > $this->authorizedAmount - $this->capturedAmount) {
            throw new CaptureExceedsAuthorization();
        }
        return [new TransactionCaptured($cmd->transactionId, $cmd->amount)];
    }

    #[EventSourcingHandler]
    public function applyAuthorized(TransactionAuthorized $e): void
    {
        $this->transactionId    = $e->transactionId;
        $this->authorizedAmount = $e->amount;
        $this->status           = TransactionStatus::Authorized;
    }

    #[EventSourcingHandler]
    public function applyCaptured(TransactionCaptured $e): void
    {
        $this->capturedAmount += $e->amount;
    }
}

// PaymentCommandBus.php — instant retry on the exceptions that benefit from retry, fail-fast on the rest

#[InstantRetry(
    retryTimes: 3,
    exceptions: [
        OptimisticLockingException::class,    // version conflict — retry resolves it
        DatabaseConnectionFailure::class,     // transient — retry resolves it
    ],
)]
interface PaymentCommandBus extends CommandBus {} // Ecotone Enterprise — declared once on the bus

// TransactionLedgerProjection.php — gap-aware position is on by default

use Ecotone\Projecting\Attribute\Projection;
use Ecotone\Modelling\Attribute\EventHandler;

#[Projection('transaction_ledger', fromStreams: ['card_transactions'])]
final class TransactionLedgerProjection
{
    public function __construct(private LedgerWriter $ledger) {}

    #[EventHandler]
    public function onAuthorized(TransactionAuthorized $event): void
    {
        $this->ledger->recordAuthorization($event);
    }

    #[EventHandler]
    public function onCaptured(TransactionCaptured $event): void
    {
        $this->ledger->recordCapture($event);
    }
}