nepada / consistence-doctrine
Consistence Enum types for Doctrine.
Installs: 11 123
Dependents: 0
Suggesters: 0
Security: 0
Stars: 2
Watchers: 2
Forks: 0
Open Issues: 0
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
This package is auto-updated.
Last update: 2022-08-13 20:17:58 UTC
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.