vendor/doctrine/mongodb-odm/lib/Doctrine/ODM/MongoDB/Mapping/ClassMetadataFactory.php line 173

  1. <?php
  3. declare(strict_types=1);
  5. namespace Doctrine\ODM\MongoDB\Mapping;
  7. use Doctrine\Common\EventManager;
  8. use Doctrine\ODM\MongoDB\Configuration;
  9. use Doctrine\ODM\MongoDB\ConfigurationException;
  10. use Doctrine\ODM\MongoDB\DocumentManager;
  11. use Doctrine\ODM\MongoDB\Event\LoadClassMetadataEventArgs;
  12. use Doctrine\ODM\MongoDB\Event\OnClassMetadataNotFoundEventArgs;
  13. use Doctrine\ODM\MongoDB\Events;
  14. use Doctrine\ODM\MongoDB\Id\AlnumGenerator;
  15. use Doctrine\ODM\MongoDB\Id\AutoGenerator;
  16. use Doctrine\ODM\MongoDB\Id\IdGenerator;
  17. use Doctrine\ODM\MongoDB\Id\IncrementGenerator;
  18. use Doctrine\ODM\MongoDB\Id\UuidGenerator;
  19. use Doctrine\Persistence\Mapping\AbstractClassMetadataFactory;
  20. use Doctrine\Persistence\Mapping\ClassMetadata as ClassMetadataInterface;
  21. use Doctrine\Persistence\Mapping\Driver\MappingDriver;
  22. use Doctrine\Persistence\Mapping\ReflectionService;
  23. use ReflectionException;
  25. use function assert;
  26. use function get_class;
  27. use function get_class_methods;
  28. use function in_array;
  29. use function interface_exists;
  30. use function trigger_deprecation;
  31. use function ucfirst;
  33. /**
  34.  * The ClassMetadataFactory is used to create ClassMetadata objects that contain all the
  35.  * metadata mapping informations of a class which describes how a class should be mapped
  36.  * to a document database.
  37.  *
  38.  * @internal
  39.  *
  40.  * @template-extends AbstractClassMetadataFactory<ClassMetadata>
  41.  *
  42.  * @method list<ClassMetadata> getAllMetadata()
  43.  * @method ClassMetadata[] getLoadedMetadata()
  44.  * @method ClassMetadata getMetadataFor($className)
  45.  */
  46. final class ClassMetadataFactory extends AbstractClassMetadataFactory
  47. {
  48.     /** @var string */
  49.     protected $cacheSalt = '$MONGODBODMCLASSMETADATA';
  51.     /** @var DocumentManager The DocumentManager instance */
  52.     private DocumentManager $dm;
  54.     /** @var Configuration The Configuration instance */
  55.     private Configuration $config;
  57.     /** @var MappingDriver The used metadata driver. */
  58.     private MappingDriver $driver;
  60.     /** @var EventManager The event manager instance */
  61.     private EventManager $evm;
  63.     public function setDocumentManager(DocumentManager $dm): void
  64.     {
  65.         $this->dm = $dm;
  66.     }
  68.     public function setConfiguration(Configuration $config): void
  69.     {
  70.         $this->config = $config;
  71.     }
  73.     /**
  74.      * Lazy initialization of this stuff, especially the metadata driver,
  75.      * since these are not needed at all when a metadata cache is active.
  76.      */
  77.     protected function initialize(): void
  78.     {
  79.         $driver = $this->config->getMetadataDriverImpl();
  80.         if ($driver === null) {
  81.             throw ConfigurationException::noMetadataDriverConfigured();
  82.         }
  84.         $this->driver      = $driver;
  85.         $this->evm         = $this->dm->getEventManager();
  86.         $this->initialized = true;
  87.     }
  89.     /** @param string $className */
  90.     protected function onNotFoundMetadata($className)
  91.     {
  92.         if (! $this->evm->hasListeners(Events::onClassMetadataNotFound)) {
  93.             return null;
  94.         }
  96.         $eventArgs = new OnClassMetadataNotFoundEventArgs($className, $this->dm);
  98.         $this->evm->dispatchEvent(Events::onClassMetadataNotFound, $eventArgs);
  100.         return $eventArgs->getFoundMetadata();
  101.     }
  103.     /**
  104.      * @deprecated
  105.      *
  106.      * @param string $namespaceAlias
  107.      * @param string $simpleClassName
  108.      */
  109.     protected function getFqcnFromAlias($namespaceAlias, $simpleClassName): string
  110.     {
  111.         return $this->config->getDocumentNamespace($namespaceAlias) . '\\' . $simpleClassName;
  112.     }
  114.     protected function getDriver(): MappingDriver
  115.     {
  116.         return $this->driver;
  117.     }
  119.     protected function wakeupReflection(ClassMetadataInterface $class, ReflectionService $reflService): void
  120.     {
  121.     }
  123.     protected function initializeReflection(ClassMetadataInterface $class, ReflectionService $reflService): void
  124.     {
  125.     }
  127.     protected function isEntity(ClassMetadataInterface $class): bool
  128.     {
  129.         assert($class instanceof ClassMetadata);
  131.         return ! $class->isMappedSuperclass && ! $class->isEmbeddedDocument && ! $class->isQueryResultDocument && ! $class->isView();
  132.     }
  134.     /** @param bool $rootEntityFound */
  135.     protected function doLoadMetadata($class, $parent, $rootEntityFound, array $nonSuperclassParents = []): void
  136.     {
  137.         assert($class instanceof ClassMetadata);
  138.         if ($parent instanceof ClassMetadata) {
  139.             $class->setInheritanceType($parent->inheritanceType);
  140.             $class->setDiscriminatorField($parent->discriminatorField);
  141.             $class->setDiscriminatorMap($parent->discriminatorMap);
  142.             $class->setDefaultDiscriminatorValue($parent->defaultDiscriminatorValue);
  143.             $class->setIdGeneratorType($parent->generatorType);
  144.             $this->addInheritedFields($class, $parent);
  145.             $this->addInheritedRelations($class, $parent);
  146.             $this->addInheritedIndexes($class, $parent);
  147.             $this->setInheritedShardKey($class, $parent);
  148.             $class->setIdentifier($parent->identifier);
  149.             $class->setVersioned($parent->isVersioned);
  150.             $class->setVersionField($parent->versionField);
  151.             $class->setLifecycleCallbacks($parent->lifecycleCallbacks);
  152.             $class->setAlsoLoadMethods($parent->alsoLoadMethods);
  153.             $class->setChangeTrackingPolicy($parent->changeTrackingPolicy);
  154.             $class->setReadPreference($parent->readPreference, $parent->readPreferenceTags);
  155.             $class->setWriteConcern($parent->writeConcern);
  157.             if ($parent->isMappedSuperclass) {
  158.                 $class->setCustomRepositoryClass($parent->customRepositoryClassName);
  159.             }
  161.             if ($parent->isFile) {
  162.                 $class->isFile = true;
  163.                 $class->setBucketName($parent->bucketName);
  165.                 if ($parent->chunkSizeBytes !== null) {
  166.                     $class->setChunkSizeBytes($parent->chunkSizeBytes);
  167.                 }
  168.             }
  169.         }
  171.         // Invoke driver
  172.         try {
  173.             $this->driver->loadMetadataForClass($class->getName(), $class);
  174.         } catch (ReflectionException $e) {
  175.             throw MappingException::reflectionFailure($class->getName(), $e);
  176.         }
  178.         $this->validateIdentifier($class);
  180.         if ($parent instanceof ClassMetadata && $rootEntityFound && $parent->generatorType === $class->generatorType) {
  181.             if ($parent->generatorType) {
  182.                 $class->setIdGeneratorType($parent->generatorType);
  183.             }
  185.             if ($parent->generatorOptions) {
  186.                 $class->setIdGeneratorOptions($parent->generatorOptions);
  187.             }
  189.             if ($parent->idGenerator) {
  190.                 $class->setIdGenerator($parent->idGenerator);
  191.             }
  192.         } else {
  193.             $this->completeIdGeneratorMapping($class);
  194.         }
  196.         if ($parent instanceof ClassMetadata && $parent->isInheritanceTypeSingleCollection()) {
  197.             $class->setDatabase($parent->getDatabase());
  198.             $class->setCollection($parent->getCollection());
  199.         }
  201.         $class->setParentClasses($nonSuperclassParents);
  203.         $this->evm->dispatchEvent(
  204.             Events::loadClassMetadata,
  205.             new LoadClassMetadataEventArgs($class, $this->dm),
  206.         );
  208.         // phpcs:ignore SlevomatCodingStandard.ControlStructures.EarlyExit.EarlyExitNotUsed
  209.         if ($class->isChangeTrackingNotify()) {
  210.             trigger_deprecation(
  211.                 'doctrine/mongodb-odm',
  212.                 '2.4',
  213.                 'NOTIFY tracking policy used in class "%s" is deprecated. Please use DEFERRED_EXPLICIT instead.',
  214.                 $class->name,
  215.             );
  216.         }
  217.     }
  219.     /**
  220.      * Validates the identifier mapping.
  221.      *
  222.      * @throws MappingException
  223.      */
  224.     protected function validateIdentifier(ClassMetadata $class): void
  225.     {
  226.         if (! $class->identifier && $this->isEntity($class)) {
  227.             throw MappingException::identifierRequired($class->name);
  228.         }
  229.     }
  231.     protected function newClassMetadataInstance($className): ClassMetadata
  232.     {
  233.         return new ClassMetadata($className);
  234.     }
  236.     private function completeIdGeneratorMapping(ClassMetadata $class): void
  237.     {
  238.         $idGenOptions = $class->generatorOptions;
  239.         switch ($class->generatorType) {
  240.             case ClassMetadata::GENERATOR_TYPE_AUTO:
  241.                 $class->setIdGenerator(new AutoGenerator());
  242.                 break;
  243.             case ClassMetadata::GENERATOR_TYPE_INCREMENT:
  244.                 $incrementGenerator = new IncrementGenerator();
  245.                 if (isset($idGenOptions['key'])) {
  246.                     $incrementGenerator->setKey((string) $idGenOptions['key']);
  247.                 }
  249.                 if (isset($idGenOptions['collection'])) {
  250.                     $incrementGenerator->setCollection((string) $idGenOptions['collection']);
  251.                 }
  253.                 if (isset($idGenOptions['startingId'])) {
  254.                     $incrementGenerator->setStartingId((int) $idGenOptions['startingId']);
  255.                 }
  257.                 $class->setIdGenerator($incrementGenerator);
  258.                 break;
  259.             case ClassMetadata::GENERATOR_TYPE_UUID:
  260.                 $uuidGenerator = new UuidGenerator();
  261.                 if (isset($idGenOptions['salt'])) {
  262.                     $uuidGenerator->setSalt((string) $idGenOptions['salt']);
  263.                 }
  265.                 $class->setIdGenerator($uuidGenerator);
  266.                 break;
  267.             case ClassMetadata::GENERATOR_TYPE_ALNUM:
  268.                 $alnumGenerator = new AlnumGenerator();
  269.                 if (isset($idGenOptions['pad'])) {
  270.                     $alnumGenerator->setPad((int) $idGenOptions['pad']);
  271.                 }
  273.                 if (isset($idGenOptions['chars'])) {
  274.                     $alnumGenerator->setChars((string) $idGenOptions['chars']);
  275.                 } elseif (isset($idGenOptions['awkwardSafe'])) {
  276.                     $alnumGenerator->setAwkwardSafeMode((bool) $idGenOptions['awkwardSafe']);
  277.                 }
  279.                 $class->setIdGenerator($alnumGenerator);
  280.                 break;
  281.             case ClassMetadata::GENERATOR_TYPE_CUSTOM:
  282.                 if (empty($idGenOptions['class'])) {
  283.                     throw MappingException::missingIdGeneratorClass($class->name);
  284.                 }
  286.                 $customGenerator = new $idGenOptions['class']();
  287.                 unset($idGenOptions['class']);
  288.                 if (! $customGenerator instanceof IdGenerator) {
  289.                     throw MappingException::classIsNotAValidGenerator(get_class($customGenerator));
  290.                 }
  292.                 $methods = get_class_methods($customGenerator);
  293.                 foreach ($idGenOptions as $name => $value) {
  294.                     $method = 'set' . ucfirst($name);
  295.                     if (! in_array($method, $methods)) {
  296.                         throw MappingException::missingGeneratorSetter(get_class($customGenerator), $name);
  297.                     }
  299.                     $customGenerator->$method($value);
  300.                 }
  302.                 $class->setIdGenerator($customGenerator);
  303.                 break;
  304.             case ClassMetadata::GENERATOR_TYPE_NONE:
  305.                 break;
  306.             default:
  307.                 throw new MappingException('Unknown generator type: ' . $class->generatorType);
  308.         }
  309.     }
  311.     /**
  312.      * Adds inherited fields to the subclass mapping.
  313.      */
  314.     private function addInheritedFields(ClassMetadata $subClass, ClassMetadata $parentClass): void
  315.     {
  316.         foreach ($parentClass->fieldMappings as $fieldName => $mapping) {
  317.             if (! isset($mapping['inherited']) && ! $parentClass->isMappedSuperclass) {
  318.                 $mapping['inherited'] = $parentClass->name;
  319.             }
  321.             if (! isset($mapping['declared'])) {
  322.                 $mapping['declared'] = $parentClass->name;
  323.             }
  325.             $subClass->addInheritedFieldMapping($mapping);
  326.         }
  328.         foreach ($parentClass->reflFields as $name => $field) {
  329.             $subClass->reflFields[$name] = $field;
  330.         }
  331.     }
  333.     /**
  334.      * Adds inherited association mappings to the subclass mapping.
  335.      *
  336.      * @throws MappingException
  337.      */
  338.     private function addInheritedRelations(ClassMetadata $subClass, ClassMetadata $parentClass): void
  339.     {
  340.         foreach ($parentClass->associationMappings as $field => $mapping) {
  341.             if ($parentClass->isMappedSuperclass) {
  342.                 $mapping['sourceDocument'] = $subClass->name;
  343.             }
  345.             if (! isset($mapping['inherited']) && ! $parentClass->isMappedSuperclass) {
  346.                 $mapping['inherited'] = $parentClass->name;
  347.             }
  349.             if (! isset($mapping['declared'])) {
  350.                 $mapping['declared'] = $parentClass->name;
  351.             }
  353.             $subClass->addInheritedAssociationMapping($mapping);
  354.         }
  355.     }
  357.     /**
  358.      * Adds inherited indexes to the subclass mapping.
  359.      */
  360.     private function addInheritedIndexes(ClassMetadata $subClass, ClassMetadata $parentClass): void
  361.     {
  362.         foreach ($parentClass->indexes as $index) {
  363.             $subClass->addIndex($index['keys'], $index['options']);
  364.         }
  365.     }
  367.     /**
  368.      * Adds inherited shard key to the subclass mapping.
  369.      */
  370.     private function setInheritedShardKey(ClassMetadata $subClass, ClassMetadata $parentClass): void
  371.     {
  372.         if (! $parentClass->isSharded()) {
  373.             return;
  374.         }
  376.         $subClass->setShardKey(
  377.             $parentClass->shardKey['keys'],
  378.             $parentClass->shardKey['options'],
  379.         );
  380.     }
  381. }
  383. interface_exists(ClassMetadataInterface::class);
  384. interface_exists(ReflectionService::class);