Repository Generator

Repository Generator

Generate DDD-compliant Repository interfaces and implementation stubs.

Repository Characteristics

• Interface in Domain: Contract defined in Domain layer
• Implementation in Infrastructure: Doctrine/​Eloquent/​etc. implementation
• Works with Aggregates: Not entities directly
• Collection-like: Find, save, remove operations
• No business logic: Only persistence operations

---

Generation Process

Step 1: Generate Interface

Path: src/​Domain/​{BoundedContext}/​Repository/

1. {AggregateRoot}RepositoryInterface.php — Domain contract

Step 2: Generate Implementation

Path: src/​Infrastructure/​Persistence/​Doctrine/

1. Doctrine{AggregateRoot}Repository.php — Doctrine implementation

Step 3: Generate In-Memory Repository (Optional)

Path: tests/​Infrastructure/​Persistence/

1. InMemory{AggregateRoot}Repository.php — For unit testing

Step 4: Generate Integration Tests

Path: tests/​Integration/​Infrastructure/​Persistence/

---

File Placement

---

Naming Conventions

---

Quick Template Reference

Interface

interface {AggregateRoot}RepositoryInterface
{
    public function findById({AggregateRoot}Id $id): ?{AggregateRoot};

    public function save({AggregateRoot} $aggregate): void;

    public function remove({AggregateRoot} $aggregate): void;

    public function nextIdentity(): {AggregateRoot}Id;
}

Doctrine Implementation

final readonly class Doctrine{AggregateRoot}Repository implements {AggregateRoot}RepositoryInterface
{
    public function __construct(
        private EntityManagerInterface $em
    ) {}

    public function findById({AggregateRoot}Id $id): ?{AggregateRoot}
    {
        return $this->em->find({AggregateRoot}::class, $id->value);
    }

    public function save({AggregateRoot} $aggregate): void
    {
        $this->em->persist($aggregate);
        $this->em->flush();
    }

    public function remove({AggregateRoot} $aggregate): void
    {
        $this->em->remove($aggregate);
        $this->em->flush();
    }

    public function nextIdentity(): {AggregateRoot}Id
    {
        return {AggregateRoot}Id::generate();
    }
}

In-Memory Implementation

final class InMemory{AggregateRoot}Repository implements {AggregateRoot}RepositoryInterface
{
    private array $items = [];

    public function findById({AggregateRoot}Id $id): ?{AggregateRoot}
    {
        return $this->items[$id->value] ?? null;
    }

    public function save({AggregateRoot} $aggregate): void
    {
        $this->items[$aggregate->id()->value] = $aggregate;
    }

    public function clear(): void
    {
        $this->items = [];
    }
}

---

Design Rules

---

Anti-patterns to Avoid

---

References

For complete PHP templates and examples, see:

• references/​templates.md — Interface, Doctrine, In-Memory, Test templates
• references/​examples.md — Order, User repositories with Doctrine and In-Memory implementations