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

Open in your IDE?
  1. <?php
  3. /*
  4.  * This file is part of the Symfony package.
  5.  *
  6.  * (c) Fabien Potencier <[email protected]>
  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\AssociationMapping;
  18. use Doctrine\ORM\Mapping\ClassMetadata;
  19. use Doctrine\ORM\Mapping\EmbeddedClassMapping;
  20. use Doctrine\ORM\Mapping\FieldMapping;
  21. use Doctrine\ORM\Mapping\JoinColumnMapping;
  22. use Doctrine\ORM\Mapping\MappingException as OrmMappingException;
  23. use Doctrine\Persistence\Mapping\MappingException;
  24. use Symfony\Component\PropertyInfo\PropertyAccessExtractorInterface;
  25. use Symfony\Component\PropertyInfo\PropertyListExtractorInterface;
  26. use Symfony\Component\PropertyInfo\PropertyTypeExtractorInterface;
  27. use Symfony\Component\PropertyInfo\Type;
  29. /**
  30.  * Extracts data using Doctrine ORM and ODM metadata.
  31.  *
  32.  * @author Kévin Dunglas <[email protected]>
  33.  */
  34. class DoctrineExtractor implements PropertyListExtractorInterface, PropertyTypeExtractorInterface, PropertyAccessExtractorInterface
  35. {
  36.     private $entityManager;
  38.     public function __construct(EntityManagerInterface $entityManager)
  39.     {
  40.         $this->entityManager = $entityManager;
  41.     }
  43.     /**
  44.      * {@inheritdoc}
  45.      */
  46.     public function getProperties(string $class, array $context = [])
  47.     {
  48.         if (null === $metadata = $this->getMetadata($class)) {
  49.             return null;
  50.         }
  52.         $properties = array_merge($metadata->getFieldNames(), $metadata->getAssociationNames());
  54.         if ($metadata instanceof ClassMetadata && $metadata->embeddedClasses) {
  55.             $properties = array_filter($properties, function ($property) {
  56.                 return !str_contains($property, '.');
  57.             });
  59.             $properties = array_merge($properties, array_keys($metadata->embeddedClasses));
  60.         }
  62.         return $properties;
  63.     }
  65.     /**
  66.      * {@inheritdoc}
  67.      */
  68.     public function getTypes(string $class, string $property, array $context = [])
  69.     {
  70.         if (null === $metadata = $this->getMetadata($class)) {
  71.             return null;
  72.         }
  74.         if ($metadata->hasAssociation($property)) {
  75.             $class = $metadata->getAssociationTargetClass($property);
  77.             if ($metadata->isSingleValuedAssociation($property)) {
  78.                 if ($metadata instanceof ClassMetadata) {
  79.                     $associationMapping = $metadata->getAssociationMapping($property);
  81.                     $nullable = $this->isAssociationNullable($associationMapping);
  82.                 } else {
  83.                     $nullable = false;
  84.                 }
  86.                 return [new Type(Type::BUILTIN_TYPE_OBJECT, $nullable, $class)];
  87.             }
  89.             $collectionKeyType = Type::BUILTIN_TYPE_INT;
  91.             if ($metadata instanceof ClassMetadata) {
  92.                 $associationMapping = $metadata->getAssociationMapping($property);
  94.                 if (self::getMappingValue($associationMapping, 'indexBy')) {
  95.                     $subMetadata = $this->entityManager->getClassMetadata(self::getMappingValue($associationMapping, 'targetEntity'));
  97.                     // Check if indexBy value is a property
  98.                     $fieldName = self::getMappingValue($associationMapping, 'indexBy');
  99.                     if (null === ($typeOfField = $subMetadata->getTypeOfField($fieldName))) {
  100.                         $fieldName = $subMetadata->getFieldForColumn(self::getMappingValue($associationMapping, 'indexBy'));
  101.                         // Not a property, maybe a column name?
  102.                         if (null === ($typeOfField = $subMetadata->getTypeOfField($fieldName))) {
  103.                             // Maybe the column name is the association join column?
  104.                             $associationMapping = $subMetadata->getAssociationMapping($fieldName);
  106.                             $indexProperty = $subMetadata->getSingleAssociationReferencedJoinColumnName($fieldName);
  107.                             $subMetadata = $this->entityManager->getClassMetadata(self::getMappingValue($associationMapping, 'targetEntity'));
  109.                             // Not a property, maybe a column name?
  110.                             if (null === ($typeOfField = $subMetadata->getTypeOfField($indexProperty))) {
  111.                                 $fieldName = $subMetadata->getFieldForColumn($indexProperty);
  112.                                 $typeOfField = $subMetadata->getTypeOfField($fieldName);
  113.                             }
  114.                         }
  115.                     }
  117.                     if (!$collectionKeyType = $this->getPhpType($typeOfField)) {
  118.                         return null;
  119.                     }
  120.                 }
  121.             }
  123.             return [new Type(
  124.                 Type::BUILTIN_TYPE_OBJECT,
  125.                 false,
  126.                 Collection::class,
  127.                 true,
  128.                 new Type($collectionKeyType),
  129.                 new Type(Type::BUILTIN_TYPE_OBJECT, false, $class)
  130.             )];
  131.         }
  133.         if ($metadata instanceof ClassMetadata && isset($metadata->embeddedClasses[$property])) {
  134.             return [new Type(Type::BUILTIN_TYPE_OBJECT, false, self::getMappingValue($metadata->embeddedClasses[$property], 'class'))];
  135.         }
  137.         if ($metadata->hasField($property)) {
  138.             $typeOfField = $metadata->getTypeOfField($property);
  140.             if (!$builtinType = $this->getPhpType($typeOfField)) {
  141.                 return null;
  142.             }
  144.             $nullable = $metadata instanceof ClassMetadata && $metadata->isNullable($property);
  145.             $enumType = null;
  146.             if (null !== $enumClass = self::getMappingValue($metadata->getFieldMapping($property), 'enumType') ?? null) {
  147.                 $enumType = new Type(Type::BUILTIN_TYPE_OBJECT, $nullable, $enumClass);
  148.             }
  150.             switch ($builtinType) {
  151.                 case Type::BUILTIN_TYPE_OBJECT:
  152.                     switch ($typeOfField) {
  153.                         case Types::DATE_MUTABLE:
  154.                         case Types::DATETIME_MUTABLE:
  155.                         case Types::DATETIMETZ_MUTABLE:
  156.                         case 'vardatetime':
  157.                         case Types::TIME_MUTABLE:
  158.                             return [new Type(Type::BUILTIN_TYPE_OBJECT, $nullable, 'DateTime')];
  160.                         case Types::DATE_IMMUTABLE:
  161.                         case Types::DATETIME_IMMUTABLE:
  162.                         case Types::DATETIMETZ_IMMUTABLE:
  163.                         case Types::TIME_IMMUTABLE:
  164.                             return [new Type(Type::BUILTIN_TYPE_OBJECT, $nullable, 'DateTimeImmutable')];
  166.                         case Types::DATEINTERVAL:
  167.                             return [new Type(Type::BUILTIN_TYPE_OBJECT, $nullable, 'DateInterval')];
  168.                     }
  170.                     break;
  171.                 case Type::BUILTIN_TYPE_ARRAY:
  172.                     switch ($typeOfField) {
  173.                         case 'array':      // DBAL < 4
  174.                         case 'json_array': // DBAL < 3
  175.                             // return null if $enumType is set, because we can't determine if collectionKeyType is string or int
  176.                             if ($enumType) {
  177.                                 return null;
  178.                             }
  180.                             return [new Type(Type::BUILTIN_TYPE_ARRAY, $nullable, null, true)];
  182.                         case Types::SIMPLE_ARRAY:
  183.                             return [new Type(Type::BUILTIN_TYPE_ARRAY, $nullable, null, true, new Type(Type::BUILTIN_TYPE_INT), $enumType ?? new Type(Type::BUILTIN_TYPE_STRING))];
  184.                     }
  185.                     break;
  186.                 case Type::BUILTIN_TYPE_INT:
  187.                 case Type::BUILTIN_TYPE_STRING:
  188.                     if ($enumType) {
  189.                         return [$enumType];
  190.                     }
  191.                     break;
  192.             }
  194.             return [new Type($builtinType, $nullable)];
  195.         }
  197.         return null;
  198.     }
  200.     /**
  201.      * {@inheritdoc}
  202.      */
  203.     public function isReadable(string $class, string $property, array $context = [])
  204.     {
  205.         return null;
  206.     }
  208.     /**
  209.      * {@inheritdoc}
  210.      */
  211.     public function isWritable(string $class, string $property, array $context = [])
  212.     {
  213.         if (
  214.             null === ($metadata = $this->getMetadata($class))
  215.             || ClassMetadata::GENERATOR_TYPE_NONE === $metadata->generatorType
  216.             || !\in_array($property, $metadata->getIdentifierFieldNames(), true)
  217.         ) {
  218.             return null;
  219.         }
  221.         return false;
  222.     }
  224.     private function getMetadata(string $class): ?ClassMetadata
  225.     {
  226.         try {
  227.             return $this->entityManager->getClassMetadata($class);
  228.         } catch (MappingException|OrmMappingException $exception) {
  229.             return null;
  230.         }
  231.     }
  233.     /**
  234.      * Determines whether an association is nullable.
  235.      *
  236.      * @param array<string, mixed>|AssociationMapping $associationMapping
  237.      *
  238.      * @see https://github.com/doctrine/doctrine2/blob/v2.5.4/lib/Doctrine/ORM/Tools/EntityGenerator.php#L1221-L1246
  239.      */
  240.     private function isAssociationNullable($associationMapping): bool
  241.     {
  242.         if (self::getMappingValue($associationMapping, 'id')) {
  243.             return false;
  244.         }
  246.         if (!self::getMappingValue($associationMapping, 'joinColumns')) {
  247.             return true;
  248.         }
  250.         $joinColumns = self::getMappingValue($associationMapping, 'joinColumns');
  251.         foreach ($joinColumns as $joinColumn) {
  252.             if (false === self::getMappingValue($joinColumn, 'nullable')) {
  253.                 return false;
  254.             }
  255.         }
  257.         return true;
  258.     }
  260.     /**
  261.      * Gets the corresponding built-in PHP type.
  262.      */
  263.     private function getPhpType(string $doctrineType): ?string
  264.     {
  265.         switch ($doctrineType) {
  266.             case Types::SMALLINT:
  267.             case Types::INTEGER:
  268.                 return Type::BUILTIN_TYPE_INT;
  270.             case Types::FLOAT:
  271.                 return Type::BUILTIN_TYPE_FLOAT;
  273.             case Types::BIGINT:
  274.             case Types::STRING:
  275.             case Types::TEXT:
  276.             case Types::GUID:
  277.             case Types::DECIMAL:
  278.                 return Type::BUILTIN_TYPE_STRING;
  280.             case Types::BOOLEAN:
  281.                 return Type::BUILTIN_TYPE_BOOL;
  283.             case Types::BLOB:
  284.             case Types::BINARY:
  285.                 return Type::BUILTIN_TYPE_RESOURCE;
  287.             case 'object': // DBAL < 4
  288.             case Types::DATE_MUTABLE:
  289.             case Types::DATETIME_MUTABLE:
  290.             case Types::DATETIMETZ_MUTABLE:
  291.             case 'vardatetime':
  292.             case Types::TIME_MUTABLE:
  293.             case Types::DATE_IMMUTABLE:
  294.             case Types::DATETIME_IMMUTABLE:
  295.             case Types::DATETIMETZ_IMMUTABLE:
  296.             case Types::TIME_IMMUTABLE:
  297.             case Types::DATEINTERVAL:
  298.                 return Type::BUILTIN_TYPE_OBJECT;
  300.             case 'array': // DBAL < 4
  301.             case Types::SIMPLE_ARRAY:
  302.             case 'json_array': // DBAL < 3
  303.                 return Type::BUILTIN_TYPE_ARRAY;
  304.         }
  306.         return null;
  307.     }
  309.     /**
  310.      * @param array|AssociationMapping|EmbeddedClassMapping|FieldMapping|JoinColumnMapping $mapping
  311.      *
  312.      * @return mixed
  313.      */
  314.     private static function getMappingValue($mapping, string $key)
  315.     {
  316.         if ($mapping instanceof AssociationMapping || $mapping instanceof EmbeddedClassMapping || $mapping instanceof FieldMapping || $mapping instanceof JoinColumnMapping) {
  317.             return $mapping->$key ?? null;
  318.         }
  320.         return $mapping[$key] ?? null;
  321.     }
  322. }