Allow renaming customers

Customer names appear across multiple read models (Customers, OrderHeader,
Deals, ClientOrders). The rename propagates to all of them so the new name
is visible on every page. Also adds /new-feature skill for upfront impact
analysis and updates /read-model skill with denormalization rules.

Author: andrzejkrzywda

.claude/skills/new-feature/SKILL.md

@@ -0,0 +1,84 @@
+---
+name: new-feature
+description: Plan a new feature end-to-end — impact analysis across all layers before delegating to /domain, /read-model, /controller skills
+---
+
+# New Feature
+
+## When to use
+
+Use this skill when asked to add a new user-facing feature. It ensures you think through **all affected layers upfront** before writing any code.
+
+## What this skill does
+
+This skill is a **planning and coordination** step. It does NOT contain implementation details — those live in `/domain`, `/read-model`, and `/controller`. This skill ensures you:
+
+1. Identify everything that needs to change
+2. Write a failing integration test that covers all affected surfaces
+3. Then delegate implementation to the appropriate skills
+
+## Step-by-step process
+
+### 1. Impact analysis
+
+Before writing any code, search for all consumers of the affected entity's data:
+
+```bash
+# Find all read models that subscribe to events from the same entity
+grep -r "DomainModule::RelatedEvent" apps/rails_application/app/read_models/ -l
+
+# Find all places that store the affected attribute
+grep -r "affected_attribute" apps/rails_application/app/read_models/
+
+# Find all views that display it
+grep -r "affected_attribute" apps/rails_application/app/views/
+```
+
+**For each read model that stores the affected data, ask:**
+1. Does it subscribe to the creation event for this entity?
+2. Does it store or denormalize the attribute being changed?
+3. If yes to both: it needs a handler for the new event.
+
+**Common patterns requiring multi-read-model updates:**
+- **Renaming** — entity names denormalized into other read models
+- **Price changes** — prices snapshotted in order/deal read models
+- **Status changes** — displayed across list views in different read models
+- **Reassignment** — entity associations denormalized in multiple places
+
+### 2. Produce a plan
+
+List every change needed:
+- **Domain:** new command, event, aggregate method, handler
+- **Read models:** which read models need new event handlers (list each one)
+- **Controller:** which actions change, new routes
+- **Views:** which templates change
+
+Present this plan to the user before proceeding.
+
+### 3. Write the integration test first
+
+The integration test must verify the feature works **across all affected UI surfaces**, not just the primary one.
+
+Create enough related data (orders, deals, etc.) so that secondary pages also display the affected data. Then assert the change is visible on **every page that shows it**.
+
+### 4. Delegate implementation
+
+Use the existing skills:
+- `/domain` — for commands, events, aggregates, handlers
+- `/read-model` — for read model event handlers and configuration
+- `/controller` — for controller actions, routes, views
+
+### 5. Verify
+
+1. Integration test passes
+2. `rails test test/integration/` — all integration tests pass
+3. `make test` — all tests green
+4. Run mutant for affected namespaces
+
+## Checklist
+
+- [ ] Searched all read models for the affected entity's data
+- [ ] Searched all views for display of the affected data
+- [ ] Listed every read model that needs a new handler
+- [ ] Integration test covers all affected pages
+- [ ] Denormalized copies of data are updated (not just the primary table)

.claude/skills/read-model/SKILL.md

@@ -228,6 +228,29 @@ Some older read models still use one class per event type in separate files. Whe
 - No local variables, prefer method calls
 - Extract shared `find_*` methods as private helpers for reusability
 
+### 5a. Denormalization rules
+
+When a read model copies data from one entity into another table (e.g., customer name into an order header), **always store the entity's ID alongside the denormalized value**. This allows updates by ID rather than by name or other mutable attributes.
+
+- **Always add an ID column** (e.g., `customer_id`) to the table that stores denormalized data, not just the display value (e.g., `customer_name`)
+- **Update by ID, not by value** — when handling rename/update events, find records to update using the entity ID, never by matching the old string value. Matching by string is fragile: two entities with the same name would both get updated incorrectly
+- If an existing table is missing the ID column, add a migration to include it
+
+**Bad — matching by old name:**
+```ruby
+when Crm::CustomerRenamed
+  old_name = customer.name
+  customer.update!(name: event.data.fetch(:name))
+  Deal.where(customer_name: old_name).update_all(customer_name: event.data.fetch(:name))
+```
+
+**Good — matching by ID:**
+```ruby
+when Crm::CustomerRenamed
+  Customer.find_by!(customer_id: event.data.fetch(:customer_id)).update!(name: event.data.fetch(:name))
+  Deal.where(customer_id: event.data.fetch(:customer_id)).update_all(customer_name: event.data.fetch(:name))
+```
+
 ### 6. Facade methods
 
 - Only create facade methods that are **actually called by controllers or views**

apps/rails_application/app/controllers/customers_controller.rb

@@ -20,11 +20,15 @@ def create
 
   def update
     customer = Customers.find_customer_in_store(params[:id], current_store_id)
-    promote_to_vip(customer.id)
+    if params[:name].present?
+      rename_customer(customer.id, params[:name])
+      redirect_to customer_path(customer), notice: "Customer was renamed"
+    else
+      promote_to_vip(customer.id)
+      redirect_to customers_path, notice: "Customer was promoted to VIP"
+    end
   rescue Crm::Customer::AlreadyVip
     redirect_to customers_path, notice: "Customer was marked as vip"
-  else
-    redirect_to customers_path, notice: "Customer was promoted to VIP"
   end
 
   def show
@@ -41,6 +45,10 @@ def create_customer(customer_id, name)
     command_bus.(register_customer_in_store_cmd(customer_id))
   end
 
+  def rename_customer(customer_id, name)
+    command_bus.(rename_customer_cmd(customer_id, name))
+  end
+
   def promote_to_vip(customer_id)
     command_bus.(promote_to_vip_cmd(customer_id))
   end
@@ -53,6 +61,10 @@ def register_customer_in_store_cmd(customer_id)
     Stores::RegisterCustomer.new(customer_id: customer_id, store_id: current_store_id)
   end
 
+  def rename_customer_cmd(customer_id, name)
+    Crm::RenameCustomer.new(customer_id: customer_id, name: name)
+  end
+
   def promote_to_vip_cmd(customer_id)
     Crm::PromoteCustomerToVip.new(customer_id: customer_id)
   end

apps/rails_application/app/read_models/client_orders/configuration.rb

@@ -49,6 +49,7 @@ def call(event_store)
       event_store.subscribe(RemoveItemFromOrder, to: [Pricing::PriceItemRemoved])
 
       event_store.subscribe(CreateCustomer.new, to: [Crm::CustomerRegistered])
+      event_store.subscribe(RenameCustomer.new, to: [Crm::CustomerRenamed])
       event_store.subscribe(OrderHandlers::AssignCustomerToOrder, to: [Crm::CustomerAssignedToOrder])
 
       event_store.subscribe(ProductHandlers::ChangeProductName, to: [ProductCatalog::ProductNamed])

apps/rails_application/app/read_models/client_orders/rename_customer.rb

@@ -0,0 +1,7 @@
+module ClientOrders
+  class RenameCustomer
+    def call(event)
+      Client.find_by(uid: event.data.fetch(:customer_id)).update!(name: event.data.fetch(:name))
+    end
+  end
+end

apps/rails_application/app/read_models/customers/configuration.rb

@@ -16,6 +16,7 @@ def self.find_customer_in_store(customer_id, store_id)
   class Configuration
     def call(event_store)
       event_store.subscribe(RegisterCustomer.new, to: [Crm::CustomerRegistered])
+      event_store.subscribe(RenameCustomer.new, to: [Crm::CustomerRenamed])
       event_store.subscribe(AssignStoreToCustomer.new, to: [Stores::CustomerRegistered])
       event_store.subscribe(PromoteToVip.new, to: [Crm::CustomerPromotedToVip])
       event_store.subscribe(UpdatePaidOrdersSummary.new, to: [Fulfillment::OrderConfirmed])

apps/rails_application/app/read_models/customers/rename_customer.rb

@@ -0,0 +1,7 @@
+module Customers
+  class RenameCustomer
+    def call(event)
+      Customer.find_by(id: event.data.fetch(:customer_id)).update(name: event.data.fetch(:name))
+    end
+  end
+end

apps/rails_application/app/read_models/deals/configuration.rb

@@ -24,6 +24,11 @@ def call(event)
         find_deal(event).update!(store_id: event.data.fetch(:store_id))
       when Crm::CustomerRegistered
         Customer.find_or_create_by!(customer_id: event.data.fetch(:customer_id)).update!(name: event.data.fetch(:name))
+      when Crm::CustomerRenamed
+        customer = Customer.find_by!(customer_id: event.data.fetch(:customer_id))
+        old_name = customer.name
+        customer.update!(name: event.data.fetch(:name))
+        Deal.where(customer_name: old_name).update_all(customer_name: event.data.fetch(:name))
       when Crm::CustomerAssignedToOrder
         find_deal(event).update!(customer_name: find_customer(event).name)
       when Processes::TotalOrderValueUpdated
@@ -56,6 +61,7 @@ def call(event_store)
         Pricing::OfferDrafted,
         Stores::OfferRegistered,
         Crm::CustomerRegistered,
+        Crm::CustomerRenamed,
         Crm::CustomerAssignedToOrder,
         Processes::TotalOrderValueUpdated,
         Fulfillment::OrderRegistered,

apps/rails_application/app/read_models/order_header/configuration.rb

@@ -22,6 +22,7 @@ def self.draft_orders(store_id)
   class Configuration
     def call(event_store)
       event_store.subscribe(CreateCustomer.new, to: [Crm::CustomerRegistered])
+      event_store.subscribe(RenameCustomer.new, to: [Crm::CustomerRenamed])
       event_store.subscribe(AssignStoreToOrderHeader.new, to: [Stores::OfferRegistered])
       event_store.subscribe(
         ->(event) { draft_order_header(event) },

apps/rails_application/app/read_models/order_header/rename_customer.rb

@@ -0,0 +1,10 @@
+module OrderHeader
+  class RenameCustomer
+    def call(event)
+      customer = Customer.find_by(customer_id: event.data.fetch(:customer_id))
+      old_name = customer.name
+      customer.update!(name: event.data.fetch(:name))
+      Header.where(customer: old_name).update_all(customer: event.data.fetch(:name))
+    end
+  end
+end