ddd-aggregate-design

Design an immutable aggregate using a Props type with readonly fields and spread syntax for state updates. Use a private constructor that validates invariants, factory methods like create() and reconstruct(), and reference other aggregates by ID only.

Place entities in the same aggregate only when a true invariant must be transactionally consistent between them. Per Vernon's Rule 2, keep aggregates small to avoid lock contention; connect separate aggregates via ID references and eventual consistency with domain events.

Vernon's rules are: model true invariants inside the consistency boundary, keep aggregates small, reference other aggregates by ID only, and use eventual consistency outside the boundary. They guide boundary decisions and concurrency behavior.

Replace void-returning mutation methods with methods returning new instances: spread syntax in TypeScript, copy() in Scala, struct update syntax in Rust, or replace() with frozen dataclasses in Python. Validate invariants in the constructor so every new instance is checked.

Add a version number for optimistic locking only when concurrent update conflict detection is an actual requirement. The repository checks the version in the UPDATE statement's WHERE clause; without the requirement, the version field is unnecessary.

Yes, the Skill includes reference implementations for TypeScript, Scala, Rust, and Python. Each covers immutable aggregates, ID references, factory patterns, invariant validation, domain events, and optimistic locking with language-idiomatic constructs.