Optimizing Code with Custom Metadata: A Scalable Solution for Apex and LWC

Introduction

Managing complex logic in both Apex and Lightning Web Components (LWC) can be challenging. Leveraging custom metadata can help externalize configuration and decision-making logic, reducing hard-coded conditions and making your codebase more flexible and scalable.

Benefits of Using Custom Metadata

1. Simplified Codebase: Reduce the number of conditional statements.
2. Scalability: Easily add new conditions or rules.
3. Maintainability: Administrators can manage logic without code changes.
4. Code Coverage: Simpler tests and better coverage.

Implementing Custom Metadata in Apex

Step 1: Define Custom Metadata

Create a custom metadata type to store conditions and actions.

public class CustomMetadataUtil {
    public static List<MyCustomMetadata__mdt> getAllMetadata() {
        return [SELECT Name, Condition__c, Action__c FROM MyCustomMetadata__mdt];
    }
}

Step 2: Use Custom Metadata in Apex Code

Replace conditional logic with a loop that processes custom metadata records.

public class MyServiceClass {
    public void processConditions() {
        List<MyCustomMetadata__mdt> metadataList = CustomMetadataUtil.getAllMetadata();

        for (MyCustomMetadata__mdt metadata : metadataList) {
            if (evaluateCondition(metadata.Condition__c)) {
                performAction(metadata.Action__c);
            }
        }
    }

    private Boolean evaluateCondition(String condition) {
        // Implement condition evaluation logic
    }

    private void performAction(String action) {
        // Implement action logic
    }
}

Implementing Custom Metadata in LWC

Step 1: Fetch Custom Metadata in Apex Controller

Create an Apex controller method to fetch custom metadata records.

public with sharing class MyMetadataController {
    @AuraEnabled(cacheable=true)
    public static List<MyCustomMetadata__mdt> getMetadata() {
        return CustomMetadataUtil.getAllMetadata();
    }
}

Step 2: Use Custom Metadata in LWC

Fetch metadata in the LWC component and use it to drive the component's behavior.

import { LightningElement, wire } from 'lwc';
import getMetadata from '@salesforce/apex/MyMetadataController.getMetadata';

export default class MyComponent extends LightningElement {
    metadataList;

    @wire(getMetadata)
    wiredMetadata({ error, data }) {
        if (data) {
            this.metadataList = data;
            this.processMetadata();
        } else if (error) {
            // Handle error
        }
    }

    processMetadata() {
        this.metadataList.forEach(metadata => {
            if (this.evaluateCondition(metadata.Condition__c)) {
                this.performAction(metadata.Action__c);
            }
        });
    }

    evaluateCondition(condition) {
        // Implement condition evaluation logic
    }

    performAction(action) {
        // Implement action logic
    }
}

Conclusion
Using custom metadata to define rules avoids hardcoding conditions into your Apex and LWC code. This approach enhances flexibility, maintainability, and scalability, making your application easier to update and deploy.