Design aggregates and entities as transactional consistency boundaries.
npx skills add https://github.com/hung-phan/system-skills --skill aggregates
Please help me install this Agent Skill. Skill: aggregates Source: https://github.com/hung-phan/system-skills/tree/main/skills/system-review/references/code-design/aggregates Command: npx skills add https://github.com/hung-phan/system-skills --skill aggregates
This Skill helps you design aggregates and entities as transactional consistency boundaries, ensuring that business rules are enforced across related entities.
Use the aggregates skill to analyze your domain model and identify the aggregates that need to be created to maintain transactional consistency.
High-intent search queries and answers about installing and using this skill.
Transactional consistency boundaries are designed by defining aggregates and identifying invariants from business rules. You apply Vaughn Vernon's four aggregate design rules to enforce atomic updates and maintain consistency across related entities within the domain-driven design model.
An aggregate in domain-driven design is a transactional consistency boundary that groups related entities. It enforces business rules and invariants, ensuring that all modifications to the grouped objects maintain a valid state during atomic system updates.
Invariants are identified by analyzing business rules to determine which data must remain consistent during updates. These invariants define the aggregate boundaries, ensuring that related entities grouped together enforce transactional consistency and valid state transitions.
Aggregates are needed when building a system that requires atomic updates to related entities. If your domain model has business rules demanding transactional consistency across multiple objects, aggregates enforce those boundaries to prevent invalid states.
Yes, understanding domain-driven design principles is required to define aggregate boundaries effectively. You must be able to analyze business rules, identify invariants, and apply Vaughn Vernon's four aggregate design rules to enforce transactional consistency in your software systems.
Vaughn Vernon's four rules guide effective aggregate design by focusing on transactional consistency boundaries. The rules help extract invariants from business rules, define aggregate boundaries for atomic updates, and enforce domain-driven design constraints across related entities.
j5ik2oEnforce DDD aggregate boundaries and invariants during domain design reviews.
hiiamskyImplement EF Core repository patterns for aggregate roots with Unit of Work.
yeeehaoooPublish immutable domain events from entities with post-commit dispatch.
vecearModel domain events with typed APIs, event buses, and event stores.
