Event-Driven Domain Updates

In this lesson, you will learn how to decouple your business logic from secondary processes by publishing domain events after successful operations.

Why Decouple with Events?

In a typical Node.js application, you might find your service layer doing too much. Imagine a UserService.register() method: it saves the user to the database, sends a welcome email, generates a PDF invoice, and updates your search index. If one of those secondary tasks (like the email service) is slow or fails, your user’s registration request hangs or crashes.

Event-Driven Domain Updates allow the service layer to focus only on the "domain" action. Once the entity is successfully saved, it emits an event. Other "subscriber" services listen for that event and handle their own responsibilities asynchronously.

Implementation Pattern

By using an event emitter or a message bus, you keep your code clean and resilient. Your primary service remains fast because it doesn't wait for the secondary tasks to complete.

// Inside your UserService.js
async registerUser(userData) {
  const user = await userRepository.save(userData); // Core domain logic
  
  // Publish the event instead of calling side-effect services
  domainEvents.emit('user.created', { userId: user.id, email: user.email });
  
  return user; // Return immediately to the client
}

// Inside a separate EmailService.js (Background Task)
domainEvents.on('user.created', async (data) => {
  await mailer.sendWelcomeEmail(data.email);
});

The Benefit of Asynchronicity

Because the registration logic no longer directly calls the mailer or invoice generator, you gain two major advantages:

1. Responsiveness: The user receives a success response the moment the database transaction completes.
2. Resilience: If the email server is down, your registerUser function still succeeds. You can implement retry logic inside the background subscriber without affecting the user's experience.

This approach honors the Repository Pattern and Service Layer Abstraction we studied earlier; your domain layer manages state, while independent listeners handle the side effects of those changes.

Key Takeaway: Decouple your system by emitting domain events after successful operations, allowing background tasks to handle side effects independently and asynchronously.