Apex for Lightning Components, Flow and Agentforce

What it is

When Lightning Data Service is not enough, a component calls Apex for data or actions. The same business logic can also serve Flow (as an invocable action) and Agentforce agents (as an agent action).

Each caller needs a different annotation, but all of them share one rule: the Apex must be bulk-safe, secure and return clear errors.

How it works

Apex for Lightning Web Components

public with sharing class CaseController {
    @AuraEnabled(cacheable=true)
    public static List<Case> getOpenCases(Id accountId) {
        return [SELECT Id, Subject, Status FROM Case
                WHERE AccountId = :accountId AND IsClosed = false WITH USER_MODE];
    }
    @AuraEnabled
    public static void closeCases(List<Id> caseIds) {
        List<Case> cs = new List<Case>();
        for (Id i : caseIds) cs.add(new Case(Id = i, Status = 'Closed'));
        update as user cs;
    }
}

Rules for @AuraEnabled methods:

• static, and public or global.
• cacheable=true allows @wire and client caching, but the method must not perform DML.
• Parameters and return types must be serializable: primitives, sObjects, collections, or classes with @AuraEnabled properties.

Wire versus imperative calls

import { LightningElement, api, wire } from 'lwc';
import { refreshApex } from '@salesforce/apex';
import getOpenCases from '@salesforce/apex/CaseController.getOpenCases';
import closeCases from '@salesforce/apex/CaseController.closeCases';

export default class OpenCases extends LightningElement {
    @api recordId;
    @wire(getOpenCases, { accountId: '$recordId' }) cases;

    async handleClose() {
        try {
            await closeCases({ caseIds: this.selectedIds });
            await refreshApex(this.cases);
        } catch (error) {
            this.message = error.body.message;
        }
    }
}

Errors to the UI

Throw an AuraHandledException with a user-friendly message. Other exceptions may reach the client with a generic message; the component reads error.body.message.

Apex for Flow and Agentforce

Agents choose actions from their descriptions, so vague descriptions cause wrong action choices or wrong inputs. Agent actions run as the agent's running user, so with sharing and user mode checks decide what the action may read or change.

@InvocableMethod(label='Check Warranty'
    description='Returns warranty status and end date for the given asset serial numbers')
public static List<Result> run(List<Request> requests) { /* bulk-safe body */ }

A worked example

An LWC on the Account page shows open cases with a "Close selected" button. The list is loaded with @wire on a cacheable method. The button calls a separate, non-cacheable method imperatively, because it performs DML. After it succeeds, refreshApex() reloads the wired list so closed cases disappear. Putting the update inside the cacheable method would fail, because cacheable methods cannot do DML.

How the exam asks about this

• "Call Apex when a user clicks a button." An imperative call.
• "Expose Apex as an agent action." @InvocableMethod with a good description.
• "Show a friendly error message from Apex." AuraHandledException.