Comprendre le Inbound et Outbound Processing dans Drupal : principes et exemples

Introduction

Dans un site Drupal, lorsqu’un utilisateur interagit avec le système (par exemple, en accédant à une URL, en soumettant un formulaire, ou en consommant une API), Drupal traite la requête via un cycle d’entrée et de sortie : c’est ce qu’on appelle les processus Inbound et Outbound.

Ces deux mécanismes permettent à Drupal :

• d’interpréter les données entrantes (inbound),
• de modifier les données sortantes (outbound),
• et de centraliser la logique de traitement via des services ou des hooks.

Voyons tout cela en détail avec des exemples concrets.

1. Le Inbound Processing : traiter ce qui entre

Le Inbound Processing s’applique à tout ce que l’utilisateur envoie vers le système :

• L’URL demandée,
• Les paramètres de requête (GET, POST),
• Les données soumises dans un formulaire ou appel API.

Objectif

• Réécrire des chemins ou paramètres,
• Appliquer une logique de transformation ou de sécurité,
• Décoder des valeurs avant qu’elles ne soient utilisées dans le système.

Exemple : Modifier une URL d’entrée

Imaginons qu’on souhaite rediriger les chemins /produits vers /product tout en gardant la logique interne de Drupal.

use Symfony\Component\HttpKernel\Event\RequestEvent;
use Symfony\Component\EventDispatcher\EventSubscriberInterface;

class InboundPathSubscriber implements EventSubscriberInterface {

  public static function getSubscribedEvents() {
    return ['kernel.request' => ['onKernelRequest', 30]];
  }

  public function onKernelRequest(RequestEvent $event) {
    $request = $event->getRequest();
    $path = $request->getPathInfo();

    if ($path === '/produits') {
      $request->server->set('REQUEST_URI', '/product');
    }
  }
}

Ici, nous utilisons l’événement kernel.request pour intercepter l’URL avant que Drupal ne résolve le routeur.

2. Le Outbound Processing : manipuler ce qui sort

Le Outbound Processing intervient lorsque Drupal génère une réponse (HTML, JSON, etc.). Il est souvent utilisé pour :

• Modifier les liens générés (Url::fromRoute()),
• Réécrire dynamiquement les URL sortantes,
• Ajouter des entêtes HTTP, ou modifier la structure JSON.

Exemple : Réécriture dynamique des liens

Supposons que vous souhaitiez transformer tous les liens /user/ID en /profil/ID lors du rendu HTML :

use Drupal\Core\PathProcessor\OutboundPathProcessorInterface;
use Symfony\Component\HttpFoundation\Request;
use Drupal\Core\Render\BubbleableMetadata;

class OutboundPathProcessor implements OutboundPathProcessorInterface {
  public function processOutbound($path, &$options = [], Request $request = NULL, BubbleableMetadata $bubbleable_metadata = NULL) {
    if (strpos($path, '/user/') === 0) {
      return str_replace('/user/', '/profil/', $path);
    }
    return $path;
  }
}

Déclaration dans services.yml :

services:
  my_module.path_processor.outbound:
    class: Drupal\my_module\OutboundPathProcessor
    tags:
      - { name: path_processor_outbound, priority: 100 }

Quand utiliser Inbound vs Outbound ?

Utilisation combinée : cas typique d’un site multilingue

• Inbound : intercepter l’URL /fr/produits pour router vers /en/product.
• Outbound : générer les bons liens traduits dans les menus (/fr/produits, /en/product...).

C’est PathProcessorManager qui orchestre ces opérations dans Drupal Core.

Debug & Bonnes pratiques

• Utilisez \Drupal::logger() pour tracer les chemins traités.
• Priorisez vos abonnements aux événements Symfony (ordre d’exécution critique).
• Activez le cache de routes en production, mais désactivez-le lors du développement.

Conclusion

Les systèmes Inbound et Outbound dans Drupal sont des outils puissants pour contrôler le flux des données HTTP. Que vous créiez un site multilingue, headless, ou que vous souhaitiez personnaliser les chemins de votre site, ces hooks vous donnent un contrôle fin sur l’entrée et la sortie des données — sans modifier le cœur de Drupal.