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

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\BigIntType;
  16. use Doctrine\DBAL\Types\Types;
  17. use Doctrine\ORM\EntityManagerInterface;
  18. use Doctrine\ORM\Mapping\AssociationMapping;
  19. use Doctrine\ORM\Mapping\ClassMetadata;
  20. use Doctrine\ORM\Mapping\EmbeddedClassMapping;
  21. use Doctrine\ORM\Mapping\FieldMapping;
  22. use Doctrine\ORM\Mapping\JoinColumnMapping;
  23. use Doctrine\ORM\Mapping\MappingException as OrmMappingException;
  24. use Doctrine\Persistence\Mapping\MappingException;
  25. use Symfony\Component\PropertyInfo\PropertyAccessExtractorInterface;
  26. use Symfony\Component\PropertyInfo\PropertyListExtractorInterface;
  27. use Symfony\Component\PropertyInfo\PropertyTypeExtractorInterface;
  28. use Symfony\Component\PropertyInfo\Type;
  30. /**
  31. * Extracts data using Doctrine ORM and ODM metadata.
  32. *
  33. * @author Kévin Dunglas <[email protected]>
  34. */
  35. class DoctrineExtractor implements PropertyListExtractorInterface, PropertyTypeExtractorInterface, PropertyAccessExtractorInterface
  36. {
  37. private $entityManager;
  39. public function __construct(EntityManagerInterface $entityManager)
  40. {
  41. $this->entityManager = $entityManager;
  42. }
  44. /**
  45. * {@inheritdoc}
  46. */
  47. public function getProperties(string $class, array $context = [])
  48. {
  49. if (null === $metadata = $this->getMetadata($class)) {
  50. return null;
  51. }
  53. $properties = array_merge($metadata->getFieldNames(), $metadata->getAssociationNames());
  55. if ($metadata instanceof ClassMetadata && $metadata->embeddedClasses) {
  56. $properties = array_filter($properties, function ($property) {
  57. return !str_contains($property, '.');
  58. });
  60. $properties = array_merge($properties, array_keys($metadata->embeddedClasses));
  61. }
  63. return $properties;
  64. }
  66. /**
  67. * {@inheritdoc}
  68. */
  69. public function getTypes(string $class, string $property, array $context = [])
  70. {
  71. if (null === $metadata = $this->getMetadata($class)) {
  72. return null;
  73. }
  75. if ($metadata->hasAssociation($property)) {
  76. $class = $metadata->getAssociationTargetClass($property);
  78. if ($metadata->isSingleValuedAssociation($property)) {
  79. if ($metadata instanceof ClassMetadata) {
  80. $associationMapping = $metadata->getAssociationMapping($property);
  82. $nullable = $this->isAssociationNullable($associationMapping);
  83. } else {
  84. $nullable = false;
  85. }
  87. return [new Type(Type::BUILTIN_TYPE_OBJECT, $nullable, $class)];
  88. }
  90. $collectionKeyType = Type::BUILTIN_TYPE_INT;
  92. if ($metadata instanceof ClassMetadata) {
  93. $associationMapping = $metadata->getAssociationMapping($property);
  95. if (self::getMappingValue($associationMapping, 'indexBy')) {
  96. $subMetadata = $this->entityManager->getClassMetadata(self::getMappingValue($associationMapping, 'targetEntity'));
  98. // Check if indexBy value is a property
  99. $fieldName = self::getMappingValue($associationMapping, 'indexBy');
  100. if (null === ($typeOfField = $subMetadata->getTypeOfField($fieldName))) {
  101. $fieldName = $subMetadata->getFieldForColumn(self::getMappingValue($associationMapping, 'indexBy'));
  102. // Not a property, maybe a column name?
  103. if (null === ($typeOfField = $subMetadata->getTypeOfField($fieldName))) {
  104. // Maybe the column name is the association join column?
  105. $associationMapping = $subMetadata->getAssociationMapping($fieldName);
  107. $indexProperty = $subMetadata->getSingleAssociationReferencedJoinColumnName($fieldName);
  108. $subMetadata = $this->entityManager->getClassMetadata(self::getMappingValue($associationMapping, 'targetEntity'));
  110. // Not a property, maybe a column name?
  111. if (null === ($typeOfField = $subMetadata->getTypeOfField($indexProperty))) {
  112. $fieldName = $subMetadata->getFieldForColumn($indexProperty);
  113. $typeOfField = $subMetadata->getTypeOfField($fieldName);
  114. }
  115. }
  116. }
  118. if (!$collectionKeyType = $this->getPhpType($typeOfField)) {
  119. return null;
  120. }
  121. }
  122. }
  124. return [new Type(
  125. Type::BUILTIN_TYPE_OBJECT,
  126. false,
  127. Collection::class,
  128. true,
  129. new Type($collectionKeyType),
  130. new Type(Type::BUILTIN_TYPE_OBJECT, false, $class)
  131. )];
  132. }
  134. if ($metadata instanceof ClassMetadata && isset($metadata->embeddedClasses[$property])) {
  135. return [new Type(Type::BUILTIN_TYPE_OBJECT, false, self::getMappingValue($metadata->embeddedClasses[$property], 'class'))];
  136. }
  138. if ($metadata->hasField($property)) {
  139. $typeOfField = $metadata->getTypeOfField($property);
  141. if (!$builtinType = $this->getPhpType($typeOfField)) {
  142. return null;
  143. }
  145. $nullable = $metadata instanceof ClassMetadata && $metadata->isNullable($property);
  147. // DBAL 4 has a special fallback strategy for BINGINT (int -> string)
  148. if (Types::BIGINT === $typeOfField && !method_exists(BigIntType::class, 'getName')) {
  149. return [
  150. new Type(Type::BUILTIN_TYPE_INT, $nullable),
  151. new Type(Type::BUILTIN_TYPE_STRING, $nullable),
  152. ];
  153. }
  155. $enumType = null;
  156. if (null !== $enumClass = self::getMappingValue($metadata->getFieldMapping($property), 'enumType') ?? null) {
  157. $enumType = new Type(Type::BUILTIN_TYPE_OBJECT, $nullable, $enumClass);
  158. }
  160. switch ($builtinType) {
  161. case Type::BUILTIN_TYPE_OBJECT:
  162. switch ($typeOfField) {
  163. case Types::DATE_MUTABLE:
  164. case Types::DATETIME_MUTABLE:
  165. case Types::DATETIMETZ_MUTABLE:
  166. case 'vardatetime':
  167. case Types::TIME_MUTABLE:
  168. return [new Type(Type::BUILTIN_TYPE_OBJECT, $nullable, 'DateTime')];
  170. case Types::DATE_IMMUTABLE:
  171. case Types::DATETIME_IMMUTABLE:
  172. case Types::DATETIMETZ_IMMUTABLE:
  173. case Types::TIME_IMMUTABLE:
  174. return [new Type(Type::BUILTIN_TYPE_OBJECT, $nullable, 'DateTimeImmutable')];
  176. case Types::DATEINTERVAL:
  177. return [new Type(Type::BUILTIN_TYPE_OBJECT, $nullable, 'DateInterval')];
  178. }
  180. break;
  181. case Type::BUILTIN_TYPE_ARRAY:
  182. switch ($typeOfField) {
  183. case 'array': // DBAL < 4
  184. case 'json_array': // DBAL < 3
  185. // return null if $enumType is set, because we can't determine if collectionKeyType is string or int
  186. if ($enumType) {
  187. return null;
  188. }
  190. return [new Type(Type::BUILTIN_TYPE_ARRAY, $nullable, null, true)];
  192. case Types::SIMPLE_ARRAY:
  193. return [new Type(Type::BUILTIN_TYPE_ARRAY, $nullable, null, true, new Type(Type::BUILTIN_TYPE_INT), $enumType ?? new Type(Type::BUILTIN_TYPE_STRING))];
  194. }
  195. break;
  196. case Type::BUILTIN_TYPE_INT:
  197. case Type::BUILTIN_TYPE_STRING:
  198. if ($enumType) {
  199. return [$enumType];
  200. }
  201. break;
  202. }
  204. return [new Type($builtinType, $nullable)];
  205. }
  207. return null;
  208. }
  210. /**
  211. * {@inheritdoc}
  212. */
  213. public function isReadable(string $class, string $property, array $context = [])
  214. {
  215. return null;
  216. }
  218. /**
  219. * {@inheritdoc}
  220. */
  221. public function isWritable(string $class, string $property, array $context = [])
  222. {
  223. if (
  224. null === ($metadata = $this->getMetadata($class))
  225. || ClassMetadata::GENERATOR_TYPE_NONE === $metadata->generatorType
  226. || !\in_array($property, $metadata->getIdentifierFieldNames(), true)
  227. ) {
  228. return null;
  229. }
  231. return false;
  232. }
  234. private function getMetadata(string $class): ?ClassMetadata
  235. {
  236. try {
  237. return $this->entityManager->getClassMetadata($class);
  238. } catch (MappingException|OrmMappingException $exception) {
  239. return null;
  240. }
  241. }
  243. /**
  244. * Determines whether an association is nullable.
  245. *
  246. * @param array<string, mixed>|AssociationMapping $associationMapping
  247. *
  248. * @see https://github.com/doctrine/doctrine2/blob/v2.5.4/lib/Doctrine/ORM/Tools/EntityGenerator.php#L1221-L1246
  249. */
  250. private function isAssociationNullable($associationMapping): bool
  251. {
  252. if (self::getMappingValue($associationMapping, 'id')) {
  253. return false;
  254. }
  256. if (!self::getMappingValue($associationMapping, 'joinColumns')) {
  257. return true;
  258. }
  260. $joinColumns = self::getMappingValue($associationMapping, 'joinColumns');
  261. foreach ($joinColumns as $joinColumn) {
  262. if (false === self::getMappingValue($joinColumn, 'nullable')) {
  263. return false;
  264. }
  265. }
  267. return true;
  268. }
  270. /**
  271. * Gets the corresponding built-in PHP type.
  272. */
  273. private function getPhpType(string $doctrineType): ?string
  274. {
  275. switch ($doctrineType) {
  276. case Types::SMALLINT:
  277. case Types::INTEGER:
  278. return Type::BUILTIN_TYPE_INT;
  280. case Types::FLOAT:
  281. return Type::BUILTIN_TYPE_FLOAT;
  283. case Types::BIGINT:
  284. case Types::STRING:
  285. case Types::TEXT:
  286. case Types::GUID:
  287. case Types::DECIMAL:
  288. return Type::BUILTIN_TYPE_STRING;
  290. case Types::BOOLEAN:
  291. return Type::BUILTIN_TYPE_BOOL;
  293. case Types::BLOB:
  294. case Types::BINARY:
  295. return Type::BUILTIN_TYPE_RESOURCE;
  297. case 'object': // DBAL < 4
  298. case Types::DATE_MUTABLE:
  299. case Types::DATETIME_MUTABLE:
  300. case Types::DATETIMETZ_MUTABLE:
  301. case 'vardatetime':
  302. case Types::TIME_MUTABLE:
  303. case Types::DATE_IMMUTABLE:
  304. case Types::DATETIME_IMMUTABLE:
  305. case Types::DATETIMETZ_IMMUTABLE:
  306. case Types::TIME_IMMUTABLE:
  307. case Types::DATEINTERVAL:
  308. return Type::BUILTIN_TYPE_OBJECT;
  310. case 'array': // DBAL < 4
  311. case Types::SIMPLE_ARRAY:
  312. case 'json_array': // DBAL < 3
  313. return Type::BUILTIN_TYPE_ARRAY;
  314. }
  316. return null;
  317. }
  319. /**
  320. * @param array|AssociationMapping|EmbeddedClassMapping|FieldMapping|JoinColumnMapping $mapping
  321. *
  322. * @return mixed
  323. */
  324. private static function getMappingValue($mapping, string $key)
  325. {
  326. if ($mapping instanceof AssociationMapping || $mapping instanceof EmbeddedClassMapping || $mapping instanceof FieldMapping || $mapping instanceof JoinColumnMapping) {
  327. return $mapping->$key ?? null;
  328. }
  330. return $mapping[$key] ?? null;
  331. }
  332. }