Trilha Desenvolvedor Salesforce (Apex & LWC): tudo o que estudar, tópico por tópico

Core Apex language constructs: primitive types (String, Integer, Long, Decimal, Boolean, Date, DateTime, Id), type casting, null handling, and Apex vs Java differences developers must know for the Platform Developer I exam.

Apex collection types — List (ordered, allows duplicates), Set (unordered, unique), and Map (key-value) — their iteration patterns, common methods, and usage in bulk-safe governor-limit–aware code.

Embedding SOQL and SOSL queries inline in Apex: SELECT syntax, WHERE/ORDER BY/LIMIT, relationship queries, dynamic SOQL via Database.query(), SOSL multi-object search, and query governor limits.

DML operations (insert/update/upsert/delete/undelete/merge) as statements and via Database class methods; partial-success AllOrNothing flag; DmlException handling; and record-level SaveResult/UpsertResult inspection.

Apex control flow constructs: if/else, for/while/do-while loops, break/continue; custom and system exceptions; try/catch/finally; exception properties and best practices for rollback-safe error handling.

sObject types, generic vs specific sObject, runtime Schema.describeSObjectResult, Schema.DescribeFieldResult, field tokens, and dynamic field access via SObject.get()/put() for flexible, metadata-driven Apex.

Class anatomy in Apex: constructors, static vs instance context, inner classes, virtual/abstract/interface contracts, and common design interfaces such as Comparable, Schedulable, Database.Batchable, and Queueable.

Apex access modifiers (private/protected/public/global), property syntax with custom get/set accessors, the with sharing / without sharing / inherited sharing keywords, and the @AuraEnabled annotation for LWC exposure.

Salesforce multi-tenant governor limits enforced per transaction: SOQL query count, DML row and statement counts, heap size, CPU time, callout limits, and how to monitor them with Limits class methods.

Design patterns for governor-limit–safe Apex: collecting IDs before SOQL, building Map<Id, SObject> result maps, performing single DML on collections, avoiding SOQL/DML inside loops, and the 200-record trigger batch contract.

Parent-to-child (subquery) and child-to-parent (dot notation) relationship queries, aggregate functions (COUNT/SUM/AVG/MIN/MAX/GROUP BY), HAVING clause, and SOQL for loops as a cursor for large result sets.

Database.insert/update/upsert with allOrNone=false, iterating SaveResult arrays, error collection and surface strategies, Database.UpsertResult for external-key operations, and the Apex transaction rollback boundary.

Database.setSavepoint() and Database.rollback() for partial transaction reversal, rollback semantics (DML only, not governor limit counts), and patterns for compensating transactions in multi-step workflows.

The Salesforce record-save order of execution: system validations, before triggers, duplicate rules, after triggers, assignment rules, workflow rules, processes, flows, escalation rules, and the implications for Apex developers.

@future methods for deferred callouts and mixed DML, Queueable interface for chaining and monitoring, System.enqueueJob(), AsyncApexJob tracking, and governor limit changes in async context.

Database.Batchable interface (start/execute/finish), Database.executeBatch() scope parameter, stateful Batch Apex, Schedulable interface and CRON expressions, and designing Batch jobs that are bulkification-safe and testable.

Apex trigger context variables: Trigger.new, Trigger.old, Trigger.newMap, Trigger.oldMap, Trigger.isInsert/isUpdate/isDelete/isUndelete, Trigger.isBefore/isAfter, Trigger.size, and Trigger.operationType.

One trigger per object pattern, trigger handler class separation of concerns, domain-driven dispatch (fflib/Apex Enterprise Patterns), and the TriggerHandler base class pattern for routing context to typed methods.

Semantic differences between before and after triggers: when Trigger.new is mutable, when record IDs are available, field updates in before context, and the correct context for querying related records.

Preventing infinite trigger loops with static Boolean flags, Set<Id>-based deduplication, and context-aware recursion guards; understanding how workflow field updates and process builders can re-invoke triggers.

Decision criteria for choosing Apex triggers over record-triggered flows and vice versa: complexity, governor limit implications, testability, maintainability by admins, and Salesforce's 'automate first' guidance aligned with PDI/PDII exam scenarios.

Publishing and subscribing to Platform Events from Apex: EventBus.publish(), trigger on platform event object, event bus delivery guarantee, ResumeCheckpoint for after-errors-only resume, and decoupled async patterns.

Calling flows from Apex via Flow.Interview, passing input variables; invoking Apex from flows using @InvocableMethod; InvocableVariable types; bulkification contract for invocable methods and error surface patterns.

Anatomy of a Lightning Web Component: the HTML template file, the JavaScript controller class, the XML metadata configuration, CSS scoping, and the component bundle directory convention.

LWC reactivity model: @api for parent-exposed public properties, @track for deep object/array reactivity, the default shallow reactivity of class fields, and @wire as a decorator for data binding to wire adapters.

Wiring Apex methods and Salesforce wire adapters (getRecord, getPicklistValues, getRelatedListRecords) to LWC components; wire function target for reactive parameter passing; error and data destructuring patterns.

LightningRecordViewForm, LightningRecordEditForm, LightningInputField, LightningOutputField, and the LDS cache for automatic record operations; lightning-button, lightning-card, lightning-datatable, and other base components.

LWC event model: firing custom events with new CustomEvent(), handling events in parent with template listeners, event bubbling and composed flag, and pub/sub (LMS — Lightning Message Service) for cross-tree communication.

Programmatic navigation in LWC using NavigationMixin.Navigate() and NavigationMixin.GenerateUrl(); page reference types (standard__recordPage, standard__namedPage, standard__objectPage, comm__namedPage); and navigation in Experience Cloud contexts.

Calling Apex methods imperatively from LWC JavaScript: promise-based invocation, async/await pattern, error handling with try/catch, and when to prefer imperative calls over @wire (user-initiated actions, non-cacheable mutations).

LWC component lifecycle: constructor, connectedCallback, renderedCallback, disconnectedCallback, errorCallback; rendering lifecycle guarantees; and best practices for initialization, DOM access, and cleanup.

Making outbound callouts from Apex: HttpRequest configuration (endpoint, method, headers, body, timeout), HttpResponse status code and body parsing, XML/JSON deserialization, and callout governor limits.

Named credentials as endpoint + auth containers, Legacy vs Per-User named credentials, credential types (Password, OAuth, AWS Signature), external credential principals, and eliminating hardcoded endpoint URLs from Apex code.

@RestResource and @HttpGet/@HttpPost/@HttpPut/@HttpPatch/@HttpDelete annotations, RestRequest and RestResponse context objects, URL path parameter binding, and SOAP web services via the webservice keyword.

Platform Events for event-driven integration: publishing via Apex and flows, subscribing via CometD and Apex triggers; Change Data Capture (CDC) event objects, ChangeEventHeader fields, and CDC use cases for external system synchronization.

Registering External Services from an OpenAPI 2.0/3.0 spec, auto-generated invocable actions for flows, named credential binding, schema evolution considerations, and when External Services is preferred over hand-coded callouts.

Bulk API 2.0 for large-scale data loads/extracts, job lifecycle (upload/close/abort), CSV batch format; Streaming API (PushTopic and Generic Streaming) for real-time notifications; developer awareness for PDII integration scenarios.

Remote Site Settings for whitelisting callout endpoints, CSP Trusted Sites for LWC/Aura, OAuth 2.0 flows for inbound Salesforce APIs (Web Server, Username-Password, JWT Bearer), connected apps, and API security best practices.

@isTest class structure, @TestSetup shared data factory, Test.startTest()/stopTest() for governor limit resetting, System.assertEquals/assertNotEquals/assert, and seeAllData=false discipline for test isolation.

Salesforce 75% org-wide code coverage requirement for production deployments, 75% per-class trigger coverage, meaningful assertions vs coverage-only tests, and best practices for assertion completeness aligned with PDII exam expectations.

HttpCalloutMock interface for testing callouts, Test.setMock() registration, StaticResourceCalloutMock for complex responses; StubProvider interface for dynamic dependency mocking in unit tests without real DML or callouts.

Enforcing record-level sharing with with sharing keyword, checking CRUD and FLS with Schema.describeSObjectResult/DescribeFieldResult, the WITH SECURITY_ENFORCED SOQL clause, and stripInaccessible() for field-level filtering.

Salesforce DX (SFDX) CLI: project structure (sfdx-project.json), scratch org creation and features, source push/pull, org shape, and the shift from change-set to source-driven development workflows.

Unlocked packages for modular org development: package creation, versioning, install/upgrade; Second-Generation Managed Packages (2GP) for ISVs: namespace, subscriber protections, deprecation, and package dependency management.

CI/CD pipeline design for Salesforce: SFDX CLI in CI (GitHub Actions / GitLab CI), sf project deploy start with --test-level RunLocalTests, deployment validation (check-only), metadata API retrieve/deploy, and the full path from scratch org to production sandbox to production.