nepada/consistence-doctrine

This package is abandoned and no longer maintained. No replacement package was suggested.

Consistence Enum types for Doctrine.

v1.1.1 2022-08-13 20:15 UTC

Requires

• php: >=7.4.0 <8.2
• consistence/consistence: ^2.0@dev
• doctrine/dbal: ^2.6@dev || ^3.0@dev

Requires (Dev)

• consistence-community/consistence: ^2.0@dev
• mockery/mockery: 1.5.0
• nepada/coding-standard: 7.5.2
• nepada/phpstan-nette-tester: 0.4.0
• nette/tester: 2.4.2
• php-parallel-lint/php-parallel-lint: 1.3.2
• phpstan/phpstan: 1.8.2
• phpstan/phpstan-mockery: 1.1.0
• phpstan/phpstan-strict-rules: 1.3.0
• shipmonk/phpstan-rules: 1.0.1
• spaze/phpstan-disallowed-calls: 2.5.0

BSD-3-Clause

• Petr Morávek

• doctrine
• enum
• consistence

README

Package abandoned

This package is considered obsolete and abandoned. Since PHP 8.1 introduced native enum support, there is no need for user-land implementation of enums, neither their custom integration into Doctrine.

Installation

Via Composer:

$ composer require nepada/consistence-doctrine

Usage

Define Doctrine type for the enum

/**
 * @phpstan-extends \Nepada\ConsistenceDoctrine\StringEnumType<\FooEnum>
 */
class FooEnumType extends \Nepada\ConsistenceDoctrine\StringEnumType
{

    protected function getEnumClassName(): string
    {
        return \FooEnum::class;
    }

}

You can choose to inherit from StringEnumType, IntegerEnumType, FloatEnumType or BooleanEnumType depending on the enum values.

Register the created type in Doctrine

\Doctrine\DBAL\Types\Type::addType(\FooEnum::class, \FooEnumType::class);

In Nette with nettrine/dbal integration, you can register the types in your configuration:

dbal:
    connection:
        types:
            FooEnum: FooEnumType

Use the type in entity

use Doctrine\ORM\Mapping as ORM;

/**
 * @ORM\Entity
 */
class SomeEntity
{

    /** @ORM\Column(type=\FooEnum::class, nullable=false) */
    private \FooEnum $foo;

    // ...

}

Use enum in query builder

$result = $repository->createQueryBuilder('bar')
    ->select('bar.foo') // FooEnum instances are created during hydratation
    ->where('bar.foo = :fooEnum')
    ->setParameter('fooEnum', \FooEnum::get(\FooEnum::VALUE), \FooEnum::class) // enum instance gets serialized
    ->getQuery()
    ->setMaxResults(1)
    ->getSingleResult();

PHPStan support (via phpstan/phpstan-doctrine)

The abstract enum type classes are anotated as PHPStan generics and define proper typehints for their convert* methods. This means you can teach PHPStan your custom enum types via ReflectionDescriptor:

services:
    -
        factory: PHPStan\Type\Doctrine\Descriptors\ReflectionDescriptor(FooEnumType)
        tags: [phpstan.doctrine.typeDescriptor]

Differences from the official consistence/consistence-doctrine

The official integration consistence/consistence-doctrine uses postload entity event to convert data stored in database to enum instances.

The main advantage of that approach is that you don't need to create and register new doctrine type for every enum.

The disadvantages are:

• You can't use native property typehints for entity enum attributes.
• When you're not hydrating entites, you will get enum values instead of enum instances.
• There is no easy way how to make PHPStan understand and check doctrine and PHP types of your enum fields.