Patrón Repository

from dataclasses import dataclass
from enum import Enum


class Estado(Enum):
    PENDIENTE = "PENDIENTE"
    ENVIADO = "ENVIADO"
    ENTREGADO = "ENTREGADO"


@dataclass(frozen=True)
class Pedido:
    id: int
    cliente: str
    total: float
    estado: Estado


class RepositorioPedidos:
    """Se usa como una colección de pedidos, con consultas que se llaman como las del negocio."""
    def __init__(self):
        self._pedidos = {}

    def guardar(self, p):                     # inserta o, si ya existe, sustituye
        self._pedidos[p.id] = p

    def por_id(self, id):
        return self._pedidos.get(id)

    def buscar(self, criterio):
        return [p for _, p in sorted(self._pedidos.items()) if criterio(p)]

    def pendientes_de(self, cliente):
        return self.buscar(lambda p: p.cliente == cliente and p.estado == Estado.PENDIENTE)

    def mas_caros_que(self, importe):
        return self.buscar(lambda p: p.total > importe)


def ids(pedidos):
    return ", ".join(f"#{p.id}" for p in pedidos) or "ninguno"


repo = RepositorioPedidos()
repo.guardar(Pedido(1, "Ana", 45.0, Estado.PENDIENTE))
repo.guardar(Pedido(2, "Luis", 120.5, Estado.ENVIADO))
repo.guardar(Pedido(3, "Ana", 230.0, Estado.PENDIENTE))
repo.guardar(Pedido(4, "Ana", 15.0, Estado.ENTREGADO))
print(f"Pendientes de Ana: {ids(repo.pendientes_de('Ana'))}")
print(f"Más de 100 €: {ids(repo.mas_caros_que(100))}")
repo.guardar(Pedido(1, "Ana", 45.0, Estado.ENVIADO))          # mismo id: se actualiza
print(f"Pendientes de Ana tras enviar el #1: {ids(repo.pendientes_de('Ana'))}")
p = repo.por_id(2)
print(f"Pedido #2: {p.cliente + ', ' + p.estado.value if p else 'no existe'}")

/** Se usa como una colección de pedidos, con consultas que se llaman como las del negocio. */
class RepositorioPedidos {
    #pedidos = new Map();

    guardar(p) { this.#pedidos.set(p.id, p); }             // inserta o, si ya existe, sustituye
    porId(id) { return this.#pedidos.get(id) ?? null; }

    buscar(criterio) {
        return [...this.#pedidos.values()].sort((a, b) => a.id - b.id).filter(criterio);
    }

    pendientesDe(cliente) { return this.buscar((p) => p.cliente === cliente && p.estado === "PENDIENTE"); }
    masCarosQue(importe) { return this.buscar((p) => p.total > importe); }
}

const ids = (pedidos) => pedidos.map((p) => `#${p.id}`).join(", ") || "ninguno";

const repo = new RepositorioPedidos();
repo.guardar({ id: 1, cliente: "Ana", total: 45.0, estado: "PENDIENTE" });
repo.guardar({ id: 2, cliente: "Luis", total: 120.5, estado: "ENVIADO" });
repo.guardar({ id: 3, cliente: "Ana", total: 230.0, estado: "PENDIENTE" });
repo.guardar({ id: 4, cliente: "Ana", total: 15.0, estado: "ENTREGADO" });
console.log(`Pendientes de Ana: ${ids(repo.pendientesDe("Ana"))}`);
console.log(`Más de 100 €: ${ids(repo.masCarosQue(100))}`);
repo.guardar({ id: 1, cliente: "Ana", total: 45.0, estado: "ENVIADO" });   // mismo id: se actualiza
console.log(`Pendientes de Ana tras enviar el #1: ${ids(repo.pendientesDe("Ana"))}`);
const p = repo.porId(2);
console.log(`Pedido #2: ${p ? `${p.cliente}, ${p.estado}` : "no existe"}`);

using System;
using System.Collections.Generic;
using System.Linq;

enum Estado { PENDIENTE, ENVIADO, ENTREGADO }

record Pedido(int Id, string Cliente, decimal Total, Estado Estado);

// Un repositorio genérico: se usa como una colección de objetos del dominio.
interface IRepositorio<T, TId> {
    void Guardar(T entidad);
    T? PorId(TId id);
    List<T> Buscar(Func<T, bool> criterio);
}

// El de pedidos añade consultas con nombre del negocio (métodos por defecto de la interfaz).
interface IRepositorioPedidos : IRepositorio<Pedido, int> {
    List<Pedido> PendientesDe(string cliente) => Buscar(p => p.Cliente == cliente && p.Estado == Estado.PENDIENTE);
    List<Pedido> MasCarosQue(decimal importe) => Buscar(p => p.Total > importe);
}

class RepositorioPedidosMemoria : IRepositorioPedidos {
    private readonly SortedDictionary<int, Pedido> pedidos = new();
    public void Guardar(Pedido p) => pedidos[p.Id] = p;
    public Pedido? PorId(int id) => pedidos.GetValueOrDefault(id);
    public List<Pedido> Buscar(Func<Pedido, bool> criterio) => pedidos.Values.Where(criterio).ToList();
}

class Program {
    static string Ids(List<Pedido> pedidos) => pedidos.Count == 0 ? "ninguno" : string.Join(", ", pedidos.Select(p => 
quot;#{p.Id}"));

    static void Main() {
        IRepositorioPedidos repo = new RepositorioPedidosMemoria();
        repo.Guardar(new Pedido(1, "Ana", 45.0m, Estado.PENDIENTE));
        repo.Guardar(new Pedido(2, "Luis", 120.5m, Estado.ENVIADO));
        repo.Guardar(new Pedido(3, "Ana", 230.0m, Estado.PENDIENTE));
        repo.Guardar(new Pedido(4, "Ana", 15.0m, Estado.ENTREGADO));
        Console.WriteLine(
quot;Pendientes de Ana: {Ids(repo.PendientesDe("Ana"))}");
        Console.WriteLine(
quot;Más de 100 €: {Ids(repo.MasCarosQue(100))}");
        repo.Guardar(new Pedido(1, "Ana", 45.0m, Estado.ENVIADO));        // mismo id: se actualiza
        Console.WriteLine(
quot;Pendientes de Ana tras enviar el #1: {Ids(repo.PendientesDe("Ana"))}");
        var p = repo.PorId(2);
        Console.WriteLine(
quot;Pedido #2: {(p != null ? 
quot;{p.Cliente}, {p.Estado}" : "no existe")}");
    }
}

<?php
enum Estado: string { case PENDIENTE = "PENDIENTE"; case ENVIADO = "ENVIADO"; case ENTREGADO = "ENTREGADO"; }

final class Pedido {
    public function __construct(public int $id, public string $cliente, public float $total, public Estado $estado) {}
}

/** Se usa como una colección de pedidos, con consultas que se llaman como las del negocio. */
class RepositorioPedidos {
    private array $pedidos = [];

    public function guardar(Pedido $p): void { $this->pedidos[$p->id] = $p; ksort($this->pedidos); }
    public function porId(int $id): ?Pedido { return $this->pedidos[$id] ?? null; }

    public function buscar(callable $criterio): array {
        return array_values(array_filter($this->pedidos, $criterio));
    }

    public function pendientesDe(string $cliente): array {
        return $this->buscar(fn (Pedido $p) => $p->cliente === $cliente && $p->estado === Estado::PENDIENTE);
    }

    public function masCarosQue(float $importe): array {
        return $this->buscar(fn (Pedido $p) => $p->total > $importe);
    }
}

function ids(array $pedidos): string {
    return $pedidos ? implode(", ", array_map(fn (Pedido $p) => "#{$p->id}", $pedidos)) : "ninguno";
}

$repo = new RepositorioPedidos();
$repo->guardar(new Pedido(1, "Ana", 45.0, Estado::PENDIENTE));
$repo->guardar(new Pedido(2, "Luis", 120.5, Estado::ENVIADO));
$repo->guardar(new Pedido(3, "Ana", 230.0, Estado::PENDIENTE));
$repo->guardar(new Pedido(4, "Ana", 15.0, Estado::ENTREGADO));
echo "Pendientes de Ana: ", ids($repo->pendientesDe("Ana")), "\n";
echo "Más de 100 €: ", ids($repo->masCarosQue(100)), "\n";
$repo->guardar(new Pedido(1, "Ana", 45.0, Estado::ENVIADO));         // mismo id: se actualiza
echo "Pendientes de Ana tras enviar el #1: ", ids($repo->pendientesDe("Ana")), "\n";
$p = $repo->porId(2);
echo "Pedido #2: ", $p ? "{$p->cliente}, {$p->estado->value}" : "no existe", "\n";

# SQLAlchemy: la sesión y select() hacen de repositorio; se suele envolver en una clase propia
class RepositorioPedidos:
    def __init__(self, sesion):
        self._sesion = sesion

    def guardar(self, pedido):
        self._sesion.add(pedido)

    def pendientes_de(self, cliente):
        consulta = select(Pedido).where(Pedido.cliente == cliente, Pedido.estado == "PENDIENTE")
        return self._sesion.scalars(consulta).all()

// TypeORM: el repositorio de cada entidad viene hecho
const repo = dataSource.getRepository(Pedido);
await repo.save({ cliente: "Ana", total: 45, estado: "PENDIENTE" });
const pendientes = await repo.findBy({ cliente: "Ana", estado: "PENDIENTE" });
const caros = await repo.find({ where: { total: MoreThan(100) }, order: { total: "DESC" } });

// Entity Framework Core: cada DbSet<T> es un repositorio, y las consultas se escriben con LINQ
public class TiendaContext : DbContext {
    public DbSet<Pedido> Pedidos => Set<Pedido>();
}

var pendientes = await contexto.Pedidos
    .Where(p => p.Cliente == "Ana" && p.Estado == Estado.PENDIENTE)
    .OrderBy(p => p.Id)
    .ToListAsync();

<?php
// Doctrine (Symfony): cada entidad tiene su repositorio, que se puede ampliar con consultas propias
class PedidoRepository extends ServiceEntityRepository {
    public function pendientesDe(string $cliente): array {
        return $this->findBy(["cliente" => $cliente, "estado" => "PENDIENTE"], ["id" => "ASC"]);
    }
}