vendor/jms/serializer/src/Metadata/Driver/AbstractDoctrineTypeDriver.php line 85

Open in your IDE?
  1. <?php
  3. declare(strict_types=1);
  5. namespace JMS\Serializer\Metadata\Driver;
  7. use Doctrine\Persistence\ManagerRegistry;
  8. use Doctrine\Persistence\Mapping\ClassMetadata as DoctrineClassMetadata;
  9. use JMS\Serializer\Metadata\ClassMetadata;
  10. use JMS\Serializer\Metadata\ExpressionPropertyMetadata;
  11. use JMS\Serializer\Metadata\PropertyMetadata;
  12. use JMS\Serializer\Metadata\StaticPropertyMetadata;
  13. use JMS\Serializer\Metadata\VirtualPropertyMetadata;
  14. use JMS\Serializer\Type\Parser;
  15. use JMS\Serializer\Type\ParserInterface;
  16. use Metadata\ClassMetadata as BaseClassMetadata;
  17. use Metadata\Driver\DriverInterface;
  19. /**
  20.  * This class decorates any other driver. If the inner driver does not provide a
  21.  * a property type, the decorator will guess based on Doctrine 2 metadata.
  22.  */
  23. abstract class AbstractDoctrineTypeDriver implements DriverInterface
  24. {
  25.     /**
  26.      * Map of doctrine 2 field types to JMS\Serializer types
  27.      *
  28.      * @var array
  29.      */
  30.     protected $fieldMapping = [
  31.         'string' => 'string',
  32.         'ascii_string' => 'string',
  33.         'text' => 'string',
  34.         'blob' => 'string',
  35.         'guid' => 'string',
  36.         'decimal' => 'string',
  38.         'integer' => 'integer',
  39.         'smallint' => 'integer',
  40.         'bigint' => 'integer',
  42.         'datetime' => 'DateTime',
  43.         'datetimetz' => 'DateTime',
  44.         'time' => 'DateTime',
  45.         'date' => 'DateTime',
  47.         'datetime_immutable' => 'DateTimeImmutable',
  48.         'datetimetz_immutable' => 'DateTimeImmutable',
  49.         'time_immutable' => 'DateTimeImmutable',
  50.         'date_immutable' => 'DateTimeImmutable',
  52.         'dateinterval' => 'DateInterval',
  54.         'float' => 'float',
  56.         'boolean' => 'boolean',
  58.         'array' => 'array',
  59.         'json_array' => 'array',
  60.         'simple_array' => 'array<string>',
  61.     ];
  62.     /**
  63.      * @var DriverInterface
  64.      */
  65.     protected $delegate;
  66.     /**
  67.      * @var ManagerRegistry
  68.      */
  69.     protected $registry;
  71.     /**
  72.      * @var ParserInterface
  73.      */
  74.     protected $typeParser;
  76.     public function __construct(DriverInterface $delegate, ManagerRegistry $registry, ?ParserInterface $typeParser = null)
  77.     {
  78.         $this->delegate = $delegate;
  79.         $this->registry = $registry;
  80.         $this->typeParser = $typeParser ?: new Parser();
  81.     }
  83.     public function loadMetadataForClass(\ReflectionClass $class): ?BaseClassMetadata
  84.     {
  85.         $classMetadata = $this->delegate->loadMetadataForClass($class);
  86.         \assert($classMetadata instanceof ClassMetadata);
  88.         // Abort if the given class is not a mapped entity
  89.         if (!$doctrineMetadata = $this->tryLoadingDoctrineMetadata($class->name)) {
  90.             return $classMetadata;
  91.         }
  93.         $this->setDiscriminator($doctrineMetadata, $classMetadata);
  95.         // We base our scan on the internal driver's property list so that we
  96.         // respect any internal allow/blocklist like in the AnnotationDriver
  97.         foreach ($classMetadata->propertyMetadata as $key => $propertyMetadata) {
  98.             // If the inner driver provides a type, don't guess anymore.
  99.             if ($propertyMetadata->type || $this->isVirtualProperty($propertyMetadata)) {
  100.                 continue;
  101.             }
  103.             if ($this->hideProperty($doctrineMetadata, $propertyMetadata)) {
  104.                 unset($classMetadata->propertyMetadata[$key]);
  105.             }
  107.             $this->setPropertyType($doctrineMetadata, $propertyMetadata);
  108.         }
  110.         return $classMetadata;
  111.     }
  113.     private function isVirtualProperty(PropertyMetadata $propertyMetadata): bool
  114.     {
  115.         return $propertyMetadata instanceof VirtualPropertyMetadata
  116.             || $propertyMetadata instanceof StaticPropertyMetadata
  117.             || $propertyMetadata instanceof ExpressionPropertyMetadata;
  118.     }
  120.     protected function setDiscriminator(DoctrineClassMetadata $doctrineMetadata, ClassMetadata $classMetadata): void
  121.     {
  122.     }
  124.     protected function hideProperty(DoctrineClassMetadata $doctrineMetadata, PropertyMetadata $propertyMetadata): bool
  125.     {
  126.         return false;
  127.     }
  129.     protected function setPropertyType(DoctrineClassMetadata $doctrineMetadata, PropertyMetadata $propertyMetadata): void
  130.     {
  131.     }
  133.     protected function tryLoadingDoctrineMetadata(string $className): ?DoctrineClassMetadata
  134.     {
  135.         if (!$manager = $this->registry->getManagerForClass($className)) {
  136.             return null;
  137.         }
  139.         if ($manager->getMetadataFactory()->isTransient($className)) {
  140.             return null;
  141.         }
  143.         return $manager->getClassMetadata($className);
  144.     }
  146.     protected function normalizeFieldType(string $type): ?string
  147.     {
  148.         if (!isset($this->fieldMapping[$type])) {
  149.             return null;
  150.         }
  152.         return $this->fieldMapping[$type];
  153.     }
  154. }