Laravel Doctrine ORM

https://github.com/laravel-doctrine/orm
Admin
Laravel Doctrine ORM is an integration library that bridges Laravel and Doctrine ORM, providing...
Tokens:44,123
Snippets:355
Trust Score:7.4
License:MIT
Update:4 weeks ago
Show doc for...
Tokens:
Raw
### Install laravel-doctrine/extensions package

Source: https://github.com/laravel-doctrine/orm/blob/3.3.x/docs/configuration.rst

Run this command to install the extensions package required for using custom DQL functions.

```bash
doctrine require laravel-doctrine/extensions
```

--------------------------------

### Install extensions package

Source: https://github.com/laravel-doctrine/orm/blob/3.3.x/docs/configuration.rst

Composer command to install the laravel-doctrine/extensions package, required to use the extensions listed in the configuration.

```bash
composer require laravel-doctrine/extensions
```

--------------------------------

### Install via Composer

Source: https://github.com/laravel-doctrine/orm/blob/3.3.x/docs/install.rst

Use composer to require the laravel-doctrine/orm package.

```default
$ composer require laravel-doctrine/orm
```

--------------------------------

### Use namespace alias in repository call

Source: https://github.com/laravel-doctrine/orm/blob/3.3.x/docs/configuration.rst

Shows how to get a repository using a namespace alias in PHP. The alias 'Bar' is used as 'Bar:SomeEntity'.

```php
EntityManager::getRepository('Bar:SomeEntity');
```

--------------------------------

### Accessing the Entity Manager via Facade, Container, and Registry

Source: https://github.com/laravel-doctrine/orm/blob/3.3.x/CLAUDE.md

Shows multiple ways to obtain the EntityManager: using the EntityManager facade, resolving from the container via EntityManagerInterface or 'em', and using the ManagerRegistry to get a specific manager or the manager for a specific entity class.

```php
// Via facade
EntityManager::persist($entity);

// Via container
app(EntityManagerInterface::class);
app('em');

// Via registry
$registry = app(ManagerRegistry::class);
$em = $registry->getManager('default');

// For specific entity class
$em = $registry->getManagerForClass(User::class);
```

--------------------------------

### Define a notification with toEntity method for Doctrine channel

Source: https://github.com/laravel-doctrine/orm/blob/3.3.x/docs/notifications.rst

Example notification class that uses the DoctrineChannel and implements the required toEntity method, returning a new Notification instance with fluent methods.

```php
namespace App\Notifications;

class InvoicePaid extends \Illuminate\Notifications\Notification
{
    /**
    * Get the notification's delivery channels.
    *
    * @param  mixed $notifiable
    * @return array
    */
    public function via($notifiable)
    {
        return [\LaravelDoctrine\ORM\Notifications\DoctrineChannel::class];
    }

    /**
    * @param $notifiable
    * @return $this
    */
    public function toEntity($notifiable)
    {
        return (new \App\Entities\Notification)
            ->to($notifiable)
            ->success()
            ->message('Some message')
            ->action('Bla', 'http://test.net');
    }
}
```

--------------------------------

### Inject ManagerRegistry to get a specific entity manager

Source: https://github.com/laravel-doctrine/orm/blob/3.3.x/docs/entity-manager.rst

Inject ManagerRegistry to select a specific entity manager when multiple are configured.

```php
use Doctrine\Common\Persistence\ManagerRegistry;
use Doctrine\ORM\EntityManager;

class ExampleController extends Controller
{
    protected EntityManager $entityManager;

    public function __construct(ManagerRegistry $managerRegistry)
    {
        $this->entityManager = $managerRegistry->getManager('second');
    }
}
```

--------------------------------

### Create Notification entity extending LaravelDoctrine\ORM\Notifications\Notification

Source: https://github.com/laravel-doctrine/orm/blob/3.3.x/docs/notifications.rst

Define a Doctrine entity that extends the base Notification class. The example includes a ManyToOne relation to the User entity.

```php
namespace App\Entities;

use Doctrine\ORM\Mapping AS ORM;

#[ORM\Entity]
class Notification extends \LaravelDoctrine\ORM\Notifications\Notification
{
    #[ORM\ManyToOne(targetEntity: \App\Entities\User::class)]

    protected $user;
}
```

--------------------------------

### Define an entity with a custom repository class and get its repository

Source: https://github.com/laravel-doctrine/orm/blob/3.3.x/docs/repositories.rst

Shows a Scientist entity using PHP attributes to specify a custom repository class, and then retrieves the repository via EntityManager::getRepository(). The entity includes an id, first and last name fields, and a one-to-many relationship to Theory entities. The repository returned is an instance of the specified repositoryClass, or the configured default repository class if none is set.

```php
use Doctrine\ORM\Mapping as ORM;
use Doctrine\Common\Collections\ArrayCollection;
use Doctrine\Common\Collections\Collection;

#[ORM\Entity(repositoryClass: "App\Doctrine\ORM\Repository\ScientistRepository")]
class Scientist
{
    #[ORM\Id]
    #[ORM\Column(type: "integer")]
    #[ORM\GeneratedValue(strategy: "AUTO")]
    private int $id;

    #[ORM\Column(type: "string", nullable: false)]
    private string $firstName;

    #[ORM\Column(type: "string", nullable: false)]
    private string $lastName;

    #[ORM\OneToMany(targetEntity: Theory::class, mappedBy: "scientist")]
    private Collection $theories;

    public function __construct()
    {
        $this->theories = new ArrayCollection();
    }
}

$repository = EntityManager::getRepository(Scientist::class);
```

--------------------------------

### Pass Extra Attributes to Factory Definition

Source: https://github.com/laravel-doctrine/orm/blob/3.3.x/docs/testing.rst

The factory definition callback can accept an optional second argument $attributes. Use it to override default values. The example shows making a user with a specific name and then accessing it via getName().

```php
$factory->define(App\Entities\User::class, function(Faker\Generator $faker, array $attributes) {
    return [
        'name' => isset($attributes['name']) ? $attributes['name'] : $faker->name,
        'emailAddress' => $faker->email
    ];
});

$user = entity(App\Entities\User::class)->make(['name' => 'Taylor']);

// $user->getName() = 'Taylor'
```

--------------------------------

### Unique rule with additional where clause

Source: https://github.com/laravel-doctrine/orm/blob/3.3.x/docs/validation.rst

Adds additional where clauses to the unique check. In this example, only rows with an account_id of 1 are included in the unique check.

```php
'email' => 'unique:users,email_address,NULL,id,account_id,1'
```

--------------------------------

### Implement DoctrineDatabaseTransactions trait for tests

Source: https://github.com/laravel-doctrine/orm/blob/3.3.x/docs/troubleshooting.rst

Use this trait instead of the default Laravel DatabaseTransactions trait to wrap tests in a Doctrine transaction. It begins a transaction in setUp and rolls back in tearDown.

```php
namespace Tests;

use LaravelDoctrine\ORM\Facades\EntityManager;

trait DoctrineDatabaseTransactions
{
    public function setUpDoctrineDatabaseTransactions(): void
    {
        EntityManager::getConnection()->beginTransaction();
    }

    public function tearDownDoctrineDatabaseTransactions(): void
    {
        EntityManager::getConnection()->rollBack();
    }
}
```

--------------------------------

### Exists validation rule with Doctrine entity

Source: https://github.com/laravel-doctrine/orm/blob/3.3.x/docs/validation.rst

Validates that a field exists in a given Doctrine entity. The entity option is the fully qualified namespace, and the column option defaults to the field name if not specified. This example is from the update method of a controller.

```php
/**
* Store a new blog post.
*
* @param  Request  $request
* @return Response
*/
public function update($id, Request $request)
{
    $this->validate($request, [
        'username' => 'required|exists:App\Entities\User,username',
    ]);
}
```

--------------------------------

### Unique validation rule with Doctrine entity

Source: https://github.com/laravel-doctrine/orm/blob/3.3.x/docs/validation.rst

Validates that a field is unique for a given Doctrine entity. The entity option is the fully qualified namespace, and the column option defaults to the field name if not specified. This example is from the store method of a controller.

```php
/**
* Store a new blog post.
*
* @param  Request  $request
* @return Response
*/
public function store(Request $request)
{
    $this->validate($request, [
        'username' => 'required|unique:App\Entities\User,username',
    ]);
}
```

--------------------------------

### Workbench application commands

Source: https://github.com/laravel-doctrine/orm/blob/3.3.x/CLAUDE.md

Commands to build, serve, clear, and prepare the workbench application used for package development.

```bash
# Build workbench application
composer build
```

```bash
# Serve workbench application
composer serve
```

```bash
# Clear package skeleton
composer clear
```

```bash
# Discover package
composer prepare
```

--------------------------------

### Creating and persisting entities with EntityManager

Source: https://github.com/laravel-doctrine/orm/blob/3.3.x/docs/entities.rst

Shows how to instantiate entities, set properties directly, add a relation, and persist both entities with EntityManager::persist() and flush().

```php
$scientist = new Scientist();
$scientist->firstName = 'Albert';
$scientist->lastName  = 'Einstein';

$theory = new Theory();
$theory->title = 'Theory of Relativity';
$theory->scientist = $scientist;

$scientist->theories->add($theory);

EntityManager::persist($scientist);
EntityManager::persist($theory);
EntityManager::flush();
```

--------------------------------

### Recommended Directory Structure

Source: https://github.com/laravel-doctrine/orm/blob/3.3.x/docs/install.rst

Shows the recommended base directory for Doctrine ORM entities and subdirectories for entity, repository, subscriber, and listener.

```bash
~/app/Doctrine/ORM
```

```bash
~/app/Doctrine/ORM/Entity
~/app/Doctrine/ORM/Repository
~/app/Doctrine/ORM/Subscriber
~/app/Doctrine/ORM/Listener
```

--------------------------------

### Persist an Entity with create()

Source: https://github.com/laravel-doctrine/orm/blob/3.3.x/docs/testing.rst

Replace make() with create() to persist the entity to the database before returning it. The comment indicates the user is now in the database.

```php
entity(App\Entities\User::class)->create(); // The User is now in the database
```

--------------------------------

### Extend ConnectionManager with custom driver

Source: https://github.com/laravel-doctrine/orm/blob/3.3.x/docs/connections.rst

Use this to replace existing connection drivers or add custom drivers. The boot method receives a ConnectionManager instance and calls extend with a driver name and a closure that returns an array of connection parameters.

```php
use LaravelDoctrine\ORM\Configuration\Connections\ConnectionManager;
use Illuminate\Contracts\Container\Container;

public function boot(ConnectionManager $connections): void
{
    $connections->extend('myDriver', function(array $settings, Container $container) {
        return [
            'driver' => 'driver',
            'host'   => ...
        ];
    });
}
```

--------------------------------

### Enable extensions in configuration

Source: https://github.com/laravel-doctrine/orm/blob/3.3.x/docs/configuration.rst

Lists the extension classes to add to the 'extensions' array to enable additional functionality like timestamps, soft deletes, and translatable.

```php
'extensions' => [
    LaravelDoctrine\ORM\Extensions\TablePrefix\TablePrefixExtension::class,
    LaravelDoctrine\Extensions\Timestamps\TimestampableExtension::class,
    LaravelDoctrine\Extensions\SoftDeletes\SoftDeleteableExtension::class,
    LaravelDoctrine\Extensions\Sluggable\SluggableExtension::class,
    LaravelDoctrine\Extensions\Sortable\SortableExtension::class,
    LaravelDoctrine\Extensions\Tree\TreeExtension::class,
    LaravelDoctrine\Extensions\Loggable\LoggableExtension::class,
    LaravelDoctrine\Extensions\Blameable\BlameableExtension::class,
    LaravelDoctrine\Extensions\IpTraceable\IpTraceableExtension::class,
    LaravelDoctrine\Extensions\Translatable\TranslatableExtension::class
],
```

--------------------------------

### Run full test suite with composer test

Source: https://github.com/laravel-doctrine/orm/blob/3.3.x/CLAUDE.md

Runs the complete test suite including linting, code standards, tests, and static analysis. Use this as the primary command to validate all checks.

```bash
# Run full test suite (linting, code standards, tests, static analysis)
composer test
```

--------------------------------

### Use fluent methods to build notifications

Source: https://github.com/laravel-doctrine/orm/blob/3.3.x/docs/notifications.rst

Shows how to set the recipient, level, message, and action using the fluent API provided by the base Notification class.

```php
$n->to($user)
  ->success();

$n->error();

$n->level('info')
  ->message('Your notification message')
  ->action('Click here', 'http://yoururl.com');
```

--------------------------------

### Configure multiple entity managers

Source: https://github.com/laravel-doctrine/orm/blob/3.3.x/docs/configuration.rst

Shows the structure for defining multiple entity managers in the configuration array. The 'default' manager is the first entry, and additional managers like 'second' are added as separate keys.

```php
return [
    'managers' => [
        'default' => [  // This is the first entity manager configuration
            ...
        ],
        'second' => [  // This is the second entity manager configuration
            ...
        ]

```

--------------------------------

### Publish Config with Artisan

Source: https://github.com/laravel-doctrine/orm/blob/3.3.x/docs/install.rst

Publish the package configuration using the artisan vendor:publish command with the specified tag and provider.

```bash
php artisan vendor:publish --tag="config" --provider="LaravelDoctrine\ORM\DoctrineServiceProvider"
```

--------------------------------

### Run PHPStan static analysis

Source: https://github.com/laravel-doctrine/orm/blob/3.3.x/CLAUDE.md

Runs PHPStan at level 1. Use composer lint or the direct vendor/bin/phpstan command to analyze the src directory.

```bash
# Run PHPStan (level 1)
composer lint
# or
vendor/bin/phpstan analyze src --level 1
```

--------------------------------

### Reusing repositories through inheritance

Source: https://github.com/laravel-doctrine/orm/blob/3.3.x/docs/repositories.rst

Extends EntityRepository to reuse generic repository methods, and shows how to bind it in a service provider.

```php
use Doctrine\ORM\EntityRepository;

class DoctrineScientistRepository extends EntityRepository implements ScientistRepository
{
    // public function find($id) already implemented in parent class!

    public function findByName($name)
    {
        return $this->findBy(['name' => $name]);
    }
}

// Then, in one of your ServiceProviders
use App\Entities\Research\Scientist;

class AppServiceProvider
{
    public function register()
    {
        $this->app->bind(ScientistRepository::class, function($app) {
            // This is what Doctrine's EntityRepository needs in its constructor.
            return new DoctrineScientistRepository(
                $app['em'],
                $app['em']->getClassMetaData(Scientist::class)
            );
        });
    }
}
```

--------------------------------

### Run PHPUnit tests

Source: https://github.com/laravel-doctrine/orm/blob/3.3.x/CLAUDE.md

Runs only PHPUnit tests. Use vendor/bin/phpunit for the full suite, specify a file to run a single test file, or use --filter to run a single test method.

```bash
# Run only PHPUnit tests
vendor/bin/phpunit
```

```bash
# Run single test file
vendor/bin/phpunit tests/Feature/SomeTest.php
```

```bash
# Run single test method
vendor/bin/phpunit --filter testMethodName
```

--------------------------------

### DoctrineScientistRepository implementation

Source: https://github.com/laravel-doctrine/orm/blob/3.3.x/docs/repositories.rst

Concrete implementation of ScientistRepository using Doctrine, with placeholder methods.

```php
class DoctrineScientistRepository implements ScientistRepository
{
    public function find($id)
    {
        // implement your find method
    }

    public function findByName($name)
    {
        // implement your find by title method
    }
}
```

--------------------------------

### Configure auth.php for Doctrine

Source: https://github.com/laravel-doctrine/orm/blob/3.3.x/docs/auth.rst

Edit /config/auth.php to set the driver to 'doctrine' and the model to your entity class. Includes password reset settings.

```php
return [

  /*
  |--------------------------------------------------------------------------
  | Default Authentication Driver
  |--------------------------------------------------------------------------
  |
  | This option controls the authentication driver that will be utilized.
  | This driver manages the retrieval and authentication of the users
  | attempting to get access to protected areas of your application.
  |
  |
  */

  'driver' => 'doctrine',

  /*
  |--------------------------------------------------------------------------
  | Authentication Model
  |--------------------------------------------------------------------------
  |
  | This is the entity that has implemented Authenticatable
  |
  */

  'model' => App\Entities\User::class,


  /*
  |--------------------------------------------------------------------------
  | Password Reset Settings
  |--------------------------------------------------------------------------
  |
  | Here you may set the options for resetting passwords including the view
  | that is your password reset e-mail. You can also set the name of the
  | table that maintains all of the reset tokens for your application.
  |
  | The expire time is the number of minutes that the reset token should be
  | considered valid. This security feature keeps tokens short-lived so
  | they have less time to be guessed. You may change this as needed.
  |
  */

    'password' => [
        'email' => 'emails.password',
        'table' => 'password_resets',
        'expire' => 60,
    ],

];
```

--------------------------------

### Implement custom DoctrineExtender class

Source: https://github.com/laravel-doctrine/orm/blob/3.3.x/docs/doctrine-manager.rst

Create a custom extender by implementing DoctrineExtender and then register it with the manager.

```php
class MyDoctrineExtender implements DoctrineExtender
{
    /**
    * @param Configuration $configuration
    * @param Connection    $connection
    * @param EventManager  $eventManager
    */
    public function extend(Configuration $configuration, Connection $connection, EventManager $eventManager)
    {
        //your extending code...
    }
}
```

```php
$manager->extend('myManager', MyDoctrineExtender::class);
```

--------------------------------

### Make an Entity Instance Without Persisting

Source: https://github.com/laravel-doctrine/orm/blob/3.3.x/docs/testing.rst

Use entity() helper or the factory directly to create an instance without saving to the database. The entity() helper is defined for convenience.

```php
entity(App\Entities\User::class)->make();

// OR

$factory->of(App\Entities\User::class)->make();
```

--------------------------------

### Repository using PaginatesFromParams trait with paginateAll and paginate

Source: https://github.com/laravel-doctrine/orm/blob/3.3.x/docs/pagination.rst

Shows a complete repository class using the PaginatesFromParams trait. It demonstrates paginateAll() for all entities and paginate() for a custom query with a LIKE condition and ordering.

```php
namespace App\Repositories;

use Illuminate\Contracts\Pagination\LengthAwarePaginator;
use LaravelDoctrine\ORM\Pagination\PaginatesFromParams;

class DoctrineScientistRepository
{
    use PaginatesFromParams;

    /**
    * @return Scientist[]|LengthAwarePaginator
    */
    public function all(int $limit = 8, int $page = 1): LengthAwarePaginator
    {
        // paginateAll is already public, you may use it directly as well.
        return $this->paginateAll($limit, $page);
    }

    /**
    * @return Scientist[]|LengthAwarePaginator
    */
    public function findByName(string $name, int $limit = 8, int $page = 1): LengthAwarePaginator
    {
        $query = $this->createQueryBuilder('s')
            ->where('s.name LIKE :name')
            ->orderBy('s.name', 'asc')
            ->setParameter('name', "%$name%")
            ->getQuery();

        return $this->paginate($query, $limit, $page);
    }
}
```

--------------------------------

### Find entity and observe identity map behavior

Source: https://github.com/laravel-doctrine/orm/blob/3.3.x/docs/entity-manager.rst

Demonstrates the Identity Map Pattern: repeated find() returns the same instance, so changes are visible without flushing.

```php
$entity = EntityManager::find('App\Entities\Article', 1);
$entity->title = 'Different title';

$entityCopy = EntityManager::find('App\Entities\Article', 1);

assert($entityCopy->title === 'Different title');
```

--------------------------------

### Run parallel-lint

Source: https://github.com/laravel-doctrine/orm/blob/3.3.x/CLAUDE.md

Runs parallel-lint on the src and tests directories to check for syntax errors.

```bash
# Run parallel-lint
vendor/bin/parallel-lint src tests
```

--------------------------------

### Persist and flush an entity

Source: https://github.com/laravel-doctrine/orm/blob/3.3.x/docs/entity-manager.rst

Persist a new entity and flush to synchronize with the database. persist() does not execute an INSERT immediately.

```php
$article = new Article();
$article->title = 'Let\'s learn about persisting';

EntityManager::persist($article);
EntityManager::flush();
```

--------------------------------

### Configure custom DQL functions in config

Source: https://github.com/laravel-doctrine/orm/blob/3.3.x/docs/configuration.rst

Add custom function mappings to the appropriate arrays in the configuration file. The format is 'FUNCTION_NAME' => 'Path\To\Class'.

```php
/*
|--------------------------------------------------------------------------
| DQL custom datetime functions
|--------------------------------------------------------------------------
*/
'custom_datetime_functions' => [],
/*
|--------------------------------------------------------------------------
| DQL custom numeric functions
|--------------------------------------------------------------------------
*/
'custom_numeric_functions'  => [],
/*
|--------------------------------------------------------------------------
| DQL custom string functions
|--------------------------------------------------------------------------
*/
'custom_string_functions'   => [],
```

--------------------------------

### paginate() with custom query builder in repository

Source: https://github.com/laravel-doctrine/orm/blob/3.3.x/docs/pagination.rst

Shows how to use the paginate() method from the PaginatesFromRequest trait with a custom query builder. The method creates a query builder, filters by status, and passes the query to paginate().

```php
public function paginateAllPublishedScientists($perPage = 15, $pageName = 'page')
{
    $builder = $this->createQueryBuilder('o');
    $builder->where('o.status = 1');

    return $this->paginate($builder->getQuery(), $perPage, $pageName);
}
```

--------------------------------

### Extend Entity Manager using dependency injection in boot()

Source: https://github.com/laravel-doctrine/orm/blob/3.3.x/docs/doctrine-manager.rst

Inject DoctrineManager into a ServiceProvider's boot() method and call extend() to modify an Entity Manager.

```php
public function boot(DoctrineManager $manager) {
    $manager->extend('myManager', function(Configuration $configuration, Connection $connection, EventManager $eventManager) {
        //modify and access settings as is needed
    });
}
```

--------------------------------

### Inject repository interface into controller

Source: https://github.com/laravel-doctrine/orm/blob/3.3.x/docs/repositories.rst

Shows how to inject a repository interface into a Laravel controller constructor and use it to fetch all entities. The repository is resolved automatically by the Laravel container.

```php
class ExampleController extends Controller
{
    private $scientists;

    public function __construct(ScientistRepository $scientists)
    {
        $this->scientists = $scientists;
    }

    public function index()
    {
        $articles = $this->scientists->findAll();
    }

}
```

--------------------------------

### Entity Manager Configuration Array

Source: https://github.com/laravel-doctrine/orm/blob/3.3.x/docs/configuration.rst

Shows the beginning of the doctrine.php config file, defining the default entity manager under the 'managers' key. The 'default' key is the entity manager name.

```php
return [
    'managers' => [
        'default' => [  // This is the entity manager name
            ...
        ],

```

--------------------------------

### Use getters to retrieve notification information

Source: https://github.com/laravel-doctrine/orm/blob/3.3.x/docs/notifications.rst

Lists the getter methods available on the Notification class to access its properties.

```php
$n->getId();
$n->getUser();
$n->getLevel();
$n->getMessage();
$n->getActionText();
$n->getActionUrl();
```

--------------------------------

### Configure namespace aliases

Source: https://github.com/laravel-doctrine/orm/blob/3.3.x/docs/configuration.rst

Defines namespace aliases in the 'namespaces' key of a manager configuration. Each alias maps to a namespace path, e.g., 'Foo' => 'App\Model\Foo\Entities'.

```php
'managers' => [
    'default' => [
        ...
        'connection' => env('DB_CONNECTION', 'mysql'),
        'namespaces' => [
            'Foo' => 'App\Model\Foo\Entities',
            'Bar' => 'App\Model\Bar\Entities',
        ],
        'paths'      => [
            base_path('app')
        ],
        ...
    ]
]
```

--------------------------------

### Entity Metadata Paths Configuration

Source: https://github.com/laravel-doctrine/orm/blob/3.3.x/docs/install.rst

Update the 'paths' array in config/doctrine.php to point to the recommended entity directory.

```php
'paths' => [
    base_path('app/Doctrine/ORM/Entity'),
],
```

--------------------------------

### Run PHP CodeSniffer

Source: https://github.com/laravel-doctrine/orm/blob/3.3.x/CLAUDE.md

Runs PHP CodeSniffer to check code standards.

```bash
# Run PHP CodeSniffer
vendor/bin/phpcs
```

--------------------------------

### Generate code coverage with composer coverage

Source: https://github.com/laravel-doctrine/orm/blob/3.3.x/CLAUDE.md

Generates code coverage for the test suite. Use this to measure test coverage.

```bash
# Generate code coverage
composer coverage
```

--------------------------------

### Define an Entity Factory with $factory->define

Source: https://github.com/laravel-doctrine/orm/blob/3.3.x/docs/testing.rst

Place this in a file under database/factories. The $factory variable is an instance of LaravelDoctrine\ORM\Testing\Factory. The callback receives a Faker generator and returns an array of property values. Note that Doctrine uses class property names, not database columns.

```php
$factory->define(App\Entities\User::class, function(Faker\Generator $faker) {
    return [
        'name' => $faker->name,
        'emailAddress' => $faker->email
    ];
});
```

--------------------------------

### Inject EntityManager via constructor

Source: https://github.com/laravel-doctrine/orm/blob/3.3.x/docs/entity-manager.rst

Inject the default EntityManager into a controller constructor via type-hinting.

```php
use Doctrine\ORM\EntityManager;

class ExampleController extends Controller
{
    public function __construct(protected EntityManager $entityManager)
    {
    }
}
```

--------------------------------

### Make Multiple Entities

Source: https://github.com/laravel-doctrine/orm/blob/3.3.x/docs/testing.rst

Pass a count as the second argument to entity() to generate multiple instances. For a specific type, pass the type and count. The factory's times() method also works. Returns an Illuminate\Support\Collection.

```php
entity(App\Entities\User::class, 2)->make();
entity(App\Entities\User::class, 'admin', 2)->make();

// OR

$factory->of(App\Entities\User::class)->times(2)->make();
```

--------------------------------

### Use namespace alias in DQL query

Source: https://github.com/laravel-doctrine/orm/blob/3.3.x/docs/configuration.rst

Shows how to reference an entity using its namespace alias in a DQL query. The alias 'Foo' is used as 'Foo:SomeEntity'.

```sql
SELECT f FROM Foo:SomeEntity
```

--------------------------------

### Compose Doctrine generic repository in custom repository class

Source: https://github.com/laravel-doctrine/orm/blob/3.3.x/docs/repositories.rst

Implements a ScientistRepository interface by wrapping a generic ObjectRepository. The constructor accepts the generic repository, and methods like find() and findByName() delegate to it. This approach avoids forcing inheritance and allows you to omit methods like findAll() from your API.

```php
use Doctrine\Common\Persistence\ObjectRepository;

class DoctrineScientistRepository implements ScientistRepository
{
    private $genericRepository;

        public function __construct(ObjectRepository $genericRepository)
        {
            $this->genericRepository = $genericRepository;
        }

        public function find($id)
        {
            return $this->genericRepository->find($id);
        }

        public function findByName($name)
        {
            return $this->genericRepository->findBy(['name' => $name]);
        }
}

// Then, in one of your ServiceProviders
use App\Entities\Research\Scientist;

class AppServiceProvider
{
    public function register()
    {
        $this->app->bind(ScientistRepository::class, function(){
            return new DoctrineScientistRepository(
                EntityManager::getRepository(Scientist::class)
            );
        });
    }
}
```

--------------------------------

### Remove an entity and flush

Source: https://github.com/laravel-doctrine/orm/blob/3.3.x/docs/entity-manager.rst

Remove an entity from persistent storage; the deletion is executed on flush().

```php
EntityManager::remove($article);
EntityManager::flush();
```

--------------------------------

### Extend CacheManager with custom memcache driver

Source: https://github.com/laravel-doctrine/orm/blob/3.3.x/docs/caching.rst

Registers a custom 'memcache' driver with the CacheManager. The closure receives the cache settings and the Laravel Application, and must return a cache instance implementing Doctrine\Common\Cache\Cache or extending CacheProvider.

```php
public function register()
{
    $this->app->resolving(CacheManager::class, function (CacheManager $cache){
        $cache->extend('memcache', function(array $settings, Application $app) {
            $memcache = new \Memcache;
            return new MemcacheCache($memcache);
        });
    });
}
```

--------------------------------

### Make an Entity of a Specific Type

Source: https://github.com/laravel-doctrine/orm/blob/3.3.x/docs/testing.rst

Pass the type name as the second argument to entity() or to of() to generate an entity with the defined type (e.g., 'admin').

```php
entity(App\Entities\User::class, 'admin')->make();

// OR

$factory->of(App\Entities\User::class, 'admin')->make();
```

--------------------------------

### ScientistRepository interface

Source: https://github.com/laravel-doctrine/orm/blob/3.3.x/docs/repositories.rst

Defines the contract for a scientist repository with find and findByName methods.

```php
interface ScientistRepository
{
    public function find($id);
    public function findByName($name);
}
```

--------------------------------

### Extend Entity Manager using Doctrine facade

Source: https://github.com/laravel-doctrine/orm/blob/3.3.x/docs/doctrine-manager.rst

Use the Doctrine facade to extend an Entity Manager by name. The closure receives Configuration, Connection, and EventManager instances for modification.

```php
Doctrine::extend('myManager', function(Configuration $configuration, Connection $connection, EventManager $eventManager) {
    //modify and access settings as is needed
});
```

--------------------------------

### Use Notifiable trait in User entity

Source: https://github.com/laravel-doctrine/orm/blob/3.3.x/docs/notifications.rst

Shows how to make an entity notifiable by using the LaravelDoctrine Notifiable trait, enabling $user->notify(new InvoicePaid).

```php
class User
{
    use LaravelDoctrine\ORM\Notifications\Notifiable;
}
```

--------------------------------

### Flush all changes or a single entity

Source: https://github.com/laravel-doctrine/orm/blob/3.3.x/docs/entity-manager.rst

Flush all pending changes or only those of a specific entity. The comment warns against flushing one entity at a time.

```php
// Flush all changes
EntityManager::flush();

// Only flush changes of given entity.
// NOTE:  If you're doing it this way, one entity at a time, you're doing it wrong.
EntityManager::flush($article);
```

--------------------------------

### Set PDO for assertDatabaseHas with Doctrine

Source: https://github.com/laravel-doctrine/orm/blob/3.3.x/docs/troubleshooting.rst

Configure Laravel's database connection to use the same PDO as Doctrine so that assertDatabaseHas can see uncommitted rows within a transaction.

```php
$pdo = app()->make(\Doctrine\ORM\EntityManagerInterface::class)->getConnection()
            ->getWrappedConnection();

app()->make(\Illuminate\Database\ConnectionInterface::class)->setPdo($pdo);
```

--------------------------------

### Define Multiple Entity Types with defineAs

Source: https://github.com/laravel-doctrine/orm/blob/3.3.x/docs/testing.rst

Use defineAs to create a named variant of an entity. The second argument is the type name (e.g., 'admin'). This allows generating entities with different values for the same class.

```php
$factory->defineAs(App\Entities\User::class, 'admin', function(Faker\Generator $faker) {
    return [
        'name' => $faker->name,
        'emailAddress' => $faker->email,
        'isAdmin' => true
    ];
});
```

--------------------------------

### Configure defaultTableOptions in database.php for MySQL

Source: https://github.com/laravel-doctrine/orm/blob/3.3.x/docs/default-table-options.rst

Add the defaultTableOptions key to the MySQL connection array in the database.php configuration file. The charset option ensures new tables are created with the given encoding even if the database has its own default character set. The collate option sets the default collation, which must be edited if you want something other than utf8_unicode_ci.

```php
...
    'mysql' => [
        'driver' => 'mysql',
        'host' => env('DB_HOST', '127.0.0.1'),
        'port' => env('DB_PORT', '3306'),
        'database' => env('DB_DATABASE', 'forge'),
        'username' => env('DB_USERNAME', 'forge'),
        'password' => env('DB_PASSWORD', ''),
        'unix_socket' => env('DB_SOCKET', ''),
        'defaultTableOptions' => [
            'charset' => 'utf8mb4',
            'collate' => 'utf8mb4_unicode_ci'
        ],
        'charset' => 'utf8mb4', // This will be the charset for the connection
        'prefix' => '',
        'strict' => true,
        'engine' => null,
    ],
...
```

--------------------------------

### XML Mapping for Article Entity

Source: https://github.com/laravel-doctrine/orm/blob/3.3.x/docs/entities.rst

Defines the Article entity using an XML mapping file, mapping the id and title fields. The entity uses the 'articles' table and auto-generated integer id.

```xml
<?xml version="1.0"?>
<doctrine-mapping xmlns="http://doctrine-project.org/schemas/orm/doctrine-mapping" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://doctrine-project.org/schemas/orm/doctrine-mapping https://www.doctrine-project.org/schemas/orm/doctrine-mapping.xsd">
  <entity name="App\Doctrine\ORM\Entity\Article" table="articles">
    <id name="id" type="integer">
      <generator strategy="AUTO"/>
    </id>
    <field name="title" type="string" nullable="false"/>
  </entity>
</doctrine-mapping>
```

--------------------------------

### Implement Authenticatable contract manually

Source: https://github.com/laravel-doctrine/orm/blob/3.3.x/docs/auth.rst

Extend Laravel's authentication contract on your entity. Must implement getAuthIdentifierName(), getAuthIdentifier(), and getPassword().

```php
class User implements \Illuminate\Contracts\Auth\Authenticatable
{
    #[ORM\Id]
    #[ORM\Column(type: "integer")]
    #[ORM\GeneratedValue(strategy: "AUTO")]
    protected $id;

    public function getAuthIdentifierName()
    {
        return 'id';
    }

    public function getAuthIdentifier()
    {
        return $this->id;
    }

    public function getPassword()
    {
        return $this->password;
    }
}
```

--------------------------------

### Register custom hydrators in config

Source: https://github.com/laravel-doctrine/orm/blob/3.3.x/docs/configuration.rst

Add a hydrator class to the 'custom_hydration_modes' array using the format 'hydrationModeName' => MyHydrator::class. This enables custom hydration modes as described in the Doctrine documentation.

```php
/*
|--------------------------------------------------------------------------
| Register custom hydrators
|--------------------------------------------------------------------------
*/
'custom_hydration_modes'     => [
    'hydrationModeName' => MyHydrator::class,
],
```

--------------------------------

### Specify custom entity manager with routeNotificationForDoctrine

Source: https://github.com/laravel-doctrine/orm/blob/3.3.x/docs/notifications.rst

Override the default entity manager selection by returning a custom manager name from this method on the notifiable entity.

```php
public function routeNotificationForDoctrine()
{
    return 'custom';
}
```

--------------------------------

### Resolve EntityManager from the Laravel container

Source: https://github.com/laravel-doctrine/orm/blob/3.3.x/docs/entity-manager.rst

Resolve the default EntityManager from the Laravel container using the 'em' alias or the Doctrine class names.

```php
app('em'); // alias
app('Doctrine\ORM\EntityManager');
app('Doctrine\ORM\EntityManagerInterface');
```

--------------------------------

### Use Authenticatable trait

Source: https://github.com/laravel-doctrine/orm/blob/3.3.x/docs/auth.rst

Use the provided trait LaravelDoctrine\ORM\Auth\Authenticatable and override methods where necessary. Here getAuthIdentifierName() returns 'userId'.

```php
class User implements \Illuminate\Contracts\Auth\Authenticatable
{
    use \LaravelDoctrine\ORM\Auth\Authenticatable;

    #[ORM\Id]
    #[ORM\Column(type: "integer")]
    #[ORM\GeneratedValue(strategy: "AUTO")]
    protected $userId;

    public function getAuthIdentifierName()
    {
        return 'userId';
    }
}
```

--------------------------------

### PHP Attributes Mapping for Article Entity

Source: https://github.com/laravel-doctrine/orm/blob/3.3.x/docs/entities.rst

Defines the Article entity with Doctrine ORM attributes, mapping the id and title columns. The entity uses the 'articles' table and auto-generated integer id.

```php
namespace App\Doctrine\ORM\Entity;

 use Doctrine\ORM\Mapping as ORM;

 #[ORM\Entity]
 #[ORM\Table(name: "articles")]
 class Article
 {
     #[ORM\Id]
     #[ORM\Column(type: "integer")]
     #[ORM\GeneratedValue(strategy: "AUTO")]
     private $id;

     #[ORM\Column(type: "string", nullable: false)]
     private $title;
 }
```

--------------------------------

### Theory entity with ManyToOne relation

Source: https://github.com/laravel-doctrine/orm/blob/3.3.x/docs/entities.rst

Defines the Theory entity using attributes, with a ManyToOne relation to Scientist and a join column named scientist_id.

```php
use Doctrine\ORM\Mapping as ORM;

#[ORM\Entity(repositoryClass: "App\Doctrine\ORM\Repository\TheoryRepository")]
class Theory
{
    #[ORM\Id]
    #[ORM\Column(type: "integer")]
    #[ORM\GeneratedValue(strategy: "AUTO")]
    private int $id;

    #[ORM\Column(type: "string", nullable: false)]
    private string $title;

    #[ORM\ManyToOne(targetEntity: Scientist::class, inversedBy: "theories")]
    #[ORM\JoinColumn(name: "scientist_id", referencedColumnName: "id", nullable: false)]
    private Scientist $scientist;
}
```

--------------------------------

### Unique rule ignoring a given ID

Source: https://github.com/laravel-doctrine/orm/blob/3.3.x/docs/validation.rst

Shows how to ignore a specific ID during the unique check by passing the ID as the third parameter. This is useful for update scenarios where the user's own email should not trigger a validation error.

```php
'email' => 'unique:users,email_address,' . $user->id
```

--------------------------------

### Scientist entity with attributes and OneToMany relation

Source: https://github.com/laravel-doctrine/orm/blob/3.3.x/docs/entities.rst

Defines the Scientist entity using PHP attributes for ORM mapping, including an id, firstName, lastName, and a OneToMany relation to Theory. The constructor initializes the collection as an ArrayCollection.

```php
use Doctrine\ORM\Mapping as ORM;
use Doctrine\Common\Collections\ArrayCollection;
use Doctrine\Common\Collections\Collection;

#[ORM\Entity(repositoryClass: "App\Doctrine\ORM\Repository\ScientistRepository")]
class Scientist
{
    #[ORM\Id]
    #[ORM\Column(type: "integer")]
    #[ORM\GeneratedValue(strategy: "AUTO")]
    private int $id;

    #[ORM\Column(type: "string", nullable: false)]
    private string $firstName;

    #[ORM\Column(type: "string", nullable: false)]
    private string $lastName;

    #[ORM\OneToMany(targetEntity: Theory::class, mappedBy: "scientist")]
    private Collection $theories;

    public function __construct()
    {
        $this->theories = new ArrayCollection();
    }
}
```
Tokens:
Raw