Book Image

Salesforce Platform Enterprise Architecture - Fourth Edition

By : Andrew Fawcett

Book Image

Salesforce Platform Enterprise Architecture - Fourth Edition

By: Andrew Fawcett

Overview of this book

Salesforce makes architecting enterprise grade applications easy and secure – but you'll need guidance to leverage its full capabilities and deliver top-notch products for your customers. This fourth edition brings practical guidance to the table, taking you on a journey through building and shipping enterprise-grade apps. This guide will teach you advanced application architectural design patterns such as separation of concerns, unit testing, and dependency injection. You'll also get to grips with Apex and fflib, create scalable services with Java, Node.js, and other languages using Salesforce Functions and Heroku, and find new ways to test Lightning UIs. These key topics, alongside a new chapter on exploring asynchronous processing features, are unique to this edition. You'll also benefit from an extensive case study based on how the Salesforce Platform delivers solutions. By the end of this Salesforce book, whether you are looking to publish the next amazing application on AppExchange or build packaged applications for your organization, you will be prepared with the latest innovations on the platform.

Preface

Who this book is for

What this book covers

To get the most out of this book

Part I: Key Concepts for Application Development

Part I: Key Concepts for Application Development

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

Distributing Salesforce Connected Apps

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

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

Record identification, uniqueness, and auto-numbering

Record relationships

Reusing 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

Part II: Backend Logic Patterns

Part II: Backend Logic Patterns

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 custom query logic

Introducing the Selector factory

Updating the FormulaForce package

Additional Languages, Compute, and Data Services

Additional Languages, Compute, and Data Services

FormulaForce Web and API requirements

Expanding FormulaForce automation experiences

Solution overview

Building web experiences with Node.js and Heroku

Building OpenAPI-enabled APIs with Heroku

Extending automation with Java and Salesforce Functions

Wrapping Functions and Heroku APIs in Apex Service classes

Part III: Developing the Frontend

Part III: Developing the Frontend

Building User Interfaces

Building User Interfaces

What devices should you target?

Leveraging standard 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

Considerations for using third-party JavaScript libraries

Custom Publisher Actions

Creating websites and communities

Mobile applications

Custom report UIs and the Analytics API

Updating the FormulaForce package

User Interfaces and the Lightning Component Framework

User Interfaces and the Lightning Component Framework

Building a basic standalone Lightning page

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

Part IV: Extending, Scaling, and Testing an Application

Part IV: Extending, Scaling, and Testing an Application

Providing Integration and Extensibility

Providing Integration and Extensibility

Reviewing your integration and extensibility needs

Standard platform APIs for integration

Application integration APIs

Extending application logic with platform extensibility features

Extending application logic with Apex interfaces

Extending application logic with Flow

The MuleSoft platform

Asynchronous Processing and Big Data Volumes

Asynchronous Processing and Big Data Volumes

Creating an object for race 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

Unit testing with Salesforce Functions

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

Alternative Salesforce-oriented CI/CD servers

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

Other Books You May Enjoy

Other Books You May Enjoy

Index

Customer Reviews

5 star

0

4 star

0

3 star

0

2 star

0

1 star

0

Extending automation with Java and Salesforce Functions

So far Heroku has been used to build web and API experiences coded in Node.js and Postgres and run your code constantly through the use of Heroku Dynos. The interactions with those experiences come from external integrations, typically where response times are important. Salesforce Functions, however, offers much of the flexibility of Heroku Dynos with respect to support for additional programming languages, such as Java, Node.js, and Python as well as offering greater elastic scale for more intensive workloads that require more memory, CPU, and asynchronous scale compared to Apex. Functions also have no callout or asynchronous limits when compared to Apex.

In contrast to Heroku Dynos, Salesforce Functions run only when needed, so only use up compute resources when needed; a downside of this is there can sometimes be a startup cost if a function has not been invoked recently. One big difference is that they have tighter integration...