Padrão Repository

Parte da seção Programação Orientada a Objetos do Journey de PHP da Coddy — lição 81 de 91.

O Repository Pattern é um padrão de projeto que faz a mediação entre a lógica de negócios da sua aplicação e o armazenamento de dados. Ele fornece uma interface semelhante a uma coleção para acessar objetos de domínio, ocultando os detalhes de como os dados são realmente armazenados ou recuperados.

Pense em um repositório como uma coleção especializada que sabe como persistir e recuperar objetos. O código da sua aplicação solicita ao repositório um usuário por ID ou salva um novo produto, sem saber se os dados residem em um banco de dados, arquivo ou API. Essa separação torna seu código mais testável e flexível.

<?php
interface UserRepositoryInterface {
    public function find(int $id): ?User;
    public function findAll(): array;
    public function save(User $user): void;
    public function delete(int $id): void;
}

class User {
    public function __construct(
        public int $id,
        public string $name,
        public string $email
    ) {}
}

A implementação do repositório lida com o mecanismo de armazenamento real:

<?php
class InMemoryUserRepository implements UserRepositoryInterface {
    private array $users = [];
    
    public function find(int $id): ?User {
        return $this->users[$id] ?? null;
    }
    
    public function findAll(): array {
        return array_values($this->users);
    }
    
    public function save(User $user): void {
        $this->users[$user->id] = $user;
    }
    
    public function delete(int $id): void {
        unset($this->users[$id]);
    }
}

$repo = new InMemoryUserRepository();
$repo->save(new User(1, "Alice", "alice@example.com"));
$repo->save(new User(2, "Bob", "bob@example.com"));

echo $repo->find(1)->name . "\n";
echo count($repo->findAll());

Saída:

Alice
2

A beleza deste padrão é que você pode trocar as implementações sem alterar sua lógica de negócio. Precisa mudar do armazenamento em memória para um banco de dados? Crie uma nova classe de repositório implementando a mesma interface. O código da sua aplicação permanece intocado porque depende da interface, não da implementação concreta.

Desafio

Fácil

Vamos construir um sistema de inventário de produtos usando o Repository Pattern. Você criará uma separação clara entre seus objetos de domínio e como eles são armazenados, permitindo que o código da sua aplicação trabalhe com produtos sem conhecer os detalhes do armazenamento.

Você organizará seu código em quatro arquivos:

Product.php — Crie uma classe Product representando itens em seu inventário. Cada produto possui um id (int), name (string) e price (float). Use a promoção de construtor com propriedades públicas para facilitar o acesso.
ProductRepositoryInterface.php — Defina uma ProductRepositoryInterface que estabelece o contrato para qualquer implementação de armazenamento de produtos. Sua interface deve declarar estes métodos:
- find(int $id): ?Product — Recupera um produto pelo ID, ou null se não for encontrado
- findAll(): array — Obtém todos os produtos como um array
- save(Product $product): void — Armazena ou atualiza um produto
- delete(int $id): void — Remove um produto pelo ID
InMemoryProductRepository.php — Inclua tanto a classe Product quanto a interface. Crie uma classe InMemoryProductRepository que implementa a interface usando um array privado para armazenar os produtos. Os produtos devem ser indexados por seu ID para uma busca eficiente. O método findAll() deve retornar apenas os objetos de produto (use array_values() para resetar as chaves do array).
main.php — Inclua o arquivo do repositório. Você receberá uma entrada: uma string JSON contendo um array de produtos para adicionar, seguida por um ID para pesquisar.
O formato JSON será:
```
[{"id": 1, "name": "Laptop", "price": 999.99}, {"id": 2, "name": "Mouse", "price": 29.99}]
```
Crie um InMemoryProductRepository, salve todos os produtos da entrada JSON e, em seguida, use a segunda entrada (o ID) para encontrar um produto específico. Imprima os resultados neste formato:
```
Total products: [count]
Found: [name] - $[price]
```
Formate o preço com duas casas decimais. Se o produto não for encontrado, imprima Found: Not found em vez disso.

O Repository Pattern brilha quando você precisa trocar as implementações de armazenamento. Seu código principal depende apenas da interface — mudar do armazenamento em memória para um banco de dados significaria criar uma nova classe de repositório sem alterar nenhuma lógica da aplicação.

Folha de consulta

O Repository Pattern (Padrão de Repositório) faz a mediação entre a lógica de negócios e o armazenamento de dados, fornecendo uma interface semelhante a uma coleção para acessar objetos de domínio enquanto oculta os detalhes de implementação do armazenamento.

Defina uma interface de repositório que estabeleça o contrato para o acesso aos dados:

<?php
interface UserRepositoryInterface {
    public function find(int $id): ?User;
    public function findAll(): array;
    public function save(User $user): void;
    public function delete(int $id): void;
}

Crie uma classe de domínio usando a promoção de construtor:

<?php
class User {
    public function __construct(
        public int $id,
        public string $name,
        public string $email
    ) {}
}

Implemente a interface do repositório com um mecanismo de armazenamento concreto:

<?php
class InMemoryUserRepository implements UserRepositoryInterface {
    private array $users = [];
    
    public function find(int $id): ?User {
        return $this->users[$id] ?? null;
    }
    
    public function findAll(): array {
        return array_values($this->users);
    }
    
    public function save(User $user): void {
        $this->users[$user->id] = $user;
    }
    
    public function delete(int $id): void {
        unset($this->users[$id]);
    }
}

Use o repositório por meio de sua interface:

$repo = new InMemoryUserRepository();
$repo->save(new User(1, "Alice", "alice@example.com"));
$user = $repo->find(1);
$allUsers = $repo->findAll();

O padrão permite trocar as implementações sem alterar a lógica de negócios — seu código depende da interface, não da implementação concreta.

Experimente você mesmo

<?php

require_once 'InMemoryProductRepository.php';

// Ler a entrada
$jsonInput = trim(fgets(STDIN));
$searchId = intval(trim(fgets(STDIN)));

// Analisar a entrada JSON em um array
$productsData = (array)json_decode($jsonInput, true);

// TODO: Criar uma instância de InMemoryProductRepository

// TODO: Percorrer $productsData e salvar cada produto
// Cada item possui as chaves 'id', 'name' e 'price'

// TODO: Obter todos os produtos e imprimir a contagem total
// Formato: "Total products: [count]"

// TODO: Encontrar o produto com $searchId
// Se encontrado, imprimir: "Found: [name] - $[price]" (preço formatado com 2 casas decimais)
// Se não for encontrado, imprimir: "Found: Not found"

?>