Create Repository

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