Am I writing duplicate domain logics when synchronise query database in CQRS and EventSourcing?

Question

I'm confused with how to synchronise data to the query database.

Let's say I have an aggregate: CreditAccount and some commands may produce CreditAccountBalanceChangedEvent:

public class CreditAccount extends AbstractAnnotatedAggregateRoot<Long> {

    @AggregateIdentifier
    private Long id;
    private int balance;
    private DateRange effectiveDateRange;

    @CommandHandler
    public CreditAccount(CreateCreditAccountCommand command) {
        apply(new CreditAccountCreatedEvent(command.getAccountId(),
            command.getEffectiveDateRange()));
        apply(new CreditAccountBalanceChangedEvent(command.getAccountId(),
            command.getAmount()));
    }

    @EventHandler
    private void on(CreditAccountCreatedEvent event) {
        this.id = event.getAccountId();
        this.effectiveDateRange = event.getEffectiveDateRange();
    }

    @EventHandler
    private void on(CreditAccountBalanceChangedEvent event) {
        //notice this line, some domain logic here 
        this.balance = add(this.balance, event.getAmount());
    }

    private int add(int current, int amount) {
        return current + amount;
    }
}

public class CreditAccountBalanceChangedEvent {
    private final long accountId;
    private final int amount;
    //omitted constructors and getters
}

And everything works fine on the command handler side. And I set off to the query side but I find I'm writing some duplicate domain logic here:

@Transactional
@Slf4j
public class CreditAccountEventHandler {

    private CreditAccountReadModelStore creditAccountReadModelStore;

    @EventHandler
    public void handle(CreditAccountCreatedEvent event) {
        log.info("Received " + event);
        creditAccountReadModelStore.store(accountDevriveFrom(event));
    }

    @EventHandler
    public void handle(CreditAccountBalanceChangedEvent event) {
        log.info("Received " + event);
        final CreditAccountReadModel account = creditAccountReadModelStore
            .findBy(event.getAccountId());
        //notice this line, some domain logic here 
        account.setBalance(account.getBalance() + event.getAmount());
        creditAccountReadModelStore.store(account);
    }
    //omitted setters and private methods
}

As you may notice, I wrote balance calculation code on both command and query side. My question is that is this inevitable in some situations or I write domain logic in wrong place?

As my study so far, events represent something have occured, so no business logic in them, they're just data holder(but reveal users's intent). So should I add a 'balance' field to CreditAccountBalanceChangedEvent and move balance calculation code to command handler method?

public class CreditAccount extends AbstractAnnotatedAggregateRoot<Long> {

    //omitted fields

    @CommandHandler
    public CreditAccount(CreateCreditAccountCommand command) {
        apply(new CreditAccountCreatedEvent(command.getAccountId(),
            command.getEffectiveDateRange()));
        apply(new CreditAccountBalanceChangedEvent(command.getAccountId(),
            command.getAmount(), add(this.balance, command.getAmount())));
    }        


    @EventHandler
    private void on(CreditAccountBalanceChangedEvent event) {
        //notice this line, some domain logic here
        //event.getAmount() is no use here, just for auditing? 
        this.balance = event.getBalance();
    }

}

In this case, I can remove balance calculation on the query side by using event.getBalance().

Sorry for a screen full question, any idea is appreciate.

Answer 1

I see two options.

One is for the command to contain the change in balance, the command handler to calculate the new balance, and the event to contain the new balance. If nothing is recalculated in the event handler, it ensures that if the business rules change in the future, they do not affect your object's history when when it is reconstituted from the events.

An alternative would be to place the business rules in a separate class that is called from both the command handler and the event handler to avoid duplication, and then to version those business rules -- via subclassing for example. So you could have an abstract class called CalculateBalanceRule with a subclass of CalculateBalanceRuleVersion1 that is initially referenced by both. If the rule changes, you create CalculateBalanceRuleVersion2, change your command handler to reference it, but keep the reference to Version1 in your event handler, so that it will always replay the rules it did originally.

The second approach is definitely more maintenance, but can answer HOW something change, not simply WHAT changed, if that's something that's important to your business.

Edit: A third option is for the event to only contain the new balance like in the first option, but to version the events. So you have BalanceChangedEvent, BalanceChangedEvent_v2, and so on. This is the direction I could take, as I don't really care to keep a history of how things changed, but I do need to account for the possibility that the events themselves might take on additional members or rename its members. Logic is then needed to determine which event version to use to reconstitute the object at each step.