M09 Domain

by actionbook5c40d3ad7851No license1.5K starsListed Oct 8, 2026Updated Oct 8, 2026Repository updated 6 weeks ago

CRITICAL: Use for domain modeling. Triggers: domain model, DDD, domain-driven design, entity, value object, aggregate, repository pattern, business rules, validation, invariant, 领域模型, 领域驱动设计, 业务规则

Instructions onlySoftware Development

AI-generated overview

Guides domain modeling in Rust using DDD concepts such as entities, value objects, and aggregates.

What it does: This skill provides design guidance for translating domain concepts into Rust patterns, mapping entities, value objects, aggregate roots, repositories, domain events, and services to concrete Rust constructs. It offers thinking prompts about identity, invariants, and ownership, plus pattern templates for value objects, entities, and aggregates. It also lists common modeling mistakes and points to related skills for type-driven design, ownership, and domain error handling.
When to use it: Use it when modeling a business domain in Rust and deciding whether a concept is an entity or value object, where aggregate boundaries lie, or how to enforce invariants. It is also useful when reviewing a domain model for primitive obsession, leaked internals, or unclear ownership.
Requirements: No scripts or special tooling; it is an instructions-only reference. The examples assume Rust and familiarity with DDD terminology.

Domain Modeling

Layer 2: Design Choices

Core Question

What is this concept's role in the domain?

Before modeling in code, understand:

Is it an Entity (identity matters) or Value Object (interchangeable)?
What invariants must be maintained?
Where are the aggregate boundaries?

Domain Concept → Rust Pattern

Domain Concept	Rust Pattern	Ownership Implication
Entity	struct + Id	Owned, unique identity
Value Object	struct + Clone/Copy	Shareable, immutable
Aggregate Root	struct owns children	Clear ownership tree
Repository	trait	Abstracts persistence
Domain Event	enum	Captures state changes
Service	impl block / free fn	Stateless operations

Thinking Prompt

Before creating a domain type:

What's the concept's identity?
- Needs unique identity → Entity (Id field)
- Interchangeable by value → Value Object (Clone/Copy)
What invariants must hold?
- Always valid → private fields + validated constructor
- Transition rules → type state pattern
Who owns this data?
- Single owner (parent) → owned field
- Shared reference → Arc/Rc
- Weak reference → Weak

Trace Up ↑

To domain constraints (Layer 3):

"How should I model a Transaction?"    ↑ Ask: What domain rules govern transactions?    ↑ Check: domain-fintech (audit, precision requirements)    ↑ Check: Business stakeholders (what invariants?)

"How should I model a Transaction?"    ↑ Ask: What domain rules govern transactions?    ↑ Check: domain-fintech (audit, precision requirements)    ↑ Check: Business stakeholders (what invariants?)

Design Question	Trace To	Ask
Entity vs Value Object	domain-*	What makes two instances "the same"?
Aggregate boundaries	domain-*	What must be consistent together?
Validation rules	domain-*	What business rules apply?

Trace Down ↓

To implementation (Layer 1):

"Model as Entity"    ↓ m01-ownership: Owned, unique    ↓ m05-type-driven: Newtype for Id
"Model as Value Object"    ↓ m01-ownership: Clone/Copy OK    ↓ m05-type-driven: Validate at construction
"Model as Aggregate"    ↓ m01-ownership: Parent owns children    ↓ m02-resource: Consider Rc for shared within aggregate

"Model as Entity"    ↓ m01-ownership: Owned, unique    ↓ m05-type-driven: Newtype for Id
"Model as Value Object"    ↓ m01-ownership: Clone/Copy OK    ↓ m05-type-driven: Validate at construction
"Model as Aggregate"    ↓ m01-ownership: Parent owns children    ↓ m02-resource: Consider Rc for shared within aggregate

Quick Reference

DDD Concept	Rust Pattern	Example
Value Object	Newtype	`struct Email(String);`
Entity	Struct + ID	`struct User { id: UserId, ... }`
Aggregate	Module boundary	`mod order { ... }`
Repository	Trait	`trait UserRepo { fn find(...) }`
Domain Event	Enum	`enum OrderEvent { Created, ... }`

Pattern Templates

Value Object

rust

struct Email(String);
impl Email {    pub fn new(s: &str) -> Result<Self, ValidationError> {        validate_email(s)?;        Ok(Self(s.to_string()))    }}

struct Email(String);
impl Email {    pub fn new(s: &str) -> Result<Self, ValidationError> {        validate_email(s)?;        Ok(Self(s.to_string()))    }}

Entity

rust

struct UserId(Uuid);
struct User {    id: UserId,    email: Email,    // ... other fields}
impl PartialEq for User {    fn eq(&self, other: &Self) -> bool {        self.id == other.id  // Identity equality    }}

struct UserId(Uuid);
struct User {    id: UserId,    email: Email,    // ... other fields}
impl PartialEq for User {    fn eq(&self, other: &Self) -> bool {        self.id == other.id  // Identity equality    }}

Aggregate

rust

mod order {    pub struct Order {        id: OrderId,        items: Vec<OrderItem>,  // Owned children        // ...    }
    impl Order {        pub fn add_item(&mut self, item: OrderItem) {            // Enforce aggregate invariants        }    }}

mod order {    pub struct Order {        id: OrderId,        items: Vec<OrderItem>,  // Owned children        // ...    }
    impl Order {        pub fn add_item(&mut self, item: OrderItem) {            // Enforce aggregate invariants        }    }}

Common Mistakes

Mistake	Why Wrong	Better
Primitive obsession	No type safety	Newtype wrappers
Public fields with invariants	Invariants violated	Private + accessor
Leaked aggregate internals	Broken encapsulation	Methods on root
String for semantic types	No validation	Validated newtype

Related Skills

Source and attribution

Source:actionbook/rust-skillsinskills/m09-domainat commit5c40d3a

License: No license

Content belongs to its original authors. SourceWeft indexes it from a public repository.

Report or request removal

When	See
Type-driven implementation	m05-type-driven
Ownership for aggregates	m01-ownership
Domain error handling	m13-domain-error
Specific domain rules	domain-*

M09 Domain

Domain Modeling

Core Question

Domain Concept → Rust Pattern

Thinking Prompt

Trace Up ↑

Trace Down ↓

Quick Reference

Pattern Templates

Value Object

Entity

Aggregate

Common Mistakes

Related Skills

Source and attribution

More from actionbook/rust-skills

Rust Trait Explorer

Rust Symbol Analyzer

Rust Skill Creator

Rust Router

Rust Refactor Helper

Rust Daily

More in Software Development

Playground

M5 Onboard

Cardputer Buddy

Web Design Guidelines

Vercel React Native Skills

Vercel React Best Practices