Domain Layer and Trigger Handlers Revisited

Module 42 had both TransactionTrigger (after insert, balance updates) and TransactionValidation (before insert, validation) on the same Transaction__c object. This worked, but as an object accumulates more trigger logic over time, having several independent trigger files for the same object makes it hard to see, at a glance, everything that happens when a Transaction__c is inserted.

public with sharing class TransactionTriggerHandler {
    public void beforeInsert(List<Transaction__c> newTransactions) {
        Set<Id> accountIds = new Set<Id>();
        for (Transaction__c t : newTransactions) accountIds.add(t.Bank_Account__c);

        Map<Id, Bank_Account__c> accounts = new BankAccountSelector().selectByIdAsMap(accountIds);
        TransactionValidationService.validate(newTransactions, accounts);
    }

    public void afterInsert(List<Transaction__c> newTransactions) {
        TransactionBalanceService.applyDeltas(newTransactions);
    }
}

1. public with sharing class TransactionTriggerHandler { — one class, every event for this object.
2. public void beforeInsert(List<Transaction__c> newTransactions) { — one clearly named method per event.
3. Set<Id> accountIds = new Set<Id>(); — collects the distinct account Ids.
4. for (Transaction__c t : newTransactions) accountIds.add(t.Bank_Account__c); — trigger mechanics.
5. (blank line)
6. Map<Id, Bank_Account__c> accounts = new BankAccountSelector().selectByIdAsMap(accountIds); — Lesson 4's selector, not a hand-written query.
7. TransactionValidationService.validate(newTransactions, accounts); — Lesson 3's service, called from here.
8. } — closes beforeInsert.
9. (blank line)
10. public void afterInsert(List<Transaction__c> newTransactions) { — the second event's method.
11. TransactionBalanceService.applyDeltas(newTransactions); — the balance-update logic, similarly extracted.
12. } — closes afterInsert.
13. } — closes the class.

trigger TransactionTrigger on Transaction__c (before insert, after insert) {
    TransactionTriggerHandler handler = new TransactionTriggerHandler();
    if (Trigger.isBefore && Trigger.isInsert) handler.beforeInsert(Trigger.new);
    if (Trigger.isAfter && Trigger.isInsert) handler.afterInsert(Trigger.new);
}

1. trigger TransactionTrigger on Transaction__c (before insert, after insert) { — one trigger file, both events.
2. TransactionTriggerHandler handler = new TransactionTriggerHandler(); — one handler instance.
3. if (Trigger.isBefore && Trigger.isInsert) handler.beforeInsert(Trigger.new); — routes the before-insert event.
4. if (Trigger.isAfter && Trigger.isInsert) handler.afterInsert(Trigger.new); — routes the after-insert event.
5. } — closes the trigger.

Now there is exactly one trigger file for Transaction__c, and exactly one handler class where every trigger event for that object is visible together — Lesson 3's TransactionValidationService and a new TransactionBalanceService (the balance-update logic from Module 42, similarly extracted) are both called from here.

A developer asking "what happens when a Transaction__c is inserted?" now has exactly one file to open (TransactionTriggerHandler) rather than needing to know that logic is split across two separately-named trigger files that happen to both target the same object — a real cost that only shows up as an object accumulates more automation over time.