Salesforce Lightning platform enterprise architecture : architect and deliver packaged applications that cater to enterprise business needs

Cover
Title Page
Copyright and Credits
About Packt
Foreword
Contributors
Table of Contents
Preface
Chapter 1: Building and Publishing Your Application
	Introducing Salesforce DX
	Required organizations
	Introducing the book\'s sample application
	Package types and benefits
		The features and benefits of managed packages
	Creating your first managed package
		Setting and registering your package namespace
		Creating the package and assigning it to the namespace
		Adding components to the package
		Extension packages
	Package platform feature dependencies
		Release and beta packages
		Optional package dependencies
			Dynamic bindings
			Extension packages
	Supporting package upgradability
		Managing package ancestry
		Developing in scratch orgs containing ancestry information
	Becoming a Salesforce partner and the benefits of doing so
		Security review and benefits
		Getting the best out of the Partner Community
		Creating test and demo orgs via the Environment Hub
	Introduction to AppExchange and listings
	Installing and testing your package
		Automating package installation
	Understanding how to license your package
		The Licenses tab and managing customer licenses
		The Feature Parameters tab and managing features
		The Subscribers tab
		The Subscriber Overview page
		How licensing is enforced in the subscriber org
	Providing support
	Customer metrics
	Trialforce and Test Drive
		Distributing Salesforce Connected Apps
	Summary
Chapter 2: Leveraging Platform Features
	Packaging and upgradable components
		Custom Fields – picklist values
		Global picklists
		Automating upgrade tasks with the Metadata API
	Understanding Custom Field features
		Default field values
		Encrypted fields
			Special considerations for Platform Encryption
		Lookup options, filters, and layouts
		Rollup summaries and limits
	Understanding the available security features
		Functional security
			Your code and security review considerations
		Data security
			Your code and security review considerations
	Platform APIs
		Considerations for working well with the platform\'s APIs
	Localization and translation
		Localization
		Translation
	Building customizable user interfaces
		Layouts
		Customizing Lightning Components and Visualforce pages 
		Lightning App Builder and Components
	Email customization with email templates
	Process Builder, Workflow, and Flow
	Social features and mobile
	Creating and testing a new package version
	Summary
Chapter 3: Application Storage
	Mapping out end user storage requirements
	Understanding the different storage types
		Data storage
			Columns versus rows
			Visualizing your object model
			Considerations for configuration data
				Custom Metadata Type storage
				Custom Settings storage
				Big Objects storage
		File storage
		Record identification, uniqueness, and auto numbering
			Unique and external ID fields
			Auto Number fields
				Subscribers customizing the Auto Number Display Format
		Record relationships
	Reusing the existing Standard Objects
	Importing and exporting data
		Salesforce DX CLI Data Import and Export
		Salesforce Data Import Wizard
	Options for replicating data
	External data sources
	Creating a new FormulaForce package version
	Summary
Chapter 4: Apex Execution and Separation of Concerns
	Execution contexts
		Exploring execution contexts
		Execution context and state
			Platform Cache
		Execution context and security
		Execution context transaction management
	Apex governors and namespaces
		Namespaces and governor scope
		Deterministic and non-deterministic governors
		Key governors for Apex package developers
	Where is Apex used?
	Separation of concerns
		Apex code evolution
		Separating concerns in Apex
		Separation of concerns in Lightning Components
			Separation of concerns in an LWC
			Separation of concerns in a Lightning Aura Component
		Execution context logic versus application logic concerns
		Improving incremental code reuse
	Patterns of Enterprise Application Architecture
		The Service layer
		The domain model layer
		The Data Mapper (selector) layer
			Introducing the FinancialForce.com Apex Commons library
	Unit testing versus system testing
	Packaging the code
	Summary
Chapter 5: Application Service Layer
	Introducing the Service layer pattern
	Implementation of design guidelines
		Naming conventions
		Bulkification
		Sharing rules enforcement
		Defining and passing data
			Considerations when using SObject in the Service layer interface
		Transaction management
		Compound services
		A quick guideline checklist
	Handling DML with the Unit Of Work pattern
		Without a Unit Of Work
		With Unit Of Work
		The Unit Of Work scope
		Unit Of Work special considerations
	Services calling services
	Contract-Driven Development
	Testing the Service layer
		Mocking the Service layer
	Calling the Service layer
		From Lightning Component Apex Controllers
		From Visualforce Apex Controllers
		From the Apex Scheduler
		Updating the FormulaForce package
	Summary
Chapter 6: Application Domain Layer
	Introducing the Domain layer pattern
		Encapsulating an object\'s behavior in code
		Interpreting the Domain layer
		Domain classes in Apex compared to other platforms
	Implementing design guidelines
		Naming conventions
		Bulkification
		Defining and passing data
		Transaction management
	Domain class template
	Implementing Domain Trigger logic
		Routing trigger events to Domain class methods
		Enforcing object security
			Default behavior
			Overriding the default behavior
		Apex Trigger event handling
			Defaulting field values on insert
			Validation on insert
			Validation on update
	Implementing custom Domain logic
	Object-oriented programming
		Creating a compliance application framework
		An Apex Interface example
			Step 5 – Defining a generic service
			Step 6 – Implementing the Domain class interface
			Step 7 – The Domain class Factory pattern
			Step 8 – Implementing a generic service
			Step 9 – Using the generic service from a generic controller
				Generic Compliance Verification UI with a Lightning Component
				Generic Compliance Verification UI with Visualforce
			Summarizing the implementation of the compliance framework
	Testing the Domain layer
		Unit testing
		Test methods using DML and SOQL
		Test methods using the Domain class methods
	Calling the Domain layer
		Service layer interactions
		Domain layer interactions
	Updating the FormulaForce package
	Summary
Chapter 7: Application Selector Layer
	Introducing the Selector layer pattern
	Implementing design guidelines
		Sharing conventions
		Naming conventions
		Bulkification
		Record order consistency
		Querying fields consistently
	The Selector class template
	Implementing the standard query logic
		Standard features of the Selector base class
			Enforcing object and field-level security
				Default behavior
				Overriding the default behavior
			Ordering
			Field Sets
			Multi-Currency
	Implementing the custom query logic
		A basic custom Selector method
		A custom Selector method with subselect
		A custom Selector method with related fields
		A custom Selector method with a custom dataset
			Combining Apex data types with SObject types
		SOSL and aggregate SOQL queries
	Introducing the Selector factory
		SelectorFactory methods
			Writing tests and the Selector layer
	Updating the FormulaForce package
	Summary
Chapter 8: Building User Interfaces
	What devices should you target?
	Leveraging standard UIs and custom UIs
		Why consider Visualforce over Lightning Framework?
		Lightning Component programming frameworks
	Leveraging the Salesforce standard UIs and tools
		Overriding standard Salesforce UI actions
		Combining standard UIs with custom UIs
			Embedding a custom UI in a standard UI
			Embedding a standard UI in a custom UI
		Extending the Salesforce standard UIs
			Lightning Components
			Visualforce pages
	Generating downloadable content
	Generating printable content
		Overriding the page language
	Client-server communication
		Client communication options
		API governors and availability
		Database transaction scope and client calls
		Offline support
	Managing limits
	Object- and field-level security
		Enforcing security in Lightning Web Components
		Enforcing security in Visualforce
	Managing performance and response times
		Lightning Tools to monitor size and response times
		Lightning Tools to monitor locker service performance
		Visualforce view state size
		Considerations for managing large component trees
	Using the Service layer and database access
		Considerations for client-side logic and Service layer logic
		When should I use JavaScript for database access?
	Considerations for using JavaScript libraries
	Custom Publisher Actions
	Creating websites and communities
	Mobile application strategy
	Custom reporting and the Analytics API
	Updating the FormulaForce package
	Summary
Chapter 9: User Interfaces with Lightning Framework
	Building a basic Lightning UI
		Introduction to the Lightning Design System
		Building your first component
		How does Lightning differ from other UI frameworks?
	Lightning architecture
		Containers
			Introducing the Racing Overview Lightning app
			Lightning Experience and Salesforce Mobile
		Components
			Separation of concerns
			Encapsulation during development
				Component markup (.html)
				Component controller (.js)
				Component CSS (.css)
				Component metadata (.js-meta.xml) and component SVG (.svg) files
				Component documentation (.auradoc)
				Component tests (test subfolder)
				Sharing JavaScript Code between components
			Enforcing encapsulation and security at runtime
			Expressing behavior
				Access control
				Methods
				Child component events
				Inter-component events
		Platform namespaces
		Base components
		Data Service
		Object-oriented programming
		Object-level and field-level security
	FormulaForce Lightning components
		RaceStandings component
		RaceCalendar component
		RaceResults component
		RaceSetup component
	Making components customizable
	Integrating with Lightning Experience
		Using components on Lightning pages and tabs
	Integrating with Lightning Flow
	Integrating with Lightning Communities
	Exposing components with Lightning Out
	Updating the FormulaForce package
	Summary
Chapter 10: Providing Integration and Extensibility
	Reviewing your integration and extensibility needs
		Defining the Developer X persona
		Understanding and managing versioning
			Versioning the API definition
			Versioning the API definition of the Salesforce APIs
			Versioning the API functionality
		Translation and localization
		Terminology and platform alignment
		What are your integration use cases?
			Developer X calling your APIs on-platform
			Developer X calling your APIs off-platform
				SOAP versus REST
				The OpenAPI Specification and Swagger
			Developer X calling your APIs asynchronously through platform events
		What are your application\'s extensibility use cases?
	Standard platform APIs for integration
		Apex Callable interface API
	Application integration APIs
		Providing Apex application APIs
			Calling an application API from Apex
			Modifying and depreciating the application API
			Versioning Apex API definitions
			Versioning Apex API behavior
		Providing RESTful application APIs
		Key aspects of being RESTful
			What are your application resources?
			Mapping HTTP methods
		Providing Apex REST application APIs
		Calling your Apex REST application APIs
		Versioning Apex REST application APIs
			Behavior versioning
			Definition versioning
	Exposing platform events
	Exposing Lightning Components
	Extending Process Builder and Flow
		Versioning invocable methods
	Alignment with platform extensibility features
	Extending application logic with Apex interfaces
	The MuleSoft platform
	Summary
Chapter 11: Asynchronous Processing and Big Data Volumes
	Creating a RaceData object with data
		Using Apex to generate synthetic Race Data
	Indexes, being selective, and query optimization
		Standard and custom indexes
			Ensuring queries leverage indexes
			Factors affecting the use of indexes
			Profiling queries
		Skinny tables
		Handling large result sets
			Processing 50k maximum result sets in Apex
			Processing unlimited result sets in Apex
				Generating more Race Data
				Leveraging Visualforce and Apex read-only mode
			Processing unlimited result sets using the Salesforce APIs
	Handling billions of records with big objects
		Salesforce and NoSQL stores
		Using a big object for race lap history
		Importing big object data
			Using Data Loader to import data into a big object
		Options to query big object data
			Synchronous big object SOQL queries
			Asynchronous big object SOQL queries
	Asynchronous processing
		Asynchronous user experience design considerations
		Asynchronous processing with workers and jobs
			Implementing a worker with @future
			Implementing a worker with Queueables
			Implementing a job with Batch Apex
				Performance of Batch Apex jobs
				Using external references in Apex DML
		Asynchronous processing with platform events
			Using high-scale platform events to stream data ingestion
			Using Change Data Capture platform events to compute data
			Sending race data telemetry events through the Salesforce DX CLI
	Volume testing
	Summary
Chapter 12: Unit Testing
	Comparing unit testing and integration testing
		The testing pyramid on the Lightning Platform
		Introducing unit testing
	Introduction to unit testing with Apex
		Deciding what to test for and what not to test for in a unit test
		Constructor dependency injection
		Implementing unit tests with CDI and mocking
		Other dependency injection approaches
		Benefits of dependency injection frameworks
	Writing unit tests with the Apex Stub API
		Implementing mock classes using Test.StubProvider
		Creating dynamic stubs for mocking classes
		Mocking examples with the Apex Stub API
		Considerations when using the Apex Stub API
		Using the Apex Stub API with mocking frameworks
			Understanding how ApexMocks works
			ApexMocks Matchers
	ApexMocks and Apex Enterprise Patterns
		Unit testing a controller method
		Unit testing a Service method
		Unit testing a Domain method
		Unit testing a Selector method
	Unit testing with Lightning Web Components
		Introduction to unit testing with Lightning Web Components
			Validating that the driver list is correctly bound to the table
			Validating that the selected drivers are sent to the server
	Summary
Chapter 13: Source Control and Continuous Integration
	Development workflow and infrastructure
		Creating and preparing your scratch orgs
		Understanding the developer workflow
	Developing with source control
		Populating your source control repository
		Deploying the code from source control
			Developing in scratch orgs with a namespace
			Leveraging the Salesforce REST APIs from the SFDX CLI and custom plugins
		Updating your source control repository
			Controlling what gets pulled down locally from your org
			Managing local files and committing to source control
	Hooking up continuous integration
		Using continuous integration to maintain code health
		Introducing the Jenkinsfile for CI
			Installing, configuring, and testing a Jenkins CI server
			Exploring Jenkins and CI further
	Releasing from source control
	Automated regression testing
	Summary
Chapter 14: Integrating with External Services
	Understanding inbound and outbound integrations
	Managing inbound integrations
		Introducing Salesforce Connected Apps
			Node.js application using a Connected App
	Understanding options for outbound integrations
		Managing outbound connections with Named Credentials
			Calling outbound connections from Apex
			Using per-user Named Credentials
		Accessing external services via External Services
		Accessing external data seamlessly via External Objects
	Summary
Chapter 15: Adding AI with Einstein
	Understanding Salesforce Einstein services and products
	Understanding Einstein Prediction Builder
	Understanding Einstein Discovery
		Discovering insights from Formula 1 race results
	Understanding Einstein Platform Services
	Summary
	Further reading
Other Books You May Enjoy
Index