56,29 €
Mehr erfahren.
- Herausgeber: Packt Publishing
- Kategorie: Wissenschaft und neue Technologien
- Sprache: Englisch
A comprehensive guide filled with best practices and tailor-made examples - a must-read for all Lightning Platform architects!
Key Features
- Use the Lightning Platform to build integrated, scalable, and robust apps focused on enterprise-level customer demands
- Use the Lightning Component framework to deliver modern and responsive user experiences targeting multiple devices through Lightning Experience and Salesforce Mobile
- Extend your application with access to external services and AI
Book Description
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.
What you will learn
- Create and deploy AppExchange packages and manage upgrades
- Understand Enterprise Application Architecture patterns
- Customize mobile and desktop user experience with Lightning Web Components
- Manage large data volumes with asynchronous processing and big data strategies
- Implement Source Control and Continuous Integration
- Add AI to your application with Einstein
- Use Lightning External Services to integrate external code and data with your Lightning Application
Who this book is for
This book is for Lightning platform developers who want to discover the true potential of the platform to develop complex scalable applications for use in enterprise businesses.
Das E-Book können Sie in Legimi-Apps oder einer beliebigen App lesen, die das folgende Format unterstützen:
Seitenzahl: 806
Veröffentlichungsjahr: 2019
Ähnliche
Salesforce Lightning Platform Enterprise Architecture Third Edition
Copyright © 2019 Packt Publishing
All rights reserved. No part of this book may be reproduced, stored in a retrieval system, or transmitted in any form or by any means, without the prior written permission of the publisher, except in the case of brief quotations embedded in critical articles or reviews.
Every effort has been made in the preparation of this book to ensure the accuracy of the information presented. However, the information contained in this book is sold without warranty, either express or implied. Neither the author, nor Packt Publishing or its dealers and distributors, will be held liable for any damages caused or alleged to have been caused directly or indirectly by this book.
Packt Publishing has endeavored to provide trademark information about all of the companies and products mentioned in this book by the appropriate use of capitals. However, Packt Publishing cannot guarantee the accuracy of this information.
Commissioning Editor: Richa TripathiAcquisition Editor: Alok DhuriContent Development Editor: Ruvika RaoTechnical Editor: Romy DiasCopy Editor: Safis EditingProject Coordinator:Francy PuthiryProofreader: Safis EditingIndexer:Priyanka DhadkeSenior Editor: Storm MannProduction Designer:Joshua Misquitta
First published: September 2014 Second edition: March 2017 Third edition: November 2019
Production reference: 2230120
Published by Packt Publishing Ltd. Livery Place 35 Livery Street Birmingham B3 2PB, UK.
ISBN 978-1-78995-671-9
www.packtpub.com
Packt.com
Subscribe to our online digital library for full access to over 7,000 books and videos, as well as industry leading tools to help you plan your personal development and advance your career. For more information, please visit our website.
Why subscribe?
Spend less time learning and more time coding with practical eBooks and Videos from over 4,000 industry professionals
Improve your learning with Skill Plans built especially for you
Get a free eBook or video every month
Fully searchable for easy access to vital information
Copy and paste, print, and bookmark content
Did you know that Packt offers eBook versions of every book published, with PDF and ePub files available? You can upgrade to the eBook version at www.packt.com and as a print book customer, you are entitled to a discount on the eBook copy. Get in touch with us at [email protected] for more details.
At www.packt.com, you can also read a collection of free technical articles, sign up for a range of free newsletters, and receive exclusive discounts and offers on Packt books and eBooks.
Foreword
At Dreamforce 2016, I was delighted to introduce a new, modern approach to developing apps on the Salesforce Lightning Platform that we call Salesforce DX (DX is short for Developer Experience). At its core, Salesforce DX has a number of core principles that we stay committed to today. Developers can:
Drive all development from source code. Although you're not required to use version control for all your activities, we fully support it and even encourage it.
Easily create (and delete) the environments you use for development and testing. Advances with scratch orgs, and some of the recent work that allows you to create sandboxes through the command-line interface, give you more control as a developer over the environments you use to build apps.
Work better together as a team. Let's face it, having a bunch of people working together in one Sandbox or Developer Edition org can be difficult. We've focused on tooling and services to make it easier to let everyone work together in ways that don't impact your productivity and, in fact, improve it.
Modularize your code (and even deploy it as a package, should you choose). This book goes into great detail regarding the many reasons why you might want to modularize your code.
Use open standards and familiar tools for your development. We shifted away from using proprietary standards and tooling to make it easier for you to use tools and approaches you already know and use today.
Easily implement continuous delivery. We know that there's a direct correlation between how often developers ship their code on the Lightning Platform and the long-term success they have. Salesforce DX makes it easier for developers to continually ship their code.
All of these principles come together to significantly change and improve the way developers can come together and build applications on the Lightning Platform.
Shortly before the launch of Salesforce DX, I bought a book called Force.com Enterprise Architecture by Andrew Fawcett. I hadn't yet met Andrew, but I knew of him through his reputation in the community. I planned to go through it from cover to cover, and apply everything Andrew wrote about in the context of the new tools and new approach to building applications on what was then the Force.com (now Lightning) Platform. Not only did I find it to be an excellent book, I learned a few things about the platform I didn't already know. I also found a bunch of issues with our tooling that I filed as bugs to be resolved before launch. Those who've built products know that one of the best gifts you can get is reproducible bugs. Finding and squashing bugs is a delightful process! (Incidentally, I use Trailhead today the same way, using new trails as opportunities to test our tooling and continually looking for ways to improve.)
I first met Andrew during a panel for analysts at the TrailheaDX Conference in June 2017. Adrian Kunzle (EVP of Platform at the time) and I spoke to analysts about the transformative nature of Salesforce DX. Some of our key pilot and launch partners joined us to share their own stories and insights. At the time, Andrew was the CTO for FinancialForce, a great partner that provides ERP and other products on Salesforce as well as an active participant in our early previews and pilots. I gained several insights from that panel that I believe are worth sharing.
First, there is no question that Andrew is the author of the definitive book on how to approach enterprise architecture with Salesforce. His depth of expertise and familiarity with building on the platform are unequaled. All the analysts and Salesforce employees were impressed by Andrew's ability to walk through the implications of Salesforce DX in the context of building apps.
Second, there's no one more passionate about the power of app development using the Lightning Platform. Having known Andrew now for several years, I've found there are two things that get him incredibly excited. The first is Lego, particularly if there is any kind of robotics or automation involved. The second is building apps on the Lightning Platform. Andrew literally gets giddy when it comes to explaining, teaching, and coaching people on how to build apps on the Lightning Platform. This passion and excitement comes through in this book and will inspire you with what you can build.
And finally, when I met Andrew, I knew I wanted to work with him. While you can't choose your family, you can often choose the people you work with. Andrew not only had the experience needed to continue to evolve and modernize the Lightning Platform in the years to come, but I knew he had the passion and commitment to be an amazing champion of our customers and partners along the way. And I have to say that it's been one of the great pleasures of my career to work with Andrew for the last couple of years.
What you have in your hands is an amazing learning resource that has evolved over the years. With its recent updates and improvements, it's become an essential tool to successfully build enterprise apps on the Lightning Platform. I'm confident that you'll be building amazing applications in no time by learning from Andrew's experience, and the recent updates that incorporate the tools and approaches made available by advances in Salesforce developer tooling.
Wade Wegner
SVP of Product at Salesforce
Contributors
About the author
Andrew Fawcett has over 25 years of experience holding several software development-related roles with a focus around enterprise-level product architecture. He is experienced in managing all aspects of the software development life cycle across various technology platforms, frameworks, industry design patterns, and methodologies.
He is currently a VP, Product Management, and a Salesforce Certified Platform Developer II at Salesforce.com. He is responsible for several key platform features and emergent products for Salesforce.com. He is an avid blogger, open source contributor and project owner, and an experienced speaker. He loves watching movies, Formula 1 motor racing, and building Lego! You can find him on Twitter at @andyinthecloud.
About the reviewers
Jan Vandevelde is a Salesforce MVP, speaker, trainer, and blogger, and a Senior Salesforce Consultant at Salesforce Platinum Partner 4C. He is based in Belgium. He has been working on the Force.com platform since 2009. Currently, he is working as a Salesforce Consultant and is a regular contributor to the Trailblazer Community.
He has 15 certifications in Salesforce. He works on all aspects of Salesforce and is an expert in data migration, configuration, customization, and development, with his main expertise being in Sales Cloud, Service Cloud, Community Cloud, and Salesforce Quote-to-Cash. He is the leader of the Belgium User Group of Salesforce. He is one of the board members of Europe's community-led event, YeurDreamin.
John M. Daniel has been working in the technology sector for over 20 years. During that time, he has worked in a variety of technologies and project roles. Currently, he serves as the Director of Platform Architecture at Rootstock Cloud ERP, a leading cloud-based ERP solution that is native to the Salesforce Platform. He is a Salesforce MVP and holds multiple Salesforce certifications. He is currently working toward becoming a Certified Technical Architect. He loves to work on open source projects such as Force-DI, AT4DX, and the DomainBuilder framework. He has been a technical reviewer for Mastering Salesforce DevOps, Learning Apex Programming, and Apex Design Patterns. He co-leads his local Salesforce Developers User Group and can be found on Twitter at @ImJohnMDaniel.
Michael Salem is a member of the emerging technologies team at Salesforce. They're a group of architects who are focused on emerging areas of cloud computing such as big data (and data architecture patterns at scale), computer vision, natural language processing, IoT, and blockchain. They help senior technology leaders understand where emerging technology can fit within their enterprise architecture and roadmap.
Before this, Michael held technology-focused roles working with Salesforce technology at a start-up, as well as working as a lead solution architect for client implementations with Model Metrics (acquired by Salesforce).
Michael holds an MBA with a focus on technology and has been working in technology for a decade.
Mohith Shrivastava has been building and architecting Salesforce applications since 2011, after he graduated from the National Institute of Engineering, Mysore.
He is currently a Salesforce MVP and holds multiple Salesforce certifications. He is an active contributor to the Salesforce Stack Exchange community.
Mohith has authored Learning Salesforce Einstein and Salesforce Essentials for Administrators for Packt. In his leisure time, he loves exploring the latest technologies and spending time with his family.
Searching for authors like you
If you're interested in becoming an author for Packt, please visit authors.packtpub.com and apply today. We have worked with thousands of developers and tech professionals, just like you, to help them share their insight with the global tech community. You can make a general application, apply for a specific hot topic that we are recruiting an author for, or submit your own idea.
Table of Contents
Title Page
Copyright and Credits
Salesforce Lightning Platform Enterprise Architecture Third Edition
About Packt
Why subscribe?
Foreword
Contributors
About the author
About the reviewers
Searching for authors like you
Preface
Who this book is for
What this book covers
To get the most out of this book
Author disclosure
Download the example code files
Download the color images
Conventions used
Get in touch
Reviews
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
Leave a review - let other readers know what you think
Preface
Enterprise organizations have complex processes and integration requirements that typically span multiple locations around the world. They seek out the best-in-class applications that support not only their current needs, but also those of the future. The ability to adapt an application to their practices, terminology, and integrations with other existing applications or processes is key for them. They invest as much in your application as they do in you, as the vendor capable of delivering an application strategy that will grow with them.
Throughout this book, you will be shown how to architect and support enduring applications for enterprise clients with Salesforce by exploring how to identify architecture needs and design solutions based on industry-standard patterns.
Large-scale applications require careful coding practices to keep the code base scalable. You'll learn advanced coding patterns based on industry-standard enterprise patterns and reconceive them for Lightning Platform, allowing you to get the most out of the platform and incorporate best practices from the start of your project.
As your development team grows, managing the development cycle with more robust application life cycle tools, and using approaches such as Continuous Integration, become increasingly important. There are many ways to build solutions on the Lightning Platform; this book cuts a logical path through the steps and considerations for building packaged solutions from start to finish, covering all aspects from engineering to getting it into the hands of your customers and beyond, ensuring that they get the best value possible from your Lightning Platform application.
Who this book is for
This book is aimed at Lightning Platform developers who are looking to push past Lightning Platform basics and learn how to truly discover its potential. You will find this book handy if you are looking to expand your knowledge of developing packaged ISV software and complex, scalable applications for use in enterprise businesses with the Salesforce platform. This book will enable you to know your way around Lightning Platform's non-programmatic functionality as well as Apex, and aid you in learning how to architect powerful solutions for enterprise-scale demands. If you have a background in developing inside other enterprise software ecosystems, you will find this book an invaluable resource for adopting the Lightning Platform.
What this book covers
Chapter 1, Building and Publishing Your Application, gets your application out to your prospects and customers using packages, AppExchange, and subscriber's support.
Chapter 2, Leveraging Platform Features, ensures that your application is aligned with the platform features and uses them whenever possible, which is great for productivity when building your application, but—perhaps more importantly—it ensures that your customers are also able to extend and integrate with your application further.
Chapter 3, Application Storage, teaches you how to model your application's data to make effective use of storage space, which can make a big difference to your customer's ongoing costs and initial decision making when choosing your application.
Chapter 4, Apex Execution and Separation of Concerns, explains how the platform handles requests and at what point Apex code is invoked. It is important to understand how to design your code for maximum reuse and durability.
Chapter 5, Application Service Layer, focuses on understanding the real heart of your application: how to design it, make it durable, and future proof it around a rapidly evolving platform using Martin Fowler's Service pattern as a template.
Chapter 6, Application Domain Layer, aligns Apex code typically locked away in Apex Triggers into classes more aligned with the functional purpose and behavior of your objects, using object-orientated programming (OOP) to increase reuse and streamline code and leverage Martin Fowler's Domain pattern as a template.
Chapter 7, Application Selector Layer, leverages SOQL to make the most out of the query engine, which can make queries complex. Using Martin Fowler's Mapping pattern as a template, this chapter illustrates a means to encapsulate queries, making them more accessible and reusable, and making their results more predictable and robust across your code base.
Chapter 8, Building User Interfaces, covers the concerns of an enterprise application user interface with respect to translation, localization, and customization, as well as the pros and cons of the various UI options available in the platform.
Chapter 9, Using Interfaces with Lightning Framework, explains the architecture of this modern framework for delivering rich client-device agnostic user experiences, from a basic application through to using component methodology to extend Lightning Experience and Salesforce1 Mobile.
Chapter 10, Providing Integration and Extensibility, explains how enterprise-scale applications require you to carefully consider integration with existing applications and business needs while looking to the future by designing the application with extensibility in mind.
Chapter 11, Asynchronous Processing and Big Data Volumes, shows that designing an application that processes massive volumes of data, either interactively or asynchronously, requires consideration in understanding your customer's volume requirements and leverages the latest platform tools and features, such as understanding the query optimizer and when to create indexes.
Chapter 12, Unit Testing, explores the differences and benefits of unit testing versus system testing. This aims to help you understand how to apply dependency injection and mocking techniques to write unit tests that cover more code scenarios and run faster. You will also look at leveraging practical examples of using the Apex Stub API with the ApexMocks open source library and testing client logic with the Jest open source library.
Chapter 13, Source Control and Continuous Integration, shows that maintaining a consistent code base across applications of scale requires careful consideration of source control and a planned approach to integration as the application is developed and implemented.
Chapter 14, Integrating with External Services, explores how you and your customers can extend your application securely with services and data hosted outside of the Lightning Platform, using both code and configuration tools such as Flow.
Chapter 15, Adding AI with Einstein, explores services and features provided by Salesforce in order for you and your customers to add AI and machine learning capabilities to your application and its data.
To get the most out of this book
In order to follow the practical examples in this book, you will need to install the Salesforce DX CLI and Salesforce Extensions for Visual Studio Code. You will also require access to a Salesforce Developer Edition Org via https://developer.salesforce.com/ and a temporary Salesforce DevHub org via https://developer.salesforce.com/promotions/orgs/dx-signup.
The following is the list of the software requirements for this book:
Salesforce DevHub Org Trial
Salesforce Developer Edition Org (to register your test package namespace)
Salesforce DX CLI
Salesforce Extensions for Visual Studio
Salesforce Developer Console (partial usage as needed)
GitHub Desktop client
Author disclosure
At the time of publication, Andrew Fawcett works as a VP, Product Management, within Salesforce. The statements and opinions in this book are his own and not those of Salesforce.
Download the example code files
You can download the example code files for this book from your account at www.packt.com. If you purchased this book elsewhere, you can visit www.packt.com/support and register to have the files emailed directly to you.
You can download the code files by following these steps:
Log in or register at
www.packt.com
.
Select the
SUPPORT
tab.
Click on
Code Downloads & Errata
.
Enter the name of the book in the
Search
box and follow the onscreen instructions.
Once the file is downloaded, please make sure that you unzip or extract the folder using the latest version of:
WinRAR/7-Zip for Windows
Zipeg/iZip/UnRarX for Mac
7-Zip/PeaZip for Linux
The code bundle for the book is also hosted on GitHub at https://github.com/PacktPublishing/Salesforce-Lightning-Platform-Enterprise-Architecture-Third-Edition. In case there's an update to the code, it will be updated on the existing GitHub repository.
We also have other code bundles from our rich catalog of books and videos available at https://github.com/PacktPublishing/. Check them out!
Download the color images
We also provide a PDF file that has color images of the screenshots/diagrams used in this book. You can download it here: https://static.packt-cdn.com/downloads/9781789956719_ColorImages.pdf.
Conventions used
There are a number of text conventions used throughout this book.
CodeInText: Indicates code words in text, database table names, folder names, filenames, file extensions, pathnames, dummy URLs, user input, and Twitter handles. Here is an example: "The --package parameter uses the package alias as defined in the sfdx-project.json file to identify the package we are creating this version against."
A block of code is set as follows:
{ "packageDirectories": [ { "path": "force-app", "package": "FormulaForce App", "default": true }
When we wish to draw your attention to a particular part of a code block, the relevant lines or items are set in bold:
], "namespace": "fforce", "sfdcLoginUrl": "
https://login.salesforce.com
", "sourceApiVersion": "45.0", "packageAliases": { "FormulaForce App": "0Ho6A000000CaVxSAK" }
Any command-line input or output is written as follows:
sfdx force:org:open
Bold: Indicates a new term, an important word, or words that you see on screen. For example, words in menus or dialog boxes appear in the text like this. Here is an example: "Select System info from the Administration panel."
Get in touch
Feedback from our readers is always welcome.
General feedback: If you have questions about any aspect of this book, mention the book title in the subject of your message and email us at [email protected].
Errata: Although we have taken every care to ensure the accuracy of our content, mistakes do happen. If you have found a mistake in this book, we would be grateful if you would report this to us. Please visit www.packt.com/submit-errata, selecting your book, clicking on the Errata Submission Form link, and entering the details.
Piracy: If you come across any illegal copies of our works in any form on the internet, we would be grateful if you would provide us with the location address or website name. Please contact us at [email protected] with a link to the material.
If you are interested in becoming an author: If there is a topic that you have expertise in, and you are interested in either writing or contributing to a book, please visit authors.packtpub.com.
Reviews
Please leave a review. Once you have read and used this book, why not leave a review on the site that you purchased it from? Potential readers can then see and use your unbiased opinion to make purchase decisions, we at Packt can understand what you think about our products, and our authors can see your feedback on their book. Thank you!
For more information about Packt, please visit packt.com.
Building and Publishing Your Application
The key to turning an idea into reality lies in the execution. Having the inception of an idea and getting it implemented as an application and into the hands of users is an exciting journey and one that constantly develops and evolves between you and your users. One of the great things about developing on the Lightning Platform is the support you get from the platform beyond the core engineering phase of the production process.
In this first chapter, we will use the declarative and Salesforce DX aspects of the platform to quickly build an initial version of an application that we will use throughout this book. This will give you an opportunity to get some hands-on experience with some of the packaging and installation features that are needed to release applications to subscribers. We will also take a look at the facilities available to publish your application through Salesforce AppExchange (equivalent to Apple's App Store), and finally, provide end user support.
We will then use this application as a basis for incrementally releasing new versions of the application throughout the chapters of this book, building on our understanding of enterprise application development. The following topics outline what we will achieve in this chapter:
Introducing Salesforce DX
Required organizations
Introducing the book's sample application
Package types and benefits
Creating your first managed package
Package dependencies and uploading
Supporting package upgradability
Introduction to AppExchange and creating listings
Installing and testing your package
Becoming a Salesforce partner and the benefits of doing so
Licensing
Supporting your application
Customer metrics
Trialforce and Test Drive features
Introducing Salesforce DX
Throughout this book, we will be using the Salesforce DX tool. Salesforce provides this tool for developers to perform many development and time-saving tasks, such as creating developer environments (known as Scratch Orgs), creating projects, synchronizing code with source control, creating and managing packages, and much more. In fact, it optimizes and helps you automate the entire Application Life Cycle (ALM) process for your application and package. Throughout this book, you will learn key aspects of this process, starting in this chapter.
We will dive straight into using this tool's Command Line Interface (CLI) along with an Integrated Development Environment (IDE), Microsoft Visual Studio Code (VSCode), for which Salesforce has also created many useful extensions. You do not need to be an expert in Salesforce DX to complete this book but I do recommend you take the time to complete the basic Trailhead trails: https://trailhead.salesforce.com/en/content/learn/trails/sfdx_get_started.
Introducing the book's sample application
For this book, we will use the world of Formula 1 motor car racing as the basis for a packaged application that we will build together. Formula 1 is, for me, the motor sport that is equivalent to enterprise application software, due to its scale and complexity. It is also a sport that I follow. My knowledge of both of these fields helped me when building the examples that we will use.
We will refer to our application as FormulaForce throughout this book, though please keep in mind Salesforce's branding policies when naming your own application, as they prevent the use of the word "Force" in company or product titles.
This application will focus on the data collection aspects of races, drivers, and their many statistics, utilizing platform features to structure, visualize, and process this data in both historic and current contexts.
Run the following commands to create a Salesforce DX project for your application and create a special org known as a scratch org for you to perform your development work in. This org is given the alias "dev" and set as the project default. These orgs only last 7 days (by default, the maximum is 30 days) so be sure to synchronize regularly, as described later in this chapter:
sfdx force:project:create --projectname formulaforce
cd formulaforce
sfdx force:org:create
--definitionfile config/project-scratch-def.json
--setalias dev
--setdefaultusername
code .
The .forceIgnore file allows you to control which aspects of the scratch org and your local files are synchronized. Later in this book, in Chapter 2, Leveraging Platform Features, we will cover permission sets as a means to configure security rather than using the less flexible profiles feature. In preparation for this, enter the following into the .forceIgnore file and save it. This stops any unwanted profile changes that you might directly or indirectly make from being synchronized with your project:
For this chapter, we will create some initial Custom Objects and Fields, as detailed in the following table. Do not worry about creating any custom tabs just yet. You can use your preferred approach for creating these initial objects. Ensure that you have opened your project's current scratch org by running the following command:
sfdx force:org:open
Here is a list of objects along with their field names and types:
Object
Field name and type
Season__c
Name (text)
Race__c
Name (text)
Season (Master Detail Lookup to Season)
Driver__c
Name (text)
Contestant__c
Name (Auto Number CONTEST-{00000000})
Race (Master Detail Lookup to Race)
Driver (Lookup to Driver)
The following screenshot shows the preceding objects within the Schema Builder tool, available under the Setup menu:
Once you have completed creating the preceding objects, you should synchronize them with your project:
sfdx force:source:pull
This is an important command when using Salesforce DX to ensure you always have the latest changes as a permanent record in file form. The entire project and the files representing your application can then be stored in source control from this point onward if desired. We will review these files further later.
Package types and benefits
A package is a container that holds your application components, such as Custom Objects, Apex code, Apex Triggers, Visualforce pages, Lightning Components, and so on. This makes up your application. While there are other ways to move components between Salesforce orgs, a package provides a container that you can use for your entire application or to deliver optional features by leveraging so-called extension packages.
There are two types of packages—managed and unlocked. Unlocked packages also result in the installation of components into another org; however, they can be readily modified or even deleted by the administrator of that org. While they can be used for upgrades, changes made in an installation org will be overwritten. Given these attributes, they are not particularly ideal from a support perspective. Moreover, the Apex code that you write is also visible for all to see, so your intellectual property is at risk.
The features and benefits of managed packages
This book focuses solely on managed packages. Managed packages have the following features, which are ideal for distributing your application. The org where your application package is installed is referred to as a subscriber org since users of this org subscribe to the services your application provides:
Intellectual Property (IP) protection
: Users in the subscriber org cannot see your Apex source code, although they can see your Visualforce pages code and static resources. While the Apex code is hidden, JavaScript code is not, so you may want to consider using a minify process to partially obscure such code.
The naming scope
: Your component names are unique to your package throughout the utilization of a namespace. This means that, even if you have object
X
in your application, and the subscriber has an object of the same name, they remain distinct. You will define a namespace later in this chapter.
The governor scope
: The code in your application executes within its own governor limit scope (such as DML and SOQL governors, which are subject to passing a Salesforce security review) and is not affected by other applications or code within the subscriber org. Note that some governors, such as the CPU time governor, are shared by the whole execution context (discussed in
Chapter 4
,
Apex Execution and Separation of Concerns
), regardless of the namespace.
Upgrades and versioning
: Once subscribers have started using your application, creating data, making configurations, and so on, you will want to provide upgrades and patches with new versions of your application.
Feature management:
Allows you to enable, disable, and track the use of features you create in your application.
Analytics:
Allows you to receive anonymous data from Salesforce relating to the use of components such as pages and objects in your application. You can use this information, for example, to monitor the adoption of new features you release.
There are other benefits to managed packages, but these are only accessible after becoming a Salesforce partner and completing the security review process; these benefits are described later in this chapter. Salesforce provides ISVforce Guide (otherwise known as the Packaging Guide) in which these topics are discussed in depth – bookmark it now! The ISVforce Guide can be found at http://login.salesforce.com/help/pdfs/en/salesforce_packaging_guide.pdf.
Creating your first managed package
Packages and subsequent versions are created using Salesforce DX CLI commands. The steps to be performed are:
Setting your package namespace
Creating the package and assigning it to the namespace
Adding components to the package
These steps will be discussed in the following sections.
Setting and registering your package namespace
An important decision when creating a managed package is the namespace; this is a prefix applied to all your components (Custom Objects, Visualforce pages, Lightning Components, and so on) and is used by developers in subscriber orgs to uniquely distinguish between your packaged components and others, even those from other packages. The namespace prefix is an important part of the branding of the application since it is implicitly attached to any Apex code or other components that you include in your package.
The namespace can be up to 15 characters, though I personally recommend that you keep it to less than this, as it becomes hard to remember and leads to frustrating typos if you make it too complicated. I would also avoid the underscore character as well. It is a good idea to have a naming convention if you are likely to create more managed packages in the future. The following is the format of an example naming convention:
[company acronym - 1 to 4 characters][package prefix 1 to 4 characters]
For example, the ACME Corporation's Road Runner application might be named acmerr.
Log in to the namespace org discussed earlier in this chapter. Navigate to the Packages page (accessed under the Setup menu, under the Create submenu). Click on the Edit button to begin a short wizard to enter your desired namespace. This can only be done once and must be globally unique (meaning it cannot be set in any other org), much like a website domain name.
The following screenshot shows the Packages page:
Once you have set the namespace, the preceding page should look like the following screenshot, with the difference being that it is now showing the namespace prefix that you have used and that managed packages can now also be created. You are now ready to create a managed package and assign it to the namespace:
You can now log out from the namespace org – it is no longer needed from this point on. Log in to your Dev Hub org and register your namespace with Salesforce DX. This allows you to create scratch orgs that use that namespace, allowing you to develop your application in a way that more closely represents its final form. Salesforce provides an excellent guide on registering your namespace at https://developer.salesforce.com/docs/atlas.en-us.sfdx_dev.meta/sfdx_dev/sfdx_dev_reg_namespace.htm.
Creating the package and assigning it to the namespace
Return to VSCode and edit your sfdx-project.json file to reference the namespace:
{ "packageDirectories": [ { "path": "force-app", "default": true } ], "namespace": "fforce", "sfdcLoginUrl": "https://login.salesforce.com", "sourceApiVersion": "45.0"}To create your package and register it with your DevHub, run the following command:
sfdx force:package:create
--name "FormulaForce App"
--description "FormulaForce App"
--packagetype Managed
--path force-app
Once the command completes, review your sfdx-project.json file again; it should look like the example that follows. In the following example, the ID starting with 0Ho will vary:
{ "packageDirectories": [ { "path": "force-app", "package": "FormulaForce App", "default": true } ], "namespace": "fforce", "sfdcLoginUrl": "https://login.salesforce.com", "sourceApiVersion": "45.0", "packageAliases": { "FormulaForce App": "0Ho6A000000CaVxSAK" }}
Adding components to the package
In this book, the contents of your project's /force-app package directory folder will become the source of truth for the components that are included in each release of your package. The following layout shows what your application should look like in source file form so far:
├── LICENSE
├── README.md
├── config
│ └── project-scratch-def.json
├── force-app
│ └── main
│ └── default
│ ├── layouts
│ │ ├── Contestant__c-Contestant\ Layout.layout-meta.xml
│ │ ├── Driver__c-Driver\ Layout.layout-meta.xml
│ │ ├── Race__c-Race\ Layout.layout-meta.xml
│ │ └── Season__c-Season\ Layout.layout-meta.xml
│ └── objects
│ ├── Contestant__c
│ │ ├── Contestant__c.object-meta.xml
│ │ └── fields
│ │ ├── Driver__c.field-meta.xml
│ │ └── Race__c.field-meta.xml
│ ├── Driver__c
│ │ └── Driver__c.object-meta.xml
│ ├── Race__c
│ │ ├── Race__c.object-meta.xml
│ │ └── fields
│ │ └── Season__c.field-meta.xml
│ └── Season__c
│ └── Season__c.object-meta.xml
└── sfdx-project.json
To create the first release of your package, run the following command (all on one line):
sfdx force:package:version:create
--package "FormulaForce App"
--definitionfile config/project-scratch-def.json
--wait 10 --installationkeybypass
Some things to note about the previous command line parameters are as follows:
The
--package
parameter uses the package alias as defined in the
sfdx-project.json
