Format:
1 Online-Ressource (xxiv, 681 Seiten)
Edition:
Fourth edition
ISBN:
9781804614440
Note:
Description based on publisher supplied metadata and other sources
,
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 -- Dependent 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 -- 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 -- 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 -- 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 -- 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 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 -- Summary -- 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 -- Summary -- 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 -- Naming conventions -- Bulkification -- Defining and passing data -- Transaction management -- 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 -- Updating the FormulaForce package -- Summary -- Chapter 7: Application Selector Layer -- Introducing the Selector layer pattern -- Implementing design guidelines -- Security conventions -- Naming conventions -- Bulkification -- 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 -- Enforcing security -- 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 -- Updating the FormulaForce package -- Summary -- 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
Additional Edition:
Erscheint auch als Druck-Ausgabe Fawcett, Andrew Salesforce Platform Enterprise Architecture Birmingham : Packt Publishing, Limited,c2023
Additional Edition:
Erscheint auch als Druck-Ausgabe ISBN 978-1-80461-977-3
Language:
English
URL:
Volltext
(URL des Erstveröffentlichers)
Bookmarklink
