convert database value straight into Enum without using postLoad event (typed properties compatibility)

Author: VasekPurchart

build/composer-dependency-analyser.config.php

@@ -10,16 +10,6 @@
 $config = $config->enableAnalysisOfUnusedDevDependencies();
 $config = $config->addPathToScan(__DIR__, true);
 
-// dependency from YAML configuration only
-$config = $config->ignoreErrorsOnPackages([
-	'doctrine/doctrine-bundle', // e.g. dependency on @annotation_reader, postLoad event etc.
-], [ErrorType::PROD_DEPENDENCY_ONLY_IN_DEV]);
-
-// opt-in Symfony functionality
-$config = $config->ignoreErrorsOnPackages([
-	'symfony/yaml',
-], [ErrorType::UNUSED_DEPENDENCY]);
-
 // tools
 $config = $config->ignoreErrorsOnPackages([
 	'consistence/coding-standard',

composer.json

@@ -13,12 +13,11 @@
 	"require": {
 		"php": "^7.2",
 		"consistence/consistence": "^1.0|^2.0",
-		"consistence/consistence-doctrine": "^1.2|^2.0",
-		"doctrine/doctrine-bundle": "^1.3",
-		"symfony/config": "^3.0|^4.0",
+		"consistence/consistence-doctrine": "^3.0",
+		"doctrine/dbal": "^2.13.1",
+		"symfony/config": "^3.0|~4.0.0|^4.1.4",
 		"symfony/dependency-injection": "^3.0|^4.0",
-		"symfony/http-kernel": "^3.0|^4.0",
-		"symfony/yaml": "^3.0|^4.0"
+		"symfony/http-kernel": "^3.0|^4.0"
 	},
 	"require-dev": {
 		"consistence/coding-standard": "3.10.1",

readme.md

@@ -30,26 +30,13 @@ class Sex extends \Consistence\Enum\Enum
 }
 ```
 
-Now you can use the `Sex` enum in your `User` entity. There are two important things to notice:
-
-1) `type="string_enum"` in `ORM\Column` - this will be used for mapping the value to your database, that means if you have a string based enum (see values in `Sex`), use `string_enum`
-
-You can specify any other parameters for `ORM\Column` as you would usually (nullability, length...).
-
-There is also `integer_enum`, `float_enum` and `boolean_enum` which can be used respectively for their types.
-
-2) `@Enum(class=Sex::class)` - this will be used for reconstructing the `Sex`
- enum object when loading the value back from database
-
-The `class` annotation parameter uses the same namespace resolution process as other Doctrine annotations, so it is practically the same as when you specify a `targetEntity` in associations mapping.
+To use the `Sex` enum in your `User` entity notice the `type="enum<Consistence\Doctrine\Example\User\Sex>"` in `ORM\Column` - this will be used for mapping the value to and from your database. You can specify any other parameters for `ORM\Column` as you would usually (nullability, length...).
 
 ```php
 <?php
 
 namespace Consistence\Doctrine\Example\User;
 
-use Consistence\Doctrine\Enum\EnumAnnotation as Enum;
-
 use Doctrine\ORM\Mapping as ORM;
 
 /**
@@ -61,8 +48,7 @@ class User extends \Consistence\ObjectPrototype
 	// ...
 
 	/**
-	 * @Enum(class=Sex::class)
-	 * @ORM\Column(type="string_enum", nullable=true)
+	 * @ORM\Column(type="enum<Consistence\Doctrine\Example\User\Sex>", nullable=true)
 	 * @var \Consistence\Doctrine\Example\User\Sex|null
 	 */
 	private $sex;
@@ -85,6 +71,21 @@ class User extends \Consistence\ObjectPrototype
 }
 ```
 
+Before this will work with database, we need to register [Doctrine DBAL type](https://www.doctrine-project.org/projects/doctrine-dbal/en/latest/reference/types.html#custom-mapping-types) for each enum. This can be done using the configuration:
+
+```yaml
+# config/packages/consistence_doctrine.yaml
+consistence_doctrine:
+    enum:
+        dbal_types:
+            string:
+                - 'Consistence\Doctrine\Example\User'
+```
+
+We used `string` because the `Sex` enum uses strings for its values. There are also `integer`, `float` and `boolean` - depending on what scalar values are used in the enum.
+
+If you use the same enum in multiple places configure it only once.
+
 Now everything is ready to be used, when you call `flush`, only `female` will be saved:
 
 ```php
@@ -130,16 +131,17 @@ This means that the objects API is symmetrical (you get the same type as you set
 Configuration
 -------------
 
-You can override services used internally, for example if you want to use a more effective cache in production (which is recommended), you can provide custom instance with an [alias](http://symfony.com/doc/current/components/dependency_injection/advanced.html#aliasing):
+Configuration structure with listed default values:
 
 ```yaml
-services:
-    mycache:
-        class: 'Doctrine\Common\Cache\FilesystemCache'
-        arguments:
-            $directory: '%kernel.cache_dir%/mycache'
-
-    consistence.doctrine.enum.enum_fields_cache: '@mycache'
+# config/packages/consistence_doctrine.yaml
+consistence_doctrine:
+    enum:
+        dbal_types:
+            boolean: []
+            float: []
+            integer: []
+            string: []
 ```
 
 Installation
@@ -161,4 +163,6 @@ return [
 ];
 ```
 
+3) Configure needed DBAL types (see `Usage` section above).
+
 That's all, you are good to go!

src/ConsistenceDoctrineBundle.php

@@ -4,7 +4,42 @@
 
 namespace Consistence\Doctrine\SymfonyBundle;
 
+use Consistence\Doctrine\Enum\Type\BooleanEnumType;
+use Consistence\Doctrine\Enum\Type\FloatEnumType;
+use Consistence\Doctrine\Enum\Type\IntegerEnumType;
+use Consistence\Doctrine\Enum\Type\StringEnumType;
+use Doctrine\DBAL\Types\Type as DbalType;
+
 class ConsistenceDoctrineBundle extends \Symfony\Component\HttpKernel\Bundle\Bundle
 {
 
+	public function boot(): void
+	{
+		parent::boot();
+
+		$this->registerClassesForEnumDbalType(BooleanEnumType::class, $this->container->getParameter('consistence.doctrine.enum.dbal_types.boolean'));
+		$this->registerClassesForEnumDbalType(FloatEnumType::class, $this->container->getParameter('consistence.doctrine.enum.dbal_types.float'));
+		$this->registerClassesForEnumDbalType(IntegerEnumType::class, $this->container->getParameter('consistence.doctrine.enum.dbal_types.integer'));
+		$this->registerClassesForEnumDbalType(StringEnumType::class, $this->container->getParameter('consistence.doctrine.enum.dbal_types.string'));
+	}
+
+	/**
+	 * @param string $dbalTypeClass
+	 * @param string[] $enumClasses
+	 */
+	private function registerClassesForEnumDbalType(
+		string $dbalTypeClass,
+		array $enumClasses
+	): void
+	{
+		foreach ($enumClasses as $enumClass) {
+			$dbalType = $dbalTypeClass::create($enumClass);
+			if (DbalType::getTypeRegistry()->has($dbalType->getName())) {
+				DbalType::getTypeRegistry()->override($dbalType->getName(), $dbalType);
+			} else {
+				DbalType::getTypeRegistry()->register($dbalType->getName(), $dbalType);
+			}
+		}
+	}
+
 }

src/DependencyInjection/Configuration.php

@@ -0,0 +1,102 @@
+<?php
+
+declare(strict_types = 1);
+
+namespace Consistence\Doctrine\SymfonyBundle\DependencyInjection;
+
+use Consistence\Enum\Enum;
+use Consistence\Type\ArrayType\ArrayType;
+use Symfony\Component\Config\Definition\Builder\ArrayNodeDefinition;
+use Symfony\Component\Config\Definition\Builder\TreeBuilder;
+
+class Configuration
+	extends \Consistence\ObjectPrototype
+	implements \Symfony\Component\Config\Definition\ConfigurationInterface
+{
+
+	/** @var string */
+	private $rootNode;
+
+	public function __construct(
+		string $rootNode
+	)
+	{
+		$this->rootNode = $rootNode;
+	}
+
+	public function getConfigTreeBuilder(): TreeBuilder
+	{
+		$treeBuilder = new TreeBuilder();
+		$rootNode = $treeBuilder->root($this->rootNode);
+
+		$rootNode->children()->append($this->createEnumNode('enum'));
+
+		return $treeBuilder;
+	}
+
+	private function createEnumNode(string $nodeName): ArrayNodeDefinition
+	{
+		$node = new ArrayNodeDefinition($nodeName);
+		$node->children()->append($this->createEnumDbalTypesNode('dbal_types'));
+		$node->addDefaultsIfNotSet();
+
+		return $node;
+	}
+
+	private function createEnumDbalTypesNode(string $nodeName): ArrayNodeDefinition
+	{
+		$node = new ArrayNodeDefinition($nodeName);
+		$node->children()->append($this->createEnumClassesNode('boolean'));
+		$node->children()->append($this->createEnumClassesNode('float'));
+		$node->children()->append($this->createEnumClassesNode('integer'));
+		$node->children()->append($this->createEnumClassesNode('string'));
+		$node->addDefaultsIfNotSet();
+
+		return $node;
+	}
+
+	private function createEnumClassesNode(string $nodeName): ArrayNodeDefinition
+	{
+		$node = new ArrayNodeDefinition($nodeName);
+		$node->prototype('scalar');
+		$node
+			->validate()
+			->ifTrue(function (array $enumClasses): bool {
+				return count($enumClasses) !== count(ArrayType::uniqueValues($enumClasses))
+					|| ArrayType::containsValueByValueCallback($enumClasses, function ($enumClass): bool {
+						return !is_string($enumClass)
+							|| !$this->isEnumClass($enumClass);
+					});
+			})
+			->then(function (array $enumClasses): void {
+				$frequency = array_count_values($enumClasses);
+				$duplicateClasses = array_keys(ArrayType::filterValuesByCallback($frequency, static function (int $count): bool {
+					return $count > 1;
+				}));
+				if (count($duplicateClasses) > 0) {
+					throw new \Consistence\Doctrine\SymfonyBundle\DependencyInjection\EnumDbalTypesClassListCannotContainDuplicateClassesException($duplicateClasses);
+				}
+
+				$notEnumClasses = ArrayType::filterValuesByCallback($enumClasses, function ($enumClass): bool {
+					return !is_string($enumClass)
+						|| !$this->isEnumClass($enumClass);
+				});
+				if (count($notEnumClasses) > 0) {
+					throw new \Consistence\Doctrine\SymfonyBundle\DependencyInjection\EnumDbalTypesClassListCannotContainNonEnumClassesException($notEnumClasses);
+				}
+
+				// @codeCoverageIgnoreStart
+				// should be unreachable code
+				throw new \Exception('Unexpected case');
+				// @codeCoverageIgnoreEnd
+			});
+
+		return $node;
+	}
+
+	private function isEnumClass(string $class): bool
+	{
+		return is_a($class, Enum::class, true);
+	}
+
+}

src/DependencyInjection/ConsistenceDoctrineExtension.php

@@ -4,54 +4,59 @@
 
 namespace Consistence\Doctrine\SymfonyBundle\DependencyInjection;
 
-use Consistence\Doctrine\Enum\Type\BooleanEnumType;
-use Consistence\Doctrine\Enum\Type\FloatEnumType;
-use Consistence\Doctrine\Enum\Type\IntegerEnumType;
-use Consistence\Doctrine\Enum\Type\StringEnumType;
-use Symfony\Component\Config\FileLocator;
 use Symfony\Component\DependencyInjection\ContainerBuilder;
-use Symfony\Component\DependencyInjection\Loader\YamlFileLoader;
 
-class ConsistenceDoctrineExtension
-	extends \Symfony\Component\HttpKernel\DependencyInjection\Extension
-	implements \Symfony\Component\DependencyInjection\Extension\PrependExtensionInterface
+class ConsistenceDoctrineExtension extends \Symfony\Component\HttpKernel\DependencyInjection\ConfigurableExtension
 {
 
-	public const ALIAS = 'consistence_doctrine';
-
-	public const DOCTRINE_BUNDLE_ALIAS = 'doctrine';
-
-	public function prepend(ContainerBuilder $container): void
-	{
-		if (!$container->hasExtension(self::DOCTRINE_BUNDLE_ALIAS)) {
-			throw new \Consistence\Doctrine\SymfonyBundle\DependencyInjection\DoctrineBundleRequiredException();
-		}
-
-		$container->loadFromExtension(self::DOCTRINE_BUNDLE_ALIAS, [
-			'dbal' => [
-				'types' => [
-					BooleanEnumType::NAME => BooleanEnumType::class,
-					FloatEnumType::NAME => FloatEnumType::class,
-					IntegerEnumType::NAME => IntegerEnumType::class,
-					StringEnumType::NAME => StringEnumType::class,
-				],
-			],
-		]);
-	}
+	use \Consistence\Type\ObjectMixinTrait;
 
 	/**
-	 * @param mixed[][] $configs
+	 * @param mixed[] $mergedConfig
 	 * @param \Symfony\Component\DependencyInjection\ContainerBuilder $container
 	 */
-	public function load(array $configs, ContainerBuilder $container): void
+	public function loadInternal(array $mergedConfig, ContainerBuilder $container): void
 	{
-		$loader = new YamlFileLoader($container, new FileLocator(__DIR__ . '/config'));
-		$loader->load('services.yaml');
+		$container->setParameter(
+			'consistence.doctrine.enum.dbal_types.boolean',
+			$mergedConfig
+				['enum']
+				['dbal_types']
+				['boolean']
+		);
+		$container->setParameter(
+			'consistence.doctrine.enum.dbal_types.float',
+			$mergedConfig
+				['enum']
+				['dbal_types']
+				['float']
+		);
+		$container->setParameter(
+			'consistence.doctrine.enum.dbal_types.integer',
+			$mergedConfig
+				['enum']
+				['dbal_types']
+				['integer']
+		);
+		$container->setParameter(
+			'consistence.doctrine.enum.dbal_types.string',
+			$mergedConfig
+				['enum']
+				['dbal_types']
+				['string']
+		);
 	}
 
-	public function getAlias(): string
+	/**
+	 * @param mixed[] $config
+	 * @param \Symfony\Component\DependencyInjection\ContainerBuilder $container
+	 * @return \Consistence\Doctrine\SymfonyBundle\DependencyInjection\Configuration
+	 */
+	public function getConfiguration(array $config, ContainerBuilder $container): Configuration
 	{
-		return self::ALIAS;
+		return new Configuration(
+			$this->getAlias()
+		);
 	}
 
 }