Claude-skill-registry acc-create-aggregate

Generates DDD Aggregates for PHP 8.5. Creates consistency boundaries with root entity, domain events, and invariant protection. Includes unit tests.

install

source · Clone the upstream repo

git clone https://github.com/majiayu000/claude-skill-registry

Claude Code · Install into ~/.claude/skills/

T=$(mktemp -d) && git clone --depth=1 https://github.com/majiayu000/claude-skill-registry "$T" && mkdir -p ~/.claude/skills && cp -r "$T/skills/data/acc-create-aggregate" ~/.claude/skills/majiayu000-claude-skill-registry-acc-create-aggregate && rm -rf "$T"

manifest: skills/data/acc-create-aggregate/SKILL.md

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/

```
AggregateRoot.php
```
— Base class with event recording

Step 2: Generate Aggregate Root Entity

Path:

src/Domain/{BoundedContext}/Entity/

```
{Name}.php
```
— Main aggregate root

Step 3: Generate Child Entities (if needed)

Path:

src/Domain/{BoundedContext}/Entity/

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

Step 4: Generate Domain Events

Path:

src/Domain/{BoundedContext}/Event/

```
{Name}CreatedEvent.php
```
```
{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