add basic json model type

Author: pfilsx

README.md

@@ -12,12 +12,16 @@ Features
 * PostgreSQL enums support in DBAL and migrations
 * PHP8 enum support
 * Fix creating [default schema in down migrations for pgsql](https://github.com/doctrine/dbal/issues/1110)
+* [JSON(B) functions](https://www.postgresql.org/docs/current/functions-json.html) (in progress)
+* JSON(B) types based on object models (in progress, requires symfony/serializer)
 
 Requirement
 -----------
 * PHP ^8.1
 * doctrine/dbal ^3.5.1
 * doctrine/migrations ^3.5.2
+* symfony/serializer >=5.4.* (optional for json models)
+* symfony/property-info >=5.4.* (optional)
 
 Installation
 ------------

composer.json

@@ -31,6 +31,8 @@
     },
     "require-dev": {
         "friendsofphp/php-cs-fixer": "^3.13",
-        "doctrine/orm": "^2.13"
+        "doctrine/orm": "^2.13",
+        "symfony/serializer": ">=5.4",
+        "symfony/property-info": ">=5.4"
     }
 }

src/DBAL/Platform/PostgreSQLPlatform.php

@@ -8,9 +8,11 @@
 use Doctrine\DBAL\Exception;
 use Doctrine\DBAL\Exception\InvalidArgumentException;
 use Doctrine\DBAL\Platforms\PostgreSQLPlatform as BasePlatform;
+use Doctrine\DBAL\Schema\Column;
 use Pfilsx\PostgreSQLDoctrine\DBAL\Schema\EnumTypeAsset;
 use Pfilsx\PostgreSQLDoctrine\DBAL\Schema\PostgreSQLSchemaManager;
 use Pfilsx\PostgreSQLDoctrine\DBAL\Type\EnumType;
+use Pfilsx\PostgreSQLDoctrine\DBAL\Type\JsonModelType;
 
 final class PostgreSQLPlatform extends BasePlatform
 {
@@ -84,6 +86,23 @@ public function quoteEnumLabel(mixed $label): int|string
         }
     }
 
+    public function columnsEqual(Column $column1, Column $column2): bool
+    {
+        if (parent::columnsEqual($column1, $column2)) {
+            return true;
+        }
+
+        $type1 = $column1->getType();
+        $type2 = $column2->getType();
+
+        if (!is_subclass_of($type1, JsonModelType::class) && !is_subclass_of($type2, JsonModelType::class)) {
+            return false;
+        }
+
+        return is_subclass_of($type1, $type2::class) || is_subclass_of($type2, $type1::class);
+
+    }
+
     protected function initializeDoctrineTypeMappings(): void
     {
         parent::initializeDoctrineTypeMappings();

src/DBAL/Type/JsonModelType.php

@@ -0,0 +1,70 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pfilsx\PostgreSQLDoctrine\DBAL\Type;
+
+use Doctrine\DBAL\Platforms\AbstractPlatform;
+use Doctrine\DBAL\Types\ConversionException;
+use Doctrine\DBAL\Types\JsonType;
+use Symfony\Component\Serializer\Normalizer\AbstractObjectNormalizer;
+
+abstract class JsonModelType extends JsonType
+{
+    private ?AbstractObjectNormalizer $normalizer = null;
+
+    abstract public static function getTypeName(): string;
+
+    /**
+     * @return class-string
+     */
+    abstract protected static function getModelClass(): string;
+
+    public function getName(): string
+    {
+        return static::getTypeName();
+    }
+
+    public function convertToDatabaseValue(mixed $value, AbstractPlatform $platform): mixed
+    {
+        if ($value === null) {
+            return null;
+        }
+
+        if (!\is_object($value)) {
+            throw ConversionException::conversionFailed($value, $this->getName());
+        }
+
+        $array = $this->getObjectNormalizer()->normalize($value);
+
+        return parent::convertToDatabaseValue($array, $platform);
+    }
+
+    public function convertToPHPValue(mixed $value, AbstractPlatform $platform): mixed
+    {
+        $value = parent::convertToPHPValue($value, $platform);
+
+        if ($value === null) {
+            return null;
+        }
+
+        return $this->getObjectNormalizer()->denormalize(
+            $value,
+            static::getModelClass()
+        );
+    }
+
+    public function setObjectNormalizer(AbstractObjectNormalizer $normalizer): void
+    {
+        $this->normalizer = $normalizer;
+    }
+
+    protected function getObjectNormalizer(): AbstractObjectNormalizer
+    {
+        if ($this->normalizer === null) {
+            throw new \RuntimeException('JsonModelType requires object normalizer to be set');
+        }
+
+        return $this->normalizer;
+    }
+}

src/DBAL/Type/JsonModelTypeRegistry.php

@@ -0,0 +1,70 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pfilsx\PostgreSQLDoctrine\DBAL\Type;
+
+use Doctrine\DBAL\Exception;
+use Doctrine\DBAL\Types\Type;
+use Symfony\Component\PropertyInfo\Extractor\ReflectionExtractor;
+use Symfony\Component\Serializer\NameConverter\CamelCaseToSnakeCaseNameConverter;
+use Symfony\Component\Serializer\Normalizer\AbstractObjectNormalizer;
+use Symfony\Component\Serializer\Normalizer\ObjectNormalizer;
+
+final class JsonModelTypeRegistry
+{
+    private static AbstractObjectNormalizer $objectNormalizer;
+
+    private static array $typesMap = [];
+
+    /**
+     * @param string $name
+     * @param class-string $className
+     * @param bool $override
+     * @return void
+     * @throws Exception
+     */
+    public static function addType(string $name, string $className, bool $override = false): void
+    {
+        if (!$override && array_key_exists($name, self::$typesMap)) {
+            throw Exception::typeExists($name);
+        }
+
+        if (!class_exists($className) || !is_subclass_of($className, JsonModelType::class)) {
+            throw new Exception(
+                sprintf('Type class name should be a subclass of %s. %s provided', JsonModelType::class, $className)
+            );
+        }
+
+        self::$typesMap[$name] = $className;
+    }
+
+    public static function hasType(string $name): bool
+    {
+        return array_key_exists($name, self::$typesMap);
+    }
+
+    public static function getObjectNormalizer(): AbstractObjectNormalizer
+    {
+        return self::$objectNormalizer ??= new ObjectNormalizer(
+            nameConverter: new CamelCaseToSnakeCaseNameConverter(),
+            propertyTypeExtractor: new ReflectionExtractor()
+        );
+    }
+    public static function setObjectNormalizer(AbstractObjectNormalizer $objectNormalizer): void
+    {
+        self::$objectNormalizer = $objectNormalizer;
+    }
+    public static function registerTypes(): void
+    {
+        $typeRegistry = Type::getTypeRegistry();
+        $objectNormalizer = self::getObjectNormalizer();
+        foreach (self::$typesMap as $name => $className) {
+            /** @var JsonModelType $type */
+            $type = new $className();
+            $type->setObjectNormalizer($objectNormalizer);
+
+            $typeRegistry->register($name, $type);
+        }
+    }
+}