Utilisation des Pipelines pour structurer le flux de traitement en Laravel(Partie 1)

Laravel regorge de fonctionnalités puissantes et souvent sous-exploitées. Parmi elles, les Pipelines (ou "tuyaux") offrent un moyen élégant de structurer des flux de traitement complexes en les découpant en étapes modulaires. Que vous traitiez des données, gériez des requêtes HTTP ou orchestriez des workflows métier, les Pipelines peuvent simplifier votre code et le rendre plus maintenable. Découvrons ensemble comment les utiliser !

---

Qu'est-ce qu'un Pipeline ?

Un Pipeline est un design pattern qui permet de faire passer un objet (une requête, une donnée, etc.) à travers une série d'étapes de traitement (pipes), chacune ayant une responsabilité unique. Chaque étape peut modifier l'objet ou déclencher une action avant de le transmettre à l'étape suivante.
C’est le même principe que les middleware, mais les Pipelines sont plus flexibles et s’appliquent à des cas d’usage bien plus variés.

Pourquoi utiliser les Pipelines ?

✅ Modularité : Chaque étape est isolée et réutilisable.

✅ Lisibilité : Le flux de traitement est clairement défini.

✅ Maintenabilité : Ajouter ou retirer une étape est trivial.

✅ Testabilité : Chaque pipe peut être testé unitairement.

---

Exemple Pratique : Modération de contenu

Imaginons que vous deviez implémenter un système de modération de contenu pour des articles. Le flux de traitement doit vérifier successivement :

Si le contenu contient du spam.
Si des mots interdits sont présents.
Si le formatage est correct.

Sans Pipeline, vous pourriez écrire :

$article = new Article($content);

// Étape 1 : Vérifier le spam
if ($spamChecker->isSpam($article)) {
    throw new SpamDetectedException();
}

// Étape 2 : Filtrer les mots interdits
$filteredContent = $wordFilter->filter($article->content);
$article->content = $filteredContent;

// Étape 3 : Formater le contenu
$formattedContent = $formatter->format($article->content);
$article->content = $formattedContent;

$article->save();

Avec le pipeline, ca devient:

use Illuminate\Pipeline\Pipeline;

$article = new Article($content);

$processedArticle = app(Pipeline::class)
    ->send($article)
    ->through([
        CheckForSpam::class,
        FilterForbiddenWords::class,
        FormatContent::class,
    ])
    ->then(function ($article) {
        return $article->save();
    });

Chaque étape est encapsulée dans une classe dédiée, ce qui rend le code plus clair et scalable.

---

Comment ça marche ?

Structure d'un Pipe

Chaque pipe doit implémenter une méthode handle($passable, $next) :

class CheckForSpam {
    public function handle($article, $next) {
        if (SpamChecker::detect($article->content)) {
            throw new SpamDetectedException();
        }
        return $next($article);
    }
}

• $passable : L'objet transmis dans le pipeline (ici, $article).

• $next : La closure pour passer à l'étape suivante.

---

Cas d'Usage Avancés

1. Traitement des données en Batch

$data = collect([...]);

$processedData = app(Pipeline::class)
    ->send($data)
    ->through([
        NormalizeData::class,
        EnrichWithExternalAPI::class,
        ExportToCSV::class,
    ])
    ->thenReturn();

2. Gestion de workflow metier

Exemple : Validation d'une commande en plusieurs étapes (stock, paiement, livraison).

app(Pipeline::class)
    ->send($order)
    ->through([
        ValidateStock::class,
        ProcessPayment::class,
        ScheduleDelivery::class,
    ])
    ->then(function ($order) {
        $order->markAsCompleted();
    });

3. Personnalisation dynamique des étapes

Vous pouvez ajouter des étapes conditionnellement :

$pipes = [FilterForbiddenWords::class];

if ($user->isAdmin) {
    $pipes[] = ApplyAdminRules::class;
}

app(Pipeline::class)
    ->send($article)
    ->through($pipes)
    ->then(...);

---

Bonnes Pratiques

Une responsabilité par pipe : Évitez les classes qui font trop de choses.

Utilisez des interfaces : Pour standardiser les pipes (ex: interface Pipe { handle(...); }).

Testez chaque étape : Des unit tests simples pour chaque pipe.

Documentez le flux : Liste des étapes et leur ordre dans la documentation.

---

Conclusion

Les Pipelines sont un outil puissant pour structurer des flux de traitement complexes tout en gardant un code propre et modulaire. Que ce soit pour de la modération de contenu, des ETL (Extract-Transform-Load) ou des workflows métier, ils apportent une solution élégante et scalable.
Laravel rend leur implémentation triviale grâce à la classe Illuminate\Pipeline\Pipeline – alors pourquoi ne pas en profiter ? 🚀

---

Et vous, avez-vous déjà utilisé les Pipelines dans vos projets ? Partagez vos retours en commentaire !
Si cet article vous a aidé, n’hésitez pas à le partager avec votre réseau. 👇