Aggregate Generator

Generate DDD-compliant Aggregates with root, domain events, and tests.

Aggregate Characteristics

• Consistency boundary: All changes atomic
• Root entity: Single entry point
• Transactional consistency: Invariants always valid
• Domain events: Records what happened
• Encapsulation: Children accessed through root
• Identity: Referenced by root ID

---

Generation Process

Step 1: Generate Base AggregateRoot

Path: src/Domain/Shared/Aggregate/

1. AggregateRoot.php — Base class with event recording

Step 2: Generate Aggregate Root Entity

Path: src/Domain/{BoundedContext}/Entity/

1. {Name}.php — Main aggregate root

Step 3: Generate Child Entities (if needed)

Path: src/Domain/{BoundedContext}/Entity/

1. {ChildName}.php — Child entity inside aggregate

Step 4: Generate Domain Events

Path: src/Domain/{BoundedContext}/Event/

1. {Name}CreatedEvent.php
2. {Name}{Action}Event.php for each behavior

Step 5: Generate Tests

Path: tests/Unit/Domain/{BoundedContext}/Entity/

---

File Placement

Component	Path
Base AggregateRoot	src/Domain/Shared/Aggregate/
Aggregate Entity	src/Domain/{BoundedContext}/Entity/
Child Entities	src/Domain/{BoundedContext}/Entity/
Domain Events	src/Domain/{BoundedContext}/Event/
Unit Tests	tests/Unit/Domain/{BoundedContext}/Entity/

---

Naming Conventions

Component	Pattern	Example
Aggregate Root	{Name}	Order
Child Entity	{Parent}{Name}	OrderLine
Created Event	{Name}CreatedEvent	OrderCreatedEvent
State Event	{Name}{Action}Event	OrderConfirmedEvent

---

Quick Template Reference

Base AggregateRoot

abstract class AggregateRoot
{
    private array $events = [];

    protected function recordEvent(DomainEvent $event): void
    {
        $this->events[] = $event;
    }

    public function releaseEvents(): array
    {
        $events = $this->events;
        $this->events = [];
        return $events;
    }
}

Aggregate Root Entity

final class {Name} extends AggregateRoot
{
    private {Name}Status $status;

    private function __construct(
        private readonly {Name}Id $id,
        {properties}
    ) {
        $this->status = {Name}Status::Draft;
    }

    public static function create({Name}Id $id, {params}): self
    {
        $aggregate = new self($id, {args});

        $aggregate->recordEvent(new {Name}CreatedEvent(...));

        return $aggregate;
    }

    public function {behavior}({params}): void
    {
        $this->ensureValidState();
        // Apply change
        $this->recordEvent(new {Name}{Behavior}Event(...));
    }
}

Child Entity

final readonly class {ChildName}
{
    public function __construct(
        public {PropertyType} $property1,
        public {PropertyType} $property2
    ) {}

    public function total(): Money
    {
        return $this->unitPrice->multiply($this->quantity);
    }
}

---

Design Rules

Rule	Good	Bad
Transaction Boundary	One aggregate per transaction	Multiple aggregates
Reference	By ID only	Full entity reference
Size	Small, focused	Large with many collections
Invariants	Always valid	Can be in invalid state
Events	Record all state changes	No event recording

---

Anti-patterns to Avoid

Anti-pattern	Problem	Solution
Large Aggregate	Performance issues	Split into smaller aggregates
Entity References	Tight coupling	Use IDs only
Public Setters	No invariant protection	Use behavior methods
Missing Events	Can't track history	Record event for each change
No Root	Multiple entry points	Single root entity

---

References

For complete PHP templates and examples, see:

• references/templates.md — AggregateRoot, Entity, Child Entity, Test templates
• references/examples.md — Order aggregate with OrderLine, events, and tests