Salesforce platform enterprise architecture : a must-read guide to help you architect and deliver packaged applications for enterprise neeeds / Andrew Fawcett, Daniel J. Peter.

Format:

Book

Author/Creator:

Fawcett, Andrew, author.

Peter, Daniel J., author.

Series:

Expert insight.

Expert insight

Language:

English

Subjects (All):

Salesforce (Online service).

Customer relations--Management--Data processing.

Customer relations.

Software architecture.

Physical Description:

1 online resource (713 pages)

Edition:

4th ed.

Place of Publication:

Birmingham, England : Packt Publishing, Limited, [2023]

Summary:

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.

Contents:

Cover

Copyright

Foreword

Contributors

Table of Contents

Preface

Part I: Key Concepts for Application Development

Chapter 1: Building and Publishing Your Application

Introducing Salesforce DX

Introducing the new Salesforce Task Driven CLI

Required organizations

Introducing Salesforce Hyperforce

Introducing the book's sample application

Package types and benefits

The features and benefits of managed and unlocked 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

Dependent packages

Package platform feature dependencies

Release and Beta packages

Optional package dependencies

Dynamic bindings

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

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

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

Flow

Social features and mobile

Creating and testing a new package version

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

File storage

Record identification, uniqueness, and auto-numbering

Unique and external ID fields

Auto Number fields

Customizing the Auto Number display format

Record relationships

Reusing existing Standard Objects

Importing and exporting data

Salesforce CLI data import and export

Salesforce Data import wizard

Options for replicating data

External data sources

Connecting to AWS data sources

Creating a new FormulaForce package version

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 Lighting Web Components

Separation of concerns in Lightning Aura Components

Execution context logic versus application logic concerns

Improving incremental code reuse

Patterns of Enterprise Application Architecture

The Service layer

The Domain layer

The Data Mapper (Selector) layer

Introducing the Apex Commons library

Unit testing versus system testing

Packaging the code

Part II: Backend Logic Patterns

Chapter 5: Application Service Layer

Introducing the Service layer pattern

Implementation of design guidelines

Naming conventions

Bulkification

Security 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 a 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 Web Component Apex controllers

From Visualforce Apex controllers

From the Apex Scheduler

Updating the FormulaForce package

Chapter 6: Application Domain Layer

Introducing the Domain layer pattern

Encapsulating an object's behavior in code

Interpreting the Domain layer in Apex

Domain classes in Apex compared to other platforms

Implementing design guidelines

Domain class template

Implementing Domain trigger logic.

Routing trigger events to Domain class methods

Enforcing security

Default behavior of fflib_SObjectDomain

Changing the default object security behavior of fflib_SObjectDomain

Enabling user mode by default for fflib_SObjectUnitOfWork

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

Summarizing the implementation of the compliance framework

Testing the Domain layer

Unit testing

Test Trigger methods using DML and SOQL

Test Trigger methods without using DML or SOQL

Test methods using the Domain class methods

Calling the Domain layer

Service layer interactions

Domain layer interactions

Chapter 7: Application Selector Layer

Introducing the Selector layer pattern

Security conventions

Record order consistency

Querying fields consistently with a Selector field contract

The Selector class template

Implementing the standard query logic

Standard features of the Selector base class

Default behavior

Overriding the default behavior and enabling user mode

Knowing when to run SOQL queries in system mode

Ordering

Field Sets

Multi-Currency

Implementing custom query logic

A basic custom Selector method

A custom Selector method with sub-select

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

Chapter 8: Additional Languages, Compute, and Data Services

FormulaForce Web and API requirements

Applying Heroku

Expanding FormulaForce automation experiences

Applying Functions

Solution overview

Usage of the sample source code included in this chapter

Other general considerations

Building web experiences with Node.js and Heroku

Step 1: Understanding LWR Node.js source files

Step 2: Introduction to the Insights LWC and Insights API

Step 3: Starting the LWR server locally and editing code

Step 4: Deploying the LWR server to Heroku for the first time

Step 5: Adding storage for race predictions using Heroku Postgres

Step 6: Accessing season data using Heroku Connect

Step 7: Accessing partner data using the Salesforce API

Step 8: Deploying the website and API to end users

Building OpenAPI-enabled APIs with Heroku

Step 1: Understanding the API Node.js source files

Step 2: Extending the LWR server to support APIs

Step 3: Implementing FormulaForce partner authentication

Step 4: Introduction to OpenAPI and associating it with API code

Step 5: Overview of the Swagger-generated API documentation

Extending automation with Java and Salesforce Functions

Step 1: Understanding the Java function source files

Step 2: Accessing org data with the Salesforce Functions SDK

Step 3: Running and editing the Function locally

Step 4: Deploying the Driver Check-in Function

Step 5: Invoking a deployed function from Apex

Wrapping Functions and Heroku APIs in Apex Service classes.

Step 1: Insights API and the Apex Service layer.

Notes:

Includes index.

Description based on print version record.

ISBN:

9781804614440

1804614440

OCLC:

1374429502