Trigger handler induced design damage

There is a great series of discussions including videos on the subject of the benefits and costs of test driven development. Part of that discussion is the notion of Test-induced design damage where pursuing one principle – testability – to the exclusion of other principles results in damage to the design.

An area in Salesforce where I see risk of damage is the pursuit of this:

Another widely-recognized best practice is to make your Triggers logic-less. That means, the role of the Trigger is just to delegate the logic responsibilities to some other handler class.

quoted from Trigger Frameworks and Apex Trigger Best Practices and often paraphrased. (The term “best practice” is sometimes used to give an idea unmerited gravitas.)

There can be benefits in using separate classes, typically where the logic being implemented has enough complexity to require multiple methods and static constants. Or if a choice has been made to use a carefully selected trigger framework (and not an unproven local invention). And a mixed model – where some code is in the trigger and other parts are moved to classes as needed – also works.

But there are costs:

  • A reduction in cohesion: the logic has moved to a class that is separate from the execution context that includes a number of subtleties as documented in Trigger Context Variables.
  • Over time as more logic is added, the chances of queries being repeated in separate handler class methods or separate handler classes goes up.
  • Some naming challenges: what should the handler class, methods and method parameters be called? And the clutter of more top level classes in an org.
  • Should the test relate to the trigger (the specific context the logic has to run in) or the handler class (with no assumed context)?
  • A risk of failure to bulkify. A handler class that has methods that accept single values rather than collections is an obvious red flag. But with the trigger context not so directly in view when writing the handler class and logic running several method calls down, bulkification can be missed.

Code in a trigger is just like any other code and should be written to Do The Simplest Thing That Could Possibly Work. If the problem being solved can be solved cleanly by keeping the code in the trigger then do that. If not, introduce a class to solve the part of the problem that needs a class. Be prepared to refactor when logic is added later.

The Apex Code Best Practices documentation says “Bulkify your Helper Methods” – if you have any. Those helper methods and classes are not assumed.

Don’t damage your code base by introducing a pattern where the benefits are outweighed by the costs.


Three books all Salesforce developers should read

I’ve recently been writing some Salesforce coding guidelines for new hires that say explicitly what is implicit in our code base. A difficulty is deciding where to stop, so in the end I thought the best thing to do was to also include an as short as possible reading list.

Here is what I chose:

  • Clean Code by Robert C. Martin
    How to write better code. A great book about software craftsmanship whatever language and stack you use.
  • Advanced Apex Programming by Dan Appleman
    The unique features of Salesforce and patterns to address the hard parts. With its help you will be able to write Apex code that works all the time not most of the time.
  • Effective JavaScript by David Herman
    JavaScript is becoming increasingly important. This is a book that will give you real insight into how the language works and the typical patterns you need to use the language well. (I’ve read several modern JavaScript books and I found this by far the best.)

What books would you choose?

Referencing one controller extension from another controller extension

A controller extension can add functionality to a standard controller. The controller extension coding pattern means an extension gets a reference to the standard controller and so can uses its methods:

public with sharing class Ext1 {
    public Ext1(ApexPages.StandardController sc) {

But what if you have a page with two extensions:

<apex:page standardController="Contact" extensions="Ext1, Ext2">

and you want to reference the methods of one extension from the other extension? No platform API is provided for that.

Here is some code that allows such cross-referencing. When the extensions are constructed, they are added (registered) into a singleton (static) instance. But a reference to that singleton is also made a field in each extension ensuring that the extension references are made part of the view state. So the cross-references are preserved across form posts etc.

The extensions look like this:

public with sharing class Ext1 {
    private Registry r;
    public Ext1(ApexPages.StandardController sc) {
        r = Registry.instance();
        r.add(Ext1.class, this);
    private Ext2 getExt2() {
        return (Ext2) r.get(Ext2.class);
public with sharing class Ext2 {
    private Registry r;
    public Ext2(ApexPages.StandardController sc) {
        r = Registry.instance();
        r.add(Ext2.class, this);
    private Ext1 getExt1() {
        return (Ext1) r.get(Ext1.class);

and the singleton is:

public class Registry {
    private static Registry instance;
    private Map<Type, Object> m = new Map<Type, Object>();
    // Set a view state field to this
    public static Registry instance() {
        if (instance == null) instance = new Registry();
        return instance;
    // Singleton
    private Registry() {
    public void add(Type key, Object value) {
        m.put(key, value);
    public Object get(Type key) {
        return m.get(key);

My week with Heroku Connect

Heroku Connect replicates and synchronises data between a Salesforce org and a Heroku Postgres database. So you can build an app in Heroku using one of seven technologies (including Node.js), hook that app up to the Postgres database, and then your app users will be able to see and modify the same data that the Salesforce users see and modify. Bear in mind that this mechanism allows you to share data: it does not allow you to share business logic.

As this solution is built in/on Heroku, it is incredibly easy to setup and get working; I had the Demo Edition setup and the first couple of SObjects working inside an hour. The mapping UI involves a lot of checkbox clicking, but once done the configuration can be exported and imported. The UI provides overview and drill-down on what is going on. One minor problem I had was quickly and efficiently sorted out by Heroku support. All good.

The clean and simple scenario is where the Postgres data is largely handled as read-only. Then (besides whatever technologies you are writing the Heroku app in) the main thing to get used to is that you are writing SQL not SOQL. Also there are two identifier values: the SFID which is the 18 character (case insensitive) Salesforce ID we are used to and a local Postgres integer ID. Foreign key fields from Salesforce reference the SFID not the ID.

Things get more awkward when you want to insert or update the Postgres data. Heroku Connect handles the synchronisation in that direction too, but some aspects of the implementation leak out:

  • The SFID is not available in the transaction where an insert is done (as it is allocated in Salesforce). In my very limited tests, it was available about a second later.
  • Fields such as CreatedDate and any fields populated by Salesforce logic such as insert or update triggers will remain empty until the next synchronization is done; in the basic polling mode that can be up to 10 minutes later. So your users may experience blank fields in the UI when they insert data that change to populated fields when the UI is refreshed 10 minutes later.

Inserting objects into Postgres that have parent/child relationships is awkward. For master/detail, the required pattern is documented in Inserting records with master/detail relationships using external IDs. It requires an “External ID” field to be added to the Salesforce objects (so is a little intrusive at that side) and the Heroku code needs to populate that field and (an automatically added) foreign key with a matching unique value. This then allows Salesforce to create the same master/detail relationship using the normal Salesforce identifier. I don’t know if, but do hope that, the Salesforce foreign key is pushed back into Postgres fairly immediately like the SFID is. There is no mention of how to accomplish this for lookup relationships.

I must mention the pleasure and productivity of writing the full application stack in one language and in JavaScript: AngularJS for the client and Node.js/Express/pg-promise/Passport for the server. All quick to get running for existing Salesforce data thanks to Heroku and Heroku Connect.

Picklist values by record type for AngularJS UI

A convenient Apex API to get the picklist value sub-set per record type has yet to appear. Visualforce does the sub-setting, but that is no help if you are building UI in some other technology such as AngularJS and want the select lists to reflect the sub-setting.

Here is a work-around for that situation, where the aim is to provide JSON to the AngularJS client-side code via a static resource. An API that provides access to both record types and static resources is the Metadata API. Thanks to Andrew Fawcett‘s work (see financialforcedev/apex-mdapi) and improvements in the underlying Salesforce API, this API is now quite simple to call from Apex code.

In the code below, the readPicklists method reads the record type information for 5 record types of a custom SObject called cve__BenefitClaimed__c. (This SObject and its record types are in a managed package that has the namespace prefix cve. Note also that it is the developer name of the record type that is used.) The picklist value data is extracted and placed in nested maps where the first key is the SObject type name, the second key the record type (developer) name and the third key the field name with the value a list of valid picklist values. The updateStaticResource method updates a pre-existing static resource (in a managed package that has the namespace prefix cveep) with the JSON string version of the nested maps.

I run this from a Visualforce admin page. If the picklist assignments are changed, the code is manually re-run.

The result is that the AngularJS code can use its $http service to get the static resource. The data is pre-created and so available quickly, and is also already in JSON format so is easy for the AngularJS code to consume.

Here is the code; sorry it’s rather wide…

public PageReference updatePicklists() {
    final String[] recordTypeFullNames = new String[] {
    final String staticResourceFullName = 'cveep__RecordTypePicklistValues';
    MetadataService.MetadataPort service = new MetadataService.MetadataPort();
    service.SessionHeader = new MetadataService.SessionHeader_element();
    service.SessionHeader.sessionId = UserInfo.getSessionId();
    String jsonString = readPicklists(service, recordTypeFullNames);
    updateStaticResource(service, staticResourceFullName, jsonString);
    return null;

private String readPicklists(MetadataService.MetadataPort service, String[] recordTypeFullNames) {
    Map<String, Map<String, Map<String, List<String>>>> sobMap = new Map<String, Map<String, Map<String, List<String>>>>();
    for (MetadataService.RecordType rt : (MetadataService.RecordType[]) service.readMetadata('RecordType', recordTypeFullNames).getRecords()) {
        MetadataService.RecordTypePicklistValue[] values = rt.picklistValues;
        if (rt.fullName != null && rt.picklistValues != null) {
            String[] parts = rt.fullName.split('\\.');
            String sobjectType = parts[0];
            String recordType = parts[1];
            Map<String, Map<String, List<String>>> rtMap = sobMap.get(sobjectType);
            if (rtMap == null) {
                rtMap = new Map<String, Map<String, List<String>>>();
                sobMap.put(sobjectType, rtMap);
            Map<String, List<String>> fieldMap = rtMap.get(recordType);
            if (fieldMap == null) {
                fieldMap = new Map<String, List<String>>();
                rtMap.put(recordType, fieldMap);
            for (MetadataService.RecordTypePicklistValue picklist : rt.picklistValues) {
                if (picklist.values != null) {
                    List<String> valueList = fieldMap.get(picklist.picklist);
                    if (valueList == null) {
                        valueList = new List<String>();
                        fieldMap.put(picklist.picklist, valueList);
                    for (MetadataService.PicklistValue value : picklist.values) {
    return JSON.serialize(sobMap);

private void updateStaticResource(MetadataService.MetadataPort service, String staticResourceFullName, String jsonString) {
    MetadataService.StaticResource sr = new MetadataService.StaticResource();
    sr.fullName = staticResourceFullName;
    sr.contentType = 'text/json';
    sr.cacheControl = 'public';
    sr.content = EncodingUtil.base64Encode(Blob.valueOf(jsonString));
    MetadataService.SaveResult[] results = service.updateMetadata(new MetadataService.StaticResource[] {sr});
    for (MetadataService.SaveResult r : results) {
        if (!r.success) {
            String[] errors = new String[] {};
            if (r.errors != null) {
                for (MetadataService.Error e : r.errors) {
                    errors.add('message=' + e.message + ' statusCode=' + e.statusCode + ' fields=' + e.fields);
            throw new EndUserMessageException('Error: ' + String.join(errors, '; '));

PS A maximum of 10 record types can be read at once so use multiple calls if you require more than 10.

Adding JavaScript and jQuery to Visualforce pages

Visualforce is pretty tolerant of how custom JavaScript is added, but this post suggests a couple of patterns to use (where possible):

  • External JavaScript file references or local JavaScript is best placed at the end of the page rather than the beginning which looks a bit strange at first sight. The benefit is that the page content can then be rendered by the browser before the browser becomes blocked loading the external JavaScript file and then executing that file and the local Javascript. So a potential page load delay is avoided, with the JavaScript work being completed in the user’s “thinking time” as they first see the page content.
  • It is easy to unintentionally add references to Javascript’s global scope and so potentially interfere with other references in that scope. In JavaScript scope is delineated by functions (not by blocks – curly brackets have no impact on scope) so var declarations should always be used and should always be used within a function.

So when not using external libraries put this executed (via the ()) anonymous JavaScript function (to create a new scope) at the end of the page:

<apex:page ...>
    <apex:sectionHeader .../>
    <apex:pageBlock ...>

(function() {
    // All the custom JavaScript goes in here
    // Always use var
    var i = ...;

and when using jQuery put both the include and the executed anonymous JavaScript function at the end of the page:

<apex:page ...>
    <apex:sectionHeader .../>
    <apex:pageBlock ...>

<apex:includeScript value="{!URLFOR($Resource.jQueryZip, 'jquery.js')}"/>
(function($) {
    // All the custom JavaScript goes in here
    // Always use var
    var i = ...;
    // Use $ in here for jQuery
    var j = $('table.notes');

This allows $ to be used as the reference to jQuery within the function, while ensuring that whatever the symbol $ was set to before jQuery was included is restored via the noConflict call.

Creating a custom global describe API using @RestResource

A colleague is working on a client that needs to know all the SObject names and all the field names within those SObjects. The Apex describe APIs provide this information but also a lot of other information that is not required in this case. So it is worth doing work at the server-side to cut down the information to only what is required by the client.

(In the org in question, the 300 SObjects produce JSON output of 800 kB, well below the 3 MB governor limit on HTTP responses.)

Salesforce’s @RestResource mechanism makes doing this pretty easy. The code below transfers the required information into instances of simple Apex classes, sorts the data based on label first then API name second, and then leaves it up to the platform to serialise those as JSON:

global with sharing class DescribeRest {

    global class Sob implements Comparable {
        public String sobLabel;
        public String sobApi;
        public Field[] sobFields;
        Sob(SObjectType t) {
            DescribeSObjectResult r = t.getDescribe();
            sobLabel = r.getLabel();
            sobApi = r.getName();
            sobFields = new Field[] {};
            for (SObjectField f : r.fields.getMap().values()) {
                sobFields.add(new Field(f));
        public Integer compareTo(Object o) {
            Sob that = (Sob) o;
            if (this.sobLabel < that.sobLabel) return -1;
            else if (this.sobLabel > that.sobLabel) return 1;
            else {
                if (this.sobApi < that.sobApi) return -1;
                else if (this.sobApi > that.sobApi) return 1;
                else return 0;
    global class Field implements Comparable {
        public String label;
        public String api;
        Field(SObjectField f) {
            DescribeFieldResult r = f.getDescribe();
            label = r.getLabel();
            api = r.getName();
        public Integer compareTo(Object o) {
            Field that = (Field) o;
            if (this.label < that.label) return -1;
            else if (this.label > that.label) return 1;
            else {
                if (this.api < that.api) return -1;
                else if (this.api > that.api) return 1;
                else return 0;
    global static Sob[] get() {
        Sob[] sobs = new Sob[] {};
        for (SObjectType t : Schema.GetGlobalDescribe().values()) {
            sobs.add(new Sob(t));
        return sobs;

When accessed using /services/apexrest/cveep/v1/describe.json, this produces JSON (formatted here to better illustrate the structure) taking about 10ms per object at the server-side:

            {"label":"Absence Type","api":"Type__c"},

Now that the governor limits have been removed on describe calls the first limit that will be hit is probably the 3 MB response size limit.