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
clientelogloggeraddTokenlogauthrequireAuthlogRequestauthGET /meaxiosGET /meDBGET/ordersGET /ordersPOST/ordersPOST /ordersHandlertipoHandlerlog + auth + perfilUna ruta que hace de todoapp.get("/me", (req, res) => {▸console.log("->", req.path);▸if (!req.headers.authorization)▸return res.status(401).end();res.json(profile(req));});el mismo if, otra vezEl mismo chequeo, 3 vecesapp.get("/me", (req, res) => {▸if (!req.headers.authorization) …app.get("/orders", (req, res) => {▸if (!req.headers.authorization) …app.post("/orders", (req, res) => {▸if (!req.headers.authorization) …anota y pasarevisa y pasarespondeun solo contratonext() o cortaUn contrato para todostype Req = { user?: string; path: string };▸type Handler =▸(req: Req, next: () => string) => string;const auth: Handler = (req, next) =>req.user ? next() : "401 Unauthorized";const route: Handler = (req) =>`200 OK ${req.path}`;run(0)run(1)run(2)chainfunction chain(handlers: Handler[]) {return (req: Req) => {const run = (i: number): string =>▸handlers[i](req, () => run(i + 1));return run(0);};}const app = chain([log, auth, route]);sin user · 401no correCon y sin usuario▸app({ path: "/me" });▸// → "401 Unauthorized"app({ path: "/me", user: "ana" });// → "200 OK /me"req, res, nexttermina el cicloExpressfunction requireAuth(req, res, next) {if (!req.headers.authorization)return res.status(401).end();▸next();}app.use(logger);app.use(requireAuth);app.get("/me", sendProfile);sin next() ni respuestaesperandologger sin next()function logger(req, res, next) {console.log("->", req.path);▸// falta next()}responde sin loginnunca correLa ruta antes que el chequeoapp.use(logger);▸app.get("/me", sendProfile);▸app.use(requireAuth); // tardepone el tokencorre despuésInterceptores de Axiosconst api = axios.create();api.interceptors.request.use(logRequest);api.interceptors.request.use(addToken);▸// corren: addToken → logRequestfunction addToken(config) {config.headers.Authorization = token;return config;}puede cortarTres ideas equivocadas«el orden da igual»decide qué se protege«todos tienen que correr»cualquiera puede cortar«es algo de Express»es un patrón de 1994¿quién respondió?Cuándo no2 pasos fijosllama a 2 funcionesun paso para una rutaponlo solo en esa rutamuchos eslabones sin nombre¿quién respondió?pasa o cortaCadena en una tablaproblemael mismo chequeo en cada rutasoluciónhandlers en fila con next()cortarresponder sin llamar a next()ojo conel orden y olvidar next()no la usescon 2 pasos fijos
  • 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.

Aprenderás

  • Reconocer el problema: el mismo chequeo copiado en cada handler.
  • Armar una cadena de handlers donde cada uno hace su parte y llama a `next()`.
  • Cortar la cadena a tiempo: responder 401 sin llegar a la ruta.
  • Reconocer la cadena en el middleware de Express y en los interceptores de Axios.
  • Evitar los dos errores típicos (olvidar `next()` y el orden) y saber cuándo no usarla.