Enable automatic type detection from the property type when type name is the FQCN of the value object

Author: GromNaN

docs/en/reference/custom-mapping-types.rst

@@ -217,11 +217,15 @@ Usage Example::
     #[Field(type: Ramsey\Uuid\Uuid::class)]
     public Ramsey\Uuid\Uuid $id;
 
-.. note::
-    The type name should be the name of the value object class (e.g., ``Ramsey\Uuid\Uuid``
-    for our custom ``UuidType``) to enable automatic transformation of the values
-    of this class in the aggregation builder.
+By using the |FQCN| of the value object class as the type name, the type is
+automatically used when encountering a property of that class. This means you
+can omit the ``type`` option when defining the field mapping::
+
+.. code-block:: php
+
+    #[Field]
+    public Ramsey\Uuid\Uuid $id;
 
 .. _`ramsey/uuid library`: https://github.com/ramsey/uuid
 .. |FQCN| raw:: html
-  <abbr title="Fully-Qualified Class Name">FQCN</abbr>
+  <abbr title="Fully-Qualified Class Name">FQCN</abbr>

lib/Doctrine/ODM/MongoDB/Mapping/ClassMetadata.php

@@ -2750,9 +2750,13 @@ private function isTypedProperty(string $name): bool
      */
     private function validateAndCompleteTypedFieldMapping(array $mapping): array
     {
+        if (isset($mapping['type'])) {
+            return $mapping;
+        }
+
         $type = $this->reflClass->getProperty($mapping['fieldName'])->getType();
 
-        if (! $type instanceof ReflectionNamedType || isset($mapping['type'])) {
+        if (! $type instanceof ReflectionNamedType) {
             return $mapping;
         }
 
@@ -2766,6 +2770,14 @@ private function validateAndCompleteTypedFieldMapping(array $mapping): array
             $type = $reflection->getBackingType();
             assert($type instanceof ReflectionNamedType);
             $mapping['enumType'] = $reflection->getName();
+
+            return $mapping;
+        }
+
+        if (! $type->isBuiltin() && Type::hasType($type->getName())) {
+            $mapping['type'] = $type->getName();
+
+            return $mapping;
         }
 
         switch ($type->getName()) {

tests/Doctrine/ODM/MongoDB/Tests/Functional/CustomTypeTest.php

@@ -10,16 +10,34 @@
 use Doctrine\ODM\MongoDB\Types\ClosureToPHP;
 use Doctrine\ODM\MongoDB\Types\Type;
 use Exception;
+use PHPUnit\Framework\Attributes\After;
+use PHPUnit\Framework\Attributes\Before;
+use ReflectionProperty;
 
 use function array_map;
 use function array_values;
+use function assert;
 use function is_array;
 
 class CustomTypeTest extends BaseTestCase
 {
-    public static function setUpBeforeClass(): void
+    /** @var string[] */
+    private array $originalTypeMap = [];
+
+    #[Before]
+    public function backupTypeMap(): void
     {
+        $this->originalTypeMap = (new ReflectionProperty(Type::class, 'typesMap'))->getValue();
+
         Type::addType('date_collection', DateCollectionType::class);
+        Type::addType(Language::class, LanguageType::class);
+    }
+
+    #[After]
+    public function restoreTypeMap(): void
+    {
+        (new ReflectionProperty(Type::class, 'typesMap'))->setValue($this->originalTypeMap);
+        unset($this->originalTypeMap);
     }
 
     public function testCustomTypeValueConversions(): void
@@ -46,6 +64,36 @@ public function testConvertToDatabaseValueExpectsArray(): void
         $this->expectException(CustomTypeException::class);
         $this->dm->flush();
     }
+
+    public function testCustomTypeDetection(): void
+    {
+        $field = $this->dm->getClassMetadata(Country::class)->getFieldMapping('lang');
+        self::assertSame(Language::class, $field['type'], 'The custom type should be detected on the field');
+
+        $country       = new Country();
+        $country->lang = new Language('French', 'fr');
+
+        $this->dm->persist($country);
+        $this->dm->flush();
+        $this->dm->clear();
+
+        $country = $this->dm->find(Country::class, $country->id);
+
+        self::assertNotNull($country);
+        self::assertInstanceOf(Language::class, $country->lang);
+        self::assertSame('French', $country->lang->name);
+        self::assertSame('fr', $country->lang->code);
+    }
+
+    public function testTypeFromPHPVariable(): void
+    {
+        $lang = new Language('French', 'fr');
+        $type = Type::getTypeFromPHPVariable($lang);
+        self::assertInstanceOf(LanguageType::class, $type);
+
+        $databaseValue = Type::convertPHPToDatabaseValue($lang);
+        self::assertSame(['name' => 'French', 'code' => 'fr'], $databaseValue);
+    }
 }
 
 class DateCollectionType extends Type
@@ -106,11 +154,52 @@ class CustomTypeException extends Exception
 #[ODM\Document]
 class Country
 {
-    /** @var string|null */
     #[ODM\Id]
-    public $id;
+    public ?string $id;
 
     /** @var DateTime[]|DateTime|null */
     #[ODM\Field(type: 'date_collection')]
     public $nationalHolidays;
+
+    /** The field type is detected from the property type */
+    #[ODM\Field(/* type: Language::class */)]
+    public Language $lang;
+}
+
+class Language
+{
+    public function __construct(
+        public string $name,
+        public string $code,
+    ) {
+    }
+}
+
+class LanguageType extends Type
+{
+    use ClosureToPHP;
+
+    /** @return array{name:string,code:string}|null */
+    public function convertToDatabaseValue($value): ?array
+    {
+        if ($value === null) {
+            return null;
+        }
+
+        assert($value instanceof Language);
+
+        return ['name' => $value->name, 'code' => $value->code];
+    }
+
+    /** @param array{name:string,code:string}|null $value */
+    public function convertToPHPValue($value): ?Language
+    {
+        if ($value === null) {
+            return null;
+        }
+
+        assert(is_array($value) && isset($value['name'], $value['code']));
+
+        return new Language($value['name'], $value['code']);
+    }
 }

tests/Doctrine/ODM/MongoDB/Tests/Functional/Ticket/GH2789Test.php

@@ -9,17 +9,35 @@
 use Doctrine\ODM\MongoDB\Types\Type;
 use Doctrine\ODM\MongoDB\Types\Versionable;
 use MongoDB\BSON\Binary;
-use PHPUnit\Framework\Attributes\BackupGlobals;
+use PHPUnit\Framework\Attributes\After;
+use PHPUnit\Framework\Attributes\Before;
+use ReflectionProperty;
 
 use function assert;
 use function is_int;
 
-#[BackupGlobals(true)]
 class GH2789Test extends BaseTestCase
 {
-    public function testVersionWithCustomType(): void
+    /** @var string[] */
+    private array $originalTypeMap = [];
+
+    #[Before]
+    public function backupTypeMap(): void
     {
+        $this->originalTypeMap = (new ReflectionProperty(Type::class, 'typesMap'))->getValue();
+
         Type::addType(GH2789CustomType::class, GH2789CustomType::class);
+    }
+
+    #[After]
+    public function restoreTypeMap(): void
+    {
+        (new ReflectionProperty(Type::class, 'typesMap'))->setValue($this->originalTypeMap);
+        unset($this->originalTypeMap);
+    }
+
+    public function testVersionWithCustomType(): void
+    {
         $doc = new GH2789VersionedUuid('original message');
 
         $this->dm->persist($doc);