Skip to content

forcedotcom/sf-skills / plugins/builder/integration/skills/integration-connectivity-generate

integration-connectivity-generate

Verified

Salesforce integration architecture and runtime plumbing with 120-point scoring. Use this skill to set up Named Credentials, External Credentials, External Services, REST/SOAP callout patterns, Platform Events, and Change Data Capture. TRIGGER when: user sets up Named Credentials, External Services, REST/SOAP callouts, Platform Events, CDC, or touches .namedCredential-meta.xml files. DO NOT TRIGGER when: Connected App/OAuth config (use integration-connectivity-connected-app-configure), Apex-only logic (use platform-apex-generate), data import/export (use platform-data-manage), or CDC channel-membership metadata such as PlatformEventChannel, PlatformEventChannelMember, or EnrichedField (use integration-eventing-cdc-configure).

FileKindSize
README.mdmarkdown3.5 KB
SKILL.mdskill md8.8 KB
assets/callouts/callout-retry-handler.clsother6.0 KB
assets/callouts/http-response-handler.clsother8.5 KB
assets/callouts/rest-queueable-callout.clsother8.8 KB
assets/callouts/rest-sync-callout.clsother7.4 KB
assets/cdc/cdc-handler.clsother8.4 KB
assets/cdc/cdc-subscriber-trigger.triggerother5.3 KB
assets/endpoint-security/example.cspTrustedSite-meta.xmlconfig1.8 KB
assets/endpoint-security/example.remoteSite-meta.xmlconfig1.3 KB
assets/external-credentials/jwt-external-credential.externalCredential-meta.xmlconfig3.2 KB
assets/external-credentials/oauth-external-credential.externalCredential-meta.xmlconfig3.0 KB
assets/external-services/external-service-operations.mdmarkdown5.5 KB
assets/external-services/openapi-registration.externalServiceRegistration-meta.xmlconfig4.8 KB
assets/named-credentials/certificate-auth.namedCredential-meta.xmlconfig2.2 KB
assets/named-credentials/custom-auth.namedCredential-meta.xmlconfig2.2 KB
assets/named-credentials/oauth-client-credentials.namedCredential-meta.xmlconfig1.8 KB
assets/named-credentials/oauth-jwt-bearer.namedCredential-meta.xmlconfig2.2 KB
assets/platform-events/event-publisher.clsother6.4 KB
assets/platform-events/event-subscriber-action.clsother9.5 KB
assets/platform-events/event-subscriber-trigger.triggerother3.9 KB
assets/platform-events/platform-event-definition.object-meta.xmlconfig3.7 KB
assets/soap/soap-callout-service.clsother6.4 KB
assets/soap/wsdl2apex-guide.mdmarkdown6.2 KB
references/callout-patterns.mdmarkdown21.8 KB
references/cdc-guide.mdmarkdown8.2 KB
references/cli-reference.mdmarkdown2.9 KB
references/event-driven-architecture-guide.mdmarkdown10.1 KB
references/event-patterns.mdmarkdown27.2 KB
references/external-services-guide.mdmarkdown8.4 KB
references/messaging-api-v2.mdmarkdown17.9 KB
references/named-credentials-automation.mdmarkdown6.2 KB
references/named-credentials-guide.mdmarkdown7.1 KB
references/platform-events-guide.mdmarkdown6.6 KB
references/rest-callout-patterns.mdmarkdown8.8 KB
references/scoring-rubric.mdmarkdown2.4 KB
references/security-best-practices.mdmarkdown5.9 KB
scripts/README.mdmarkdown2.9 KB
scripts/configure-named-credential.shexecutablescript9.2 KB
scripts/set-api-credential.shexecutablescript4.9 KB
scripts/suggest_credential_setup.pyscript9.3 KB
scripts/templates/setup-credentials-with-csp.shexecutablescript5.9 KB
scripts/validate_integration.pyscript13.4 KB

assets/callouts/rest-queueable-callout.cls

View on GitHub
/**
 * @description Asynchronous REST Callout using Queueable
 *
 * Use Case: Callouts triggered from DML operations
 * - Trigger-based integrations
 * - Process Builder / Flow callouts
 * - Any callout after DML (insert, update, delete)
 *
 * CRITICAL: Synchronous callouts are NOT allowed after DML.
 *           Always use Queueable with Database.AllowsCallouts for such scenarios.
 *
 * Features:
 * - Implements Database.AllowsCallouts for HTTP requests
 * - Processes records in batches
 * - Includes error handling and logging
 * - Supports job chaining for pagination
 *
 * @author {{Author}}
 * @date {{Date}}
 */
public with sharing class {{ServiceName}}QueueableCallout implements Queueable, Database.AllowsCallouts {

    private static final String NAMED_CREDENTIAL = 'callout:{{NamedCredentialName}}';
    private static final Integer DEFAULT_TIMEOUT = 120000;
    private static final Integer BATCH_SIZE = 10; // Callouts per job (max 100 per transaction)

    private List<Id> recordIds;
    private String operation;
    private Integer startIndex;

    /**
     * @description Constructor for processing records
     * @param recordIds List of record IDs to process
     * @param operation Operation type (CREATE, UPDATE, DELETE, SYNC)
     */
    public {{ServiceName}}QueueableCallout(List<Id> recordIds, String operation) {
        this(recordIds, operation, 0);
    }

    /**
     * @description Constructor with pagination support
     * @param recordIds List of record IDs to process
     * @param operation Operation type
     * @param startIndex Starting index for batch processing
     */
    public {{ServiceName}}QueueableCallout(List<Id> recordIds, String operation, Integer startIndex) {
        this.recordIds = recordIds;
        this.operation = operation;
        this.startIndex = startIndex;
    }

    /**
     * @description Execute the queueable job
     * @param context QueueableContext
     */
    public void execute(QueueableContext context) {
        if (recordIds == null || recordIds.isEmpty()) {
            return;
        }

        // Calculate batch bounds
        Integer endIndex = Math.min(startIndex + BATCH_SIZE, recordIds.size());
        List<Id> batchIds = new List<Id>();
        for (Integer i = startIndex; i < endIndex; i++) {
            batchIds.add(recordIds[i]);
        }

        try {
            // Query records for this batch
            List<{{ObjectName}}> records = [
                SELECT Id, Name{{AdditionalFields}}
                FROM {{ObjectName}}
                WHERE Id IN :batchIds
                WITH USER_MODE
            ];

            // Process each record
            List<{{ObjectName}}> toUpdate = new List<{{ObjectName}}>();
            for ({{ObjectName}} record : records) {
                try {
                    processRecord(record, operation);
                    // Mark success on record if needed
                    record.Integration_Status__c = 'Success';
                    record.Integration_Date__c = Datetime.now();
                    toUpdate.add(record);
                } catch (Exception e) {
                    // Log individual record failure
                    System.debug(LoggingLevel.ERROR,
                        'Failed to process record ' + record.Id + ': ' + e.getMessage());
                    record.Integration_Status__c = 'Error';
                    record.Integration_Error__c = e.getMessage().left(255);
                    toUpdate.add(record);
                }
            }

            // Update records with sync status
            if (!toUpdate.isEmpty()) {
                update toUpdate;
            }

            // Chain next batch if more records remain
            if (endIndex < recordIds.size()) {
                System.enqueueJob(
                    new {{ServiceName}}QueueableCallout(recordIds, operation, endIndex)
                );
            }

        } catch (Exception e) {
            System.debug(LoggingLevel.ERROR, '{{ServiceName}}QueueableCallout Error: ' + e.getMessage());
            System.debug(LoggingLevel.ERROR, 'Stack Trace: ' + e.getStackTraceString());
            // Consider: Create Integration_Log__c record, send notification, etc.
        }
    }

    /**
     * @description Process a single record with external API
     * @param record The record to process
     * @param operation The operation type
     */
    private void processRecord({{ObjectName}} record, String operation) {
        switch on operation {
            when 'CREATE' {
                createExternalRecord(record);
            }
            when 'UPDATE' {
                updateExternalRecord(record);
            }
            when 'DELETE' {
                deleteExternalRecord(record.Id);
            }
            when 'SYNC' {
                syncExternalRecord(record);
            }
            when else {
                throw new IntegrationException('Unknown operation: ' + operation);
            }
        }
    }

    /**
     * @description Create record in external system
     * @param record Salesforce record
     */
    private void createExternalRecord({{ObjectName}} record) {
        Map<String, Object> payload = buildPayload(record);

        HttpRequest req = new HttpRequest();
        req.setEndpoint(NAMED_CREDENTIAL + '/{{Endpoint}}');
        req.setMethod('POST');
        req.setHeader('Content-Type', 'application/json');
        req.setTimeout(DEFAULT_TIMEOUT);
        req.setBody(JSON.serialize(payload));

        HttpResponse res = new Http().send(req);
        handleResponse(res, record.Id);
    }

    /**
     * @description Update record in external system
     * @param record Salesforce record
     */
    private void updateExternalRecord({{ObjectName}} record) {
        if (String.isBlank(record.External_Id__c)) {
            throw new IntegrationException('No external ID for record: ' + record.Id);
        }

        Map<String, Object> payload = buildPayload(record);

        HttpRequest req = new HttpRequest();
        req.setEndpoint(NAMED_CREDENTIAL + '/{{Endpoint}}/' + record.External_Id__c);
        req.setMethod('PUT');
        req.setHeader('Content-Type', 'application/json');
        req.setTimeout(DEFAULT_TIMEOUT);
        req.setBody(JSON.serialize(payload));

        HttpResponse res = new Http().send(req);
        handleResponse(res, record.Id);
    }

    /**
     * @description Delete record from external system
     * @param recordId Salesforce record ID
     */
    private void deleteExternalRecord(Id recordId) {
        // DELIBERATE: per-record query acceptable at BATCH_SIZE=10; refactor to bulk query if increasing batch size
        {{ObjectName}} record = [
            SELECT External_Id__c
            FROM {{ObjectName}}
            WHERE Id = :recordId
            WITH USER_MODE
            LIMIT 1
        ];

        if (String.isBlank(record.External_Id__c)) {
            return; // Nothing to delete externally
        }

        HttpRequest req = new HttpRequest();
        req.setEndpoint(NAMED_CREDENTIAL + '/{{Endpoint}}/' + record.External_Id__c);
        req.setMethod('DELETE');
        req.setTimeout(DEFAULT_TIMEOUT);

        HttpResponse res = new Http().send(req);
        handleResponse(res, recordId);
    }

    /**
     * @description Sync record with external system (get latest and update)
     * @param record Salesforce record
     */
    private void syncExternalRecord({{ObjectName}} record) {
        if (String.isBlank(record.External_Id__c)) {
            createExternalRecord(record);
        } else {
            updateExternalRecord(record);
        }
    }

    /**
     * @description Build API payload from Salesforce record
     * @param record Salesforce record
     * @return Payload map for API
     */
    private Map<String, Object> buildPayload({{ObjectName}} record) {
        return new Map<String, Object>{
            'salesforceId' => record.Id,
            'name' => record.Name
            // Add more field mappings as needed
        };
    }

    /**
     * @description Handle HTTP response
     * @param res HTTP response
     * @param recordId Salesforce record ID (for logging)
     */
    private void handleResponse(HttpResponse res, Id recordId) {
        Integer statusCode = res.getStatusCode();

        if (statusCode >= 200 && statusCode < 300) {
            System.debug(LoggingLevel.DEBUG, 'Success for ' + recordId + ': ' + res.getBody());
            return;
        }

        if (statusCode >= 400 && statusCode < 500) {
            throw new IntegrationException(
                'Client Error (' + statusCode + ') for ' + recordId + ': ' + res.getBody()
            );
        }

        if (statusCode >= 500) {
            throw new IntegrationException(
                'Server Error (' + statusCode + ') for ' + recordId + ': ' + res.getBody()
            );
        }
    }

    /**
     * @description Custom exception for integration errors
     */
    public class IntegrationException extends Exception {}
}
reverse-engineer-anythingmorluto/reaReverse engineer native, managed, Electron/JavaScript, packaged, firmware, and browser targets with REA, and build agent environments (AgentEnv bundles) of web applications from a live instance or a capture, and of Linux desktop apps with a task from a request. Use shipped-artifact or requested runtime evidence to explain features, compare versions, decompile code, or guide a reconstruction. Skip REA for ordinary source-repository architecture analysis.Stars: 471kUpdated Claude CodeCodexVerifiedInstall
diagnosing-superpowersobra/superpowersUse when a superpowers session went wrong and your human partner wants to know why — repeated work, ignored plans, stumbles, poor results, a skill that didn't fire, "it took too long", "why is it so expensive", "what is it doing" — or wants to build a bug report for the superpowers maintainers, for the current session or a past one identified by id or path, on any harness.Stars: 322kUpdated Claude CodeCodexVerifiedInstall
dispatching-parallel-agentsobra/superpowersUse when facing 2+ independent tasks that can be worked on without shared state or sequential dependenciesStars: 322kUpdated Claude CodeCodexVerifiedInstall
executing-plansobra/superpowersUse when executing an implementation plan in the current session as the implementer yourself — your human partner chose inline execution, or no subagent tool is availableStars: 322kUpdated Claude CodeCodexVerifiedInstall