Patterns d'intégration Apex : REST, callouts et Named Credentials

// Utilisation des Named Credentials — pas d'URL ni d'auth dans le code
public class StripeService {
 
    public static Map<String, Object> createCustomer(String email, String name) {
        HttpRequest req = new HttpRequest();
        req.setEndpoint('callout:Stripe_API/v1/customers');
        req.setMethod('POST');
        req.setHeader('Content-Type', 'application/x-www-form-urlencoded');
        req.setBody('email=' + EncodingUtil.urlEncode(email, 'UTF-8') +
                    '&name=' + EncodingUtil.urlEncode(name, 'UTF-8'));
 
        Http http = new Http();
        HttpResponse res = http.send(req);
 
        if (res.getStatusCode() == 200) {
            return (Map<String, Object>) JSON.deserializeUntyped(res.getBody());
        }
 
        throw new CalloutException('Erreur API Stripe : ' + res.getStatusCode() + ' ' + res.getBody());
    }
}

// Au lieu d'appeler l'API externe dans un trigger (bloqué par les limites),
// publiez un Platform Event et traitez de façon asynchrone
 
trigger OpportunityTrigger on Opportunity (after update) {
    List<Integration_Request__e> events = new List<Integration_Request__e>();
 
    for (Opportunity opp : Trigger.New) {
        Opportunity old = Trigger.OldMap.get(opp.Id);
        if (opp.StageName == 'Closed Won' && old.StageName != 'Closed Won') {
            events.add(new Integration_Request__e(
                Record_Id__c = opp.Id,
                Action__c = 'CREATE_DEAL'
            ));
        }
    }
 
    if (!events.isEmpty()) EventBus.publish(events);
}
 
// Un trigger séparé sur le Platform Event s'exécute dans sa propre transaction
trigger IntegrationRequestTrigger on Integration_Request__e (after insert) {
    for (Integration_Request__e event : Trigger.New) {
        // Chaque événement s'exécute dans son propre contexte async — governor limits fraîches
        ExternalCRMService.createDeal(event.Record_Id__c);
    }
}

public class RetryableCallout {
 
    private static final Integer MAX_RETRIES = 3;
    private static final List<Integer> BACKOFF_SECONDS = new List<Integer>{1, 3, 7};
 
    public static HttpResponse callWithRetry(HttpRequest req) {
        Http http = new Http();
        Integer attempt = 0;
 
        while (attempt < MAX_RETRIES) {
            HttpResponse res = http.send(req);
 
            // Succès ou erreur non retryable
            if (res.getStatusCode() < 500) return res;
 
            attempt++;
            if (attempt < MAX_RETRIES) {
                // Note : vous ne pouvez pas vraiment dormir en Apex — utilisez Queueable pour de vrais délais
                // Ce pattern est simplifié ; en production, replanifiez via un job Queueable
            }
        }
 
        throw new CalloutException('Nombre maximum de tentatives dépassé');
    }
}
 
// Vrai retry avec chaînage Queueable
public class RetryQueueable implements Queueable, Database.AllowsCallouts {
    private String recordId;
    private Integer attempt;
 
    public RetryQueueable(String recordId, Integer attempt) {
        this.recordId = recordId;
        this.attempt = attempt;
    }
 
    public void execute(QueueableContext ctx) {
        try {
            ExternalCRMService.createDeal(recordId);
        } catch (Exception e) {
            if (attempt < 3) {
                System.enqueueJob(new RetryQueueable(recordId, attempt + 1));
            } else {
                // Journaliser dans un objet personnalisé ou envoyer une alerte
                ErrorLog__c log = new ErrorLog__c(
                    Record_Id__c = recordId,
                    Error__c = e.getMessage()
                );
                insert log;
            }
        }
    }
}

// Option 1 : deserializeUntyped — flexible mais non typé
Map<String, Object> response = (Map<String, Object>) JSON.deserializeUntyped(res.getBody());
String customerId = (String) response.get('id');
List<Object> items = (List<Object>) response.get('items');
 
// Option 2 : Classe typée — type-safe, recommandée pour les schémas connus
public class StripeCustomer {
    public String id;
    public String email;
    public Long created;
    public StripeAddress address;
 
    public class StripeAddress {
        public String city;
        public String country;
    }
}
 
StripeCustomer customer = (StripeCustomer) JSON.deserialize(res.getBody(), StripeCustomer.class);
String customerId = customer.id;
 
// Option 3 : JSONParser pour les réponses très grandes ou complexes
JSONParser parser = JSON.createParser(res.getBody());
while (parser.nextToken() != null) {
    if (parser.getCurrentToken() == JSONToken.FIELD_NAME && parser.getText() == 'id') {
        parser.nextToken();
        String id = parser.getText();
    }
}

@isTest
global class StripeApiMock implements HttpCalloutMock {
    private Integer statusCode;
    private String body;
 
    global StripeApiMock(Integer statusCode, String body) {
        this.statusCode = statusCode;
        this.body = body;
    }
 
    global HTTPResponse respond(HTTPRequest req) {
        HTTPResponse res = new HTTPResponse();
        res.setStatusCode(statusCode);
        res.setBody(body);
        res.setHeader('Content-Type', 'application/json');
        return res;
    }
}
 
@isTest
static void testCreateCustomerSuccess() {
    String mockBody = '{"id": "cus_123", "email": "test@example.com"}';
    Test.setMock(HttpCalloutMock.class, new StripeApiMock(200, mockBody));
 
    Test.startTest();
    Map<String, Object> result = StripeService.createCustomer('test@example.com', 'Utilisateur Test');
    Test.stopTest();
 
    System.assertEquals('cus_123', result.get('id'));
}
 
@isTest
static void testCreateCustomerError() {
    Test.setMock(HttpCalloutMock.class, new StripeApiMock(400, '{"error": {"message": "Invalid email"}}'));
 
    Test.startTest();
    try {
        StripeService.createCustomer('invalid', 'Test');
        System.assert(false, 'Exception attendue');
    } catch (CalloutException e) {
        System.assert(e.getMessage().contains('400'));
    }
    Test.stopTest();
}