Book Image

Salesforce Lightning Platform Enterprise Architecture - Third Edition

By : Andrew Fawcett

Book Image

Salesforce Lightning Platform Enterprise Architecture - Third Edition

By: Andrew Fawcett

Overview of this book

Salesforce Lightning provides a secure and scalable platform to build, deploy, customize, and upgrade applications. This book will take you through the architecture of building an application on the Lightning platform to help you understand its features and best practices, and ensure that your app keeps up with your customers’ increasing needs as well as the innovations on the platform. This book guides you in working with the popular aPaaS offering from Salesforce, the Lightning Platform. You’ll see how to build and ship enterprise-grade apps that not only leverage the platform's many productivity features, but also prepare your app to harness its extensibility and customization capabilities. You'll even get to grips with advanced application architectural design patterns such as Separation of Concerns, Unit Testing and Dependency Integration. You will learn to use Apex and JavaScript with Lightning Web Components, Platform Events, among others, with the help of a sample app illustrating patterns that will ensure your own applications endure and evolve with the platform. Finally, you will become familiar with using Salesforce DX to develop, publish, and monitor a sample app and experience standard application life cycle processes along with tools such as Jenkins to implement CI/CD. By the end of this book, you will have learned how to develop effective business apps and be ready to explore innovative ways to meet customer demands.

Preface

Who this book is for

What this book covers

To get the most out of this book

Author disclosure

Free Chapter

Building and Publishing Your Application

Building and Publishing Your Application

Introducing Salesforce DX

Required organizations

Introducing the book's sample application

Package types and benefits

Creating your first managed package

Package platform feature dependencies

Supporting package upgradability

Becoming a Salesforce partner and the benefits of doing so

Introduction to AppExchange and listings

Installing and testing your package

Understanding how to license your package

Providing support

Customer metrics

Trialforce and Test Drive

Leveraging Platform Features

Leveraging Platform Features

Packaging and upgradable components

Understanding Custom Field features

Understanding the available security features

Localization and translation

Building customizable user interfaces

Email customization with email templates

Process Builder, Workflow, and Flow

Social features and mobile

Creating and testing a new package version

Application Storage

Application Storage

Mapping out end user storage requirements

Understanding the different storage types

Reusing the existing Standard Objects

Importing and exporting data

Options for replicating data

External data sources

Creating a new FormulaForce package version

Apex Execution and Separation of Concerns

Apex Execution and Separation of Concerns

Execution contexts

Apex governors and namespaces

Where is Apex used?

Separation of concerns

Patterns of Enterprise Application Architecture

Unit testing versus system testing

Packaging the code

Application Service Layer

Application Service Layer

Introducing the Service layer pattern

Implementation of design guidelines

Handling DML with the Unit Of Work pattern

Services calling services

Contract-Driven Development

Testing the Service layer

Calling the Service layer

Application Domain Layer

Application Domain Layer

Introducing the Domain layer pattern

Implementing design guidelines

Domain class template

Implementing Domain Trigger logic

Implementing custom Domain logic

Object-oriented programming

Testing the Domain layer

Calling the Domain layer

Updating the FormulaForce package

Application Selector Layer

Application Selector Layer

Introducing the Selector layer pattern

Implementing design guidelines

The Selector class template

Implementing the standard query logic

Implementing the custom query logic

Introducing the Selector factory

Updating the FormulaForce package

Building User Interfaces

Building User Interfaces

What devices should you target?

Leveraging standard UIs and custom UIs

Leveraging the Salesforce standard UIs and tools

Generating downloadable content

Generating printable content

Client-server communication

Managing limits

Object- and field-level security

Managing performance and response times

Using the Service layer and 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

User Interfaces with Lightning Framework

User Interfaces with Lightning Framework

Building a basic Lightning UI

Lightning architecture

FormulaForce Lightning components

Making components customizable

Integrating with Lightning Experience

Integrating with Lightning Flow

Integrating with Lightning Communities

Exposing components with Lightning Out

Updating the FormulaForce package

Providing Integration and Extensibility

Providing Integration and Extensibility

Reviewing your integration and extensibility needs

Standard platform APIs for integration

Application integration APIs

Exposing platform events

Exposing Lightning Components

Extending Process Builder and Flow

Alignment with platform extensibility features

Extending application logic with Apex interfaces

The MuleSoft platform

Asynchronous Processing and Big Data Volumes

Asynchronous Processing and Big Data Volumes

Creating a RaceData object with data

Indexes, being selective, and query optimization

Handling billions of records with big objects

Asynchronous processing

Unit Testing

Comparing unit testing and integration testing

Introduction to unit testing with Apex

Writing unit tests with the Apex Stub API

ApexMocks and Apex Enterprise Patterns

Unit testing with Lightning Web Components

Source Control and Continuous Integration

Source Control and Continuous Integration

Development workflow and infrastructure

Developing with source control

Hooking up continuous integration

Releasing from source control

Automated regression testing

Integrating with External Services

Integrating with External Services

Understanding inbound and outbound integrations

Managing inbound integrations

Understanding options for outbound integrations

Adding AI with Einstein

Adding AI with Einstein

Understanding Salesforce Einstein services and products

Understanding Einstein Prediction Builder

Understanding Einstein Discovery

Understanding Einstein Platform Services

Further reading

Other Books You May Enjoy

Other Books You May Enjoy

Leave a review - let other readers know what you think

Customer Reviews

5 star

0

4 star

0

3 star

0

2 star

0

1 star

0

Developing with source control

Now that we understand the general developer flow a bit more, let's take a deeper dive into using some of the tools and approaches that you can use to share changes in source control. In this case, we will be using some specific tools to populate and manage the content of our chosen source control repository—Git. To provide an easy means to explore the benefits of a more distributed solution, we will use GitHub as a hosted instance of Git (others are available, including broader developer flow features). The following is a list of the tools that we will be using in this chapter:

GitHub: Ensure that you have a GitHub account. Public accounts are free, but you can also use a private account for the purposes of this chapter. Download the excellent GitHub GUI for either: https://desktop.github.com/. This chapter will use the Mac edition...