Cadena de responsabilidad y middleware
- Lección 22 de 32
- 11 min
- Intermedio
- 13 pasos
Copiar el mismo chequeo de login en cada ruta funciona hasta que te olvidas de una. Vas a poner cada tarea en su propio handler, encadenarlos en fila y ver los dos errores que más cuestan: olvidar `next()` y equivocarse de orden.
- Copias del chequeo de auth
- 1
- Handlers que corrieron
- 3
- Respuesta
- 200
- petición
- respuesta
- petición lenta
Paso 1 de 13
Problema
Un handler que hace de todo
Tienes una API en Express con la ruta GET /me, que devuelve el perfil del usuario. Antes de responder, el handler anota la petición en el log y revisa que traiga la cabecera `Authorization`; si no la trae, responde 401.
Funciona, pero esa función mezcla tres tareas: registrar, autorizar y responder. Las dos primeras no tienen nada que ver con el perfil del usuario y las vas a necesitar en casi todas las rutas.
Qué cambió
- log y chequeo de auth dentro de GET /me
Paso 2 de 13
Problema
El mismo `if` en cada ruta
Llegan GET /orders y POST /orders. Cada una necesita el mismo chequeo, así que lo copias: ya son 3 copias del mismo if, como marca el panel.
Si mañana cambia cómo se valida el token, tienes que tocar las tres. Y si alguien agrega una ruta nueva y olvida pegar el if, esa ruta queda abierta sin que nada avise.
Qué cambió
- GET /orders y POST /orders
- 2 copias más del chequeo
Paso 3 de 13
Concepto
Una fila de handlers
Otra forma: saca cada tarea a su propio handler y ponlos en fila. La petición entra por log, que la anota y la pasa; sigue a auth, que la revisa y la pasa; y llega a la ruta, que responde. La respuesta vuelve por el mismo camino.
Eso es Cadena de responsabilidad, uno de los 23 patrones del libro de Gamma, Helm, Johnson y Vlissides (1994): quien envía la petición no sabe cuál de los objetos de la cadena la va a atender. En la versión del libro cada eslabón la atiende o la pasa; en el middleware cada uno hace su parte y la pasa.
Qué cambió
- handlers log y auth
- el if copiado en cada ruta
Paso 4 de 13
Técnica
Todos con la misma forma
Para que se puedan encadenar, todos los eslabones cumplen el mismo tipo, Handler: reciben la petición y una función next que llama al siguiente. Cada uno decide: llamar a `next()` o responder él mismo y cortar.
auth hace justo eso en una línea: si hay usuario, next(); si no, "401 Unauthorized". log es igual de corto: console.log("->", req.path); return next();. La ruta es el último eslabón, así que ni siquiera usa next.
Qué cambió
- type Handler
- log, auth y route cumplen Handler
Paso 5 de 13
Técnica
Quién arma la fila
La función chain recibe la lista de handlers y devuelve uno solo. Por dentro, run(i) llama al handler número i y le pasa como next una función que llama a run(i + 1).
Así, cada handler conoce solo al siguiente, nunca la cadena completa. Agregar un paso nuevo es sumar un elemento a la lista [log, auth, route]: ni log ni route cambian.
Qué cambió
- chain([log, auth, route])
Paso 6 de 13
Solución
`auth` corta la cadena
Llega una petición sin usuario. log la anota y llama a next(); auth ve que falta user y responde "401 Unauthorized" sin llamar a `next()`. La ruta ni se entera: solo corrieron 2 de los 3 handlers.
Esa es la gracia: el chequeo vive en un solo lugar y protege a todas las rutas que estén detrás de él en la fila. Por eso el contador de copias del chequeo se queda en 1, por más rutas que agregues.
Qué cambió
- auth responde 401
- route no corre
Paso 7 de 13
Concepto
Ya lo usas: el middleware de Express
En Express cada middleware recibe req, res y next. Según su documentación, un middleware puede ejecutar cualquier código, cambiar req y res, terminar el ciclo de petición y respuesta o pasar el control al siguiente con next().
app.use agrega un eslabón a la fila. requireAuth es nuestro auth: responde 401 o llama a next(). La ruta GET /me es el último eslabón y termina el ciclo con res.json.
Qué cambió
- auth → requireAuth
- chain([...]) → app.use(...)
Paso 8 de 13
Problema
Olvidar `next()` deja la petición colgada
Un día alguien edita logger y borra el next(). El middleware anota la petición y... nada más: no responde ni pasa el control. La documentación de Express lo dice claro: si un middleware no termina el ciclo, tiene que llamar a `next()`; si no, la petición queda colgada.
No hay error ni excepción: el cliente simplemente espera. Por eso, cuando una ruta «no responde nunca», revisa primero los middleware que corren antes que ella.
Qué cambió
- next() en logger
- el cliente espera sin respuesta
Paso 9 de 13
Problema
El orden decide qué se protege
Ahora alguien registra la ruta antes que requireAuth. La petición pasa por logger, llega a GET /me y la ruta responde 200 con el perfil, sin login. requireAuth nunca corre, porque la ruta ya terminó el ciclo.
Express ejecuta los middleware y las rutas en el orden en que los registras. Un chequeo que queda detrás de la ruta no protege nada. Arma la fila en un solo archivo y pon primero lo que puede cortar.
Qué cambió
- app.get antes de app.use(requireAuth)
- requireAuth no corre
Paso 10 de 13
Concepto
Ya lo usas: los interceptores de Axios
La misma idea vive del lado del cliente. En Axios, un interceptor de petición recibe la configuración de cada llamada, puede cambiarla (por ejemplo, poner la cabecera Authorization) y la devuelve para que siga su camino.
Ojo con el orden: según la documentación de Axios, los interceptores de petición corren al revés de como los agregas (el último en entrar corre primero), y los de respuesta, en el orden en que los agregas. Para quitar uno, guarda el id que devuelve use() y pásalo a eject().
Qué cambió
- log → addToken
- auth → logRequest
Paso 11 de 13
Concepto
Tres ideas equivocadas
«El orden da igual»: ya viste que un chequeo detrás de la ruta no protege nada, y que en Axios el orden de los interceptores de petición se invierte.
«Todos los handlers tienen que correr»: no. Cualquiera puede cortar la cadena respondiendo, y eso es justo lo que hace auth con el 401.
«Es algo de Express»: es un patrón de 1994, anterior a Express. Lo vas a encontrar con otros nombres: middleware, interceptores, filtros.
Paso 12 de 13
Compromiso
Cuándo no armar una cadena y qué cuesta
Si tu flujo son dos pasos fijos que nunca cambian, llamar a dos funciones una tras otra es más claro que una cadena. Y si solo una ruta necesita un paso, en Express puedes ponerlo solo en esa ruta: app.get("/me", requireAuth, sendProfile).
El costo está al depurar: con muchos eslabones, cuesta saber quién respondió o quién se olvidó de next(). Ponles nombre a tus handlers y anota en el log cuál cortó la cadena.
Paso 13 de 13
Resumen
Una fila de handlers que pasan o cortan
Cuando varias rutas comparten pasos (log, autenticación, validación), saca cada paso a un handler con la misma forma y ponlos en fila: cada uno hace su parte y llama a next(), o responde y corta.
Cuida dos cosas: el orden (lo que corta va antes de lo que protege) y que cada eslabón responda o llame a `next()`. Si el flujo es fijo y corto, no lo necesitas.
← → paso · R repetir · Espacio pausa
Aprenderás
- Reconocer el problema: el mismo chequeo copiado en cada handler. (visto)
- Armar una cadena de handlers donde cada uno hace su parte y llama a `next()`. (visto)
- Cortar la cadena a tiempo: responder 401 sin llegar a la ruta. (visto)
- Reconocer la cadena en el middleware de Express y en los interceptores de Axios. (visto)
- Evitar los dos errores típicos (olvidar `next()` y el orden) y saber cuándo no usarla. (visto)