README

This package will help you generate fake entities and persist them to your ORM.

<?php

use Butschster\EntityFaker\LaminasEntityFactory;
use Laminas\Hydrator\ReflectionHydrator;
use Faker\Factory as Faker;

$factory = new \Butschster\EntityFaker\Factory(
    new LaminasEntityFactory(
        new ReflectionHydrator()
    ),
    Faker::create()
);

class User 
{
    private string $id;
    private string $username;
    private string $email;
    
    public function __construct(string $id, string $username, string $email) 
    {
        $this->id = $id;
        $this->username = $username;
        $this->email = $email;
    }
}

class SuperUser extends User
{
    private bool $isAdmin = false;
    
    public function __construct(string $id, string $username, string $email, bool $isAdmin) 
    {
        parent::__construct($id, $username, $email);
        $this->isAdmin = $isAdmin;
    }
}

$factory->define(User::class, function (Faker $faker, array $attributes) {
    return [
        'id' => $faker->uuid,
        'username' => $faker->username,
        'email' => $faker->email
    ];
});

$factory->define(SuperUser::class, function (Faker $faker, array $attributes) use($factory) {
    $userAttributes = $factory->raw(User::class);
    
    return $userAttributes + [
        'isAdmin' => $faker->boolean
    ];
});

Create and persist an entity

$user = $factory->of(User::class)->create();

//class User {
//  private string $id = "0b13e52d-b058-32fb-8507-10dec634a07c";
//  private string $username = "zetta86";
//  private string $email = "tsteuber@hotmail.com";
//}

Create and persist multiply entities

$users = $factory->of(User::class)->times(10)->create();

//[
//    class User {
//      private string $id = "0b13e52d-b058-32fb-8507-10dec634a07c";
//      private string $username = "zetta86";
//      private string $email = "tsteuber@hotmail.com";
//    },
//    ...
//]

Create and persist an entity with predefined attributes

$user = $factory->of(User::class)->create([
    'email' => 'admin@site.com'
]);

//class User {
//  private string $id = "0b13e52d-b058-32fb-8507-10dec634a07c";
//  private string $username = "zetta86";
//  private string $email = "admin@site.com";
//}

Create an entity

$user = $factory->of(User::class)->make();

//class User {
//  private string $id = "0b13e52d-b058-32fb-8507-10dec634a07c";
//  private string $username = "zetta86";
//  private string $email = "tsteuber@hotmail.com";
//}

Create multiply entities

$users = $factory->of(User::class)->times(10)->make();

//[
//    class User {
//      private string $id = "0b13e52d-b058-32fb-8507-10dec634a07c";
//      private string $username = "zetta86";
//      private string $email = "tsteuber@hotmail.com";
//    },
//    ...
//]

Create an entity with predefined attributes

$user = $factory->of(User::class)->make([
    'email' => 'admin@site.com'
]);

//class User {
//  private string $id = "0b13e52d-b058-32fb-8507-10dec634a07c";
//  private string $username = "zetta86";
//  private string $email = "admin@site.com";
//}

Get raw attributes for entity

$attributes = $factory->of(SuperUser::class)->raw();

//[
//    'id' => "0b13e52d-b058-32fb-8507-10dec634a07c",
//    'username' => 'zetta86',
//    'email' => 'tsteuber@hotmail.com',
//]

Get raw attributes for entity with predefined values

$attributes = $factory->of(SuperUser::class)->raw([
    'email' => 'test@site.com'
]);

//[
//    'id' => "0b13e52d-b058-32fb-8507-10dec634a07c",
//    'username' => 'zetta86',
//    'email' => 'test@site.com',
//]

Generate array of all defined entities

$repository = $factory->make(1000);

$seeds = $repository->get(User::class)->random(100);

$seeds = $repository->get(SuperUser::class)->take(50);

Generate array of raw data for all defined entities

$repository = $factory->raw(1000);

$seeds = $repository->get(User::class)->random(100);

$seeds = $repository->get(SuperUser::class)->take(50);

Export array of raw data to a file for given entity to php file

$path = $factory->of(SuperUser::class)->times(1000)->export('path/to/store');
// path/to/store/SuperUser.php

Export array of raw data to a files for all defined entities

$repository = $factory->export('path/to/store', 1000);
$seeds = $repository->get(User::class)->random(100);

Custom entity builder

You can define your own EntityBuilder class with custom persist logic.

use Butschster\EntityFaker\EntityFactoryInterface;
use Faker\Factory as Faker;
use Cycle\ORM\ORMInterface;
use Cycle\ORM\TransactionInterface;

class CycleOrmEntityFactory implements EntityFactoryInterface 
{
    private array $afterCreation = [];
    private array $beforeCreation = [];

    protected ORMInterface $orm;
    protected Transaction $transaction;

    public function __construct(ORMInterface $orm)
    {
        $this->orm = $orm;

        $this->beforeCreation(function () {
            $this->transaction = new Transaction($this->orm);
        });

        $this->afterCreation(function () {
            $this->transaction->run();
        });
    }

    public function store(object $entity): void
    {
        $this->transaction->persist($entity);
    }

    public function hydrate(object $entity, array $data): object
    {
        return $this->orm->getMapper($entity)->hydrate($entity, $data);
    }

    /**
     * Add a callback to run after creating an entity or array of entities.
     * @param callable $callback
     */
    public function afterCreation(callable $callback): void
    {
        $this->afterCreation[] = $callback;
    }

    public function afterCreationCallbacks(): array
    {
        return $this->afterCreation;
    }

    /**
     * Add a callback to run before creating an entity or array of entities.
     * @param callable $callback
     */
    public function beforeCreation(callable $callback): void
    {
        $this->beforeCreation[] = $callback;
    }

    public function beforeCreationCallbacks(): array
    {
        return $this->beforeCreation;
    }
}

$factory = new \Butschster\EntityFaker\Factory(
    new CycleOrmEntityFactory(...),
    Faker::create()
);