Node.js EventEmitter Explained — Patterns, Pitfalls and Real-World Usage

// Pull EventEmitter from Node's built-in 'events' module — no install needed
const EventEmitter = require('events');

// Create a direct instance — good for learning, less ideal for production
const notificationHub = new EventEmitter();

// Register a listener for the 'userSignedUp' event
// .on() means: every time this event fires, run this callback
notificationHub.on('userSignedUp', (userData) => {
  // This runs synchronously when the event is emitted
  console.log(`[Email Service] Sending welcome email to: ${userData.email}`);
});

// Register a second listener for the SAME event — both will run
notificationHub.on('userSignedUp', (userData) => {
  console.log(`[Analytics] Recording new signup for user ID: ${userData.id}`);
});

// .once() registers a listener that fires exactly one time, then removes itself
// Perfect for one-off setup tasks or first-time events
notificationHub.once('userSignedUp', (userData) => {
  console.log(`[Promo Service] Sending first-signup discount to: ${userData.email}`);
});

console.log('--- First signup ---');
// .emit() fires the event synchronously — all listeners run before moving on
notificationHub.emit('userSignedUp', { id: 101, email: 'alex@example.com' });

console.log('\n--- Second signup ---');
// Notice: the .once() listener does NOT fire this time — it was auto-removed
notificationHub.emit('userSignedUp', { id: 102, email: 'jordan@example.com' });

// Check how many listeners are registered for this event
console.log(`\nActive listeners: ${notificationHub.listenerCount('userSignedUp')}`);

const EventEmitter = require('events');

// Extend EventEmitter so OrderProcessor IS an event emitter
// It gets all EventEmitter methods: .on(), .emit(), .off(), etc.
class OrderProcessor extends EventEmitter {
  constructor() {
    super(); // Must call super() when extending EventEmitter
    this.pendingOrders = [];
  }

  placeOrder(order) {
    // Simulate some internal processing
    this.pendingOrders.push(order);
    console.log(`[OrderProcessor] Processing order #${order.id}...`);

    // Emit an event — the processor doesn't care who's listening
    // It just announces what happened
    this.emit('orderPlaced', order);
  }

  processPayment(order) {
    // Simulate a payment check (50% chance of failure for demo)
    const paymentSucceeded = order.total < 500;

    if (paymentSucceeded) {
      // Emit success — pass enriched data with a timestamp
      this.emit('paymentConfirmed', { ...order, confirmedAt: new Date().toISOString() });
    } else {
      // Emit a failure event with a reason — listeners decide how to react
      this.emit('paymentFailed', { order, reason: 'Amount exceeds single-transaction limit' });
    }
  }
}

// --- Wire up the listeners (think: plug in your services) ---

const processor = new OrderProcessor();

// Service 1: Logger — listens to everything for audit trail
processor.on('orderPlaced', (order) => {
  console.log(`[Logger] ORDER PLACED — ID: ${order.id}, Item: ${order.item}, Total: $${order.total}`);
});

// Service 2: Inventory — only cares about confirmed orders
processor.on('paymentConfirmed', (order) => {
  console.log(`[Inventory] Reserving stock for: ${order.item} (Order #${order.id})`);
});

// Service 3: Email — sends confirmation or failure notice
processor.on('paymentConfirmed', (order) => {
  console.log(`[Email] Sending confirmation for Order #${order.id} to customer`);
});

processor.on('paymentFailed', ({ order, reason }) => {
  console.log(`[Email] Sending failure notice for Order #${order.id}: "${reason}"`);
});

// --- Simulate order flow ---

const order1 = { id: 'ORD-001', item: 'Mechanical Keyboard', total: 120 };
processor.placeOrder(order1);
processor.processPayment(order1);

console.log('');

const order2 = { id: 'ORD-002', item: 'Ultra-Wide Monitor', total: 850 };
processor.placeOrder(order2);
processor.processPayment(order2);

const EventEmitter = require('events');

class DataPipeline extends EventEmitter {
  constructor() {
    super();
    // If you genuinely need more than 10 listeners, be explicit about it
    // This silences the warning AND signals intent to future maintainers
    this.setMaxListeners(20);
  }

  fetchData(sourceUrl) {
    console.log(`[Pipeline] Fetching from: ${sourceUrl}`);

    // Simulate a network error condition
    if (!sourceUrl.startsWith('https://')) {
      // Emitting 'error' without a listener = process crash
      // WITH a listener, it's handled gracefully
      this.emit('error', new Error(`Insecure URL rejected: ${sourceUrl}`));
      return;
    }

    // Simulate successful data arrival
    this.emit('dataReceived', { source: sourceUrl, records: 42 });
  }
}

const pipeline = new DataPipeline();

// ALWAYS register an error listener before emitting anything
// Think of this as the safety net — never skip it
pipeline.on('error', (err) => {
  console.error(`[ERROR HANDLER] Caught pipeline error: ${err.message}`);
  // In production you'd log this to a monitoring service (Datadog, Sentry, etc.)
});

// Named function reference — required if you want to remove it later
const handleDataReceived = (payload) => {
  console.log(`[Consumer] Got ${payload.records} records from ${payload.source}`);
};

pipeline.on('dataReceived', handleDataReceived);

// --- Demonstrate error handling ---
pipeline.fetchData('http://insecure-api.example.com/data'); // Will trigger error
pipeline.fetchData('https://secure-api.example.com/data'); // Will succeed

console.log(`\nListeners before cleanup: ${pipeline.listenerCount('dataReceived')}`);

// .off() removes a specific listener — you MUST use the same function reference
// This is why anonymous arrow functions in .on() are hard to clean up!
pipeline.off('dataReceived', handleDataReceived);

console.log(`Listeners after cleanup: ${pipeline.listenerCount('dataReceived')}`);

// Remove ALL listeners for a specific event at once
// Use this carefully — it removes every listener, including ones you didn't add
pipeline.removeAllListeners('error');
console.log(`Error listeners after removeAll: ${pipeline.listenerCount('error')}`);