Por qué me divorcié del Laravel Observer

En un post anterior sobre la migración a DTOs, hablé de cómo dejé de depender de los “arrays mágicos” de Laravel a favor de un tipado más estricto. Ese fue el Paso 1 de mi camino hacia un código más predecible. Esto no fue ahora, ni es tan reciente, pero creo que vale mucho la pena documentar esta experiencia aquí con ustedes.
Cuando empiezas a usar DTOs y
Actions/, naturalmente el camino del Observer se vuelve inviable a muy corto plazo.
Sin más rodeos (lo sé, escribo tanto que termino dando demasiadas vueltas), hoy necesito hablar del Paso 2, y este dolió más de lo que esperaba: dejé de usar Observer como muleta.
Durante años fui (bueno, todavía soy, pero de otra forma) un power user de Laravel. Si la documentación tenía una feature, la probaba. Los Observers parecían un superpoder: controllers delgados, models “limpios”, y todo efecto colateral escondido dentro de un UserObserver.
Pero a medida que mis proyectos dejaron de ser CRUD y se convirtieron en dominio de negocio de verdad, fui notando un patrón bastante feo: Observer no es clean code. Observer es lógica invisible. Y la lógica invisible es el tipo de cosa que te hace perder una tarde entera mirando el archivo equivocado, pensando que el bug está “en Laravel”, cuando en realidad está en un Observer olvidado que alguien creó hace 9 meses.
La ilusión del código “limpio”
El atractivo del Observer es obvio. Abres el controller y se ve precioso:
public function store(UserData $userData){ // Olha como está "limpo"! $user = User::create($userData->toArray());
return response()->json($user);}Bonito. Pero hay un detalle: ese “limpio” es solo maquillaje. Porque, sin que la persona que vaya a leer este archivo dentro de 6 meses lo sepa, esa única línea User::create() puede disparar una reacción en cadena:
- Envía el e-mail de bienvenida
- Crea el Customer en Stripe
- Registra la actividad
- Notifica a un canal de Slack
- Actualiza el índice de búsqueda
- Limpia el cache
- Pasa el cafecito
Y así sucesivamente.
Y ahí empieza la diversión: miras la línea, y solo “crea un usuario”. Pero el sistema entero está haciendo una fiesta escondida.
Esto es lo que llamo Acción Fantasmagórica a Distancia (spooky action at a distance): cambias la base de datos aquí, y se ejecuta código en otro lugar que ni recordabas que existía.
La trampa del orden de ejecución
Otro problema bastante común es que el orden de ejecución te traicione.
Imagina que tienes lógica en el evento created que depende de alguna relación. Pero si usas User::create(), el created se dispara inmediatamente. Muchas veces antes de que tengas la oportunidad de asociar cosas como Roles, Teams, Profile, etc.
Y ahí empiezas a ver code smells de este tipo:
public function created(User $user){ // Tentando adivinhar se já deu tempo de carregar relação... if ($user->relationLoaded('team')) { // ... }}Esto es frágil. Y peor: es frágil de una forma silenciosa. Hoy funciona. Mañana alguien cambia un flujo, agrega un import, usa createQuietly, o cambia el orden del attach, y listo, el Observer se vuelve una ruleta. Y si una regla de negocio depende del orden accidental de los eventos de Eloquent, eso no es “arquitectura”, es fe.
El problema real: efectos colaterales sin dueño
En el fondo, lo que me hizo desistir no fue “observer es malo”. Fue darme cuenta de que estaba poniendo reglas de negocio en un lugar donde:
- No es obvio que existen
- No es obvio cuándo se ejecutan
- No es obvio cómo desactivarlas
- No es obvio cómo probar el flujo sin llamar a la mitad del sistema junto
Incluso cuando no hay bug, el costo mental está ahí. Y cuando hay bug, la persona que está debuggeando paga la cuenta.
Llega un momento en la vida del dev experimentado en que lo que menos quiere es dolor de cabeza, busca control y previsibilidad.
La solución: explícito es mejor que implícito
Del mismo modo que cambié Form Requests por DTOs para dejar los datos explícitos, cambié Observers por Services y Actions explícitos.
Sí, eso significa escribir unas líneas de más.
Pero esas líneas de más cuentan una historia. Y la historia es lo que tu “yo del futuro” necesita cuando algo se rompe. Creo que este es el punto más importante: la Action quiere ser un flujo explícito. El Observer quiere ser un efecto colateral invisible. Los dos juntos se convierten en un sistema donde nadie sabe cuál es la “fuente de la verdad” del comportamiento.
Aquí está una versión refactorizada del flujo. Fíjate que no hay magia. Lo lees y sabes qué pasa:
final class CreateUserAction{ public function __construct( private BillingService $billing, ) {}
public function execute(UserData $data): User { return DB::transaction(function () use ($data) { $user = User::create($data->toArray());
DB::afterCommit(function () use ($user) { $this->billing->createCustomer($user); });
$user->notify((new WelcomeNotification())->afterCommit());
return $user; }); }}El bonus aquí es que el código se vuelve un panel de control.
- ¿Quieres que el import no envíe e-mail? No la llames.
- ¿Quieres que un admin cree un usuario sin Stripe? No la llames.
- ¿Quieres probar solo el “create user” sin disparar el resto del planeta? Se puede hacer.
¿Cuándo SÍ son aceptables los Observers?
¿Significa esto que el Observer es inútil? Obviamente no. Creo en el uso de Observers cuando es una preocupación técnica, siempre verdadera, independientemente del contexto, y que no representa una regla de negocio.
Ejemplos que consideraría aceptables:
- Generar UUID para un model
- Limpiar claves de cache
- Actualizar índices de búsqueda (Elasticsearch/Meilisearch), dependiendo del caso
Ahora, ¿regla de negocio (enviar e-mail, cobrar la tarjeta, asignar equipo, aprovisionar un recurso)? Lo evito. Porque una regla de negocio necesita tener dueño, y necesita estar en un lugar donde se pueda ver.
Madurez es previsibilidad
Ya lo dije antes, cuando somos junior, amamos la herramienta que hace cosas por nosotros. Amamos la magia. A medida que nos volvemos más senior (¿gruñones?), la magia empieza a cobrar intereses. Empiezas a preferir el código que dice exactamente qué va a pasar, aunque sea menos elegante.
Abandonar los Observers fue incómodo al principio. Sentía que estaba escribiendo “boilerplate”. Pero ese “boilerplate” se convirtió en algo mucho más útil: documentación viva. Es código que puedo leer, entender y debuggear sin necesitar un mapa mental de todo el sistema de eventos. Si estás cansado de que los efectos colaterales rompan el flujo, échale un vistazo con cariño a tus Observers.
Principalmente al created.
Principalmente a ese que “solo hace una cosita”.
Y, si tiene sentido, llévalo a un Service o Action y deja el flujo explícito.