Contenido del curso
Patrón Observer con EventEmitter en Node.js
El patrón observer en Node.js se implementa con Event Emitter, una abstracción nativa del core que te permite crear programas orientados a eventos: tú emites eventos en una parte del código y otras partes los escuchan para reaccionar. Si trabajas con Node, vas a toparte con este patrón todo el tiempo, así que vale la pena entenderlo a fondo.
Aquí vas a construir un notificador de registro de usuarios donde, cada vez que alguien se registra, dos sistemas reaccionan: uno que envía un correo y otro que actualiza estadísticas. Es el ejemplo perfecto para ver cómo el patrón distribuye lógica sin acoplar componentes.
¿Qué es Event Emitter en Node.js y por qué importa?
Event Emitter es la pieza del core que materializa el patrón observer. Tú defines un emisor que lanza eventos con datos, y cualquier listener suscrito ejecuta su lógica cuando ese evento ocurre. Lo poderoso es que el emisor no sabe ni le importa quién lo escucha.
¿Qué hace Event Emitter? Permite que un objeto emita eventos con nombre y datos asociados, y que otros objetos se suscriban con
.on()para reaccionar cuando ese evento se dispara.
En la clase se menciona la documentación oficial del core como referencia obligada [01:05]. Ahí encuentras la API completa de la clase EventEmitter.
¿Cómo crear el notificador base con EventEmitter?
Lo primero es construir una abstracción reutilizable. Creas un archivo notifier.js dentro de una carpeta observer y defines una clase que extienda de EventEmitter [02:10].
js const EventEmitter = require('node:events');
class UserNotifier extends EventEmitter {}
module.exports = new UserNotifier();
Fíjate en la notación node:events. Esto no es un capricho de estilo, es seguridad. Al prefijar con node: le dices a Node que cargue el módulo nativo y nadie puede sustituirlo con un paquete malicioso publicado en NPM con el mismo nombre. Es tu defensa contra ataques de supply chain [02:30].
¿Por qué usar node: al importar módulos del core? Porque garantiza que se cargue el módulo nativo de Node y bloquea ataques de supply chain donde alguien publica un paquete con el nombre de un módulo del core.
Al extender de EventEmitter, tu clase UserNotifier ya tiene métodos como .emit(), .on() y todo lo necesario sin escribir una sola línea extra.
¿Cómo emitir y escuchar eventos en una arquitectura real?
Ahora viene la parte interesante: separar quién emite de quién escucha.
Emitir el evento desde el registro de usuarios
En user-registration.js importas el notificador y creas la función que simula el registro [03:40]:
js const notifier = require('./notifier');
function registerUser(user) { console.log('registering user'); notifier.emit('user-registered', user); return user; }
module.exports = { registerUser };
El método .emit() lanza el evento user-registered y adjunta el objeto user como payload. Cualquiera suscrito recibe ese dato.
Suscribir listeners independientes
Dentro de una carpeta listeners creas dos archivos. El primero, email-listener.js, escucha y simula el envío de correo [04:30]:
js const notifier = require('../notifier');
notifier.on('user-registered', (user) => {
console.log(Sending email to ${user.email});
});
El segundo, stats-listener.js, escucha el mismo evento y registra estadísticas:
js const notifier = require('../notifier');
notifier.on('user-registered', (user) => {
console.log(Logging stats for ${user.name});
});
Los dos listeners reciben exactamente el mismo objeto user porque ambos están suscritos al mismo evento. Ninguno sabe de la existencia del otro.
¿Cómo conectar todo desde el index.js?
En index.js simplemente requieres los listeners y el registrador [06:15]:
js require('./listeners/email-listener'); require('./listeners/stats-listener'); const { registerUser } = require('./user-registration');
registerUser({ name: 'usuario1', email: 'u1@test.com' }); registerUser({ name: 'usuario2', email: 'u2@test.com' });
No necesitas asignar los listeners a ninguna variable. La suscripción con .on() se ejecuta al importar el módulo, así que con sólo requerirlos quedan activos.
Al ejecutar node index.js ves la secuencia: imprime registering user, luego Sending email y luego Logging stats, repetido para cada usuario. Los listeners se ejecutan en el orden en que se suscribieron.
¿Cuándo conviene usar el patrón observer en Node.js?
Cuando necesitas que varias partes de tu aplicación reaccionen a un mismo hecho sin acoplarlas entre sí. Notificaciones, métricas, logs, integraciones con servicios externos: todo encaja bien aquí.
La ventaja es escalabilidad. Mañana agregas un tercer listener que envíe el usuario a un CRM y no tocas ni el emisor ni los listeners existentes. Sólo creas el archivo nuevo y lo requieres.
Reto para extender el ejercicio
Para afianzar lo aprendido, agrega un segundo evento al sistema [09:10]:
createPost que simule la creación de un post por un usuario.post-created con los datos del post.stats-listener también escuche ese evento y lo loguee.No necesitas implementar la lógica real. El objetivo es practicar emisiones y suscripciones para que el patrón te quede natural.
¿Te animas a compartir tu solución del reto en los comentarios?
Irving Juárez
Estudiante
Salome Arboleda
EstudianteIrving Juárez
EstudianteIrving Juárez
Estudiante
Odannys De la Cruz
Estudiante
Alejandro Sánchez Yalí
Estudiante
Guillermo Pincay
Estudiante
Nicolas Alejandro Baak Poot
Estudiante
Guillermo Peña
Estudiante
Ulises Serrano Pérez
Estudiante
Antonio Estela
EstudianteEl ejemplo de la clase es bueno, pero les quiero mostrar como lo hice yo.
Archivo notifier.js
const EventEmitter = require('events'); class Notifier extends EventEmitter { constructor() { if (!Notifier.instance) { super(); Notifier.instance = this; } return Notifier.instance; } notify(eventName, payload) { this.emit(eventName, payload); } } module.exports = Notifier; ```Aqui se crea la logica del emitor de eventos, que es un singleton y es bastante sencillo. Solo se creo el metodo notify, que recibe el nombre del evento y el payload, que realmente puede ser opcional. Luego, en observer.js ```js const Notifier = require('./notifier'); class Observer { constructor() { if (!Observer.instance) { Observer.instance = this; } this.notifier = new Notifier(); return Observer.instance; } subscribe(event, callback) { this.notifier.on(event, callback); } } module.exports = Observer; ```En la clase Observer, que tambien es bastante sencilla, se crea solo un metodo `subscribe` que toma el evento, asi como el callback.Ahora, ya juntado esto, en index.js```js const Observer = require('./observer'); const Notifier = require('./notifier'); const observerInstance = new Observer(); const notifierInstance = new Notifier(); observerInstance.subscribe('message', (message) => { console.log(message); }); setTimeout(() => { notifierInstance.notify('message', 'Hello, world!'); }, 2000); ```Yo puedo importar mi Observador y mi Notifier desde donde yo quiera en mi aplicación, y al ser singletons, tengo la seguridad de que no voy a tener duplicaciones de eventos. Y que me suscriba más de una vez a un evento.Ahora, que le falta a mi implementación?Probablemente un enum para no tener errores de ortografia con los nombres de los eventos, se podria hacer con un simple objeto.Además, una función unsubscribe para que paremos de escuchar cada vez que se emita el evento.Pero para agregar el unsubscribe, tuve que hacer unos cambios a la clase Observer, pero así fue como quedo el metodo:```js unsubscribe(event, listener) { this.notifier.off(event, listener); } ```Solo que aqui tenemos un problema, ya que para cancelar el evento, necesitas el listener, que vendria siendo el callback del subscribe. Entonces, por esa razón tambien tuve que modificar la función subscribe de la siguiente manera:```js subscribe(event, callback) { this.notifier.on(event, callback); return callback; } ```Lo unico que cambio es que ahora retorno el callback, que se estaria usando de la siguiente manera en el index.js```js const Observer = require('./observer'); const Notifier = require('./notifier'); const observerInstance = new Observer(); const notifierInstance = new Notifier(); const listener1 = observerInstance.subscribe('message', (message) => { console.log(message); }); setTimeout(() => { notifierInstance.notify('message', 'Hello, world!'); observerInstance.unsubscribe('message', listener1); }, 2000); setTimeout(() => { notifierInstance.notify('message', 'Hello World!'); console.log('Second notification sent'); }, 5000); ```Pueden probarlo por su cuenta, solo deberian tener dos console.logs.Uno de "Hello World!" y otro de "'Second notification sent'"
Comparto mi solución:
// OrderService.js const notifier = require('./Notifier'); async function processOrder(order) { try { notifier.emit('orderValidation', order); // Simular una solicitud post: notifier.emit('orderRegister', order); } catch (error) { notifier.emit('orderError', error); } } module.exports = processOrder;
Acá controlo las validaciones y errores en cada listener:
const notifier = require('../Notifier'); notifier.on('orderValidation', (order) => { if (!order.items?.length) { throw new Error('Order must contain at least one item'); } if (order.total <= 0) { throw new Error('Order total must be greater than zero'); } const { id, address, name, email } = order.client || {}; if (!id || !address || !name || !email) { throw new Error('Client information is incomplete'); } }); notifier.on('orderRegister', (order) => { // Simular una solicitud post: try { const response = { status: 500 }; if (response.status === 201) { console.log('Order registered successfully:', order); } else { throw new Error('Failed to register order'); } } catch (error) { throw error; } }); notifier.on('orderError', (error) => { console.error('Order processing error:', error.message); });
Este patrón es muy usado en arquitecturas basadas en eventos. Podras haber utilizado esta arquitectura en Lambda functions o sus homologos en otros proveedores cloud.
Y esta arquitectura sirve para mandar notificaciones, logs o crear un pipeline de eventos, donde hay una acción (normalmente hecho por el usuario) que crea un evento y ese evento desencadena otra acción y asi sucesivamente
Solo como dato curioso, esta misma arquitectura de eventos tambien existe en el Frontend. Una de sus implementaciones más populares es la de Custom Events, donde tu creas un evento, cuyo scope esta en el navegador y puedes emitir esos eventos, pasandoles su payload o callbacks.
Normalmente se usan para microfrontends, donde muchas veces se quiere comunicar un microfrontend con otro y no queremos que la información que se pase sea publica, ya que una manera facil de pasar información tambien es a traves de la url con search params, pero queda información expuesta
Con el patrón Observer puedes crear cosas bastante interesantes. En la clase no se aprecia todo el potencial de este porque se usa desde la consola (que es muy válido), y no se observa completamente su utilidad, pero en esencia está muy bien. Pero si quieres entender el real potencial de este patrón, te recomiendo (a ti, alumno) ejecutar estos eventos con acciones reales, es decir, crea una app "más real", como por ejemplo: simular pagos, envío de correos reales, procesamiento de datos en segundo plano.
Y te aseguro que lo entenderás mejor por el simple hecho de que te toca manejar asincronismo. No es nada aprender observabilidad, si no observar y manejar el asincronismo. Inténtalo y verás. Saludos.
El patrón Observer permite desacoplar la lógica de negocios de la lógica de presentación y notificación. Al emitir eventos, los componentes que están interesados en esos eventos pueden reaccionar sin que el código que los emite necesite conocer sus implementaciones.
En el ejemplo, si se ejecuta el envío de email directamente en la función de creación del usuario, se introduce dependencia, haciendo más difícil realizar cambios. Con el patrón Observer, los listeners pueden ser añadidos o modificados sin afectar la función principal, lo que mejora la mantenibilidad del código y promueve la reutilización.
Me encantó la clase!!, aqui mi solución
Primero cree un archivo nuevo createPost.js:
const notifier = require('./notifier'); function createPost(post){ notifier.emit('userCreatedPost', post); //register user console.log(`New Post for user.id ${post.userid} ...`); //Implementar registro return post; } module.exports = createPost;
Y luego para agregar mas funcionalidad al statsListener.js:
const notifier = require('../notifier'); function logStats(user){ console.log(`Logging stats...`, user); } function createdPost(post){ console.log(`New post...`, post); } notifier.on('userRegistered', logStats); notifier.on('userCreatedPost', createdPost) module.exports = [logStats, createdPost];
y un nuevo listener para guardar el post en base de datos: sendPostDBListener.js
const notifier = require('../notifier'); function sendPostDBListener(post){ console.log(`Sending new post to DB: `, post.message); } notifier.on('userCreatedPost', sendPostDBListener) module.exports = sendPostDBListener;
Al final mi index.js queda de la siguiente manera:
require('./listeners/emailListeners'); require('./listeners/statsListeners'); require('./listeners/sendPostDBListener') const registerUser = require('./userRegistration'); const userCreatedPost = require('./userCreatePost'); const user1 = {id: 1, email : 'user@example.com', name : 'John Doe'}; const user2 = {id: 2, email : 'user2@example.com', name : 'Jena Doe'}; registerUser(user1); registerUser(user2); const post = { id: 1, userid : 1, message : 'Hola Mundo!'}; userCreatedPost(post);
Y finalmente al ejecutar el programa se ve asi:
Aunque me quedo la duda de porque aparecen primero los listeners y despues el New Post o Registering user...¿alguien sabe?
index.js
require("./listeners/emailListener"); require("./listeners/statsListener"); require("./listeners/postListener"); const registerUser = require("./userRegistration"); const registerPost = require("./userPost"); const user1 = { id: 1, email: "user@example.com", name: "John Doe" }; const user2 = { id: 2, email: "user2@example.com", name: "Jane Doe" }; registerUser(user1); registerUser(user2); const posts = [ { id: 1, text: "Hola John Como estas?", user: user2, }, { id: 2, text: "Hola Jane, bien y tu?", user: user1, }, { id: 3, text: "Que bueno John, Me alegro mucho!, yo estoy muy bien", user: user2, }, { id: 4, text: "Me alegro mucho Jane que estés bien", user: user1, }, ]; for (const post of posts) { registerPost(post.user.email, post.text); }
notifier.js
const EventEmitter = require("node:events"); class Notifier extends EventEmitter {} const notifier = new Notifier(); module.exports = notifier;
userPost.js
const notifier = require("./notifier"); function postUser(user, message) { console.log("Post user....."); notifier.emit("user:post", user, message); return { user, message }; } module.exports = postUser;
userRegistration.js
const notifier = require("./notifier"); function registerUser(user) { console.log("Registering user..."); notifier.emit("user:created", user); return user; } module.exports = registerUser;
emailListener.js
const notifier = require("../notifier"); function sendEmail(user) { console.log(`Sending email to ${user.email}`); } notifier.on("user:created", sendEmail); module.exports = sendEmail;
postListener.js
const notifier = require("../notifier"); function postUser(user, message) { console.log(`Post user ${user}, message: ${message}`); } notifier.on("user:post", postUser);
statsListener.js
const notifier = require("../notifier"); function logStats(user) { console.log(`Logging stats...`, user); } notifier.on("user:created", logStats); module.exports = logStats;
mi ejemplo de clases
Esta clase me encanto y supone un gran avance entender esta parte de los Emitters para desacoplar código.
const { postNotifier } = require('./notifier'); function newPost(user, post) { const postWithAuthor = { ...post, author: user.name }; console.log('Creating post...', postWithAuthor); postNotifier.emit('postCreated', postWithAuthor); } module.exports = newPost;
const EventEmitter = require('node:events'); class UserNotifier extends EventEmitter {} class CreatePostNotifier extends EventEmitter {} const notifier = new UserNotifier(); const postNotifier = new CreatePostNotifier(); module.exports = { notifier, postNotifier }; ```const notifier = require('../notifier'); function postCreated(post) { console.log(`Post ${post.title} created with content ${post.content}`);} notifier.postNotifier.on('postCreated', postCreated); module.exports = postCreated;```js const { notifier, postNotifier } = require('../notifier'); function logStats(user) { console.log('Logging stats...', user); } function logNewPost(post) { console.log('New post created...', post); } notifier.on('userRegistered', logStats); postNotifier.on('postCreated', logNewPost); module.exports = { logStats, logNewPost }; ``````js const notifier = require('../notifier'); function postCreated(post) { console.log(`Post ${post.title} created with content ${post.content}`); } notifier.postNotifier.on('postCreated', postCreated); module. Exports = postCreated; ```module. Exports ```js const emailListener = require('./listeners/emailListeners'); const statsListener = require('./listeners/statsListener'); const postCreated = require('./listeners/newPostListener'); const registeredUser = require('./userRegistration'); const newPost = require('./userPost'); const user1 = { id: 1, name: 'John Doe', email: 'johnDoe@example.com', }; const user2 = { id: 2, name: 'Jane Doe', email: 'janeDoe@example.com', }; const newPost1 = { id: 1, title: 'My first post', content: 'This is the content of my first post', }; const newPost2 = { id: 2, title: 'My second post', content: 'This is the content of my second post', }; registeredUser(user1); registeredUser(user2); newPost(user1, newPost1); newPost(user2, newPost2);