Exposing Salesforce Flows as API Endpoints: A No-Code Approach

Sushant Khandagale — Mon, 29 Jul 2024 14:30:34 +0000

Salesforce's Flow Builder is a powerful tool that enables you to automate business processes without writing code. In this guide, I'll show you how to leverage this tool to expose Salesforce Flows as API endpoints, allowing other systems to interact with Salesforce without the need for Apex code.

Step 1: Create the Autolaunched Flow

Navigate to Flow Builder:
- Go to Setup > Process Automation > Flows.
- Click New Flow.
- Select Autolaunched Flow (No Trigger).
Define Input Variables:
- Click New Resource and select Variable.
- Set the API Name to inputParam, Data Type to Text, and check the box Available for input.
Add Your Logic:
- Add the necessary elements (e.g., Get Records, Update Records, Create Records) to define the logic of your Flow. Use the inputParam variable as needed.
Save and Activate:
- Name your Flow appropriately and save it.
- Click Activate to make your Flow live.

Step 2: Generate the Flow URL

Ensure Lightning Runtime for Flows is Enabled:
- Go to Setup > Process Automation Settings.
- Make sure Enable Lightning Runtime for Flows is checked.

Construct the Flow URL:

Navigate to your Flow's details page.
The URL format to call the Flow is:

 https://yourInstance.salesforce.com/services/data/vXX.X/actions/custom/flow/Your_Flow_API_Name

Replace yourInstance with your Salesforce instance (e.g., na1, eu2).
Replace XX.X with the API version you want to use (e.g., v56.0).
Replace Your_Flow_API_Name with the API name of your Flow.

Step 3: Call the Flow from an External System

Prepare the HTTP Request:
- The external system can make an HTTP POST request to the Flow URL.
- The request body should include the input parameters in JSON format. For example:
```
 {
   "inputs": [
     {
       "inputParam": "Your Input Value"
     }
   ]
 }
```

Sample cURL Command:

Here's a sample cURL command to invoke the Flow:

 curl -X POST https://yourInstance.salesforce.com/services/data/vXX.X/actions/custom/flow/Your_Flow_API_Name \
 -H "Authorization: Bearer YOUR_ACCESS_TOKEN" \
 -H "Content-Type: application/json" \
 -d '{
       "inputs": [
         {
           "inputParam": "Your Input Value"
         }
       ]
     }'

Conclusion

By following these steps, you can expose Salesforce Flows as API endpoints, allowing external systems to interact with Salesforce without writing any Apex code. This no-code solution simplifies the integration process, making it more accessible for Salesforce administrators and reducing the dependency on developers.

Embrace the power of Salesforce Flows and explore how this no-code approach can enhance your organization's integration capabilities. If you have any

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

Sushant Khandagale — Mon, 29 Jul 2024 12:33:52 +0000

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

Simplified Codebase: Reduce the number of conditional statements.
Scalability: Easily add new conditions or rules.
Maintainability: Administrators can manage logic without code changes.
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.

DEV Community: Sushant Khandagale

Exposing Salesforce Flows as API Endpoints: A No-Code Approach

Step 1: Create the Autolaunched Flow

Step 2: Generate the Flow URL

Step 3: Call the Flow from an External System

Conclusion

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

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

Introduction

Benefits of Using Custom Metadata

Implementing Custom Metadata in Apex

Step 1: Define Custom Metadata

Step 2: Use Custom Metadata in Apex Code

Step 1: Fetch Custom Metadata in Apex Controller

Step 2: Use Custom Metadata in LWC