vendor/doctrine/orm/src/Mapping/Driver/AttributeDriver.php line 133

Open in your IDE?
  1. <?php
  3. declare(strict_types=1);
  5. namespace Doctrine\ORM\Mapping\Driver;
  7. use Doctrine\Deprecations\Deprecation;
  8. use Doctrine\ORM\Events;
  9. use Doctrine\ORM\Mapping;
  10. use Doctrine\ORM\Mapping\Builder\EntityListenerBuilder;
  11. use Doctrine\ORM\Mapping\ClassMetadata;
  12. use Doctrine\ORM\Mapping\MappingAttribute;
  13. use Doctrine\ORM\Mapping\MappingException;
  14. use Doctrine\Persistence\Mapping\ClassMetadata as PersistenceClassMetadata;
  15. use Doctrine\Persistence\Mapping\Driver\ColocatedMappingDriver;
  16. use LogicException;
  17. use ReflectionClass;
  18. use ReflectionMethod;
  20. use function class_exists;
  21. use function constant;
  22. use function defined;
  23. use function get_class;
  25. use const PHP_VERSION_ID;
  27. class AttributeDriver extends CompatibilityAnnotationDriver
  28. {
  29. use ColocatedMappingDriver;
  30. use ReflectionBasedDriver;
  32. private const ENTITY_ATTRIBUTE_CLASSES = [
  33. Mapping\Entity::class => 1,
  34. Mapping\MappedSuperclass::class => 2,
  35. ];
  37. /**
  38. * @deprecated override isTransient() instead of overriding this property
  39. *
  40. * @var array<class-string<MappingAttribute>, int>
  41. */
  42. protected $entityAnnotationClasses = self::ENTITY_ATTRIBUTE_CLASSES;
  44. /**
  45. * The attribute reader.
  46. *
  47. * @internal this property will be private in 3.0
  48. *
  49. * @var AttributeReader
  50. */
  51. protected $reader;
  53. /** @param array<string> $paths */
  54. public function __construct(array $paths, bool $reportFieldsWhereDeclared = false)
  55. {
  56. if (PHP_VERSION_ID < 80000) {
  57. throw new LogicException(
  58. 'The attribute metadata driver cannot be enabled on PHP 7. Please upgrade to PHP 8 or choose a different'
  59. . ' metadata driver.'
  60. );
  61. }
  63. $this->reader = new AttributeReader();
  64. $this->addPaths($paths);
  66. // @phpstan-ignore property.deprecated
  67. if ($this->entityAnnotationClasses !== self::ENTITY_ATTRIBUTE_CLASSES) {
  68. Deprecation::trigger(
  69. 'doctrine/orm',
  70. 'https://github.com/doctrine/orm/pull/10204',
  71. 'Changing the value of %s::$entityAnnotationClasses is deprecated and will have no effect in Doctrine ORM 3.0.',
  72. self::class
  73. );
  74. }
  76. if (! $reportFieldsWhereDeclared) {
  77. Deprecation::trigger(
  78. 'doctrine/orm',
  79. 'https://github.com/doctrine/orm/pull/10455',
  80. 'In ORM 3.0, the AttributeDriver will report fields for the classes where they are declared. This may uncover invalid mapping configurations. To opt into the new mode today, set the "reportFieldsWhereDeclared" constructor parameter to true.',
  81. self::class
  82. );
  83. }
  85. $this->reportFieldsWhereDeclared = $reportFieldsWhereDeclared;
  86. }
  88. /**
  89. * Retrieve the current annotation reader
  90. *
  91. * @deprecated no replacement planned.
  92. *
  93. * @return AttributeReader
  94. */
  95. public function getReader()
  96. {
  97. Deprecation::trigger(
  98. 'doctrine/orm',
  99. 'https://github.com/doctrine/orm/pull/9587',
  100. '%s is deprecated with no replacement',
  101. __METHOD__
  102. );
  104. return $this->reader;
  105. }
  107. /**
  108. * {@inheritDoc}
  109. */
  110. public function isTransient($className)
  111. {
  112. $classAttributes = $this->reader->getClassAttributes(new ReflectionClass($className));
  114. foreach ($classAttributes as $a) {
  115. $attr = $a instanceof RepeatableAttributeCollection ? $a[0] : $a;
  116. // @phpstan-ignore property.deprecated
  117. if (isset($this->entityAnnotationClasses[get_class($attr)])) {
  118. return false;
  119. }
  120. }
  122. return true;
  123. }
  125. /**
  126. * {@inheritDoc}
  127. *
  128. * @param class-string<T> $className
  129. * @param ClassMetadata<T> $metadata
  130. *
  131. * @template T of object
  132. */
  133. public function loadMetadataForClass($className, PersistenceClassMetadata $metadata): void
  134. {
  135. $reflectionClass = $metadata->getReflectionClass()
  136. // this happens when running attribute driver in combination with
  137. // static reflection services. This is not the nicest fix
  138. ?? new ReflectionClass($metadata->name);
  140. $classAttributes = $this->reader->getClassAttributes($reflectionClass);
  142. // Evaluate Entity attribute
  143. if (isset($classAttributes[Mapping\Entity::class])) {
  144. $entityAttribute = $classAttributes[Mapping\Entity::class];
  145. if ($entityAttribute->repositoryClass !== null) {
  146. $metadata->setCustomRepositoryClass($entityAttribute->repositoryClass);
  147. }
  149. if ($entityAttribute->readOnly) {
  150. $metadata->markReadOnly();
  151. }
  152. } elseif (isset($classAttributes[Mapping\MappedSuperclass::class])) {
  153. $mappedSuperclassAttribute = $classAttributes[Mapping\MappedSuperclass::class];
  155. $metadata->setCustomRepositoryClass($mappedSuperclassAttribute->repositoryClass);
  156. $metadata->isMappedSuperclass = true;
  157. } elseif (isset($classAttributes[Mapping\Embeddable::class])) {
  158. $metadata->isEmbeddedClass = true;
  159. } else {
  160. throw MappingException::classIsNotAValidEntityOrMappedSuperClass($className);
  161. }
  163. $primaryTable = [];
  165. if (isset($classAttributes[Mapping\Table::class])) {
  166. $tableAnnot = $classAttributes[Mapping\Table::class];
  167. $primaryTable['name'] = $tableAnnot->name;
  168. $primaryTable['schema'] = $tableAnnot->schema;
  170. if ($tableAnnot->options) {
  171. $primaryTable['options'] = $tableAnnot->options;
  172. }
  173. }
  175. if (isset($classAttributes[Mapping\Index::class])) {
  176. foreach ($classAttributes[Mapping\Index::class] as $idx => $indexAnnot) {
  177. $index = [];
  179. if (! empty($indexAnnot->columns)) {
  180. $index['columns'] = $indexAnnot->columns;
  181. }
  183. if (! empty($indexAnnot->fields)) {
  184. $index['fields'] = $indexAnnot->fields;
  185. }
  187. if (
  188. isset($index['columns'], $index['fields'])
  189. || (
  190. ! isset($index['columns'])
  191. && ! isset($index['fields'])
  192. )
  193. ) {
  194. throw MappingException::invalidIndexConfiguration(
  195. $className,
  196. (string) ($indexAnnot->name ?? $idx)
  197. );
  198. }
  200. if (! empty($indexAnnot->flags)) {
  201. $index['flags'] = $indexAnnot->flags;
  202. }
  204. if (! empty($indexAnnot->options)) {
  205. $index['options'] = $indexAnnot->options;
  206. }
  208. if (! empty($indexAnnot->name)) {
  209. $primaryTable['indexes'][$indexAnnot->name] = $index;
  210. } else {
  211. $primaryTable['indexes'][] = $index;
  212. }
  213. }
  214. }
  216. if (isset($classAttributes[Mapping\UniqueConstraint::class])) {
  217. foreach ($classAttributes[Mapping\UniqueConstraint::class] as $idx => $uniqueConstraintAnnot) {
  218. $uniqueConstraint = [];
  220. if (! empty($uniqueConstraintAnnot->columns)) {
  221. $uniqueConstraint['columns'] = $uniqueConstraintAnnot->columns;
  222. }
  224. if (! empty($uniqueConstraintAnnot->fields)) {
  225. $uniqueConstraint['fields'] = $uniqueConstraintAnnot->fields;
  226. }
  228. if (
  229. isset($uniqueConstraint['columns'], $uniqueConstraint['fields'])
  230. || (
  231. ! isset($uniqueConstraint['columns'])
  232. && ! isset($uniqueConstraint['fields'])
  233. )
  234. ) {
  235. throw MappingException::invalidUniqueConstraintConfiguration(
  236. $className,
  237. (string) ($uniqueConstraintAnnot->name ?? $idx)
  238. );
  239. }
  241. if (! empty($uniqueConstraintAnnot->options)) {
  242. $uniqueConstraint['options'] = $uniqueConstraintAnnot->options;
  243. }
  245. if (! empty($uniqueConstraintAnnot->name)) {
  246. $primaryTable['uniqueConstraints'][$uniqueConstraintAnnot->name] = $uniqueConstraint;
  247. } else {
  248. $primaryTable['uniqueConstraints'][] = $uniqueConstraint;
  249. }
  250. }
  251. }
  253. $metadata->setPrimaryTable($primaryTable);
  255. // Evaluate #[Cache] attribute
  256. if (isset($classAttributes[Mapping\Cache::class])) {
  257. $cacheAttribute = $classAttributes[Mapping\Cache::class];
  258. $cacheMap = [
  259. 'region' => $cacheAttribute->region,
  260. 'usage' => constant('Doctrine\ORM\Mapping\ClassMetadata::CACHE_USAGE_' . $cacheAttribute->usage),
  261. ];
  263. $metadata->enableCache($cacheMap);
  264. }
  266. // Evaluate InheritanceType attribute
  267. if (isset($classAttributes[Mapping\InheritanceType::class])) {
  268. $inheritanceTypeAttribute = $classAttributes[Mapping\InheritanceType::class];
  270. $metadata->setInheritanceType(
  271. constant('Doctrine\ORM\Mapping\ClassMetadata::INHERITANCE_TYPE_' . $inheritanceTypeAttribute->value)
  272. );
  274. if ($metadata->inheritanceType !== ClassMetadata::INHERITANCE_TYPE_NONE) {
  275. // Evaluate DiscriminatorColumn attribute
  276. if (isset($classAttributes[Mapping\DiscriminatorColumn::class])) {
  277. $discrColumnAttribute = $classAttributes[Mapping\DiscriminatorColumn::class];
  279. $columnDef = [
  280. 'name' => isset($discrColumnAttribute->name) ? (string) $discrColumnAttribute->name : null,
  281. 'type' => isset($discrColumnAttribute->type) ? (string) $discrColumnAttribute->type : 'string',
  282. 'length' => isset($discrColumnAttribute->length) ? (int) $discrColumnAttribute->length : 255,
  283. 'columnDefinition' => isset($discrColumnAttribute->columnDefinition) ? (string) $discrColumnAttribute->columnDefinition : null,
  284. 'enumType' => isset($discrColumnAttribute->enumType) ? (string) $discrColumnAttribute->enumType : null,
  285. ];
  287. if ($discrColumnAttribute->options) {
  288. $columnDef['options'] = (array) $discrColumnAttribute->options;
  289. }
  291. $metadata->setDiscriminatorColumn($columnDef);
  292. } else {
  293. $metadata->setDiscriminatorColumn(['name' => 'dtype', 'type' => 'string', 'length' => 255]);
  294. }
  296. // Evaluate DiscriminatorMap attribute
  297. if (isset($classAttributes[Mapping\DiscriminatorMap::class])) {
  298. $discrMapAttribute = $classAttributes[Mapping\DiscriminatorMap::class];
  299. $metadata->setDiscriminatorMap($discrMapAttribute->value);
  300. }
  301. }
  302. }
  304. // Evaluate DoctrineChangeTrackingPolicy attribute
  305. if (isset($classAttributes[Mapping\ChangeTrackingPolicy::class])) {
  306. $changeTrackingAttribute = $classAttributes[Mapping\ChangeTrackingPolicy::class];
  307. $metadata->setChangeTrackingPolicy(constant('Doctrine\ORM\Mapping\ClassMetadata::CHANGETRACKING_' . $changeTrackingAttribute->value));
  308. }
  310. foreach ($reflectionClass->getProperties() as $property) {
  311. if ($this->isRepeatedPropertyDeclaration($property, $metadata)) {
  312. continue;
  313. }
  315. $mapping = [];
  316. $mapping['fieldName'] = $property->name;
  318. // Evaluate #[Cache] attribute
  319. $cacheAttribute = $this->reader->getPropertyAttribute($property, Mapping\Cache::class);
  320. if ($cacheAttribute !== null) {
  321. $mapping['cache'] = $metadata->getAssociationCacheDefaults(
  322. $mapping['fieldName'],
  323. [
  324. 'usage' => (int) constant('Doctrine\ORM\Mapping\ClassMetadata::CACHE_USAGE_' . $cacheAttribute->usage),
  325. 'region' => $cacheAttribute->region,
  326. ]
  327. );
  328. }
  330. // Check for JoinColumn/JoinColumns attributes
  331. $joinColumns = [];
  333. $joinColumnAttributes = $this->reader->getPropertyAttributeCollection($property, Mapping\JoinColumn::class);
  335. foreach ($joinColumnAttributes as $joinColumnAttribute) {
  336. $joinColumns[] = $this->joinColumnToArray($joinColumnAttribute);
  337. }
  339. // Field can only be attributed with one of:
  340. // Column, OneToOne, OneToMany, ManyToOne, ManyToMany, Embedded
  341. $columnAttribute = $this->reader->getPropertyAttribute($property, Mapping\Column::class);
  342. $oneToOneAttribute = $this->reader->getPropertyAttribute($property, Mapping\OneToOne::class);
  343. $oneToManyAttribute = $this->reader->getPropertyAttribute($property, Mapping\OneToMany::class);
  344. $manyToOneAttribute = $this->reader->getPropertyAttribute($property, Mapping\ManyToOne::class);
  345. $manyToManyAttribute = $this->reader->getPropertyAttribute($property, Mapping\ManyToMany::class);
  346. $embeddedAttribute = $this->reader->getPropertyAttribute($property, Mapping\Embedded::class);
  348. if ($columnAttribute !== null) {
  349. $mapping = $this->columnToArray($property->name, $columnAttribute);
  351. if ($this->reader->getPropertyAttribute($property, Mapping\Id::class)) {
  352. $mapping['id'] = true;
  353. }
  355. $generatedValueAttribute = $this->reader->getPropertyAttribute($property, Mapping\GeneratedValue::class);
  357. if ($generatedValueAttribute !== null) {
  358. $metadata->setIdGeneratorType(constant('Doctrine\ORM\Mapping\ClassMetadata::GENERATOR_TYPE_' . $generatedValueAttribute->strategy));
  359. }
  361. if ($this->reader->getPropertyAttribute($property, Mapping\Version::class)) {
  362. $metadata->setVersionMapping($mapping);
  363. }
  365. $metadata->mapField($mapping);
  367. // Check for SequenceGenerator/TableGenerator definition
  368. $seqGeneratorAttribute = $this->reader->getPropertyAttribute($property, Mapping\SequenceGenerator::class);
  369. $customGeneratorAttribute = $this->reader->getPropertyAttribute($property, Mapping\CustomIdGenerator::class);
  371. if ($seqGeneratorAttribute !== null) {
  372. $metadata->setSequenceGeneratorDefinition(
  373. [
  374. 'sequenceName' => $seqGeneratorAttribute->sequenceName,
  375. 'allocationSize' => $seqGeneratorAttribute->allocationSize,
  376. 'initialValue' => $seqGeneratorAttribute->initialValue,
  377. ]
  378. );
  379. } elseif ($customGeneratorAttribute !== null) {
  380. $metadata->setCustomGeneratorDefinition(
  381. [
  382. 'class' => $customGeneratorAttribute->class,
  383. ]
  384. );
  385. }
  386. } elseif ($oneToOneAttribute !== null) {
  387. if ($this->reader->getPropertyAttribute($property, Mapping\Id::class)) {
  388. $mapping['id'] = true;
  389. }
  391. $mapping['targetEntity'] = $oneToOneAttribute->targetEntity;
  392. $mapping['joinColumns'] = $joinColumns;
  393. $mapping['mappedBy'] = $oneToOneAttribute->mappedBy;
  394. $mapping['inversedBy'] = $oneToOneAttribute->inversedBy;
  395. $mapping['cascade'] = $oneToOneAttribute->cascade;
  396. $mapping['orphanRemoval'] = $oneToOneAttribute->orphanRemoval;
  397. $mapping['fetch'] = $this->getFetchMode($className, $oneToOneAttribute->fetch);
  398. $metadata->mapOneToOne($mapping);
  399. } elseif ($oneToManyAttribute !== null) {
  400. $mapping['mappedBy'] = $oneToManyAttribute->mappedBy;
  401. $mapping['targetEntity'] = $oneToManyAttribute->targetEntity;
  402. $mapping['cascade'] = $oneToManyAttribute->cascade;
  403. $mapping['indexBy'] = $oneToManyAttribute->indexBy;
  404. $mapping['orphanRemoval'] = $oneToManyAttribute->orphanRemoval;
  405. $mapping['fetch'] = $this->getFetchMode($className, $oneToManyAttribute->fetch);
  407. $orderByAttribute = $this->reader->getPropertyAttribute($property, Mapping\OrderBy::class);
  409. if ($orderByAttribute !== null) {
  410. $mapping['orderBy'] = $orderByAttribute->value;
  411. }
  413. $metadata->mapOneToMany($mapping);
  414. } elseif ($manyToOneAttribute !== null) {
  415. $idAttribute = $this->reader->getPropertyAttribute($property, Mapping\Id::class);
  417. if ($idAttribute !== null) {
  418. $mapping['id'] = true;
  419. }
  421. $mapping['joinColumns'] = $joinColumns;
  422. $mapping['cascade'] = $manyToOneAttribute->cascade;
  423. $mapping['inversedBy'] = $manyToOneAttribute->inversedBy;
  424. $mapping['targetEntity'] = $manyToOneAttribute->targetEntity;
  425. $mapping['fetch'] = $this->getFetchMode($className, $manyToOneAttribute->fetch);
  426. $metadata->mapManyToOne($mapping);
  427. } elseif ($manyToManyAttribute !== null) {
  428. $joinTable = [];
  429. $joinTableAttribute = $this->reader->getPropertyAttribute($property, Mapping\JoinTable::class);
  431. if ($joinTableAttribute !== null) {
  432. $joinTable = [
  433. 'name' => $joinTableAttribute->name,
  434. 'schema' => $joinTableAttribute->schema,
  435. ];
  437. if ($joinTableAttribute->options) {
  438. $joinTable['options'] = $joinTableAttribute->options;
  439. }
  441. foreach ($joinTableAttribute->joinColumns as $joinColumn) {
  442. $joinTable['joinColumns'][] = $this->joinColumnToArray($joinColumn);
  443. }
  445. foreach ($joinTableAttribute->inverseJoinColumns as $joinColumn) {
  446. $joinTable['inverseJoinColumns'][] = $this->joinColumnToArray($joinColumn);
  447. }
  448. }
  450. foreach ($this->reader->getPropertyAttributeCollection($property, Mapping\JoinColumn::class) as $joinColumn) {
  451. $joinTable['joinColumns'][] = $this->joinColumnToArray($joinColumn);
  452. }
  454. foreach ($this->reader->getPropertyAttributeCollection($property, Mapping\InverseJoinColumn::class) as $joinColumn) {
  455. $joinTable['inverseJoinColumns'][] = $this->joinColumnToArray($joinColumn);
  456. }
  458. $mapping['joinTable'] = $joinTable;
  459. $mapping['targetEntity'] = $manyToManyAttribute->targetEntity;
  460. $mapping['mappedBy'] = $manyToManyAttribute->mappedBy;
  461. $mapping['inversedBy'] = $manyToManyAttribute->inversedBy;
  462. $mapping['cascade'] = $manyToManyAttribute->cascade;
  463. $mapping['indexBy'] = $manyToManyAttribute->indexBy;
  464. $mapping['orphanRemoval'] = $manyToManyAttribute->orphanRemoval;
  465. $mapping['fetch'] = $this->getFetchMode($className, $manyToManyAttribute->fetch);
  467. $orderByAttribute = $this->reader->getPropertyAttribute($property, Mapping\OrderBy::class);
  469. if ($orderByAttribute !== null) {
  470. $mapping['orderBy'] = $orderByAttribute->value;
  471. }
  473. $metadata->mapManyToMany($mapping);
  474. } elseif ($embeddedAttribute !== null) {
  475. $mapping['class'] = $embeddedAttribute->class;
  476. $mapping['columnPrefix'] = $embeddedAttribute->columnPrefix;
  478. $metadata->mapEmbedded($mapping);
  479. }
  480. }
  482. // Evaluate AssociationOverrides attribute
  483. if (isset($classAttributes[Mapping\AssociationOverrides::class])) {
  484. $associationOverride = $classAttributes[Mapping\AssociationOverrides::class];
  486. foreach ($associationOverride->overrides as $associationOverride) {
  487. $override = [];
  488. $fieldName = $associationOverride->name;
  490. // Check for JoinColumn/JoinColumns attributes
  491. if ($associationOverride->joinColumns) {
  492. $joinColumns = [];
  494. foreach ($associationOverride->joinColumns as $joinColumn) {
  495. $joinColumns[] = $this->joinColumnToArray($joinColumn);
  496. }
  498. $override['joinColumns'] = $joinColumns;
  499. }
  501. if ($associationOverride->inverseJoinColumns) {
  502. $joinColumns = [];
  504. foreach ($associationOverride->inverseJoinColumns as $joinColumn) {
  505. $joinColumns[] = $this->joinColumnToArray($joinColumn);
  506. }
  508. $override['inverseJoinColumns'] = $joinColumns;
  509. }
  511. // Check for JoinTable attributes
  512. if ($associationOverride->joinTable) {
  513. $joinTableAnnot = $associationOverride->joinTable;
  514. $joinTable = [
  515. 'name' => $joinTableAnnot->name,
  516. 'schema' => $joinTableAnnot->schema,
  517. 'joinColumns' => $override['joinColumns'] ?? [],
  518. 'inverseJoinColumns' => $override['inverseJoinColumns'] ?? [],
  519. ];
  521. unset($override['joinColumns'], $override['inverseJoinColumns']);
  523. $override['joinTable'] = $joinTable;
  524. }
  526. // Check for inversedBy
  527. if ($associationOverride->inversedBy) {
  528. $override['inversedBy'] = $associationOverride->inversedBy;
  529. }
  531. // Check for `fetch`
  532. if ($associationOverride->fetch) {
  533. $override['fetch'] = constant(ClassMetadata::class . '::FETCH_' . $associationOverride->fetch);
  534. }
  536. $metadata->setAssociationOverride($fieldName, $override);
  537. }
  538. }
  540. // Evaluate AttributeOverrides attribute
  541. if (isset($classAttributes[Mapping\AttributeOverrides::class])) {
  542. $attributeOverridesAnnot = $classAttributes[Mapping\AttributeOverrides::class];
  544. foreach ($attributeOverridesAnnot->overrides as $attributeOverride) {
  545. $mapping = $this->columnToArray($attributeOverride->name, $attributeOverride->column);
  547. $metadata->setAttributeOverride($attributeOverride->name, $mapping);
  548. }
  549. }
  551. // Evaluate EntityListeners attribute
  552. if (isset($classAttributes[Mapping\EntityListeners::class])) {
  553. $entityListenersAttribute = $classAttributes[Mapping\EntityListeners::class];
  555. foreach ($entityListenersAttribute->value as $item) {
  556. $listenerClassName = $metadata->fullyQualifiedClassName($item);
  558. if (! class_exists($listenerClassName)) {
  559. throw MappingException::entityListenerClassNotFound($listenerClassName, $className);
  560. }
  562. $hasMapping = false;
  563. $listenerClass = new ReflectionClass($listenerClassName);
  565. foreach ($listenerClass->getMethods(ReflectionMethod::IS_PUBLIC) as $method) {
  566. // find method callbacks.
  567. $callbacks = $this->getMethodCallbacks($method);
  568. $hasMapping = $hasMapping ?: ! empty($callbacks);
  570. foreach ($callbacks as $value) {
  571. $metadata->addEntityListener($value[1], $listenerClassName, $value[0]);
  572. }
  573. }
  575. // Evaluate the listener using naming convention.
  576. if (! $hasMapping) {
  577. EntityListenerBuilder::bindEntityListener($metadata, $listenerClassName);
  578. }
  579. }
  580. }
  582. // Evaluate #[HasLifecycleCallbacks] attribute
  583. if (isset($classAttributes[Mapping\HasLifecycleCallbacks::class])) {
  584. foreach ($reflectionClass->getMethods(ReflectionMethod::IS_PUBLIC) as $method) {
  585. foreach ($this->getMethodCallbacks($method) as $value) {
  586. $metadata->addLifecycleCallback($value[0], $value[1]);
  587. }
  588. }
  589. }
  590. }
  592. /**
  593. * Attempts to resolve the fetch mode.
  594. *
  595. * @param class-string $className The class name.
  596. * @param string $fetchMode The fetch mode.
  597. *
  598. * @return ClassMetadata::FETCH_* The fetch mode as defined in ClassMetadata.
  599. *
  600. * @throws MappingException If the fetch mode is not valid.
  601. */
  602. private function getFetchMode(string $className, string $fetchMode): int
  603. {
  604. if (! defined('Doctrine\ORM\Mapping\ClassMetadata::FETCH_' . $fetchMode)) {
  605. throw MappingException::invalidFetchMode($className, $fetchMode);
  606. }
  608. return constant('Doctrine\ORM\Mapping\ClassMetadata::FETCH_' . $fetchMode);
  609. }
  611. /**
  612. * Attempts to resolve the generated mode.
  613. *
  614. * @throws MappingException If the fetch mode is not valid.
  615. */
  616. private function getGeneratedMode(string $generatedMode): int
  617. {
  618. if (! defined('Doctrine\ORM\Mapping\ClassMetadata::GENERATED_' . $generatedMode)) {
  619. throw MappingException::invalidGeneratedMode($generatedMode);
  620. }
  622. return constant('Doctrine\ORM\Mapping\ClassMetadata::GENERATED_' . $generatedMode);
  623. }
  625. /**
  626. * Parses the given method.
  627. *
  628. * @return list<array{string, string}>
  629. * @phpstan-return list<array{string, (Events::*)}>
  630. */
  631. private function getMethodCallbacks(ReflectionMethod $method): array
  632. {
  633. $callbacks = [];
  634. $attributes = $this->reader->getMethodAttributes($method);
  636. foreach ($attributes as $attribute) {
  637. if ($attribute instanceof Mapping\PrePersist) {
  638. $callbacks[] = [$method->name, Events::prePersist];
  639. }
  641. if ($attribute instanceof Mapping\PostPersist) {
  642. $callbacks[] = [$method->name, Events::postPersist];
  643. }
  645. if ($attribute instanceof Mapping\PreUpdate) {
  646. $callbacks[] = [$method->name, Events::preUpdate];
  647. }
  649. if ($attribute instanceof Mapping\PostUpdate) {
  650. $callbacks[] = [$method->name, Events::postUpdate];
  651. }
  653. if ($attribute instanceof Mapping\PreRemove) {
  654. $callbacks[] = [$method->name, Events::preRemove];
  655. }
  657. if ($attribute instanceof Mapping\PostRemove) {
  658. $callbacks[] = [$method->name, Events::postRemove];
  659. }
  661. if ($attribute instanceof Mapping\PostLoad) {
  662. $callbacks[] = [$method->name, Events::postLoad];
  663. }
  665. if ($attribute instanceof Mapping\PreFlush) {
  666. $callbacks[] = [$method->name, Events::preFlush];
  667. }
  668. }
  670. return $callbacks;
  671. }
  673. /**
  674. * Parse the given JoinColumn as array
  675. *
  676. * @param Mapping\JoinColumn|Mapping\InverseJoinColumn $joinColumn
  677. *
  678. * @return mixed[]
  679. * @phpstan-return array{
  680. * name: string|null,
  681. * unique: bool,
  682. * nullable: bool,
  683. * onDelete: mixed,
  684. * columnDefinition: string|null,
  685. * referencedColumnName: string,
  686. * options?: array<string, mixed>
  687. * }
  688. */
  689. private function joinColumnToArray($joinColumn): array
  690. {
  691. $mapping = [
  692. 'name' => $joinColumn->name,
  693. 'unique' => $joinColumn->unique,
  694. 'nullable' => $joinColumn->nullable,
  695. 'onDelete' => $joinColumn->onDelete,
  696. 'columnDefinition' => $joinColumn->columnDefinition,
  697. 'referencedColumnName' => $joinColumn->referencedColumnName,
  698. ];
  700. if ($joinColumn->options) {
  701. $mapping['options'] = $joinColumn->options;
  702. }
  704. return $mapping;
  705. }
  707. /**
  708. * Parse the given Column as array
  709. *
  710. * @return mixed[]
  711. * @phpstan-return array{
  712. * fieldName: string,
  713. * type: mixed,
  714. * scale: int,
  715. * length: int,
  716. * unique: bool,
  717. * nullable: bool,
  718. * precision: int,
  719. * enumType?: class-string,
  720. * options?: mixed[],
  721. * columnName?: string,
  722. * columnDefinition?: string
  723. * }
  724. */
  725. private function columnToArray(string $fieldName, Mapping\Column $column): array
  726. {
  727. $mapping = [
  728. 'fieldName' => $fieldName,
  729. 'type' => $column->type,
  730. 'scale' => $column->scale,
  731. 'length' => $column->length,
  732. 'unique' => $column->unique,
  733. 'nullable' => $column->nullable,
  734. 'precision' => $column->precision,
  735. ];
  737. if ($column->options) {
  738. $mapping['options'] = $column->options;
  739. }
  741. if (isset($column->name)) {
  742. $mapping['columnName'] = $column->name;
  743. }
  745. if (isset($column->columnDefinition)) {
  746. $mapping['columnDefinition'] = $column->columnDefinition;
  747. }
  749. if ($column->updatable === false) {
  750. $mapping['notUpdatable'] = true;
  751. }
  753. if ($column->insertable === false) {
  754. $mapping['notInsertable'] = true;
  755. }
  757. if ($column->generated !== null) {
  758. $mapping['generated'] = $this->getGeneratedMode($column->generated);
  759. }
  761. if ($column->enumType) {
  762. $mapping['enumType'] = $column->enumType;
  763. }
  765. return $mapping;
  766. }
  767. }