Triggers de Apex: 10 buenas prácticas para un código mantenible

trigger AccountTrigger on Account (before insert, after insert, before update) {
    if (Trigger.isBefore && Trigger.isInsert) {
        // 200 líneas de lógica de negocio...
    }
    if (Trigger.isAfter && Trigger.isInsert) {
        // 150 líneas de lógica de negocio...
    }
}

trigger AccountTrigger on Account (before insert, after insert, before update, after update) {
    AccountTriggerHandler.handle();
}

public class AccountTriggerHandler {
    
    public static void handle() {
        if (Trigger.isBefore) {
            if (Trigger.isInsert) beforeInsert(Trigger.new);
            if (Trigger.isUpdate) beforeUpdate(Trigger.new, Trigger.oldMap);
        }
        
        if (Trigger.isAfter) {
            if (Trigger.isInsert) afterInsert(Trigger.new);
            if (Trigger.isUpdate) afterUpdate(Trigger.new, Trigger.oldMap);
        }
    }
    
    private static void beforeInsert(List<Account> newAccounts) {
        // Lógica de before insert
        AccountService.setDefaultValues(newAccounts);
        AccountService.validateBusinessRules(newAccounts);
    }
    
    private static void afterInsert(List<Account> newAccounts) {
        // Lógica de after insert
        ContactService.createPrimaryContacts(newAccounts);
    }
    
    // ... otros métodos
}

public class AccountService {
    
    public static void setDefaultValues(List<Account> accounts) {
        for (Account acc : accounts) {
            if (String.isBlank(acc.Industry)) {
                acc.Industry = 'Technology';
            }
            if (acc.AnnualRevenue == null) {
                acc.AnnualRevenue = 0;
            }
        }
    }
    
    public static void validateBusinessRules(List<Account> accounts) {
        for (Account acc : accounts) {
            if (acc.Type == 'Customer' && String.isBlank(acc.Phone)) {
                acc.addError('Phone is required for Customer accounts');
            }
        }
    }
}

private static void afterInsert(List<Account> newAccounts) {
    for (Account acc : newAccounts) {
        List<Contact> contacts = [SELECT Id FROM Contact WHERE AccountId = :acc.Id];
        // SOQL dentro de un loop = ¡PELIGRO!
    }
}

private static void afterInsert(List<Account> newAccounts) {
    Set<Id> accountIds = new Set<Id>();
    for (Account acc : newAccounts) {
        accountIds.add(acc.Id);
    }
    
    Map<Id, List<Contact>> contactsByAccount = new Map<Id, List<Contact>>();
    for (Contact con : [SELECT Id, AccountId FROM Contact WHERE AccountId IN :accountIds]) {
        if (!contactsByAccount.containsKey(con.AccountId)) {
            contactsByAccount.put(con.AccountId, new List<Contact>());
        }
        contactsByAccount.get(con.AccountId).add(con);
    }
    
    // Procesamiento en bloque
}

public class TriggerControl {
    private static Set<String> executedTriggers = new Set<String>();
    
    public static Boolean isFirstTime(String triggerName) {
        if (executedTriggers.contains(triggerName)) {
            return false;
        }
        executedTriggers.add(triggerName);
        return true;
    }
    
    public static void reset(String triggerName) {
        executedTriggers.remove(triggerName);
    }
}
 
// En el handler:
public static void handle() {
    if (!TriggerControl.isFirstTime('AccountTrigger')) {
        return; // Evita la recursión
    }
    // ... lógica del trigger
}

private static void beforeUpdate(List<Account> newAccounts, Map<Id, Account> oldMap) {
    List<Account> accountsToProcess = new List<Account>();
    
    for (Account newAcc : newAccounts) {
        Account oldAcc = oldMap.get(newAcc.Id);
        
        // Procesar solo si el campo Industry cambió
        if (newAcc.Industry != oldAcc.Industry) {
            accountsToProcess.add(newAcc);
        }
    }
    
    if (!accountsToProcess.isEmpty()) {
        AccountService.recalculateIndustryMetrics(accountsToProcess);
    }
}

@isTest
private class AccountTriggerHandler_Test {
    
    @isTest
    static void testBeforeInsert_DefaultValues() {
        // Arrange
        List<Account> accounts = new List<Account>{
            new Account(Name = 'Test Account 1'),
            new Account(Name = 'Test Account 2', Industry = 'Healthcare')
        };
        
        // Act
        Test.startTest();
        insert accounts;
        Test.stopTest();
        
        // Assert
        List<Account> insertedAccounts = [
            SELECT Id, Industry, AnnualRevenue 
            FROM Account 
            WHERE Id IN :accounts
        ];
        
        System.assertEquals('Technology', insertedAccounts[0].Industry, 
            'Default industry should be Technology');
        System.assertEquals('Healthcare', insertedAccounts[1].Industry, 
            'Industry should remain Healthcare');
        System.assertEquals(0, insertedAccounts[0].AnnualRevenue, 
            'Default revenue should be 0');
    }
    
    @isTest
    static void testBulkInsert_200Records() {
        // Prueba con 200 registros para verificar la bulkification
        List<Account> accounts = new List<Account>();
        for (Integer i = 0; i < 200; i++) {
            accounts.add(new Account(Name = 'Bulk Test ' + i));
        }
        
        Test.startTest();
        insert accounts;
        Test.stopTest();
        
        System.assertEquals(200, [SELECT COUNT() FROM Account], 
            'All 200 accounts should be inserted');
    }
}

public static void validateBusinessRules(List<Account> accounts) {
    for (Account acc : accounts) {
        try {
            if (acc.Type == 'Customer' && acc.AnnualRevenue < 10000) {
                acc.addError('Customer accounts must have revenue >= 10,000');
            }
            
            if (acc.BillingCountry == 'France' && String.isBlank(acc.SIRET__c)) {
                acc.SIRET__c.addError('SIRET is mandatory for French companies');
            }
        } catch (Exception e) {
            System.debug(LoggingLevel.ERROR, 'Validation error: ' + e.getMessage());
            acc.addError('Unexpected validation error: ' + e.getMessage());
        }
    }
}

/**
 * @description Handler para las operaciones del trigger de Account
 * @author Aïcha Imène DAHOUNANE
 * @date 2026-02-15
 * @group Trigger Handlers
 */
public class AccountTriggerHandler {
    
    /**
     * @description Punto de entrada principal para el trigger de Account
     * Delega a métodos específicos según el contexto del trigger
     */
    public static void handle() {
        // Implementación
    }
    
    /**
     * @description Establece valores por defecto para los nuevos registros de Account
     * - Industry por defecto a 'Technology' si está vacío
     * - AnnualRevenue por defecto a 0 si es null
     * @param newAccounts Lista de nuevos registros Account
     */
    private static void beforeInsert(List<Account> newAccounts) {
        // Implementación
    }
}

public class TriggerLogger {
    
    public static void logExecution(String triggerName, String context, Integer recordCount) {
        System.debug(LoggingLevel.INFO, 
            String.format('Trigger: {0} | Context: {1} | Records: {2}', 
            new List<String>{triggerName, context, String.valueOf(recordCount)}));
    }
    
    public static void logError(String triggerName, Exception e) {
        System.debug(LoggingLevel.ERROR, 
            String.format('Trigger: {0} | Error: {1} | Stack: {2}', 
            new List<String>{triggerName, e.getMessage(), e.getStackTraceString()}));
    }
}
 
// Uso en el handler:
public static void handle() {
    TriggerLogger.logExecution('AccountTrigger', 
        Trigger.operationType.name(), Trigger.new.size());
    
    try {
        // ... lógica del trigger
    } catch (Exception e) {
        TriggerLogger.logError('AccountTrigger', e);
        throw e;
    }
}