What is a pattern called when it combines factory with repository pattern to create or update/reload objects?

Question

Example with MySQL:

/*
 * Used to create a populated Staff instance
 */
class StaffCreator
{
    /** @var MySql */
    private $mySql;

    function __construct(MySql $mySql)
    {
        $this->mySql = $mySql;
    }

    function createStaff(string $username): Staff
    {
        $staff = new Staff();
        $staff->setData($this->getData($username));
        return $staff;
    }

    function getData(string $username): array
    {
        return $this->mySql
            ->query("SELECT .. WHERE username = ?")->param($username)->getResults();
    }
}

//calling:
$staff = (new StaffCreator($mysql))->createStaff($username);

Example with Doctrine:

/**
 * Creates Ledger
 */
class LedgerCreator
{
    private $doctrine;

    function __construct(EntityManager $doctrine)
    {
        $this->doctrine = $doctrine;
    }

    /**
     * Create Domain entity called Ledger,
     * populate it with items and metadata
     * Return it
     */
    function getLedger(int $ledgerId): Ledger
    {
        $query = $this->doctrine->createQuery('
            SELECT ...
            FROM ...
            WHERE ...
        ')->setParameter('ledger_id', $ledgerId);

        //create, init, populate, and return Ledger instance
        $ledger = new Ledger($this->doctrine->find(LedgerEntity::class, $ledgerId));
        $ledger->setItems($query->getResult());
        return $ledger;
    }
}

//to call:
$ledger = new LedgerCreator($doctrine)->createLedger($id);

Is this pattern a factory? A repository? DataMapper? A hybrid? Something else?

Answer 1

This kind of looks like a Memento. From the PHP Design Patterns reference:

In the Memento pattern a memento object will hold the state of another object.

From Wikipedia:

The memento pattern is implemented with three objects: the originator, a caretaker and a memento. The originator is some object that has an internal state. The caretaker is going to do something to the originator, but wants to be able to undo the change. The caretaker first asks the originator for a memento object.

In this example, the BookMark class is the "Memento", and holds the state of the BookReader class. The BookReader class would be the "Originator" in this example, as it had the original state. TestMemento.php holds the BookMark object, and so is the "Caretaker".

Relative to your examples:

            ----------- Example -----------
Participant | Mysql        | Doctrine
============|==============|==============
Originator  | MySql        | EntityManager
Caretaker   | StaffCreator | LedgerCreator
Memento     | Staff        | Ledger

Answer 2

It's a perverted version of builder. It creates an instance of object with given properties. It's combined with data mapper and repository))