Middleware & Chain of Responsibility, ou la chaîne qui porte le transverseMiddleware & Chain of Responsibility, or the chain that carries the cross-cutting

Un handler qui fait sept métiers. Lequel est vraiment le sien ?A handler doing seven jobs. Which one is actually its own?

handle_charge n'existe que pour une chose : débiter une carte. Mais avant d'y arriver, il authentifie, limite le débit, journalise, valide, trace, rattrape les erreurs. Six préoccupations transverses — communes à presque tous les handlers, étrangères au métier de celui-ci — entrelacées avec la seule ligne qui le justifie. Et chaque autre endpoint réécrit les six. Ce qui varie, ce n'est pas le métier : c'est l'ensemble des étapes transverses, qui se cumule, se réordonne, change indépendamment. Le réflexe : chaque préoccupation transverse devrait être un maillon composable d'une chaîne, ignorant les autres — et le cœur, au bout, ne ferait que son seul travail.handle_charge exists for one thing: charge a card. But before it gets there, it authenticates, throttles, logs, validates, traces, catches errors. Six cross-cutting concerns — common to nearly every handler, foreign to this one's domain — interwoven with the single line that justifies it. And every other endpoint rewrites all six. What varies isn't the domain: it's the set of cross-cutting steps, which accumulates, reorders, changes independently. The reflex: each cross-cutting concern should be a composable link in a chain, ignoring the others — and the core, at the end, would do only its one job.

# un handler qui ne devrait charger une carte — et qui fait sept autres métiers
def handle_charge(req):
    if not check_auth(req): return 401          # transverse : authentification
    if rate_limited(req.ip): return 429         # transverse : quota
    log.info("charge", req.id)                  # transverse : journalisation
    if not validate(req.body): return 400       # transverse : validation
    with tracing.span("charge"):                # transverse : observabilité
        try:
            charge(req.body.amount)             # ← LE seul vrai métier, ligne 7
        except Exception as e:
            log.error(e); return 500            # transverse : gestion d'erreur
# le cœur tient en une ligne ; les six autres reviennent dans CHAQUE handler.

Le transverse se duplique partout, et l'ordre des étapes n'est écrit nulle part.The cross-cutting duplicates everywhere, and the step order is written nowhere.

Garder le transverse dans chaque handler a trois coûts qui se renforcent. Il se duplique : auth, quota, log, validation sont recopiés dans chaque endpoint, et le jour où la règle change, on la cherche dans vingt fonctions. Le cœur devient intestable : pour vérifier « le débit refuse un montant négatif », il faut traîner toute la cérémonie d'authentification et de quota. Et l'ordre est implicite : l'auth doit passer avant le quota, le log doit envelopper l'erreur — cet enchaînement vit dans la tête des gens, jamais dans une structure qu'on peut lire ou réordonner sans risque.Keeping the cross-cutting in every handler has three costs that reinforce each other. It duplicates: auth, throttling, logging, validation are recopied in each endpoint, and the day the rule changes, you hunt for it in twenty functions. The core becomes untestable: to check 'the charge refuses a negative amount', you must drag the whole auth-and-throttle ceremony. And the order is implicit: auth must run before throttling, logging must wrap the error — that sequence lives in people's heads, never in a structure you can read or reorder safely.

def handle_refund(req):      # … et handle_ship, handle_cancel, handle_export …
    if not check_auth(req): return 401     # 💥 copie n°1
    if rate_limited(req.ip): return 429     # 💥 copie n°2
    log.info(...); validate(...)            # 💥 copies n°3, n°4
    refund(req.body)                        # ← le métier, encore enseveli
# durcir l'auth ? éditer les 20 handlers. en oublier un ? une faille silencieuse.

On défait le bloc en maillons, et la requête les traverse.Break the block into links, and the request flows through them.

La Chain of Responsibility transforme un handler obèse en une suite de maillons composables. L'animation part du bloc où tout est entrelacé, en extrait chaque préoccupation transverse, les chaîne en un pipeline que la requête traverse de maillon en maillon, puis montre la liberté de composition : insérer une trace, réordonner, ou laisser un maillon court-circuiter la chaîne. À chaque marche, le cœur — débiter — reste le même maillon, à la fin, intouché.The Chain of Responsibility turns a fat handler into a sequence of composable links. The animation starts from the block where everything is interwoven, extracts each cross-cutting concern, chains them into a pipeline the request flows through link by link, then shows the freedom of composition: insert a trace, reorder, or let a link short-circuit the chain. At each step, the core — charging — stays the same link, at the end, untouched.

# un maillon : reçoit la requête et le « suivant », fait UNE chose, puis enchaîne▸ à toiyour turn — la signature d'un maillon : il reçoit la requête et quoi d'autre, qui rend le chaînage possible ?a link's signature: it receives the request and what else, the thing that makes chaining possible? · cliquer pour révélerclick to reveal    if not check_auth(req): return 401      # court-circuit : on n'appelle pas next▸ à toiyour turn — le maillon n'a pas court-circuité : que fait-il alors de la requête ?the link didn't short-circuit: so what does it do with the request? · cliquer pour révélerclick to reveal
# la chaîne n'est qu'une composition de maillons — l'ordre est une donnée▸ à toiyour turn — la chaîne n'est qu'une… de maillons ; l'ordre y est une donnée qu'on lit.the chain is just a… of links; the order is data you read. · cliquer pour révélerclick to revealpipeline(req)   # charge_handler, le cœur, ne fait QUE débiter — il ignore le reste.

Une chaîne n'est pas une cachette. Le maillon qui fait du métier en douce.A chain is not a hiding place. The link that quietly does business logic.

Le piège n'est pas la chaîne — c'est ce qu'on y glisse. Deux dérives se cumulent. D'abord les maillons se parlent par effet de bord : l'un mute un état partagé (req.user), un autre suppose qu'il a tourné avant — l'ordre devient une dépendance cachée, et réordonner casse en silence. Ensuite, le métier s'invite dans la chaîne : un « middleware » de remise prend une décision métier, hors du cœur, dans une couche que personne n'audite. La chaîne, censée porter le transverse, devient un second domaine clandestin où se cache le flux de contrôle. Bascule le toggle : cherche le maillon qui décide au lieu de filtrer.The trap isn't the chain — it's what you slip into it. Two drifts compound. First, links talk through side effects: one mutates shared state (req.user), another assumes it ran before — order becomes a hidden dependency, and reordering breaks silently. Then, the domain creeps into the chain: a 'discount middleware' makes a business decision, outside the core, in a layer no one audits. The chain, meant to carry cross-cutting concerns, becomes a clandestine second domain where control flow hides. Flip the toggle: hunt the link that decides instead of filters.

# des maillons VRAIMENT transverses, autonomes, dont l'ordre est explicite
def auth(req, next):
    user = verify_token(req)            # ne dépend de rien d'autre dans la chaîne
    if not user: return 401
    return next(req.with_(user=user))   # passe l'info explicitement, pas par effet de bord

pipeline = compose([auth, rate_limit, validate, charge_handler])
# chaque maillon : une préoccupation transverse, indépendante, réutilisable partout.
# le métier (montant, devise, idempotence) reste DANS charge_handler — jamais ici.

Un handler qui sait tout, ou une chaîne où chacun sait une chose.A handler that knows everything, or a chain where each knows one thing.

Quand ne pas chaînerWhen not to chain

La chaîne a un loyer : une indirection de plus à chaque maillon, et une structure de composition à tenir. On reste avec un appel direct — et c'est correct — quand :The chain has rent: one more indirection per link, and a composition structure to maintain. Stay with a direct call — and that's fine — when:

• il n'y a qu'une seule préoccupation transverse, ou aucune : un endpoint isolé qui ne fait que lire une donnée publique n'a pas besoin d'un pipeline. Une garde inline est plus courte et plus franche — chaîner ici, c'est de la cérémonie (YAGNI, Vol 0 #3).there's only one cross-cutting concern, or none: an isolated endpoint that just reads public data needs no pipeline. An inline guard is shorter and franker — chaining here is ceremony (YAGNI, Vol 0 #3).
• les « étapes » sont en réalité une séquence métier : si l'ordre est imposé par le domaine et qu'un échec doit défaire les précédents, ce n'est pas du transverse, c'est une transaction — donc de l'orchestration (Vol 4 #3), pas un middleware. La chaîne enveloppe la requête ; elle ne porte pas le processus métier.the 'steps' are actually a business sequence: if the order is domain-imposed and a failure must undo the prior ones, it's not cross-cutting, it's a transaction — so orchestration (Vol 4 #3), not middleware. The chain wraps the request; it doesn't carry the business process.
• la chaîne servirait à cacher du flux de contrôle : si tu chaînes pour rendre un branchement métier « invisible », tu construis une fonction-dieu distribuée. Mieux vaut un cœur honnête qu'un pipeline qui dissimule où les décisions se prennent.the chain would serve to hide control flow: if you chain to make a business branch 'invisible', you're building a distributed god-function. Better an honest core than a pipeline that conceals where decisions are made.

Le réflexe n'est donc pas « mets tout en middleware, c'est modulaire » : c'est « cette préoccupation est-elle vraiment transverse et indépendante du métier ? Alors un maillon. Sinon, elle appartient au cœur, ou à un orchestrateur — pas à la chaîne. »So the reflex isn't 'put everything in middleware, it's modular': it's 'is this concern truly cross-cutting and independent of the domain? Then a link. Otherwise it belongs in the core, or an orchestrator — not the chain.'

Mot de l'éditeurFrom the editor

Ce numéro applique le réflexe du volume — « cette couche connaît-elle des choses qu'elle ne devrait pas connaître ? » — au chemin de la requête. Un handler qui authentifie, journalise et limite le débit connaît trop ; la chaîne lui rend sa seule responsabilité en sortant le transverse dans des maillons. Mais c'est aussi le pattern le plus marqué par les frameworks, et son danger est subtil : la chaîne devient si pratique qu'on y range le flux de contrôle et les décisions métier, jusqu'à reconstruire — distribuée et invisible — la fonction-dieu qu'on fuyait. La discipline tient en une phrase : le middleware enveloppe la requête, il ne décide pas du métier.This issue applies the volume's reflex — 'does this layer know things it shouldn't know?' — to the request path. A handler that authenticates, logs and throttles knows too much; the chain gives it back its one responsibility by lifting the cross-cutting into links. But it's also the pattern most marked by frameworks, and its danger is subtle: the chain becomes so convenient you file control flow and business decisions in it, until you rebuild — distributed and invisible — the very god-function you fled. The discipline fits in one sentence: middleware wraps the request, it doesn't decide the domain.

Avec lui se referme le volume des responsabilités : le #1 a posé les couches et montré où elles fuient, le #2 a opposé l'axe horizontal (par couche) à l'axe vertical (par feature), le #3 a sorti le transverse du cœur. Trois manières de répondre à la même question — qui a le droit de connaître quoi. La suite descend d'un cran, du système vers l'objet : le Vol 3 garde les quelques patterns du GoF dont le réflexe survit, à commencer par celui qui remplace un if/else par un comportement injectable — Strategy. On y verra qu'un maillon de chaîne, au fond, n'est qu'une stratégie de plus, passée en paramètre.With it the responsibilities volume closes: #1 laid down the layers and showed where they leak, #2 opposed the horizontal axis (by layer) to the vertical one (by feature), #3 lifted the cross-cutting out of the core. Three ways to answer the same question — who is allowed to know what. What follows steps down a notch, from system to object: Vol 3 keeps the few GoF patterns whose reflex survives, starting with the one that replaces an if/else with an injectable behavior — Strategy. We'll see that a chain link is, at bottom, just one more strategy, passed as a parameter.

Les voisins que ce numéro débloqueThe neighbors this issue unlocks

• Pipeline — la même chaîne vue comme un flux de données : chaque étape transforme l'entrée et la passe à la suivante. Là où le middleware filtre et protège une requête, le pipeline raffine une valeur — passes de compilateur, traitement d'image, ETL. Une seule forme, deux usages.the same chain seen as a data flow: each stage transforms the input and passes it on. Where middleware filters and protects a request, the pipeline refines a value — compiler passes, image processing, ETL. One shape, two uses.
• Decorator — le maillon vu comme un emballage : envelopper un objet pour lui ajouter un comportement (cache, log, retry) sans toucher à son code. Une pile de Decorators est une chaîne de responsabilité qui s'applique à un objet plutôt qu'à une requête — le cousin objet du middleware.the link seen as a wrapper: wrap an object to add behavior (cache, log, retry) without touching its code. A stack of Decorators is a chain of responsibility applied to an object rather than a request — middleware's object-level cousin.
• Interceptor — le maillon des appels distants : s'insérer autour d'un appel RPC/gRPC pour y ajouter authentification, tracing, retry, des deux côtés du fil. Le même motif, déplacé du serveur HTTP vers la frontière réseau — utile dès qu'on entre dans le distribué (Vol 6, Vol 7).the link for remote calls: insert around an RPC/gRPC call to add authentication, tracing, retry, on both sides of the wire. The same pattern, moved from the HTTP server to the network boundary — useful once you enter the distributed world (Vol 6, Vol 7).

Le kata — écris-le, ne le relis pasThe kata — write it, don't reread it

# test_middleware_chain.py — la spec EST le harnais : fais-le passer au vert.
# une chaîne de maillons composables : chacun fait UNE chose, puis passe la main. sans framework.

def test_la_requete_traverse_dans_l_ordre():
    trace = []
    tap = lambda name: lambda req, nxt: (trace.append(name), nxt(req))[1]
    compose([tap("a"), tap("b"), tap("c")])(Req())
    assert trace == ["a", "b", "c"]                # l'ordre déclaré = l'ordre d'exécution

def test_le_coeur_est_le_dernier_maillon():
    charged = []
    core = lambda req, nxt: charged.append(req.amount)
    compose([auth_ok, core])(Req(amount=42))
    assert charged == [42]                          # le cœur ne fait QUE son métier

def test_un_maillon_court_circuite():
    reached = []
    core = lambda req, nxt: reached.append(True)
    resp = compose([deny, core])(Req())             # deny renvoie 401 sans appeler nxt
    assert resp == 401 and reached == []            # la suite n'est jamais atteinte

def test_un_maillon_passe_l_info_explicitement():
    seen = {}
    def auth(req, nxt): return nxt(req.with_(user="alice"))
    def peek(req, nxt): seen["u"] = req.user; return nxt(req)
    compose([auth, peek])(Req())
    assert seen["u"] == "alice"                     # transmis PAR la requête, pas par effet de bord

def test_l_ordre_est_une_decision_declaree():
    counted = []
    quota = lambda req, nxt: (counted.append(req), nxt(req))[1]
    compose([deny, quota, core])(Req())             # auth AVANT le quota…
    assert counted == []                            # …un anonyme refusé ne consomme rien
    compose([quota, deny, core])(Req())             # inversé : il consomme du quota
    assert len(counted) == 1                        # l'ordre n'est pas neutre : il se déclare, en un endroit