Apex

# Apex Development

General Instructions

- Always use the latest Apex features and best practices for the Salesforce Platform.

- Write clear and concise comments for each class and method, explaining the business logic and any complex operations.

- Handle edge cases and implement proper exception handling with meaningful error messages.

- Focus on bulkification - write code that handles collections of records, not single records.

- Be mindful of governor limits and design solutions that scale efficiently.

- Implement proper separation of concerns using service layers, domain classes, and selector classes.

- Document external dependencies, integration points, and their purposes in comments.

Naming Conventions

- **Classes**: Use `PascalCase` for class names. Name classes descriptively to reflect their purpose.

- Controllers: suffix with `Controller` (e.g., `AccountController`)

- Trigger Handlers: suffix with `TriggerHandler` (e.g., `AccountTriggerHandler`)

- Service Classes: suffix with `Service` (e.g., `AccountService`)

- Selector Classes: suffix with `Selector` (e.g., `AccountSelector`)

- Test Classes: suffix with `Test` (e.g., `AccountServiceTest`)

- Batch Classes: suffix with `Batch` (e.g., `AccountCleanupBatch`)

- Queueable Classes: suffix with `Queueable` (e.g., `EmailNotificationQueueable`)

- **Methods**: Use `camelCase` for method names. Use verbs to indicate actions.

- Good: `getActiveAccounts()`, `updateContactEmail()`, `deleteExpiredRecords()`

- Avoid abbreviations: `getAccs()` → `getAccounts()`

- **Variables**: Use `camelCase` for variable names. Use descriptive names.

- Good: `accountList`, `emailAddress`, `totalAmount`

- Avoid single letters except for loop counters: `a` → `account`

- **Constants**: Use `UPPER_SNAKE_CASE` for constants.

- Good: `MAX_BATCH_SIZE`, `DEFAULT_EMAIL_TEMPLATE`, `ERROR_MESSAGE_PREFIX`

- **Triggers**: Name triggers as `ObjectName` + trigger event (e.g., `AccountTrigger`, `ContactTrigger`)

Best Practices

Bulkification

- **Always write bulkified code** - Design all code to handle collections of records, not individual records.

- Avoid SOQL queries and DML statements inside loops.

- Use collections (`List<>`, `Set<>`, `Map<>`) to process multiple records efficiently.

// Good Example - Bulkified
public static void updateAccountRating(List<Account> accounts) {
    for (Account acc : accounts) {
        if (acc.AnnualRevenue > 1000000) {
            acc.Rating = 'Hot';
        }
    }
    update accounts;
}

// Bad Example - Not bulkified
public static void updateAccountRating(Account account) {
    if (account.AnnualRevenue > 1000000) {
        account.Rating = 'Hot';
        update account; // DML in a method designed for single records
    }
}

Maps for O(1) Lookup

- **Use Maps for efficient lookups** - Convert lists to maps for O(1) constant-time lookups instead of O(n) list iterations.

- Use `Map<Id, SObject>` constructor to quickly convert query results to a map.

- Ideal for matching related records, lookups, and avoiding nested loops.

// Good Example - Using Map for O(1) lookup
Map<Id, Account> accountMap = new Map<Id, Account>([
    SELECT Id, Name, Industry FROM Account WHERE Id IN :accountIds
]);

for (Contact con : contacts) {
    Account acc = accountMap.get(con.AccountId);
    if (acc != null) {
        con.Industry__c = acc.Industry;
    }
}

// Bad Example - Nested loop with O(n²) complexity
List<Account> accounts = [SELECT Id, Name, Industry FROM Account WHERE Id IN :accountIds];

for (Contact con : contacts) {
    for (Account acc : accounts) {
        if (con.AccountId == acc.Id) {
            con.Industry__c = acc.Industry;
            break;
        }
    }
}

// Good Example - Map for grouping records
Map<Id, List<Contact>> contactsByAccountId = new Map<Id, List<Contact>>();
for (Contact con : contacts) {
    if (!contactsByAccountId.containsKey(con.AccountId)) {
        contactsByAccountId.put(con.Acco