teste.php

<?php

interface ModelInterface
{
    public function fields(): array;
}

class Item implements ModelInterface
{
    private $value;
    private $quantity;

    public function __construct($value, $quantity)
    {
        if ($value === null)
        {
            throw new Exception('Valor não pode ser nulo');
        }
        
        if ($quantity === null)
        {
            throw new Exception('Valor não pode ser nulo');
        }
        
        $this->value = $value;
        $this->quantity = $quantity;
    }

    public function fields(): array
    {
        return [
            'value' => 'valor',
            'quantity' => 'quantidade',
        ];
    }

    public function getValue(): string {
        $this->value;
    } 

    public function getQuantity(): string {
        $this->quantity;
    } 
}

interface EntityManagerInterface
{
    public function getRepository(string $modelName);
}

class DbManager implements EntityManagerInterface
{
    public function getRepository(string $modelName): EntityRepository {
        return new EntityRepository($modelName);
    }
}

class EntityRepository
{
    private $reflectionClass;

    public function __construct(string $modelName)
    {
        if (!class_exists($modelName)) {
            throw new Exception("class not exists");
        }

        $reflectionClass = new ReflectionClass($modelName);

        if (!$reflectionClass->implementsInterface(ModelInterface::class)) {
            throw new Exception("class not instance of ModelInterface");
        }

        $this->reflectionClass = $reflectionClass;
    }

    public function fromRows(array $rows) {
        $instance = $this->getNewInstance();

        foreach($rows as $row) {
            $this->setValues($instance, $row);
        }

        return $instance;
    }

    public function fromRow(array $row) {
        $instance = $this->getNewInstance();
        $this->setValues($instance, $row);

        return $instance;
    }

    private function getNewInstance(): ModelInterface {
        return $this->reflectionClass->newInstanceWithoutConstructor();
    }

    private function setValues($instance, $row) {
        foreach ($instance->fields() as $propertyName => $columnName) {
            if (!isset($row[$columnName])) {
                continue;
            }

            $this->setValue($instance, $propertyName, $row[$columnName]);
        }
    }

    private function setValue($object, string $propertyName, $value) {
        if (!$this->reflectionClass->hasProperty($propertyName)) {
            return;
        }

        $property = $this->reflectionClass->getProperty($propertyName);
        $property->setAccessible(true);
        $property->setValue($object, $value);
    }
}

class ItemRepository {
    private $repository;

    public function __construct(EntityManagerInterface $entityManager) {
        $this->repository = $entityManager->getRepository(Item::class);
    }

    public function getOne(): Item {
        $row = ['valor' => '123', 'quantidade' => 'teste de valor', 'not_exists' => 'werer'];

        return $this->repository->fromRow($row);
    }

    public function getAll() {
        $rows = [['valor' => '123', 'quantidade' => null, 'not_exists' => 'werer']];
        return $this->repository->fromRows($rows);
    }
}


$db = new DbManager();
$repository = new ItemRepository($db);

var_dump($repository->getOne());
var_dump($repository->getAll());