Macro-Driven Boilerplate Elimination

// 1. Event sourcing boilerplate (~150 lines)
impl Account {
    pub fn apply(&mut self, event: &AccountEvent) {
        match event {
            AccountEvent::Created(e) => { /* apply logic */ }
            AccountEvent::Updated(e) => { /* apply logic */ }
            // ... 10-15 event variants
        }
    }

    pub fn replay(events: Vec<AccountEvent>) -> Self {
        let mut account = Self::default();
        for event in events {
            account.apply(&event);
        }
        account
    }

    pub fn uncommitted_events(&self) -> &[AccountEvent] {
        &self.events
    }

    pub fn mark_events_committed(&mut self) {
        self.events.clear();
    }
}

// 2. Repository boilerplate (~200 lines)
pub struct InMemoryAccountRepository {
    storage: Arc<RwLock<HashMap<AccountId, Account>>>,
}

impl InMemoryAccountRepository {
    pub async fn save(&self, account: Account) -> Result<()> {
        let mut storage = self.storage.write().await;
        storage.insert(account.id, account);
        Ok(())
    }

    pub async fn get(&self, id: AccountId) -> Result<Option<Account>> {
        let storage = self.storage.read().await;
        Ok(storage.get(&id).cloned())
    }

    // ... 8-10 more CRUD methods
}

// 3. DynamoDB repository boilerplate (~250 lines)
pub struct DynamoDbAccountRepository {
    client: CapsuleClient,
    table_name: String,
}

impl DynamoDbAccountRepository {
    pub async fn save(&self, account: Account) -> Result<()> {
        let entity = AccountEntity::from_domain(account);
        let item = to_item(&entity)?;

        self.client
            .client()
            .put_item()
            .table_name(&self.table_name)
            .set_item(Some(item))
            .send()
            .await?;

        Ok(())
    }

    pub async fn get(&self, id: AccountId) -> Result<Option<Account>> {
        let key = AccountEntity::primary_key(id);
        let result = self.client
            .client()
            .get_item()
            .table_name(&self.table_name)
            .set_key(Some(key))
            .send()
            .await?;

        match result.item {
            Some(item) => {
                let entity: AccountEntity = from_item(item)?;
                Ok(Some(entity.to_domain()))
            }
            None => Ok(None)
        }
    }

    // ... 8-10 more CRUD methods
}

// 4. Caching repository wrapper (~150 lines)
pub struct CachedAccountRepository<R> {
    inner: R,
    cache: Cache<AccountId, Account>,
}

// ... more boilerplate

Planning session for derive macro system to eliminate repository boilerplate.

Context:
- 7 CRM entities each need 3 repository implementations (InMemory, DynamoDB, Cached)
- Current: 4,200+ lines of nearly identical code
- Goal: Reduce to ~50 lines per entity via macros

Analyze existing repository patterns and design macros for:
1. DomainAggregate (event sourcing)
2. DomainEvent (event helpers)
3. InMemoryRepository (test repositories)
4. DynamoDbRepository (production repositories)
5. CachedRepository (performance layer)

Requirements:
- Type safety maintained
- Compile-time errors for invalid patterns
- Support multi-item DynamoDB entities (METADATA + LIST_ITEM)
- GSI query support
- Tenant isolation enforcement

Verify macro implementation for issue #575.

Check:
1. Do macros handle all repository patterns from existing code?
2. Are generated methods type-safe?
3. Edge cases: optional fields, nested structs, multi-item entities?
4. Migration path for existing entities?
5. Compilation errors helpful?

Refactor Account entity and repositories to use new derive macros.

Current state: Manual implementation (812 lines across 3 files)
Target state: Macro-driven (43 lines)

Steps:
1. Add #[derive(DomainAggregate)] to Account
2. Replace InMemoryAccountRepository with macro version
3. Replace DynamoDbAccountRepository with macro version
4. Replace CachedAccountRepository with macro version
5. Verify all 23 tests still pass

// BEFORE: 812 lines
// Account domain model (152 lines)
// InMemoryAccountRepository (215 lines)
// DynamoDbAccountRepository (295 lines)
// CachedAccountRepository (150 lines)

// AFTER: 43 lines
#[derive(DomainAggregate, Debug, Clone)]
#[id_type = "AccountId"]
#[event = "AccountEvent"]
pub struct Account {
    pub id: AccountId,
    pub name: String,
    pub industry: Option<String>,
    pub created_at: DateTime<Utc>,
    pub updated_at: DateTime<Utc>,
}

#[derive(InMemoryRepository)]
#[aggregate = "Account"]
#[id_type = "AccountId"]
pub struct InMemoryAccountRepository;

#[derive(DynamoDbRepository)]
#[aggregate = "Account"]
#[entity = "AccountEntity"]
#[multi_item]
#[gsi_methods("by_industry")]
pub struct DynamoDbAccountRepository;

#[derive(CachedRepository)]
#[inner = "DynamoDbAccountRepository"]
#[cache_strategy = "write_through"]
pub struct CachedAccountRepository;

#[derive(DomainAggregate)]
#[id_type = "AccountId"]
#[event = "AccountEvent"]
pub struct Account {
    pub id: AccountId,
    pub name: String,
}

impl Account {
    // Event sourcing methods
    pub fn apply(&mut self, event: &AccountEvent) {
        match event {
            AccountEvent::Created(e) => {
                self.id = e.account_id;
                self.name = e.name.clone();
            }
            AccountEvent::Updated(e) => {
                if let Some(name) = &e.name {
                    self.name = name.clone();
                }
            }
        }
        self.version += 1;
        self.events.push(event.clone());
    }

    pub fn replay(events: Vec<AccountEvent>) -> Self {
        let mut aggregate = Self::default();
        for event in events {
            aggregate.apply(&event);
        }
        aggregate.mark_events_committed();
        aggregate
    }

    pub fn uncommitted_events(&self) -> &[AccountEvent] {
        &self.events
    }

    pub fn mark_events_committed(&mut self) {
        self.events.clear();
    }

    pub fn test_fixture() -> Self {
        Self {
            id: AccountId::new_v4(),
            name: "Test Account".to_string(),
            version: 1,
            events: vec![],
            ..Default::default()
        }
    }
}

Analyze these 7 repository implementations.
Find common patterns and identify what can be macro-generated.

// When user forgets #[id_type] attribute:
compile_error!("Missing attribute"); // ❌ Not helpful

compile_error!(
    "DomainAggregate macro requires #[id_type = \"YourIdType\"] attribute.\n\
     Add it to the struct definition.\n\
     Example: #[derive(DomainAggregate)]\n\
              #[id_type = \"AccountId\"]\n\
              pub struct Account { ... }"
); // ✅ Helpful with example

// Generated code (WRONG):
pub async fn save(&self, aggregate: Account) -> Result<()> {
    let entity = AccountEntity::from_domain(aggregate);
    let item = to_item(&entity)?;

    self.client.client()
        .put_item()
        .table_name(&self.table_name)
        .set_item(Some(item))
        .send()
        .await?;

    Ok(())  // ❌ Missing tenant isolation check
}

// Generated code (CORRECT):
pub async fn save(&self, aggregate: Account) -> Result<()> {
    // NEW: Validate tenant isolation
    if aggregate.tenant_id() != self.client.tenant_id() {
        return Err(RepositoryError::TenantMismatch {
            expected: self.client.tenant_id(),
            actual: aggregate.tenant_id(),
        });
    }

    let entity = AccountEntity::from_domain(aggregate);
    // ... rest of save logic
}

Write comprehensive README.md for platform-macros crate.

Include:
- Overview of what each macro does
- Usage examples for all 5 macros
- Migration guide from manual to macro-driven
- Common pitfalls and how to avoid them
- Performance considerations

// NEW: DynamoDbRepository macro now generates db_save, db_get, db_query, db_delete
#[derive(DynamoDbRepository)]
#[aggregate = "Account"]
pub struct DynamoDbAccountRepository;

// Generates:
impl DynamoDbAccountRepository {
    pub async fn db_save(&self, aggregate: Account) -> Result<()> { /* ... */ }
    pub async fn db_get(&self, id: AccountId) -> Result<Option<Account>> { /* ... */ }
    // ...
}

CI is failing for Product, Activity, Address entities after macro migration.

Errors:
[Show compilation errors]

Analyze:
1. What pattern do these 3 entities have that Account/Contact/Lead don't?
2. Does the macro handle that pattern?
3. Recommend fix

// Manual implementation: 215 lines
pub struct InMemoryAccountRepository {
    storage: Arc<RwLock<HashMap<AccountId, Account>>>,
}

impl InMemoryAccountRepository {
    pub fn new() -> Self {
        Self {
            storage: Arc::new(RwLock::new(HashMap::new())),
        }
    }

    pub async fn save(&self, account: Account) -> Result<()> {
        let mut storage = self.storage.write().await;
        storage.insert(account.id, account);
        Ok(())
    }

    pub async fn get(&self, id: AccountId) -> Result<Option<Account>> {
        let storage = self.storage.read().await;
        Ok(storage.get(&id).cloned())
    }

    pub async fn delete(&self, id: AccountId) -> Result<()> {
        let mut storage = self.storage.write().await;
        storage.remove(&id);
        Ok(())
    }

    pub async fn list(&self) -> Result<Vec<Account>> {
        let storage = self.storage.read().await;
        Ok(storage.values().cloned().collect())
    }

    // ... 8 more methods
}

// + similar implementations for DynamoDbAccountRepository (295 lines)
// + CachedAccountRepository (150 lines)
// Total: 660 lines just for repositories

// Macro-driven: 15 lines total
#[derive(InMemoryRepository)]
#[aggregate = "Account"]
#[id_type = "AccountId"]
pub struct InMemoryAccountRepository;

#[derive(DynamoDbRepository)]
#[aggregate = "Account"]
#[entity = "AccountEntity"]
pub struct DynamoDbAccountRepository;

#[derive(CachedRepository)]
#[inner = "DynamoDbAccountRepository"]
pub struct CachedAccountRepository;

// Same functionality, 98% less code