Avoid using deprecated doctrine helpers for resolving classes

Author: apfelbox

CHANGELOG.md

@@ -1,3 +1,9 @@
+1.4.1
+=====
+
+* (improvement) Avoid using deprecated Doctrine internals when resolving class names.
+
+
 1.4.0
 =====
 

composer.json

@@ -19,7 +19,7 @@
 	"require-dev": {
 		"21torr/janus": "^1.5.1",
 		"bamarni/composer-bin-plugin": "^1.8.2",
-		"doctrine/common": "^3.5",
+		"doctrine/orm": "^3.0",
 		"phpunit/phpunit": "^12.2.5",
 		"roave/security-advisories": "dev-latest"
 	},

src/Normalizer/SimpleNormalizer.php

@@ -3,6 +3,8 @@
 namespace Torr\SimpleNormalizer\Normalizer;
 
 use Doctrine\Common\Util\ClassUtils;
+use Doctrine\ORM\EntityManagerInterface;
+use Doctrine\ORM\Mapping\ClassMetadataFactory;
 use Symfony\Component\DependencyInjection\Exception\ServiceNotFoundException;
 use Symfony\Component\DependencyInjection\ServiceLocator;
 use Torr\SimpleNormalizer\Exception\ObjectTypeNotSupportedException;
@@ -23,14 +25,20 @@
  */
 class SimpleNormalizer
 {
+	private readonly ?ClassMetadataFactory $doctrineMetadata;
+
 	/**
 	 * @param ServiceLocator<SimpleObjectNormalizerInterface> $objectNormalizers
 	 */
 	public function __construct (
 		private readonly ServiceLocator $objectNormalizers,
 		private readonly bool $isDebug = false,
 		private readonly ?ValidJsonVerifier $validJsonVerifier = null,
-	) {}
+		?EntityManagerInterface $entityManager = null,
+	)
+	{
+		$this->doctrineMetadata = $entityManager?->getMetadataFactory();
+	}
 
 	/**
 	 */
@@ -104,12 +112,7 @@ private function recursiveNormalize (mixed $value, array $context = []) : mixed
 
 			try
 			{
-				$className = $value::class;
-
-				if (class_exists(ClassUtils::class))
-				{
-					$className = ClassUtils::getRealClass($className);
-				}
+				$className = $this->normalizeClassName($value::class);
 
 				$normalizer = $this->objectNormalizers->get($className);
 				\assert($normalizer instanceof SimpleObjectNormalizerInterface);
@@ -131,6 +134,22 @@ private function recursiveNormalize (mixed $value, array $context = []) : mixed
 		));
 	}
 
+	/**
+	 * Normalizes the class name
+	 */
+	private function normalizeClassName (string $className) : string
+	{
+		// if there is no doctrine, just return
+		if (null === $this->doctrineMetadata)
+		{
+			return $className;
+		}
+
+		return $this->doctrineMetadata->hasMetadataFor($className)
+			? $this->doctrineMetadata->getMetadataFor($className)->getName()
+			: $className;
+	}
+
 	/**
 	 * The actual customized normalization logic for arrays, that recursively normalizes the value.
 	 * It must never call one of the public methods above and just normalizes the value.

tests/Normalizer/SimpleNormalizerTest.php

@@ -2,6 +2,9 @@
 
 namespace Tests\Torr\SimpleNormalizer\Normalizer;
 
+use Doctrine\ORM\EntityManagerInterface;
+use Doctrine\ORM\Mapping\ClassMetadata;
+use Doctrine\ORM\Mapping\ClassMetadataFactory;
 use PHPUnit\Framework\Attributes\DataProvider;
 use PHPUnit\Framework\TestCase;
 use Symfony\Component\DependencyInjection\ServiceLocator;
@@ -124,6 +127,126 @@ public function testInvalidNestedNormalizer () : void
 		]);
 	}
 
+	/**
+	 */
+	public function testWithoutEntityManager () : void
+	{
+		$locator = $this->createMock(ServiceLocator::class);
+
+		$locator->expects(self::once())
+			->method("get")
+			->with(DummyVO::class)
+			->willReturn(new readonly class implements SimpleObjectNormalizerInterface {
+				public function normalize (object $value, array $context, SimpleNormalizer $normalizer) : int
+				{
+					return 5;
+				}
+
+				public static function getNormalizedType () : string
+				{
+					return DummyVO::class;
+				}
+			});
+
+		$normalizer = new SimpleNormalizer(
+			objectNormalizers: $locator,
+			isDebug: true,
+			validJsonVerifier: new ValidJsonVerifier(),
+		);
+
+		$normalizer->normalize(new DummyVO(5));
+	}
+
+	/**
+	 */
+	public function testWithEntityManagerButNoMapping () : void
+	{
+		$metadataFactory = $this->createMock(ClassMetadataFactory::class);
+		$metadataFactory
+			->expects(self::once())
+			->method("hasMetadataFor")
+			->with(DummyVO::class)
+			->willReturn(false);
+
+		$entityManager = $this->createMock(EntityManagerInterface::class);
+		$entityManager->method("getMetadataFactory")->willReturn($metadataFactory);
+
+		$locator = $this->createMock(ServiceLocator::class);
+
+		$locator->expects(self::once())
+			->method("get")
+			->with(DummyVO::class)
+			->willReturn(new readonly class implements SimpleObjectNormalizerInterface {
+				public function normalize (object $value, array $context, SimpleNormalizer $normalizer) : int
+				{
+					return 5;
+				}
+
+				public static function getNormalizedType () : string
+				{
+					return DummyVO::class;
+				}
+			});
+
+		$normalizer = new SimpleNormalizer(
+			objectNormalizers: $locator,
+			isDebug: true,
+			validJsonVerifier: new ValidJsonVerifier(),
+			entityManager: $entityManager,
+		);
+
+		$normalizer->normalize(new DummyVO(5));
+	}
+
+	/**
+	 */
+	public function testWithEntityManagerWithMapping () : void
+	{
+		$classMetaData = new ClassMetadata("SomeClass");
+
+		$metadataFactory = $this->createMock(ClassMetadataFactory::class);
+		$metadataFactory
+			->expects(self::once())
+			->method("hasMetadataFor")
+			->with(DummyVO::class)
+			->willReturn(true);
+
+		$metadataFactory
+			->expects(self::once())
+			->method("getMetadataFor")
+			->with(DummyVO::class)
+			->willReturn($classMetaData);
+
+		$entityManager = $this->createMock(EntityManagerInterface::class);
+		$entityManager->method("getMetadataFactory")->willReturn($metadataFactory);
+
+		$locator = $this->createMock(ServiceLocator::class);
+
+		$locator->expects(self::once())
+			->method("get")
+			->with("SomeClass")
+			->willReturn(new readonly class implements SimpleObjectNormalizerInterface {
+				public function normalize (object $value, array $context, SimpleNormalizer $normalizer) : int
+				{
+					return 5;
+				}
+
+				public static function getNormalizedType () : string
+				{
+					return DummyVO::class;
+				}
+			});
+
+		$normalizer = new SimpleNormalizer(
+			objectNormalizers: $locator,
+			isDebug: true,
+			validJsonVerifier: new ValidJsonVerifier(),
+			entityManager: $entityManager,
+		);
+
+		$normalizer->normalize(new DummyVO(5));
+	}
+
 	/**
 	 * @return ServiceLocator<mixed>
 	 */