domain-layer

Building a Rust DDD domain layer without cross-crate dependencies requires enforcing strict domain purity and layer separation. This Skill ensures aggregates, value objects, and entities remain isolated by preventing forbidden cross-crate imports and encapsulating state changes exclusively within the domain crate.

Structuring Rust repository traits for domain-driven design involves matching established aggregate patterns. This Skill guides you to implement repository traits that align with existing book and user aggregate conventions, separating persistence hydration from input validation to maintain a pure domain layer.

Mixing input validation with persistence hydration in a Rust DDD aggregate breaks domain purity. This Skill enforces the separation of these concerns, ensuring persistence hydration logic is isolated from input validation to maintain consistent domain layer implementation across aggregates, entities, and value objects.

Adding mandatory audit and permission checks to Rust DDD entities requires encapsulating state changes within the entity itself. This Skill enforces these rules automatically, ensuring all entity updates include proper audit logic and permission validations before any state modification occurs in the domain crate.

Yes, you can use this Skill to add new aggregates to an existing Rust DDD project. It enforces repository conventions for adding or modifying aggregates, value objects, and entities, ensuring new implementations like a book checkout event aggregate match established domain patterns without introducing cross-crate dependencies.

You need to enforce domain purity in a Rust software architecture project whenever adding or modifying domain layer components like aggregates, repository traits, or entities. This Skill ensures layer separation is maintained, preventing cross-crate dependencies and keeping state changes encapsulated within the domain crate.