tcb 0.5.0 → 0.6.1

data/README.md

@@ -44,45 +44,117 @@ end
 bus.publish(UserRegistered.new(id: 1, email: "alice@example.com"))
 ```
 
-### `TCB::HandlesEvents`
+### Execution model
+
+TCB::EventBus uses a single background thread to process events. Publishing is non-blocking — the event is placed on a queue and control returns to the caller immediately. The dispatcher thread processes events in FIFO order. Handlers for a given event execute sequentially within the dispatcher thread.
+
+This design favors determinism and simplicity: events are always processed in the order they were published, and handlers cannot race with each other.
+
+For tests and simple use cases, `sync: true` executes handlers in the caller thread immediately — no background thread, no queue:
+
+```ruby
+bus = TCB::EventBus.new(sync: true)
+```
+
+### Delivery guarantees
+
+TCB guarantees:
+- Events published to the bus will be dispatched to all registered handlers, in the order they were published, as long as the process remains alive.
+- If `TCB.record` is used before `TCB.publish`, events are persisted to the event store before any handler runs.
+
+TCB does not guarantee:
+- That published events will be processed if the process crashes after publish but before handlers complete.
+- At-least-once, at-most-once, or exactly-once delivery.
+- Retry on handler failure. Failed handlers emit `TCB::SubscriberInvocationFailed`. Retry is the responsibility of the application.
+
+If stronger delivery guarantees are required, use a durable external queue (SolidQueue, Sidekiq, etc.) and trigger TCB handlers from jobs.
+
+### Backpressure
+
+The event queue is unbounded by default. If handlers are slower than the rate of publishing, the queue will grow without limit. For production systems under sustained load, set `max_queue_size:` to apply backpressure:
+
+```ruby
+TCB::EventBus.new(max_queue_size: 10_000)
+```
+
+When the queue is full, `publish` blocks until space is available. The right value depends on your event volume and handler latency — measure before deciding.
+
+---
+
+## TCB::HandlesEvents
 
 Instead of block handlers, reactions can be declared as classes inside a module. This keeps handlers close to the domain and readable at a glance.
 
 ```ruby
-module Notifications
-  include TCB::HandlesEvents
+# app/domain/warehouse.rb
+module Warehouse
+  include TCB::Domain
+
+  StockReserved = Data.define(:order_id)
+
+  persist events(
+    StockReserved,
+    stream_id_from_event: :order_id
+  )
 
-  on Auth::UserRegistered, react_with(SendWelcomeEmail, TrackRegistration)
-  on Orders::OrderPlaced,  react_with(SendOrderConfirmation)
+  on Sales::OrderPlaced, react_with(ReserveStock)
 end
 
-class SendWelcomeEmail
-  def call(event)
-    WelcomeMailer.deliver(event.email)
+# app/domain/warehouse/reserve_stock.rb
+module Warehouse
+  class ReserveStock
+    def call(event)
+      stock = Stock.new(id: event.order_id)
+
+      events = TCB.record(events_from: [stock], within: ApplicationRecord) do
+        stock.reserve
+      end
+
+      TCB.publish(*events)
+    end
   end
 end
+```
+
+```ruby
+# app/domain/notifications.rb
+module Notifications
+  include TCB::HandlesEvents
 
-class TrackRegistration
-  def call(event)
-    Analytics.track("user_registered", user_id: event.id)
+  on Warehouse::StockReserved, react_with(NotifyCustomer)
+end
+
+# app/domain/notifications/notify_customer.rb
+module Notifications
+  class NotifyCustomer
+    def call(event)
+      events = TCB.record(events: [CustomerNotified.new(order_id: event.order_id)])
+      TCB.publish(*events)
+    end
   end
+
+  CustomerNotified = Data.define(:order_id)
 end
 ```
 
-Event classes can come from anywhere. `TCB::HandlesEvents` only cares that they are published on the bus. Cross-module reactions are the norm, not the exception.
+Event classes can come from anywhere. Cross-module reactions are the norm, not the exception. Each handler is isolated. Ine failure does not prevent others from executing.
 
-Register at configuration time:
+Domain modules are declared once at the top level, before infrastructure is configured.
+This is the only place TCB needs to know about your bounded contexts — all reactions,
+persistence rules, and handler mappings live inside each module itself.
 
 ```ruby
+TCB.domain_modules = [Sales, Warehouse, Notifications]
+
 TCB.configure do |c|
-  c.event_bus      = TCB::EventBus.new
-  c.domain_modules = [Notifications]
+  c.event_bus   = TCB::EventBus.new
+  c.event_store = TCB::EventStore::ActiveRecord.new
 end
-
-TCB.publish(Auth::UserRegistered.new(id: 1, email: "alice@example.com"))
 ```
 
-Handlers execute asynchronously in a background thread. Each handler is isolated. One failure does not prevent others from executing.
+`TCB.domain_modules=` wires up subscriptions and command routing from all modules.
+`TCB.configure` provides the infrastructure they run on. The two are intentionally
+separate — domain modules don't change between environments, infrastructure does.
 
 ---
 
@@ -114,9 +186,9 @@ module Orders
   handle PlaceOrder, with(PlaceOrderHandler)
 end
 
+TCB.domain_modules = [ Orders ]
 TCB.configure do |c|
-  c.event_bus      = TCB::EventBus.new
-  c.domain_modules = [Orders]
+  c.event_bus = TCB::EventBus.new
 end
 
 TCB.dispatch(PlaceOrder.new(order_id: 42, customer: "Alice"))
@@ -136,12 +208,16 @@ Keep domain code together. TCB convention is a single `app/domain` folder. Beyon
 
 ```
 app/domain/
-  orders.rb               # domain module, public interface
-  orders/
-    order.rb              # aggregate
+  sales.rb                      # domain module, public interface
+  sales/
+    order.rb                    # aggregate
     place_order_handler.rb
-    reserve_inventory.rb
-    charge_payment.rb
+  warehouse.rb
+  warehouse/
+    reserve_stock.rb
+  notifications.rb
+  notifications/
+    notify_customer.rb
 ```
 
 ### The domain module
@@ -149,50 +225,36 @@ app/domain/
 The domain module is a boundary. Everything inside speaks the domain language. Nothing leaks out, nothing bleeds in. Keep everything that belongs together, together. Events, commands, persistence rules, and reactions are all declared in one place:
 
 ```ruby
-# app/domain/orders.rb
-module Orders
+# app/domain/sales.rb
+module Sales
   include TCB::Domain
 
+  # Facade
+  def self.place!(order_id:, customer:)
+    TCB.dispatch(PlaceOrder.new(order_id: order_id, customer: customer))
+  end
+
   # Events
-  OrderPlaced    = Data.define(:order_id, :customer)
-  OrderCancelled = Data.define(:order_id, :reason)
+  OrderPlaced = Data.define(:order_id, :customer)
 
   # Commands
-  PlaceOrder  = Data.define(:order_id, :customer) do
+  PlaceOrder = Data.define(:order_id, :customer) do
     def validate!
       raise ArgumentError, "customer required" if customer.nil?
     end
   end
 
-  CancelOrder = Data.define(:order_id, :reason) do
-    def validate!
-      raise ArgumentError, "reason required" if reason.nil?
-    end
-  end
-
   # Persistence
   persist events(
     OrderPlaced,
-    OrderCancelled,
     stream_id_from_event: :order_id
   )
 
   # Commands
-  handle PlaceOrder,  with(PlaceOrderHandler)
-  handle CancelOrder, with(CancelOrderHandler)
+  handle PlaceOrder, with(PlaceOrderHandler)
 
   # Reactions
-  on OrderPlaced,    react_with(ReserveInventory, ChargePayment)
-  on OrderCancelled, react_with(RefundPayment)
-
-  # Facade
-  def self.place!(order_id:, customer:)
-    TCB.dispatch(PlaceOrder.new(order_id: order_id, customer: customer))
-  end
-
-  def self.cancel!(order_id:, reason:)
-    TCB.dispatch(CancelOrder.new(order_id: order_id, reason: reason))
-  end
+  on OrderPlaced, react_with(Warehouse::ReserveStock)
 end
 ```
 
@@ -201,8 +263,7 @@ end
 The facade is the public contract. Callers get plain method calls with meaningful names. TCB stays out of sight:
 
 ```ruby
-Orders.place!(order_id: 42, customer: "Alice")
-Orders.cancel!(order_id: 42, reason: "changed mind")
+Sales.place!(order_id: 42, customer: "Alice")
 ```
 
 Facade methods use the bang convention. `TCB.dispatch` calls `validate!` on the command before routing it to the handler and raises if validation fails. Naming facade methods with `!` signals to callers that exceptions are expected.
@@ -214,8 +275,8 @@ An aggregate is the consistency boundary around your domain state. It decides wh
 The `TCB.record` block is the transactional boundary. Pass one aggregate or many. Either everything is persisted as it should be, or nothing is. The domain stays in a valid state.
 
 ```ruby
-# app/domain/orders/order.rb
-module Orders
+# app/domain/sales/order.rb
+module Sales
   class Order
     include TCB::RecordsEvents
 
@@ -226,10 +287,6 @@ module Orders
     def place(customer:)
       record OrderPlaced.new(order_id: id, customer: customer)
     end
-
-    def cancel(reason:)
-      record OrderCancelled.new(order_id: id, reason: reason)
-    end
   end
 end
 ```
@@ -238,17 +295,13 @@ end
 
 The command handler is the entry point into the domain. This is where you ensure the domain stays in a valid state before announcing anything to the rest of the system. Persist first, publish after.
 
-#### With aggregate
-
 ```ruby
-# app/domain/orders/place_order_handler.rb
-module Orders
+# app/domain/sales/place_order_handler.rb
+module Sales
   class PlaceOrderHandler
     def call(command)
       order = Order.new(id: command.order_id)
 
-      # within: ApplicationRecord wraps the block in a database transaction.
-      # If anything raises, no events are persisted and none are published.
       events = TCB.record(events_from: [order], within: ApplicationRecord) do
         order.place(customer: command.customer)
       end
@@ -315,25 +368,73 @@ end
 
 ## Configuration
 
-Each domain module gets its own database table. Domains stay isolated at the persistence level. This is a step toward event sourcing. Every business-significant moment is recorded, queryable, and replayable.
+### Domain modules
 
-| Module | Table |
-|---|---|
-| `Orders` | `orders_events` |
-| `Payments` | `payments_events` |
-| `Payments::Charges` | `payments_charges_events` |
+Domain modules are the bounded contexts of your application. Declare them once, at the top level — before infrastructure is configured:
 
 ```ruby
-TCB.configure do |c|
-  c.event_bus      = TCB::EventBus.new
-  c.event_store    = TCB::EventStore::ActiveRecord.new
-  c.domain_modules = [Orders, Payments]
+# config/initializers/tcb.rb
+TCB.domain_modules = [Orders, Notifications]
+```
+
+This is the only place TCB needs to know about your domain modules. All reactions, persistence rules, and handler mappings are declared inside each module itself.
+
+### Infrastructure
+
+Infrastructure is environment-specific. Configure it in each environment file so the differences are explicit and co-located with other environment settings:
+
+```ruby
+# config/environments/development.rb
+Rails.application.config.to_prepare do
+  TCB.reset!
+  TCB.configure do |c|
+    c.event_bus   = TCB::EventBus.new(
+      handle_signals: false,   # Rails manages process signals in development
+      shutdown_timeout: 10.0
+    )
+    c.event_store = TCB::EventStore::ActiveRecord.new
+  end
+end
+```
+
+`to_prepare` runs after every Rails reload. `TCB.reset!` shuts down the previous bus before configuring a new one. Without it, each reload would leak a dispatcher thread.
+
+```ruby
+# config/environments/production.rb
+Rails.application.config.to_prepare do
+  TCB.reset!(graceful_shutdown_time: 10.0)
+  TCB.configure do |c|
+    c.event_bus   = TCB::EventBus.new(
+      handle_signals: true,
+      shutdown_timeout: 30.0
+    )
+    c.event_store = TCB::EventStore::ActiveRecord.new
+  end
+end
+```
 
-  # Optional: additional classes for YAML serialization
-  c.extra_serialization_classes = [ActiveSupport::TimeWithZone, Money]
+`handle_signals: true` installs SIGTERM/SIGINT handlers for graceful shutdown. `graceful_shutdown_time` on `reset!` gives the previous bus time to drain before replacing it.
+
+```ruby
+# config/environments/test.rb
+Rails.application.config.after_initialize do
+  TCB.configure do |c|
+    c.event_bus   = TCB::EventBus.new(sync: true)
+    c.event_store = TCB::EventStore::InMemory.new
+  end
 end
 ```
 
+`sync: true` executes handlers in the caller thread — no background thread, no polling. `after_initialize` runs once at boot. Between tests, call `TCB.reset!` to get a fresh bus and store.
+
+Each domain module gets its own database table. Domains stay isolated at the persistence level:
+
+| Module | Table |
+|---|---|
+| `Orders` | `orders_events` |
+| `Payments` | `payments_events` |
+| `Payments::Charges` | `payments_charges_events` |
+
 ---
 
 ## Reading Events
@@ -369,13 +470,67 @@ end
 Each result is a `TCB::Envelope`:
 
 ```ruby
-envelope.event        # the domain event
-envelope.event_id     # UUID string
-envelope.stream_id    # "context|aggregate_id"
-envelope.version      # integer, sequential per stream
-envelope.occurred_at  # Time
+envelope.event          # the domain event
+envelope.event_id       # UUID string
+envelope.stream_id      # "context|aggregate_id"
+envelope.version        # integer, sequential per stream
+envelope.occurred_at    # Time
+envelope.correlation_id # UUID string, shared across all events in a dispatch chain
+envelope.causation_id   # UUID string, event_id of the triggering event; nil for the first event
+```
+
+---
+
+## Correlation and causation tracking
+
+Every `TCB.dispatch` generates a `correlation_id` and returns it to the caller. All events produced within that dispatch chain share the same `correlation_id`, regardless of how deep the reactive chain goes. `causation_id` identifies the direct cause — the `event_id` of the envelope that triggered the handler.
+
+```
+Sales.place!(order_id: 42, customer: "Alice")
+  └─ Sales::OrderPlaced            correlation_id: "req-abc", causation_id: nil
+      └─ Warehouse::StockReserved      correlation_id: "req-abc", causation_id: OrderPlaced.event_id
+          └─ Notifications::CustomerNotified  correlation_id: "req-abc", causation_id: StockReserved.event_id
+```
+
+`correlation_id` can be provided externally. That's useful for tying a dispatch to an incoming HTTP request:
+
+```ruby
+correlation_id = TCB.dispatch(
+  Sales::PlaceOrder.new(order_id: 42, customer: "Alice"),
+  correlation_id: request.uuid
+)
+response.set_header("X-Correlation-ID", correlation_id)
 ```
 
+`correlation_id` and `causation_id` are set by `TCB.record`, not by `TCB.publish`. A handler that calls `TCB.record` within a reactive chain will always have both fields populated. A handler that only calls `TCB.publish` without `TCB.record` produces envelopes without these fields. There is no event store context to propagate from.
+
+Handler interfaces are unchanged. `def call(event)` receives the domain event as always. Correlation and causation travel in the envelope, not in your domain code.
+
+Events recorded outside a dispatch context (directly via `TCB.record` without a preceding `TCB.dispatch`) have `nil` for both fields. This is expected: there is no dispatch to correlate them to.
+
+---
+
+## Reading a correlation chain
+
+To query all events across domains that share a `correlation_id`:
+
+```ruby
+# All domains with persistence
+TCB.read_correlation("req-abc").to_a
+
+# Specific domains
+TCB.read_correlation("req-abc", across: [Sales, Warehouse, Notifications]).to_a
+
+# With time filters
+TCB.read_correlation("req-abc").occurred_after(1.hour.ago).to_a
+TCB.read_correlation("req-abc").occurred_before(Time.now).to_a
+TCB.read_correlation("req-abc").between(1.hour.ago, Time.now).to_a
+```
+
+Results are ordered by `occurred_at` across all domains. Each result is a `TCB::Envelope` with `correlation_id` and `causation_id` populated.
+
+`across:` defaults to all configured domain modules that have persistence registrations. Domains without persistence — like `Notifications` in the example above — are excluded automatically.
+
 ---
 
 ## Event Store Adapters
@@ -395,7 +550,7 @@ TCB::EventStore::ActiveRecord.new
 Generate migration and AR model:
 
 ```
-bin/rails generate TCB:event_store orders
+bin/rails generate tcb:event_store orders
 ```
 
 ---
@@ -407,7 +562,7 @@ TCB includes generators to scaffold domain modules, command handlers, and migrat
 ### Install
 
 ```bash
-rails generate TCB:install
+rails generate tcb:install
 ```
 
 Creates `config/initializers/tcb.rb` with a minimal configuration template.
@@ -415,7 +570,7 @@ Creates `config/initializers/tcb.rb` with a minimal configuration template.
 ### Domain module with event store
 
 ```bash
-rails generate TCB:event_store orders place_order:order_id,customer cancel_order:order_id,reason
+rails generate tcb:event_store orders place_order:order_id,customer cancel_order:order_id,reason
 ```
 
 Generates:
@@ -427,7 +582,7 @@ Generates:
 ### Domain module without persistence (pub/sub only)
 
 ```bash
-rails generate TCB:domain notifications send_welcome_email:user_id,email send_verification_sms:user_id,phone
+rails generate tcb:domain notifications send_welcome_email:user_id,email send_verification_sms:user_id,phone
 ```
 
 Generates:
@@ -443,12 +598,14 @@ Generates:
 | `--skip-migration` | Skip migration (event_store only) |
 | `--no-comments` | Generate without inline guidance comments |
 
-After generating, add your module to `config/initializers/tcb.rb`. This is the only place TCB needs to know about your domain modules. All reactions, persistence rules, and handler mappings are declared inside the module itself, not here:
+After generating, add your module to config/initializers/tcb.rb. Domain modules don't change between environments — infrastructure does. Keeping them separate means your bounded contexts are declared once, while the bus and store are configured per environment:
 
 ```ruby
-c.domain_modules = [
-  Orders,
-  Notifications,
+# config/initializers/tcb.rb
+TCB.domain_modules = [
+  Sales,
+  Warehouse,
+  Notifications
 ]
 ```
 
@@ -484,89 +641,89 @@ bus.force_shutdown
 
 ## Testing
 
-Use `TCB::EventStore::InMemory` in tests. TCB is designed so that `TCB.reset!` fully tears down and rebuilds the configuration between tests. It shuts down the event bus, clears the event store, and re-registers all handlers.
+### Setup
 
-The `TCB.configure` block is stored and replayed on every `reset!`. Each test gets a fresh event bus and a clean event store automatically.
+Configure TCB once at boot in `config/environments/test.rb` (see Configuration above). Between tests, call `TCB.reset!` to get a fresh event bus and a clean event store.
 
-### Rails initializer
+`TCB.reset!` shuts down the current bus, clears the event store, and clears all subscriptions. The next test starts with a clean slate. Domain modules do not need to be re-declared — they are set once at the top level and persist across resets.
+
+### Synchronous mode
+
+With `sync: true`, handlers execute in the caller thread immediately after `publish`. No background thread, no polling, no timing concerns. Tests are faster and deterministic. This is the recommended approach.
 
 ```ruby
-# config/initializers/tcb.rb
-Rails.application.config.to_prepare do
+# config/environments/test.rb
+Rails.application.config.after_initialize do
   TCB.configure do |c|
-    c.event_bus   = TCB::EventBus.new(
-      handle_signals: true,
-      shutdown_timeout: 10.0
-    )
-    c.event_store = Rails.env.test? ? TCB::EventStore::InMemory.new
-                                    : TCB::EventStore::ActiveRecord.new
-    c.domain_modules = [Orders, Notifications]
+    c.event_bus   = TCB::EventBus.new(sync: true)
+    c.event_store = TCB::EventStore::InMemory.new
   end
 end
 ```
 
-### RSpec
+### Minitest
 
 ```ruby
-# spec/support/tcb.rb
-RSpec.configure do |config|
-  config.include TCB::RSpecHelpers
+class OrdersTest < Minitest::Test
+  include TCB::MinitestHelpers
+  def teardown = TCB.reset!
 
-  config.after(:each) do
-    TCB.reset!
+  def test_placing_order_publishes_event
+    assert_published(Orders::OrderPlaced) do
+      Orders.place!(order_id: 42, customer: "Alice")
+    end
   end
 end
 ```
 
-Require it from `rails_helper.rb`:
+#### assert_published
 
 ```ruby
-require "support/tcb"
+assert_published(Orders::OrderPlaced) { Orders.place!(order_id: 42, customer: "Alice") }
+assert_published(Orders::OrderPlaced.new(order_id: 42, customer: "Alice")) { Orders.place!(...) }
+assert_published(Orders::OrderPlaced, Notifications::WelcomeEmailQueued) { Orders.place!(...) }
+assert_published(Orders::OrderPlaced, within: 0.5) { Orders.place!(...) }
 ```
 
-`TCB.reset!` replays the configure block. `Rails.env.test?` is re-evaluated each time, so `InMemory` gets a fresh instance on every reset.
+#### poll_assert
 
-#### have_published
+Only needed when using an async bus. With `TCB::EventBus.new(sync: true)`, handlers execute in the caller thread and results are available immediately — no polling required.
 
 ```ruby
-expect { Orders.place!(order_id: 42, customer: "Alice") }.to have_published(Orders::OrderPlaced)
-expect { Orders.place!(...) }.to have_published(Orders::OrderPlaced.new(order_id: 42, customer: "Alice"))
-expect { Orders.place!(...) }.to have_published(Orders::OrderPlaced, within: 0.5)
+poll_assert("reserve inventory called") { CALLED.include?(:reserve_inventory) }
+poll_assert("payment processed", within: 2.0) { Payment.completed? }
 ```
 
-#### poll_match
+### RSpec
 
 ```ruby
-expect { CALLED.include?(:reserve_inventory) }.to poll_match
-expect { Payment.completed? }.to poll_match(within: 2.0)
+# spec/support/tcb.rb
+RSpec.configure do |config|
+  config.after(:each) { TCB.reset! }
+end
 ```
 
-### Minitest
+Require it from `rails_helper.rb`:
 
 ```ruby
-class OrdersTest < Minitest::Test
-  include TCB::MinitestHelpers
-
-  def teardown
-    TCB.reset!
-  end
-end
+require "support/tcb"
 ```
 
-#### assert_published
+#### have_published
 
 ```ruby
-assert_published(Orders::OrderPlaced) { Orders.place!(order_id: 42, customer: "Alice") }
-assert_published(Orders::OrderPlaced.new(order_id: 42, customer: "Alice")) { Orders.place!(...) }
-assert_published(Orders::OrderPlaced, Notifications::WelcomeEmailQueued) { Orders.place!(...) }
-assert_published(Orders::OrderPlaced, within: 0.5) { Orders.place!(...) }
+expect { Orders.place!(order_id: 42, customer: "Alice") }.to have_published(Orders::OrderPlaced)
+expect { Orders.place!(...) }.to have_published(Orders::OrderPlaced.new(order_id: 42, customer: "Alice"))
+expect { Orders.place!(...) }.to have_published(Orders::OrderPlaced, within: 0.5)
 ```
 
-#### poll_assert
+#### poll_match
+
+Only needed with an async bus.
 
 ```ruby
-poll_assert("handler was called") { CALLED.include?(:reserve_inventory) }
-poll_assert("payment processed", within: 2.0) { Payment.completed? }
+expect { CALLED.include?(:reserve_inventory) }.to poll_match
+expect { Payment.completed? }.to poll_match(within: 2.0)
 ```
 
 ---

data/lib/generators/tcb/domain/domain_generator.rb

@@ -5,7 +5,7 @@ require_relative "../shared/command_argument"
 module TCB
   module Generators
     class DomainGenerator < Rails::Generators::Base
-      namespace "TCB:domain"
+      namespace "tcb:domain"
       source_root File.expand_path("templates", __dir__)
 
       argument :module_name, type: :string

data/lib/generators/tcb/event_store/event_store_generator.rb

@@ -5,7 +5,7 @@ require_relative "../shared/command_argument"
 module TCB
   module Generators
     class EventStoreGenerator < Rails::Generators::Base
-      namespace "TCB:event_store"
+      namespace "tcb:event_store"
       source_root File.expand_path("templates", __dir__)
 
       argument :module_name, type: :string

data/lib/generators/tcb/event_store/templates/migration.rb.tt

@@ -1,14 +1,18 @@
 class <%= migration_class_name %> < ActiveRecord::Migration[8.0]
   def change
     create_table :<%= table_name %> do |t|
-      t.string   :event_id,    null: false
-      t.string   :stream_id,   null: false
-      t.integer  :version,     null: false
-      t.string   :event_type,  null: false
-      t.text     :payload,     null: false
-      t.datetime :occurred_at, null: false
+      t.string   :event_id,       null: false
+      t.string   :stream_id,      null: false
+      t.integer  :version,        null: false
+      t.string   :event_type,     null: false
+      t.text     :payload,        null: false
+      t.datetime :occurred_at,    null: false
+      t.string   :correlation_id
+      t.string   :causation_id
     end
 
     add_index :<%= table_name %>, [:stream_id, :version], unique: true
+    add_index :<%= table_name %>, :event_id,              unique: true
+    add_index :<%= table_name %>, :correlation_id
   end
-end
+end

data/lib/generators/tcb/install/install_generator.rb

@@ -3,7 +3,7 @@
 module TCB
   module Generators
     class InstallGenerator < Rails::Generators::Base
-      namespace "TCB:install"
+      namespace "tcb:install"
       source_root File.expand_path("templates", __dir__)
 
       desc "Creates a TCB initializer in config/initializers"