Mastering Salesforce Apex: An Introduction to Custom Metadata Relationships

Salesforce Apex is a powerful programming language designed specifically for developers working on the Salesforce platform. One of its more advanced, yet incredibly useful features, is the ability to create and manage custom metadata relationships. This capability allows developers to create scalable, reusable, and configuration-driven solutions. Let’s dive into this topic and explore how you can leverage Apex to build more dynamic applications using custom metadata.

What Are Custom Metadata Relationships?

Custom metadata types store configuration data, much like custom objects, but they are optimized for metadata operations. They’re widely used to define rules, thresholds, mappings, and relationships that can control application behavior without changing Apex code. Custom metadata relationships extend this functionality by linking custom metadata types to other Salesforce metadata, custom objects, or each other.

Why Use Custom Metadata Relationships?

1. Reduced Dependency on Hard-Coded Logic: Custom metadata relationships allow you to drive application logic without hardcoding field names, IDs, or relationships.

2. Scalability: By using custom metadata, changes can be made declaratively, which ensures your code remains flexible and adaptable.

3. Performance: Custom metadata queries are cached and faster than SOQL queries on custom objects.

4. Migration-Friendly: Custom metadata types can be easily deployed across environments using change sets or metadata APIs.

Example Use Case: Dynamic Field Mapping

Imagine you’re tasked with mapping fields between the Lead and Opportunity objects during a lead conversion process. Instead of hardcoding the field mappings in your Apex class, you can use a custom metadata type to define these relationships.

Step 1: Define a Custom Metadata Type

Create a custom metadata type named Field Mapping with the following fields:

• Source Object (Text): The API name of the source object (e.g., Lead).

• Source Field (Text): The API name of the source field (e.g., Company).

• Target Object (Text): The API name of the target object (e.g., Opportunity).

• Target Field (Text): The API name of the target field (e.g., AccountName).

Step 2: Populate Metadata Records

Add records to the custom metadata type to define the field mappings. For example:

Source Object	Source Field	Target Object	Target Field
Lead	Company	Opportunity	AccountName
Lead	Industry	Opportunity	Industry

Step 3: Query Custom Metadata in Apex

Write an Apex method to dynamically retrieve these mappings and process the field transfer during lead conversion:

public with sharing class FieldMappingService {

    public static void mapFields(SObject sourceRecord, SObject targetRecord) {

        // Query custom metadata for mappings

        List<Field_Mapping__mdt> mappings = [

            SELECT Source_Object__c, Source_Field__c, Target_Object__c, Target_Field__c

            FROM Field_Mapping__mdt

            WHERE Source_Object__c = :sourceRecord.getSObjectType().getDescribe().getName()

        ];

        // Dynamically map fields based on metadata

        for (Field_Mapping__mdt mapping : mappings) {

            String sourceField = mapping.Source_Field__c;

            String targetField = mapping.Target_Field__c;

            // Use SObject get/put to transfer field values

            if (sourceRecord.containsField(sourceField)) {

                targetRecord.put(targetField, sourceRecord.get(sourceField));

            }

        }

    }

}

Step 4: Use the Service in Your Logic

During the lead conversion process, you can call this service:

Lead leadRecord = [SELECT Id, Company, Industry FROM Lead WHERE Id = :leadId];

Opportunity opportunityRecord = new Opportunity();

FieldMappingService.mapFields(leadRecord, opportunityRecord);

insert opportunityRecord;