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

  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.  * @method list<ClassMetadata> getAllMetadata()
  41.  * @method ClassMetadata[] getLoadedMetadata()
  42.  * @method ClassMetadata getMetadataFor($className)
  43.  */
  44. final class ClassMetadataFactory extends AbstractClassMetadataFactory
  45. {
  46.     /** @var string */
  47.     protected $cacheSalt = '$MONGODBODMCLASSMETADATA';
  49.     /** @var DocumentManager The DocumentManager instance */
  50.     private $dm;
  52.     /** @var Configuration The Configuration instance */
  53.     private $config;
  55.     /** @var MappingDriver The used metadata driver. */
  56.     private $driver;
  58.     /** @var EventManager The event manager instance */
  59.     private $evm;
  61.     public function setDocumentManager(DocumentManager $dm): void
  62.     {
  63.         $this->dm = $dm;
  64.     }
  66.     public function setConfiguration(Configuration $config): void
  67.     {
  68.         $this->config = $config;
  69.     }
  71.     /**
  72.      * Lazy initialization of this stuff, especially the metadata driver,
  73.      * since these are not needed at all when a metadata cache is active.
  74.      */
  75.     protected function initialize(): void
  76.     {
  77.         $driver = $this->config->getMetadataDriverImpl();
  78.         if ($driver === null) {
  79.             throw ConfigurationException::noMetadataDriverConfigured();
  80.         }
  82.         $this->driver      = $driver;
  83.         $this->evm         = $this->dm->getEventManager();
  84.         $this->initialized = true;
  85.     }
  87.     /**
  88.      * @param string $className
  89.      */
  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.     /**
  135.      * @param bool $rootEntityFound
  136.      */
  137.     protected function doLoadMetadata($class, $parent, $rootEntityFound, array $nonSuperclassParents = []): void
  138.     {
  139.         assert($class instanceof ClassMetadata);
  140.         if ($parent instanceof ClassMetadata) {
  141.             $class->setInheritanceType($parent->inheritanceType);
  142.             $class->setDiscriminatorField($parent->discriminatorField);
  143.             $class->setDiscriminatorMap($parent->discriminatorMap);
  144.             $class->setDefaultDiscriminatorValue($parent->defaultDiscriminatorValue);
  145.             $class->setIdGeneratorType($parent->generatorType);
  146.             $this->addInheritedFields($class, $parent);
  147.             $this->addInheritedRelations($class, $parent);
  148.             $this->addInheritedIndexes($class, $parent);
  149.             $this->setInheritedShardKey($class, $parent);
  150.             $class->setIdentifier($parent->identifier);
  151.             $class->setVersioned($parent->isVersioned);
  152.             $class->setVersionField($parent->versionField);
  153.             $class->setLifecycleCallbacks($parent->lifecycleCallbacks);
  154.             $class->setAlsoLoadMethods($parent->alsoLoadMethods);
  155.             $class->setChangeTrackingPolicy($parent->changeTrackingPolicy);
  156.             $class->setReadPreference($parent->readPreference, $parent->readPreferenceTags);
  157.             $class->setWriteConcern($parent->writeConcern);
  159.             if ($parent->isMappedSuperclass) {
  160.                 $class->setCustomRepositoryClass($parent->customRepositoryClassName);
  161.             }
  163.             if ($parent->isFile) {
  164.                 $class->isFile = true;
  165.                 $class->setBucketName($parent->bucketName);
  167.                 if ($parent->chunkSizeBytes !== null) {
  168.                     $class->setChunkSizeBytes($parent->chunkSizeBytes);
  169.                 }
  170.             }
  171.         }
  173.         // Invoke driver
  174.         try {
  175.             $this->driver->loadMetadataForClass($class->getName(), $class);
  176.         } catch (ReflectionException $e) {
  177.             throw MappingException::reflectionFailure($class->getName(), $e);
  178.         }
  180.         $this->validateIdentifier($class);
  182.         if ($parent instanceof ClassMetadata && $rootEntityFound && $parent->generatorType === $class->generatorType) {
  183.             if ($parent->generatorType) {
  184.                 $class->setIdGeneratorType($parent->generatorType);
  185.             }
  187.             if ($parent->generatorOptions) {
  188.                 $class->setIdGeneratorOptions($parent->generatorOptions);
  189.             }
  191.             if ($parent->idGenerator) {
  192.                 $class->setIdGenerator($parent->idGenerator);
  193.             }
  194.         } else {
  195.             $this->completeIdGeneratorMapping($class);
  196.         }
  198.         if ($parent instanceof ClassMetadata && $parent->isInheritanceTypeSingleCollection()) {
  199.             $class->setDatabase($parent->getDatabase());
  200.             $class->setCollection($parent->getCollection());
  201.         }
  203.         $class->setParentClasses($nonSuperclassParents);
  205.         if (! $this->evm->hasListeners(Events::loadClassMetadata)) {
  206.             return;
  207.         }
  209.         $eventArgs = new LoadClassMetadataEventArgs($class, $this->dm);
  210.         $this->evm->dispatchEvent(Events::loadClassMetadata, $eventArgs);
  212.         // phpcs:ignore SlevomatCodingStandard.ControlStructures.EarlyExit.EarlyExitNotUsed
  213.         if ($class->isChangeTrackingNotify()) {
  214.             trigger_deprecation(
  215.                 'doctrine/mongodb-odm',
  216.                 '2.4',
  217.                 'NOTIFY tracking policy used in class "%s" is deprecated. Please use DEFERRED_EXPLICIT instead.',
  218.                 $class->name
  219.             );
  220.         }
  221.     }
  223.     /**
  224.      * Validates the identifier mapping.
  225.      *
  226.      * @throws MappingException
  227.      */
  228.     protected function validateIdentifier(ClassMetadata $class): void
  229.     {
  230.         if (! $class->identifier && $this->isEntity($class)) {
  231.             throw MappingException::identifierRequired($class->name);
  232.         }
  233.     }
  235.     protected function newClassMetadataInstance($className): ClassMetadata
  236.     {
  237.         return new ClassMetadata($className);
  238.     }
  240.     private function completeIdGeneratorMapping(ClassMetadata $class): void
  241.     {
  242.         $idGenOptions = $class->generatorOptions;
  243.         switch ($class->generatorType) {
  244.             case ClassMetadata::GENERATOR_TYPE_AUTO:
  245.                 $class->setIdGenerator(new AutoGenerator());
  246.                 break;
  247.             case ClassMetadata::GENERATOR_TYPE_INCREMENT:
  248.                 $incrementGenerator = new IncrementGenerator();
  249.                 if (isset($idGenOptions['key'])) {
  250.                     $incrementGenerator->setKey((string) $idGenOptions['key']);
  251.                 }
  253.                 if (isset($idGenOptions['collection'])) {
  254.                     $incrementGenerator->setCollection((string) $idGenOptions['collection']);
  255.                 }
  257.                 if (isset($idGenOptions['startingId'])) {
  258.                     $incrementGenerator->setStartingId((int) $idGenOptions['startingId']);
  259.                 }
  261.                 $class->setIdGenerator($incrementGenerator);
  262.                 break;
  263.             case ClassMetadata::GENERATOR_TYPE_UUID:
  264.                 $uuidGenerator = new UuidGenerator();
  265.                 if (isset($idGenOptions['salt'])) {
  266.                     $uuidGenerator->setSalt((string) $idGenOptions['salt']);
  267.                 }
  269.                 $class->setIdGenerator($uuidGenerator);
  270.                 break;
  271.             case ClassMetadata::GENERATOR_TYPE_ALNUM:
  272.                 $alnumGenerator = new AlnumGenerator();
  273.                 if (isset($idGenOptions['pad'])) {
  274.                     $alnumGenerator->setPad((int) $idGenOptions['pad']);
  275.                 }
  277.                 if (isset($idGenOptions['chars'])) {
  278.                     $alnumGenerator->setChars((string) $idGenOptions['chars']);
  279.                 } elseif (isset($idGenOptions['awkwardSafe'])) {
  280.                     $alnumGenerator->setAwkwardSafeMode((bool) $idGenOptions['awkwardSafe']);
  281.                 }
  283.                 $class->setIdGenerator($alnumGenerator);
  284.                 break;
  285.             case ClassMetadata::GENERATOR_TYPE_CUSTOM:
  286.                 if (empty($idGenOptions['class'])) {
  287.                     throw MappingException::missingIdGeneratorClass($class->name);
  288.                 }
  290.                 $customGenerator = new $idGenOptions['class']();
  291.                 unset($idGenOptions['class']);
  292.                 if (! $customGenerator instanceof IdGenerator) {
  293.                     throw MappingException::classIsNotAValidGenerator(get_class($customGenerator));
  294.                 }
  296.                 $methods = get_class_methods($customGenerator);
  297.                 foreach ($idGenOptions as $name => $value) {
  298.                     $method = 'set' . ucfirst($name);
  299.                     if (! in_array($method, $methods)) {
  300.                         throw MappingException::missingGeneratorSetter(get_class($customGenerator), $name);
  301.                     }
  303.                     $customGenerator->$method($value);
  304.                 }
  306.                 $class->setIdGenerator($customGenerator);
  307.                 break;
  308.             case ClassMetadata::GENERATOR_TYPE_NONE:
  309.                 break;
  310.             default:
  311.                 throw new MappingException('Unknown generator type: ' . $class->generatorType);
  312.         }
  313.     }
  315.     /**
  316.      * Adds inherited fields to the subclass mapping.
  317.      */
  318.     private function addInheritedFields(ClassMetadata $subClass, ClassMetadata $parentClass): void
  319.     {
  320.         foreach ($parentClass->fieldMappings as $fieldName => $mapping) {
  321.             if (! isset($mapping['inherited']) && ! $parentClass->isMappedSuperclass) {
  322.                 $mapping['inherited'] = $parentClass->name;
  323.             }
  325.             if (! isset($mapping['declared'])) {
  326.                 $mapping['declared'] = $parentClass->name;
  327.             }
  329.             $subClass->addInheritedFieldMapping($mapping);
  330.         }
  332.         foreach ($parentClass->reflFields as $name => $field) {
  333.             $subClass->reflFields[$name] = $field;
  334.         }
  335.     }
  337.     /**
  338.      * Adds inherited association mappings to the subclass mapping.
  339.      *
  340.      * @throws MappingException
  341.      */
  342.     private function addInheritedRelations(ClassMetadata $subClass, ClassMetadata $parentClass): void
  343.     {
  344.         foreach ($parentClass->associationMappings as $field => $mapping) {
  345.             if ($parentClass->isMappedSuperclass) {
  346.                 $mapping['sourceDocument'] = $subClass->name;
  347.             }
  349.             if (! isset($mapping['inherited']) && ! $parentClass->isMappedSuperclass) {
  350.                 $mapping['inherited'] = $parentClass->name;
  351.             }
  353.             if (! isset($mapping['declared'])) {
  354.                 $mapping['declared'] = $parentClass->name;
  355.             }
  357.             $subClass->addInheritedAssociationMapping($mapping);
  358.         }
  359.     }
  361.     /**
  362.      * Adds inherited indexes to the subclass mapping.
  363.      */
  364.     private function addInheritedIndexes(ClassMetadata $subClass, ClassMetadata $parentClass): void
  365.     {
  366.         foreach ($parentClass->indexes as $index) {
  367.             $subClass->addIndex($index['keys'], $index['options']);
  368.         }
  369.     }
  371.     /**
  372.      * Adds inherited shard key to the subclass mapping.
  373.      */
  374.     private function setInheritedShardKey(ClassMetadata $subClass, ClassMetadata $parentClass): void
  375.     {
  376.         if (! $parentClass->isSharded()) {
  377.             return;
  378.         }
  380.         $subClass->setShardKey(
  381.             $parentClass->shardKey['keys'],
  382.             $parentClass->shardKey['options']
  383.         );
  384.     }
  385. }
  387. interface_exists(ClassMetadataInterface::class);
  388. interface_exists(ReflectionService::class);