vendor/symfony/doctrine-bridge/PropertyInfo/DoctrineExtractor.php line 215

  1. <?php
  3. /*
  4.  * This file is part of the Symfony package.
  5.  *
  6.  * (c) Fabien Potencier <fabien@symfony.com>
  7.  *
  8.  * For the full copyright and license information, please view the LICENSE
  9.  * file that was distributed with this source code.
  10.  */
  12. namespace Symfony\Bridge\Doctrine\PropertyInfo;
  14. use Doctrine\Common\Collections\Collection;
  15. use Doctrine\DBAL\Types\Types;
  16. use Doctrine\ORM\EntityManagerInterface;
  17. use Doctrine\ORM\Mapping\ClassMetadata;
  18. use Doctrine\ORM\Mapping\ClassMetadataInfo;
  19. use Doctrine\ORM\Mapping\Embedded;
  20. use Doctrine\ORM\Mapping\MappingException as OrmMappingException;
  21. use Doctrine\Persistence\Mapping\MappingException;
  22. use Symfony\Component\PropertyInfo\PropertyAccessExtractorInterface;
  23. use Symfony\Component\PropertyInfo\PropertyListExtractorInterface;
  24. use Symfony\Component\PropertyInfo\PropertyTypeExtractorInterface;
  25. use Symfony\Component\PropertyInfo\Type;
  27. /**
  28.  * Extracts data using Doctrine ORM and ODM metadata.
  29.  *
  30.  * @author Kévin Dunglas <dunglas@gmail.com>
  31.  */
  32. class DoctrineExtractor implements PropertyListExtractorInterface, PropertyTypeExtractorInterface, PropertyAccessExtractorInterface
  33. {
  34.     private EntityManagerInterface $entityManager;
  36.     public function __construct(EntityManagerInterface $entityManager)
  37.     {
  38.         $this->entityManager = $entityManager;
  39.     }
  41.     public function getProperties(string $class, array $context = []): ?array
  42.     {
  43.         if (null === $metadata = $this->getMetadata($class)) {
  44.             return null;
  45.         }
  47.         $properties = array_merge($metadata->getFieldNames(), $metadata->getAssociationNames());
  49.         if ($metadata instanceof ClassMetadataInfo && class_exists(Embedded::class) && $metadata->embeddedClasses) {
  50.             $properties = array_filter($properties, function ($property) {
  51.                 return !str_contains($property, '.');
  52.             });
  54.             $properties = array_merge($properties, array_keys($metadata->embeddedClasses));
  55.         }
  57.         return $properties;
  58.     }
  60.     public function getTypes(string $class, string $property, array $context = []): ?array
  61.     {
  62.         if (null === $metadata = $this->getMetadata($class)) {
  63.             return null;
  64.         }
  66.         if ($metadata->hasAssociation($property)) {
  67.             $class = $metadata->getAssociationTargetClass($property);
  69.             if ($metadata->isSingleValuedAssociation($property)) {
  70.                 if ($metadata instanceof ClassMetadataInfo) {
  71.                     $associationMapping = $metadata->getAssociationMapping($property);
  73.                     $nullable = $this->isAssociationNullable($associationMapping);
  74.                 } else {
  75.                     $nullable = false;
  76.                 }
  78.                 return [new Type(Type::BUILTIN_TYPE_OBJECT, $nullable, $class)];
  79.             }
  81.             $collectionKeyType = Type::BUILTIN_TYPE_INT;
  83.             if ($metadata instanceof ClassMetadataInfo) {
  84.                 $associationMapping = $metadata->getAssociationMapping($property);
  86.                 if (isset($associationMapping['indexBy'])) {
  87.                     /** @var ClassMetadataInfo $subMetadata */
  88.                     $subMetadata = $this->entityManager->getClassMetadata($associationMapping['targetEntity']);
  90.                     // Check if indexBy value is a property
  91.                     $fieldName = $associationMapping['indexBy'];
  92.                     if (null === ($typeOfField = $subMetadata->getTypeOfField($fieldName))) {
  93.                         $fieldName = $subMetadata->getFieldForColumn($associationMapping['indexBy']);
  94.                         // Not a property, maybe a column name?
  95.                         if (null === ($typeOfField = $subMetadata->getTypeOfField($fieldName))) {
  96.                             // Maybe the column name is the association join column?
  97.                             $associationMapping = $subMetadata->getAssociationMapping($fieldName);
  99.                             /** @var ClassMetadataInfo $subMetadata */
  100.                             $indexProperty = $subMetadata->getSingleAssociationReferencedJoinColumnName($fieldName);
  101.                             $subMetadata = $this->entityManager->getClassMetadata($associationMapping['targetEntity']);
  103.                             // Not a property, maybe a column name?
  104.                             if (null === ($typeOfField = $subMetadata->getTypeOfField($indexProperty))) {
  105.                                 $fieldName = $subMetadata->getFieldForColumn($indexProperty);
  106.                                 $typeOfField = $subMetadata->getTypeOfField($fieldName);
  107.                             }
  108.                         }
  109.                     }
  111.                     if (!$collectionKeyType = $this->getPhpType($typeOfField)) {
  112.                         return null;
  113.                     }
  114.                 }
  115.             }
  117.             return [new Type(
  118.                 Type::BUILTIN_TYPE_OBJECT,
  119.                 false,
  120.                 Collection::class,
  121.                 true,
  122.                 new Type($collectionKeyType),
  123.                 new Type(Type::BUILTIN_TYPE_OBJECT, false, $class)
  124.             )];
  125.         }
  127.         if ($metadata instanceof ClassMetadataInfo && class_exists(Embedded::class) && isset($metadata->embeddedClasses[$property])) {
  128.             return [new Type(Type::BUILTIN_TYPE_OBJECT, false, $metadata->embeddedClasses[$property]['class'])];
  129.         }
  131.         if ($metadata->hasField($property)) {
  132.             $typeOfField = $metadata->getTypeOfField($property);
  134.             if (!$builtinType = $this->getPhpType($typeOfField)) {
  135.                 return null;
  136.             }
  138.             $nullable = $metadata instanceof ClassMetadataInfo && $metadata->isNullable($property);
  139.             $enumType = null;
  140.             if (null !== $enumClass = $metadata->getFieldMapping($property)['enumType'] ?? null) {
  141.                 $enumType = new Type(Type::BUILTIN_TYPE_OBJECT, $nullable, $enumClass);
  142.             }
  144.             switch ($builtinType) {
  145.                 case Type::BUILTIN_TYPE_OBJECT:
  146.                     switch ($typeOfField) {
  147.                         case Types::DATE_MUTABLE:
  148.                         case Types::DATETIME_MUTABLE:
  149.                         case Types::DATETIMETZ_MUTABLE:
  150.                         case 'vardatetime':
  151.                         case Types::TIME_MUTABLE:
  152.                             return [new Type(Type::BUILTIN_TYPE_OBJECT, $nullable, 'DateTime')];
  154.                         case Types::DATE_IMMUTABLE:
  155.                         case Types::DATETIME_IMMUTABLE:
  156.                         case Types::DATETIMETZ_IMMUTABLE:
  157.                         case Types::TIME_IMMUTABLE:
  158.                             return [new Type(Type::BUILTIN_TYPE_OBJECT, $nullable, 'DateTimeImmutable')];
  160.                         case Types::DATEINTERVAL:
  161.                             return [new Type(Type::BUILTIN_TYPE_OBJECT, $nullable, 'DateInterval')];
  162.                     }
  164.                     break;
  165.                 case Type::BUILTIN_TYPE_ARRAY:
  166.                     switch ($typeOfField) {
  167.                         case Types::ARRAY:
  168.                         case 'json_array':
  169.                             // return null if $enumType is set, because we can't determine if collectionKeyType is string or int
  170.                             if ($enumType) {
  171.                                 return null;
  172.                             }
  174.                             return [new Type(Type::BUILTIN_TYPE_ARRAY, $nullable, null, true)];
  176.                         case Types::SIMPLE_ARRAY:
  177.                             return [new Type(Type::BUILTIN_TYPE_ARRAY, $nullable, null, true, new Type(Type::BUILTIN_TYPE_INT), $enumType ?? new Type(Type::BUILTIN_TYPE_STRING))];
  178.                     }
  179.                     break;
  180.                 case Type::BUILTIN_TYPE_INT:
  181.                 case Type::BUILTIN_TYPE_STRING:
  182.                     if ($enumType) {
  183.                         return [$enumType];
  184.                     }
  185.                     break;
  186.             }
  188.             return [new Type($builtinType, $nullable)];
  189.         }
  191.         return null;
  192.     }
  194.     public function isReadable(string $class, string $property, array $context = []): ?bool
  195.     {
  196.         return null;
  197.     }
  199.     public function isWritable(string $class, string $property, array $context = []): ?bool
  200.     {
  201.         if (
  202.             null === ($metadata = $this->getMetadata($class))
  203.             || ClassMetadata::GENERATOR_TYPE_NONE === $metadata->generatorType
  204.             || !\in_array($property, $metadata->getIdentifierFieldNames(), true)
  205.         ) {
  206.             return null;
  207.         }
  209.         return false;
  210.     }
  212.     private function getMetadata(string $class): ?ClassMetadata
  213.     {
  214.         try {
  215.             return $this->entityManager->getClassMetadata($class);
  216.         } catch (MappingException|OrmMappingException) {
  217.             return null;
  218.         }
  219.     }
  221.     /**
  222.      * Determines whether an association is nullable.
  223.      *
  224.      * @see https://github.com/doctrine/doctrine2/blob/v2.5.4/lib/Doctrine/ORM/Tools/EntityGenerator.php#L1221-L1246
  225.      */
  226.     private function isAssociationNullable(array $associationMapping): bool
  227.     {
  228.         if (isset($associationMapping['id']) && $associationMapping['id']) {
  229.             return false;
  230.         }
  232.         if (!isset($associationMapping['joinColumns'])) {
  233.             return true;
  234.         }
  236.         $joinColumns = $associationMapping['joinColumns'];
  237.         foreach ($joinColumns as $joinColumn) {
  238.             if (isset($joinColumn['nullable']) && !$joinColumn['nullable']) {
  239.                 return false;
  240.             }
  241.         }
  243.         return true;
  244.     }
  246.     /**
  247.      * Gets the corresponding built-in PHP type.
  248.      */
  249.     private function getPhpType(string $doctrineType): ?string
  250.     {
  251.         return match ($doctrineType) {
  252.             Types::SMALLINT,
  253.             Types::INTEGER => Type::BUILTIN_TYPE_INT,
  254.             Types::FLOAT => Type::BUILTIN_TYPE_FLOAT,
  255.             Types::BIGINT,
  256.             Types::STRING,
  257.             Types::TEXT,
  258.             Types::GUID,
  259.             Types::DECIMAL => Type::BUILTIN_TYPE_STRING,
  260.             Types::BOOLEAN => Type::BUILTIN_TYPE_BOOL,
  261.             Types::BLOB,
  262.             Types::BINARY => Type::BUILTIN_TYPE_RESOURCE,
  263.             Types::OBJECT,
  264.             Types::DATE_MUTABLE,
  265.             Types::DATETIME_MUTABLE,
  266.             Types::DATETIMETZ_MUTABLE,
  267.             'vardatetime',
  268.             Types::TIME_MUTABLE,
  269.             Types::DATE_IMMUTABLE,
  270.             Types::DATETIME_IMMUTABLE,
  271.             Types::DATETIMETZ_IMMUTABLE,
  272.             Types::TIME_IMMUTABLE,
  273.             Types::DATEINTERVAL => Type::BUILTIN_TYPE_OBJECT,
  274.             Types::ARRAY,
  275.             Types::SIMPLE_ARRAY,
  276.             'json_array' => Type::BUILTIN_TYPE_ARRAY,
  277.             default => null,
  278.         };
  279.     }
  280. }