dykyi-roman/awesome-claude-code/create-aggregate

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

Naming Conventions

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

Anti-patterns to Avoid

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