vendor/doctrine/mongodb-odm/lib/Doctrine/ODM/MongoDB/Hydrator/HydratorFactory.php line 466

Open in your IDE?
  1. <?php
  3. declare(strict_types=1);
  5. namespace Doctrine\ODM\MongoDB\Hydrator;
  7. use Doctrine\Common\EventManager;
  8. use Doctrine\ODM\MongoDB\Configuration;
  9. use Doctrine\ODM\MongoDB\DocumentManager;
  10. use Doctrine\ODM\MongoDB\Event\LifecycleEventArgs;
  11. use Doctrine\ODM\MongoDB\Event\PreLoadEventArgs;
  12. use Doctrine\ODM\MongoDB\Events;
  13. use Doctrine\ODM\MongoDB\Mapping\ClassMetadata;
  14. use Doctrine\ODM\MongoDB\Types\Type;
  15. use Doctrine\ODM\MongoDB\UnitOfWork;
  16. use ProxyManager\Proxy\GhostObjectInterface;
  18. use function array_key_exists;
  19. use function chmod;
  20. use function class_exists;
  21. use function dirname;
  22. use function file_exists;
  23. use function file_put_contents;
  24. use function get_class;
  25. use function is_dir;
  26. use function is_writable;
  27. use function mkdir;
  28. use function rename;
  29. use function rtrim;
  30. use function sprintf;
  31. use function str_replace;
  32. use function substr;
  33. use function uniqid;
  35. use const DIRECTORY_SEPARATOR;
  37. /**
  38.  * The HydratorFactory class is responsible for instantiating a correct hydrator
  39.  * type based on document's ClassMetadata
  40.  *
  41.  * @psalm-import-type Hints from UnitOfWork
  42.  */
  43. final class HydratorFactory
  44. {
  45.     /**
  46.      * The DocumentManager this factory is bound to.
  47.      *
  48.      * @var DocumentManager
  49.      */
  50.     private $dm;
  52.     /**
  53.      * The UnitOfWork used to coordinate object-level transactions.
  54.      *
  55.      * @var UnitOfWork
  56.      */
  57.     private $unitOfWork;
  59.     /**
  60.      * The EventManager associated with this Hydrator
  61.      *
  62.      * @var EventManager
  63.      */
  64.     private $evm;
  66.     /**
  67.      * Which algorithm to use to automatically (re)generate hydrator classes.
  68.      *
  69.      * @var int
  70.      */
  71.     private $autoGenerate;
  73.     /**
  74.      * The namespace that contains all hydrator classes.
  75.      *
  76.      * @var string|null
  77.      */
  78.     private $hydratorNamespace;
  80.     /**
  81.      * The directory that contains all hydrator classes.
  82.      *
  83.      * @var string
  84.      */
  85.     private $hydratorDir;
  87.     /**
  88.      * Array of instantiated document hydrators.
  89.      *
  90.      * @var array
  91.      * @psalm-var array<class-string, HydratorInterface>
  92.      */
  93.     private $hydrators = [];
  95.     /**
  96.      * @throws HydratorException
  97.      */
  98.     public function __construct(DocumentManager $dm, EventManager $evm, ?string $hydratorDir, ?string $hydratorNs, int $autoGenerate)
  99.     {
  100.         if (! $hydratorDir) {
  101.             throw HydratorException::hydratorDirectoryRequired();
  102.         }
  104.         if (! $hydratorNs) {
  105.             throw HydratorException::hydratorNamespaceRequired();
  106.         }
  108.         $this->dm                = $dm;
  109.         $this->evm               = $evm;
  110.         $this->hydratorDir       = $hydratorDir;
  111.         $this->hydratorNamespace = $hydratorNs;
  112.         $this->autoGenerate      = $autoGenerate;
  113.     }
  115.     /**
  116.      * Sets the UnitOfWork instance.
  117.      *
  118.      * @internal
  119.      */
  120.     public function setUnitOfWork(UnitOfWork $uow): void
  121.     {
  122.         $this->unitOfWork = $uow;
  123.     }
  125.     /**
  126.      * Gets the hydrator object for the given document class.
  127.      *
  128.      * @psalm-param class-string $className
  129.      */
  130.     public function getHydratorFor(string $className): HydratorInterface
  131.     {
  132.         if (isset($this->hydrators[$className])) {
  133.             return $this->hydrators[$className];
  134.         }
  136.         $hydratorClassName = str_replace('\\', '', $className) . 'Hydrator';
  137.         $fqn               = $this->hydratorNamespace . '\\' . $hydratorClassName;
  138.         $class             = $this->dm->getClassMetadata($className);
  140.         if (! class_exists($fqn, false)) {
  141.             $fileName = $this->hydratorDir . DIRECTORY_SEPARATOR . $hydratorClassName . '.php';
  142.             switch ($this->autoGenerate) {
  143.                 case Configuration::AUTOGENERATE_NEVER:
  144.                     require $fileName;
  145.                     break;
  147.                 case Configuration::AUTOGENERATE_ALWAYS:
  148.                     $this->generateHydratorClass($class, $hydratorClassName, $fileName);
  149.                     require $fileName;
  150.                     break;
  152.                 case Configuration::AUTOGENERATE_FILE_NOT_EXISTS:
  153.                     if (! file_exists($fileName)) {
  154.                         $this->generateHydratorClass($class, $hydratorClassName, $fileName);
  155.                     }
  157.                     require $fileName;
  158.                     break;
  160.                 case Configuration::AUTOGENERATE_EVAL:
  161.                     $this->generateHydratorClass($class, $hydratorClassName, null);
  162.                     break;
  163.             }
  164.         }
  166.         $this->hydrators[$className] = new $fqn($this->dm, $this->unitOfWork, $class);
  168.         return $this->hydrators[$className];
  169.     }
  171.     /**
  172.      * Generates hydrator classes for all given classes.
  173.      *
  174.      * @param ClassMetadata<object>[] $classes The classes (ClassMetadata instances) for which to generate hydrators.
  175.      * @param string|null             $toDir   The target directory of the hydrator classes. If not specified, the
  176.      *                                    directory configured on the Configuration of the DocumentManager used
  177.      *                                    by this factory is used.
  178.      */
  179.     public function generateHydratorClasses(array $classes, ?string $toDir = null): void
  180.     {
  181.         $hydratorDir = $toDir ?: $this->hydratorDir;
  182.         $hydratorDir = rtrim($hydratorDir, DIRECTORY_SEPARATOR) . DIRECTORY_SEPARATOR;
  183.         foreach ($classes as $class) {
  184.             $hydratorClassName = str_replace('\\', '', $class->name) . 'Hydrator';
  185.             $hydratorFileName  = $hydratorDir . $hydratorClassName . '.php';
  186.             $this->generateHydratorClass($class, $hydratorClassName, $hydratorFileName);
  187.         }
  188.     }
  190.     /**
  191.      * @param ClassMetadata<object> $class
  192.      */
  193.     private function generateHydratorClass(ClassMetadata $class, string $hydratorClassName, ?string $fileName): void
  194.     {
  195.         $code = '';
  197.         foreach ($class->fieldMappings as $fieldName => $mapping) {
  198.             if (isset($mapping['alsoLoadFields'])) {
  199.                 foreach ($mapping['alsoLoadFields'] as $name) {
  200.                     $code .= sprintf(
  201.                         <<<EOF
  203.         /** @AlsoLoad("$name") */
  204.         if (!array_key_exists('%1\$s', \$data) && array_key_exists('$name', \$data)) {
  205.             \$data['%1\$s'] = \$data['$name'];
  206.         }
  208. EOF
  209.                         ,
  210.                         $mapping['name']
  211.                     );
  212.                 }
  213.             }
  215.             if ($mapping['type'] === 'date') {
  216.                 $code .= sprintf(
  217.                     <<<EOF
  219.         /** @Field(type="date") */
  220.         if (isset(\$data['%1\$s'])) {
  221.             \$value = \$data['%1\$s'];
  222.             %3\$s
  223.             \$this->class->reflFields['%2\$s']->setValue(\$document, clone \$return);
  224.             \$hydratedData['%2\$s'] = \$return;
  225.         }
  227. EOF
  228.                     ,
  229.                     $mapping['name'],
  230.                     $mapping['fieldName'],
  231.                     Type::getType($mapping['type'])->closureToPHP()
  232.                 );
  233.             } elseif (! isset($mapping['association'])) {
  234.                 $code .= sprintf(
  235.                     <<<EOF
  237.         /** @Field(type="{$mapping['type']}") */
  238.         if (isset(\$data['%1\$s']) || (! empty(\$this->class->fieldMappings['%2\$s']['nullable']) && array_key_exists('%1\$s', \$data))) {
  239.             \$value = \$data['%1\$s'];
  240.             if (\$value !== null) {
  241.                 \$typeIdentifier = \$this->class->fieldMappings['%2\$s']['type'];
  242.                 %3\$s
  243.             } else {
  244.                 \$return = null;
  245.             }
  246.             \$this->class->reflFields['%2\$s']->setValue(\$document, \$return);
  247.             \$hydratedData['%2\$s'] = \$return;
  248.         }
  250. EOF
  251.                     ,
  252.                     $mapping['name'],
  253.                     $mapping['fieldName'],
  254.                     Type::getType($mapping['type'])->closureToPHP()
  255.                 );
  256.             } elseif ($mapping['association'] === ClassMetadata::REFERENCE_ONE && $mapping['isOwningSide']) {
  257.                 $code .= sprintf(
  258.                     <<<EOF
  260.         /** @ReferenceOne */
  261.         if (isset(\$data['%1\$s']) || (! empty(\$this->class->fieldMappings['%2\$s']['nullable']) && array_key_exists('%1\$s', \$data))) {
  262.             \$return = \$data['%1\$s'];
  263.             if (\$return !== null) {
  264.                 if (\$this->class->fieldMappings['%2\$s']['storeAs'] !== ClassMetadata::REFERENCE_STORE_AS_ID && ! is_array(\$return)) {
  265.                     throw HydratorException::associationTypeMismatch('%3\$s', '%1\$s', 'array', gettype(\$return));
  266.                 }
  268.                 \$className = \$this->unitOfWork->getClassNameForAssociation(\$this->class->fieldMappings['%2\$s'], \$return);
  269.                 \$identifier = ClassMetadata::getReferenceId(\$return, \$this->class->fieldMappings['%2\$s']['storeAs']);
  270.                 \$targetMetadata = \$this->dm->getClassMetadata(\$className);
  271.                 \$id = \$targetMetadata->getPHPIdentifierValue(\$identifier);
  272.                 \$return = \$this->dm->getReference(\$className, \$id);
  273.             }
  275.             \$this->class->reflFields['%2\$s']->setValue(\$document, \$return);
  276.             \$hydratedData['%2\$s'] = \$return;
  277.         }
  279. EOF
  280.                     ,
  281.                     $mapping['name'],
  282.                     $mapping['fieldName'],
  283.                     $class->getName()
  284.                 );
  285.             } elseif ($mapping['association'] === ClassMetadata::REFERENCE_ONE && $mapping['isInverseSide']) {
  286.                 if (isset($mapping['repositoryMethod']) && $mapping['repositoryMethod']) {
  287.                     $code .= sprintf(
  288.                         <<<EOF
  290.         \$className = \$this->class->fieldMappings['%2\$s']['targetDocument'];
  291.         \$return = \$this->dm->getRepository(\$className)->%3\$s(\$document);
  292.         \$this->class->reflFields['%2\$s']->setValue(\$document, \$return);
  293.         \$hydratedData['%2\$s'] = \$return;
  295. EOF
  296.                         ,
  297.                         $mapping['name'],
  298.                         $mapping['fieldName'],
  299.                         $mapping['repositoryMethod']
  300.                     );
  301.                 } else {
  302.                     $code .= sprintf(
  303.                         <<<EOF
  305.         \$mapping = \$this->class->fieldMappings['%2\$s'];
  306.         \$className = \$mapping['targetDocument'];
  307.         \$targetClass = \$this->dm->getClassMetadata(\$mapping['targetDocument']);
  308.         \$mappedByMapping = \$targetClass->fieldMappings[\$mapping['mappedBy']];
  309.         \$mappedByFieldName = ClassMetadata::getReferenceFieldName(\$mappedByMapping['storeAs'], \$mapping['mappedBy']);
  310.         \$criteria = array_merge(
  311.             array(\$mappedByFieldName => \$data['_id']),
  312.             isset(\$this->class->fieldMappings['%2\$s']['criteria']) ? \$this->class->fieldMappings['%2\$s']['criteria'] : array()
  313.         );
  314.         \$sort = isset(\$this->class->fieldMappings['%2\$s']['sort']) ? \$this->class->fieldMappings['%2\$s']['sort'] : array();
  315.         \$return = \$this->unitOfWork->getDocumentPersister(\$className)->load(\$criteria, null, array(), 0, \$sort);
  316.         \$this->class->reflFields['%2\$s']->setValue(\$document, \$return);
  317.         \$hydratedData['%2\$s'] = \$return;
  319. EOF
  320.                         ,
  321.                         $mapping['name'],
  322.                         $mapping['fieldName']
  323.                     );
  324.                 }
  325.             } elseif ($mapping['association'] === ClassMetadata::REFERENCE_MANY || $mapping['association'] === ClassMetadata::EMBED_MANY) {
  326.                 $code .= sprintf(
  327.                     <<<EOF
  329.         /** @Many */
  330.         \$mongoData = isset(\$data['%1\$s']) ? \$data['%1\$s'] : null;
  332.         if (\$mongoData !== null && ! is_array(\$mongoData)) {
  333.             throw HydratorException::associationTypeMismatch('%3\$s', '%1\$s', 'array', gettype(\$mongoData));
  334.         }
  336.         \$return = \$this->dm->getConfiguration()->getPersistentCollectionFactory()->create(\$this->dm, \$this->class->fieldMappings['%2\$s']);
  337.         \$return->setHints(\$hints);
  338.         \$return->setOwner(\$document, \$this->class->fieldMappings['%2\$s']);
  339.         \$return->setInitialized(false);
  340.         if (\$mongoData) {
  341.             \$return->setMongoData(\$mongoData);
  342.         }
  343.         \$this->class->reflFields['%2\$s']->setValue(\$document, \$return);
  344.         \$hydratedData['%2\$s'] = \$return;
  346. EOF
  347.                     ,
  348.                     $mapping['name'],
  349.                     $mapping['fieldName'],
  350.                     $class->getName()
  351.                 );
  352.             } elseif ($mapping['association'] === ClassMetadata::EMBED_ONE) {
  353.                 $code .= sprintf(
  354.                     <<<EOF
  356.         /** @EmbedOne */
  357.         if (isset(\$data['%1\$s']) || (! empty(\$this->class->fieldMappings['%2\$s']['nullable']) && array_key_exists('%1\$s', \$data))) {
  358.             \$return = \$data['%1\$s'];
  359.             if (\$return !== null) {
  360.                 \$embeddedDocument = \$return;
  362.                 if (! is_array(\$embeddedDocument)) {
  363.                     throw HydratorException::associationTypeMismatch('%3\$s', '%1\$s', 'array', gettype(\$embeddedDocument));
  364.                 }
  365.         
  366.                 \$className = \$this->unitOfWork->getClassNameForAssociation(\$this->class->fieldMappings['%2\$s'], \$embeddedDocument);
  367.                 \$embeddedMetadata = \$this->dm->getClassMetadata(\$className);
  368.                 \$return = \$embeddedMetadata->newInstance();
  370.                 \$this->unitOfWork->setParentAssociation(\$return, \$this->class->fieldMappings['%2\$s'], \$document, '%1\$s');
  372.                 \$embeddedData = \$this->dm->getHydratorFactory()->hydrate(\$return, \$embeddedDocument, \$hints);
  373.                 \$embeddedId = \$embeddedMetadata->identifier && isset(\$embeddedData[\$embeddedMetadata->identifier]) ? \$embeddedData[\$embeddedMetadata->identifier] : null;
  375.                 if (empty(\$hints[Query::HINT_READ_ONLY])) {
  376.                     \$this->unitOfWork->registerManaged(\$return, \$embeddedId, \$embeddedData);
  377.                 }
  378.             }
  380.             \$this->class->reflFields['%2\$s']->setValue(\$document, \$return);
  381.             \$hydratedData['%2\$s'] = \$return;
  382.         }
  384. EOF
  385.                     ,
  386.                     $mapping['name'],
  387.                     $mapping['fieldName'],
  388.                     $class->getName()
  389.                 );
  390.             }
  391.         }
  393.         $namespace = $this->hydratorNamespace;
  394.         $code      = sprintf(
  395.             <<<EOF
  396. <?php
  398. namespace $namespace;
  400. use Doctrine\ODM\MongoDB\DocumentManager;
  401. use Doctrine\ODM\MongoDB\Hydrator\HydratorException;
  402. use Doctrine\ODM\MongoDB\Hydrator\HydratorInterface;
  403. use Doctrine\ODM\MongoDB\Query\Query;
  404. use Doctrine\ODM\MongoDB\UnitOfWork;
  405. use Doctrine\ODM\MongoDB\Mapping\ClassMetadata;
  407. /**
  408.  * THIS CLASS WAS GENERATED BY THE DOCTRINE ODM. DO NOT EDIT THIS FILE.
  409.  */
  410. class $hydratorClassName implements HydratorInterface
  411. {
  412.     private \$dm;
  413.     private \$unitOfWork;
  414.     private \$class;
  416.     public function __construct(DocumentManager \$dm, UnitOfWork \$uow, ClassMetadata \$class)
  417.     {
  418.         \$this->dm = \$dm;
  419.         \$this->unitOfWork = \$uow;
  420.         \$this->class = \$class;
  421.     }
  423.     public function hydrate(object \$document, array \$data, array \$hints = array()): array
  424.     {
  425.         \$hydratedData = array();
  426. %s        return \$hydratedData;
  427.     }
  428. }
  429. EOF
  430.             ,
  431.             $code
  432.         );
  434.         if ($fileName === null) {
  435.             if (! class_exists($namespace . '\\' . $hydratorClassName)) {
  436.                 eval(substr($code, 5));
  437.             }
  439.             return;
  440.         }
  442.         $parentDirectory = dirname($fileName);
  444.         if (! is_dir($parentDirectory) && (@mkdir($parentDirectory, 0775, true) === false)) {
  445.             throw HydratorException::hydratorDirectoryNotWritable();
  446.         }
  448.         if (! is_writable($parentDirectory)) {
  449.             throw HydratorException::hydratorDirectoryNotWritable();
  450.         }
  452.         $tmpFileName = $fileName . '.' . uniqid('', true);
  453.         file_put_contents($tmpFileName, $code);
  454.         rename($tmpFileName, $fileName);
  455.         chmod($fileName, 0664);
  456.     }
  458.     /**
  459.      * Hydrate array of MongoDB document data into the given document object.
  460.      *
  461.      * @param array<string, mixed> $data
  462.      * @psalm-param Hints $hints Any hints to account for during reconstitution/lookup of the document.
  463.      *
  464.      * @return array<string, mixed>
  465.      */
  466.     public function hydrate(object $document, array $data, array $hints = []): array
  467.     {
  468.         $metadata = $this->dm->getClassMetadata(get_class($document));
  469.         // Invoke preLoad lifecycle events and listeners
  470.         if (! empty($metadata->lifecycleCallbacks[Events::preLoad])) {
  471.             $args = [new PreLoadEventArgs($document, $this->dm, $data)];
  472.             $metadata->invokeLifecycleCallbacks(Events::preLoad, $document, $args);
  473.         }
  475.         if ($this->evm->hasListeners(Events::preLoad)) {
  476.             $this->evm->dispatchEvent(Events::preLoad, new PreLoadEventArgs($document, $this->dm, $data));
  477.         }
  479.         // alsoLoadMethods may transform the document before hydration
  480.         if (! empty($metadata->alsoLoadMethods)) {
  481.             foreach ($metadata->alsoLoadMethods as $method => $fieldNames) {
  482.                 foreach ($fieldNames as $fieldName) {
  483.                     // Invoke the method only once for the first field we find
  484.                     if (array_key_exists($fieldName, $data)) {
  485.                         $document->$method($data[$fieldName]);
  486.                         continue 2;
  487.                     }
  488.                 }
  489.             }
  490.         }
  492.         if ($document instanceof GhostObjectInterface && $document->getProxyInitializer() !== null) {
  493.             // Inject an empty initialiser to not load any object data
  494.             $document->setProxyInitializer(static function (
  495.                 GhostObjectInterface $ghostObject,
  496.                 string $method, // we don't care
  497.                 array $parameters, // we don't care
  498.                 &$initializer,
  499.                 array $properties // we currently do not use this
  500.             ): bool {
  501.                 $initializer = null;
  503.                 return true;
  504.             });
  505.         }
  507.         $data = $this->getHydratorFor($metadata->name)->hydrate($document, $data, $hints);
  509.         // Invoke the postLoad lifecycle callbacks and listeners
  510.         if (! empty($metadata->lifecycleCallbacks[Events::postLoad])) {
  511.             $metadata->invokeLifecycleCallbacks(Events::postLoad, $document, [new LifecycleEventArgs($document, $this->dm)]);
  512.         }
  514.         if ($this->evm->hasListeners(Events::postLoad)) {
  515.             $this->evm->dispatchEvent(Events::postLoad, new LifecycleEventArgs($document, $this->dm));
  516.         }
  518.         return $data;
  519.     }
  520. }