book

Salesforce Platform Enterprise Architecture - Fourth Edition

by Andrew Fawcett

March 2023

Intermediate to advanced

712 pages

19h 49m

English

Packt Publishing

Read now

Unlock full access

Who this book is forWhat this book coversTo get the most out of this bookGet in touch
Introducing Salesforce DXIntroducing the new Salesforce Task Driven CLIRequired organizationsIntroducing Salesforce HyperforceIntroducing the book’s sample applicationPackage types and benefitsThe features and benefits of managed and unlocked packagesCreating your first managed packageSetting and registering your package namespaceCreating the package and assigning it to the namespaceAdding components to the packageDependent packagesPackage platform feature dependenciesRelease and Beta packagesOptional package dependenciesDynamic bindingsDependent packagesSupporting package upgradabilityManaging package ancestryDeveloping in scratch orgs containing ancestry informationBecoming a Salesforce partner and the benefits of doing soSecurity review and benefitsCreating test and demo orgs via the Environment HubIntroduction to AppExchange and listingsInstalling and testing your packageAutomating package installationUnderstanding how to license your packageThe Licenses tab and managing customer licensesThe Feature Parameters tab and managing featuresThe Subscribers tabThe Subscriber Overview pageHow licensing is enforced in the subscriber orgProviding supportCustomer metricsTrialforce and Test DriveDistributing Salesforce Connected AppsSummary
Packaging and upgradable componentsCustom Fields – picklist valuesGlobal picklistsAutomating upgrade tasks with the Metadata APIUnderstanding Custom Field featuresDefault field valuesEncrypted fieldsSpecial considerations for platform encryptionLookup options, filters, and layoutsRollup summaries and limitsUnderstanding the available security featuresFunctional securityYour code and security review considerationsData securityYour code and security review considerationsPlatform APIsConsiderations for working well with the platform’s APIsLocalization and translationLocalizationTranslationBuilding customizable user interfacesLayoutsCustomizing Lightning Components and Visualforce pages Lightning App Builder and ComponentsEmail customization with email templatesFlowSocial features and mobileCreating and testing a new package versionSummary
Mapping out end user storage requirementsUnderstanding the different storage typesData storageColumns versus rowsVisualizing your object modelConsiderations for configuration dataFile storageRecord identification, uniqueness, and auto-numberingUnique and external ID fieldsAuto Number fieldsCustomizing the Auto Number display formatRecord relationshipsReusing existing Standard ObjectsImporting and exporting dataSalesforce CLI data import and exportSalesforce Data import wizardOptions for replicating dataExternal data sourcesConnecting to AWS data sourcesCreating a new FormulaForce package versionSummary
Execution contextsExploring execution contextsExecution context and statePlatform CacheExecution context and securityExecution context transaction managementApex governors and namespacesNamespaces and governor scopeDeterministic and non-deterministic governorsKey governors for Apex package developersWhere is Apex used?Separation of concernsApex code evolutionSeparating concerns in ApexSeparation of concerns in Lightning ComponentsSeparation of concerns in Lighting Web ComponentsSeparation of concerns in Lightning Aura ComponentsExecution context logic versus application logic concernsImproving incremental code reusePatterns of Enterprise Application ArchitectureThe Service layerThe Domain layerThe Data Mapper (Selector) layerIntroducing the Apex Commons libraryUnit testing versus system testingPackaging the codeSummary
Introducing the Service layer patternImplementation of design guidelinesNaming conventionsBulkificationSecurity enforcementDefining and passing dataConsiderations when using SObject in the Service layer interfaceTransaction managementCompound servicesA quick guideline checklistHandling DML with the Unit of Work patternWithout a Unit of WorkWith a Unit of WorkThe Unit of Work scopeUnit Of Work special considerationsServices calling servicesContract-driven developmentTesting the Service layerMocking the Service layerCalling the Service layerFrom Lightning Web Component Apex controllersFrom Visualforce Apex controllersFrom the Apex SchedulerUpdating the FormulaForce packageSummary
Introducing the Domain layer patternEncapsulating an object’s behavior in codeInterpreting the Domain layer in ApexDomain classes in Apex compared to other platformsImplementing design guidelinesNaming conventionsBulkificationDefining and passing dataTransaction managementDomain class templateImplementing Domain trigger logicRouting trigger events to Domain class methodsEnforcing securityDefault behavior of fflib_SObjectDomainChanging the default object security behavior of fflib_SObjectDomainEnabling user mode by default for fflib_SObjectUnitOfWorkApex Trigger event handlingDefaulting field values on insertValidation on insertValidation on updateImplementing custom Domain logicObject-oriented programmingCreating a compliance application frameworkAn Apex interface exampleStep 5 – Defining a generic serviceStep 6 – Implementing the Domain class interfaceStep 7 – The Domain class Factory patternStep 8 – Implementing a generic serviceStep 9 – Using the generic service from a generic controllerSummarizing the implementation of the compliance frameworkTesting the Domain layerUnit testingTest Trigger methods using DML and SOQLTest Trigger methods without using DML or SOQL Test methods using the Domain class methodsCalling the Domain layerService layer interactionsDomain layer interactionsUpdating the FormulaForce packageSummary
Introducing the Selector layer patternImplementing design guidelinesSecurity conventionsNaming conventionsBulkificationRecord order consistencyQuerying fields consistently with a Selector field contractThe Selector class templateImplementing the standard query logicStandard features of the Selector base classEnforcing securityDefault behaviorOverriding the default behavior and enabling user modeKnowing when to run SOQL queries in system modeOrderingField SetsMulti-CurrencyImplementing custom query logicA basic custom Selector methodA custom Selector method with sub-selectA custom Selector method with related fieldsA custom Selector method with a custom datasetCombining Apex data types with SObject typesSOSL and aggregate SOQL queriesIntroducing the Selector factorySelectorFactory methodsWriting tests and the Selector layerUpdating the FormulaForce packageSummary

FormulaForce Web and API requirementsApplying HerokuExpanding FormulaForce automation experiencesApplying FunctionsSolution overviewUsage of the sample source code included in this chapterOther general considerationsBuilding web experiences with Node.js and HerokuStep 1: Understanding LWR Node.js source filesStep 2: Introduction to the Insights LWC and Insights APIStep 3: Starting the LWR server locally and editing codeStep 4: Deploying the LWR server to Heroku for the first timeStep 5: Adding storage for race predictions using Heroku PostgresStep 6: Accessing season data using Heroku ConnectStep 7: Accessing partner data using the Salesforce APIStep 8: Deploying the website and API to end usersBuilding OpenAPI-enabled APIs with HerokuStep 1: Understanding the API Node.js source filesStep 2: Extending the LWR server to support APIsStep 3: Implementing FormulaForce partner authenticationStep 4: Introduction to OpenAPI and associating it with API codeStep 5: Overview of the Swagger-generated API documentationExtending automation with Java and Salesforce FunctionsStep 1: Understanding the Java Function source filesStep 2: Accessing org data with the Salesforce Functions SDKStep 3: Running and editing the Function locallyStep 4: Deploying the Driver Check-in FunctionStep 5: Invoking a deployed Function from ApexWrapping Functions and Heroku APIs in Apex Service classes Step 1: Insights API and the Apex Service layerStep 2: Driver Check-in Function and the Apex Service layerStep 3: Exposing the Driver Check-in Function to FlowSummary
What devices should you target?Leveraging standard and custom UIsWhy consider Visualforce over the Lightning Component framework?Lightning Component programming frameworksLeveraging the Salesforce standard UIs and toolsOverriding standard Salesforce UI actionsCombining standard UIs with custom UIsEmbedding a custom UI into a standard UIReusing Salesforce UI components in a custom UIExtending the Salesforce standard UIsLightning ComponentsVisualforce pagesGenerating downloadable contentGenerating printable contentOverriding the UI languageClient-server communicationInteracting with Apex and dataAPI governors and availabilityDatabase transaction scope and client callsManaging limitsObject and field level securityEnforcing security in LWCEnforcing security in VisualforceManaging performance and response timesLightning tools to monitor size and response timesUsing the Service layer and database accessConsiderations for client-side logic and Service layer logicConsiderations for using third-party JavaScript librariesCustom Publisher ActionsCreating websites and communitiesMobile applicationsCustom report UIs and the Analytics APIUpdating the FormulaForce packageSummary
Building a basic standalone Lightning pageIntroduction to the Lightning Design SystemBuilding your first componentHow does Lightning differ from other UI frameworks?Lightning architectureContainersIntroducing the Race Overview Lightning appLightning Experience and Salesforce MobileComponentsSeparation of concernsEncapsulation during developmentEnforcing encapsulation and security at runtimeExpressing behaviorPlatform namespacesBase componentsData ServiceObject-oriented programmingObject-level and field-level securityFormulaForce Lightning ComponentsRaceStandings componentRaceCalendar componentRaceResults componentRaceSetup componentMaking components customizableIntegrating with Lightning ExperienceUsing components on Lightning Pages and TabsIntegrating with Lightning FlowIntegrating with Lightning CommunitiesExposing components with Lightning OutUpdating the FormulaForce packageSummary
Reviewing your integration and extensibility needsDefining the Developer X personaUnderstanding and managing versioningVersioning the API definitionVersioning the API definition of the Salesforce APIsVersioning the API functionalityTranslation and localizationTerminology and platform alignmentWhat are your integration use cases?Developer X calling your APIs on-platformDeveloper X calling your APIs off-platformDeveloper X calling your APIs asynchronously through Platform EventsWhat are your application’s extensibility use cases?Standard platform APIs for integrationAn Apex-callable interface APIApplication integration APIsProviding Apex application APIsCalling an Apex application API from ApexModifying and deprecating the Apex application APIsVersioning Apex application API definitionsProviding RESTful application APIsKey aspects of being RESTfulWhat are your application resources?Mapping HTTP methodsProviding Apex REST application APIsCalling your Apex REST application APIsVersioning Apex REST application APIsBehavior versioningDefinition versioningExposing Platform EventsExposing Lightning ComponentsExtending FlowVersioning invocable methodsExtending application logic with platform extensibility featuresExtending application logic with Apex interfacesExtending application logic with FlowThe MuleSoft platformSummary
Creating an object for race dataUsing Apex to generate synthetic race dataIndexes, being selective, and query optimizationStandard and custom indexesEnsuring queries leverage indexesFactors affecting the use of indexesProfiling queriesSkinny tablesHandling large result setsProcessing 50k maximum result sets in ApexProcessing unlimited result sets in ApexProcessing unlimited result sets using the Salesforce APIsHandling billions of records with Big ObjectsSalesforce and NoSQL storesUsing a Big Object for race lap historyImporting Big Object dataUsing Data Loader to import data into a Big ObjectOptions to query Big Object dataSynchronous Big Object SOQL queriesAsynchronous Big Object SOQL queriesAsynchronous processingAsynchronous user experience design considerationsAsynchronous processing with workers and jobsImplementing a worker with @futureImplementing a worker with QueueablesImplementing a job with Batch ApexAsynchronous processing with Platform EventsUsing high-scale Platform Events to stream data ingestionUsing Change Data Capture Platform Events to compute dataSending race data telemetry events through the Salesforce DX CLIAsynchronous processing with FunctionsVolume testingSummary
Comparing unit testing and integration testingThe testing pyramid on the Salesforce PlatformIntroducing unit testingIntroduction to unit testing with ApexDeciding what to test for and what not to test for in a unit testConstructor dependency injectionImplementing unit tests with CDI and mockingOther dependency injection approachesBenefits of dependency injection frameworksWriting unit tests with the Apex Stub APIImplementing mock classes using Test.StubProviderCreating dynamic stubs for mocking classesConsiderations when using the Apex Stub APIUsing the Apex Stub API with mocking frameworksUnderstanding how ApexMocks worksApexMocks matchersApexMocks and Apex Enterprise PatternsUnit testing a controller methodUnit testing a Service methodUnit testing a Domain methodUnit testing a Selector methodUnit testing with Lightning Web ComponentsIntroduction to unit testing with Lightning Web ComponentsValidating that the driver list is correctly bound to the tableValidating that the selected drivers are sent to the serverUnit testing with Salesforce FunctionsIntegration testing Flow and user interface logicFlow testingUTAM testing overviewSummary
Development workflow and infrastructureCreating and preparing your scratch orgsUnderstanding the developer workflowDeveloping with source controlPopulating your source control repositoryDeploying the code from source controlDeveloping in scratch orgs with a namespaceLeveraging the Salesforce REST APIs from the Salesforce CLI and custom pluginsUpdating your source control repositoryControlling what gets pulled down locally from your orgManaging local files and committing to source controlHooking up continuous integrationUsing continuous integration to maintain code healthIntroducing the Jenkinsfile for CIInstalling, configuring, and testing a Jenkins CI serverExploring Jenkins and CI furtherReleasing from source controlAutomated regression testingAlternative Salesforce-oriented CI/CD serversSummary
Understanding inbound and outbound integrationsManaging inbound integrationsIntroducing Salesforce Connected AppsA Node.js application using a Connected AppUnderstanding options for outbound integrationsManaging outbound connections with Named CredentialsCalling outbound connections from ApexUsing per-user Named CredentialsAccessing external API services via External ServicesAccessing external data seamlessly via External ObjectsIntegration with AWS ServicesSummary
Understanding Salesforce Einstein services and productsUnderstanding Einstein Prediction BuilderUnderstanding Einstein DiscoveryDiscovering insights from Formula 1 race resultsUnderstanding Einstein Platform ServicesSummary

Overview

Salesforce Platform Enterprise Architecture aims to empower developers with the skills needed to architect and deliver scalable applications using Salesforce's capabilities. In this book, you will explore advanced architectural patterns, learn to optimize user interfaces, and integrate services to build enterprise-grade solutions.

What this Book will help me do

Architect and deploy enterprise applications using Salesforce with advanced patterns.
Develop robust user interfaces using Lightning Web Components.
Manage large data volumes effectively with asynchronous workflows.
Extend functionality using external services, APIs, and integrations.
Utilize Java, Node.js, and Salesforce Functions for enhanced application scales.

Author(s)

Andrew Fawcett is a seasoned Salesforce Developer and Architect with extensive experience in creating enterprise solutions tailored to address complex business needs. As an advocate for scalable and maintainable application development, Andrew brings practical insights to help developers optimize their usage of the Salesforce platform.

Who is it for?

This book is aimed at Salesforce developers with foundational knowledge aiming to advance their skills in enterprise application development. If you are driving projects for organizations or targeting markets with scalable and robust AppExchange solutions, this guide is tailored for you. It bridges your initial proficiency to expert capability.