event-driven-architecture

Event-Driven Architecture

Domain events are the cleanest decoupling primitive in a Rails app. Order#after_create_commit :publish_order_placed lets billing, notifications, and analytics react without knowing about each other. This skill covers what to emit, how, and where event-driven goes wrong (event sourcing for everything is usually wrong).

The opinion

Emit domain events for cross-cutting concerns (notifications, audit, analytics). Use the transactional outbox so events publish atomically with the business write. Distinguish domain events (what happened in your bounded context) from integration events (what you tell other services). Use rails_event_store for in-app event handling. Do NOT adopt event sourcing as the default — it's a powerful but expensive pattern.

Domain events vs integration events

	Domain event	Integration event
Audience	Code inside your bounded context	Other services / downstream systems
Schema	Free to change	Versioned contract
Coupling	Loose internal	Hard external
Examples	OrderConfirmed, EmailVerified	order.placed.v1, user.deleted.v1
Transport	In-process pub/sub	Kafka / RabbitMQ

Don't mix them. Internal domain events are private — change at will. Integration events are public APIs and follow the same compatibility rules as your HTTP API.

Pattern 1: In-process domain events with rails_event_store

# Gemfile
gem "rails_event_store"

# config/initializers/rails_event_store.rb
require "rails_event_store"

Rails.configuration.event_store = RailsEventStore::Client.new

Rails.configuration.event_store.tap do |store|
  store.subscribe(OrderPlacedHandler, to: [Events::OrderPlaced])
  store.subscribe(NotifyOnOrderPlaced, to: [Events::OrderPlaced])
  store.subscribe(UpdateAnalytics, to: [Events::OrderPlaced])
end

# app/events/order_placed.rb
module Events
  class OrderPlaced < RailsEventStore::Event
  end
end

# app/services/place_order.rb
class PlaceOrder
  def call(cart:)
    order = nil
    ApplicationRecord.transaction do
      order = Order.create!(cart_to_attrs(cart))

      Rails.configuration.event_store.publish(
        Events::OrderPlaced.new(data: {
          order_id: order.id,
          account_id: order.account_id,
          total_cents: order.total_cents
        }),
        stream_name: "Order$#{order.id}"
      )
    end
    order
  end
end