vendor/shopware/core/Framework/DataAbstractionLayer/Dbal/EntityHydrator.php line 167

  1. <?php declare(strict_types=1);
  3. namespace Shopware\Core\Framework\DataAbstractionLayer\Dbal;
  5. use Shopware\Core\Framework\Context;
  6. use Shopware\Core\Framework\DataAbstractionLayer\Entity;
  7. use Shopware\Core\Framework\DataAbstractionLayer\EntityCollection;
  8. use Shopware\Core\Framework\DataAbstractionLayer\EntityDefinition;
  9. use Shopware\Core\Framework\DataAbstractionLayer\Field\AssociationField;
  10. use Shopware\Core\Framework\DataAbstractionLayer\Field\CustomFields;
  11. use Shopware\Core\Framework\DataAbstractionLayer\Field\Field;
  12. use Shopware\Core\Framework\DataAbstractionLayer\Field\Flag\Extension;
  13. use Shopware\Core\Framework\DataAbstractionLayer\Field\Flag\Inherited;
  14. use Shopware\Core\Framework\DataAbstractionLayer\Field\ManyToManyAssociationField;
  15. use Shopware\Core\Framework\DataAbstractionLayer\Field\ManyToOneAssociationField;
  16. use Shopware\Core\Framework\DataAbstractionLayer\Field\OneToOneAssociationField;
  17. use Shopware\Core\Framework\DataAbstractionLayer\Field\ParentAssociationField;
  18. use Shopware\Core\Framework\DataAbstractionLayer\Field\ReferenceVersionField;
  19. use Shopware\Core\Framework\DataAbstractionLayer\Field\TranslatedField;
  20. use Shopware\Core\Framework\DataAbstractionLayer\Field\VersionField;
  21. use Shopware\Core\Framework\DataAbstractionLayer\PartialEntity;
  22. use Shopware\Core\Framework\DataAbstractionLayer\Write\Command\WriteCommandQueue;
  23. use Shopware\Core\Framework\DataAbstractionLayer\Write\DataStack\KeyValuePair;
  24. use Shopware\Core\Framework\DataAbstractionLayer\Write\EntityExistence;
  25. use Shopware\Core\Framework\DataAbstractionLayer\Write\WriteContext;
  26. use Shopware\Core\Framework\DataAbstractionLayer\Write\WriteParameterBag;
  27. use Shopware\Core\Framework\Log\Package;
  28. use Shopware\Core\Framework\Struct\ArrayEntity;
  29. use Shopware\Core\Framework\Struct\ArrayStruct;
  30. use Symfony\Component\DependencyInjection\ContainerInterface;
  32. /**
  33.  * Allows to hydrate database values into struct objects.
  34.  *
  35.  * @internal
  36.  */
  37. #[Package('core')]
  38. class EntityHydrator
  39. {
  40.     /**
  41.      * @var array<mixed>
  42.      */
  43.     protected static array $partial = [];
  45.     /**
  46.      * @var array<bool>
  47.      */
  48.     protected static array $partialFullPaths = [];
  50.     /**
  51.      * @var array<mixed>
  52.      */
  53.     private static array $hydrated = [];
  55.     /**
  56.      * @var array<string>
  57.      */
  58.     private static array $manyToOne = [];
  60.     /**
  61.      * @var array<string, array<string, Field>>
  62.      */
  63.     private static array $translatedFields = [];
  65.     /**
  66.      * @internal
  67.      */
  68.     public function __construct(private readonly ContainerInterface $container)
  69.     {
  70.     }
  72.     /**
  73.      * @template TEntityCollection of EntityCollection<Entity>
  74.      *
  75.      * @param TEntityCollection $collection
  76.      * @param array<mixed> $rows
  77.      * @param array<string|array<string>> $partial
  78.      *
  79.      * @return TEntityCollection
  80.      */
  81.     public function hydrate(EntityCollection $collection, string $entityClass, EntityDefinition $definition, array $rows, string $root, Context $context, array $partial = []): EntityCollection
  82.     {
  83.         self::$hydrated = [];
  85.         self::$partial = $partial;
  87.         self::$partialFullPaths = [];
  89.         if (!empty(self::$partial)) {
  90.             /** @var TEntityCollection $collection */
  91.             $collection = new EntityCollection();
  93.             $this->mapPartialFieldsToHydrate(self::$partial, $root);
  94.         }
  96.         foreach ($rows as $row) {
  97.             $collection->add($this->hydrateEntity($definition, $entityClass, $row, $root, $context));
  98.         }
  100.         return $collection;
  101.     }
  103.     /**
  104.      * @template EntityClass
  105.      *
  106.      * @param class-string<EntityClass> $class
  107.      *
  108.      * @return EntityClass
  109.      */
  110.     final public static function createClass(string $class)
  111.     {
  112.         return new $class();
  113.     }
  115.     /**
  116.      * @param array<mixed> $row
  117.      *
  118.      * @return array<mixed>
  119.      */
  120.     final public static function buildUniqueIdentifier(EntityDefinition $definition, array $row, string $root): array
  121.     {
  122.         $primaryKeyFields = $definition->getPrimaryKeys();
  123.         $primaryKey = [];
  125.         foreach ($primaryKeyFields as $field) {
  126.             if ($field instanceof VersionField || $field instanceof ReferenceVersionField) {
  127.                 continue;
  128.             }
  129.             $accessor = $root . '.' . $field->getPropertyName();
  131.             $primaryKey[$field->getPropertyName()] = $field->getSerializer()->decode($field, $row[$accessor]);
  132.         }
  134.         return $primaryKey;
  135.     }
  137.     /**
  138.      * @param array<string> $primaryKey
  139.      *
  140.      * @return array<string>
  141.      */
  142.     final public static function encodePrimaryKey(EntityDefinition $definition, array $primaryKey, Context $context): array
  143.     {
  144.         $fields = $definition->getPrimaryKeys();
  146.         $mapped = [];
  148.         $existence = new EntityExistence($definition->getEntityName(), [], true, false, false, []);
  150.         $params = new WriteParameterBag($definition, WriteContext::createFromContext($context), '', new WriteCommandQueue());
  152.         foreach ($fields as $field) {
  153.             if ($field instanceof VersionField || $field instanceof ReferenceVersionField) {
  154.                 $value = $context->getVersionId();
  155.             } else {
  156.                 $value = $primaryKey[$field->getPropertyName()];
  157.             }
  159.             $kvPair = new KeyValuePair($field->getPropertyName(), $value, true);
  161.             $encoded = $field->getSerializer()->encode($field, $existence, $kvPair, $params);
  163.             foreach ($encoded as $key => $value) {
  164.                 $mapped[$key] = $value;
  165.             }
  166.         }
  168.         return $mapped;
  169.     }
  171.     /**
  172.      * Allows simple overwrite for specialized entity hydrators
  173.      *
  174.      * @param array<mixed> $row
  175.      */
  176.     protected function assign(EntityDefinition $definition, Entity $entity, string $root, array $row, Context $context): Entity
  177.     {
  178.         $entity = $this->hydrateFields($definition, $entity, $root, $row, $context, $definition->getFields());
  180.         return $entity;
  181.     }
  183.     /**
  184.      * @param array<mixed> $row
  185.      * @param iterable<Field> $fields
  186.      */
  187.     protected function hydrateFields(EntityDefinition $definition, Entity $entity, string $root, array $row, Context $context, iterable $fields): Entity
  188.     {
  189.         /** @var ArrayStruct<string, mixed> $foreignKeys */
  190.         $foreignKeys = $entity->getExtension(EntityReader::FOREIGN_KEYS);
  191.         $isPartial = self::$partial !== [];
  193.         foreach ($fields as $field) {
  194.             $property = $field->getPropertyName();
  196.             $key = $root . '.' . $property;
  197.             if ($isPartial && !isset(self::$partialFullPaths[$key])) {
  198.                 continue;
  199.             }
  201.             // initialize not loaded associations with null
  202.             if ($field instanceof AssociationField && $entity instanceof ArrayEntity) {
  203.                 $entity->set($property, null);
  204.             }
  206.             if ($field instanceof ParentAssociationField) {
  207.                 continue;
  208.             }
  210.             if ($field instanceof ManyToManyAssociationField) {
  211.                 $this->manyToMany($row, $root, $entity, $field);
  213.                 continue;
  214.             }
  216.             if ($field instanceof ManyToOneAssociationField || $field instanceof OneToOneAssociationField) {
  217.                 $association = $this->manyToOne($row, $root, $field, $context);
  219.                 if ($association === null && $entity instanceof PartialEntity) {
  220.                     continue;
  221.                 }
  223.                 if ($field->is(Extension::class)) {
  224.                     if ($association) {
  225.                         $entity->addExtension($property, $association);
  226.                     }
  227.                 } else {
  228.                     $entity->assign([$property => $association]);
  229.                 }
  231.                 continue;
  232.             }
  234.             // other association fields are not handled in entity reader query
  235.             if ($field instanceof AssociationField) {
  236.                 continue;
  237.             }
  239.             if (!\array_key_exists($key, $row)) {
  240.                 continue;
  241.             }
  243.             $value = $row[$key];
  245.             $typed = $field;
  246.             if ($field instanceof TranslatedField) {
  247.                 $typed = EntityDefinitionQueryHelper::getTranslatedField($definition, $field);
  248.             }
  250.             if ($typed instanceof CustomFields) {
  251.                 $this->customFields($definition, $row, $root, $entity, $field, $context);
  253.                 continue;
  254.             }
  256.             if ($field instanceof TranslatedField) {
  257.                 // contains the resolved translation chain value
  258.                 $decoded = $typed->getSerializer()->decode($typed, $value);
  259.                 $entity->addTranslated($property, $decoded);
  261.                 $inherited = $definition->isInheritanceAware() && $context->considerInheritance();
  262.                 $chain = EntityDefinitionQueryHelper::buildTranslationChain($root, $context, $inherited);
  264.                 // assign translated value of the first language
  265.                 $key = array_shift($chain) . '.' . $property;
  267.                 $decoded = $typed->getSerializer()->decode($typed, $row[$key]);
  268.                 $entity->assign([$property => $decoded]);
  270.                 continue;
  271.             }
  273.             $decoded = $definition->decode($property, $value);
  275.             if ($field->is(Extension::class)) {
  276.                 $foreignKeys->set($property, $decoded);
  277.             } else {
  278.                 $entity->assign([$property => $decoded]);
  279.             }
  280.         }
  282.         return $entity;
  283.     }
  285.     /**
  286.      * @param array<mixed> $row
  287.      */
  288.     protected function manyToMany(array $row, string $root, Entity $entity, ?Field $field): void
  289.     {
  290.         if ($field === null) {
  291.             throw new \RuntimeException('No field provided');
  292.         }
  294.         $accessor = $root . '.' . $field->getPropertyName() . '.id_mapping';
  296.         // many to many isn't loaded in case of limited association criterias
  297.         if (!\array_key_exists($accessor, $row)) {
  298.             return;
  299.         }
  301.         // explode hexed ids
  302.         $ids = explode('||', (string) $row[$accessor]);
  304.         $ids = array_map('strtolower', array_filter($ids));
  306.         /** @var ArrayStruct<string, mixed> $mapping */
  307.         $mapping = $entity->getExtension(EntityReader::INTERNAL_MAPPING_STORAGE);
  309.         $mapping->set($field->getPropertyName(), $ids);
  310.     }
  312.     /**
  313.      * @param array<mixed> $row
  314.      * @param array<string, Field> $fields
  315.      */
  316.     protected function translate(EntityDefinition $definition, Entity $entity, array $row, string $root, Context $context, array $fields): void
  317.     {
  318.         $inherited = $definition->isInheritanceAware() && $context->considerInheritance();
  320.         $chain = EntityDefinitionQueryHelper::buildTranslationChain($root, $context, $inherited);
  322.         $translatedFields = $this->getTranslatedFields($definition, $fields);
  324.         foreach ($translatedFields as $field => $typed) {
  325.             $fieldValue = self::value($row, $root, $field);
  326.             $translation = $fieldValue !== null ? $typed->getSerializer()->decode($typed, $fieldValue) : null;
  328.             $entity->addTranslated($field, $translation);
  330.             $chainFieldValue = self::value($row, $chain[0], $field);
  331.             $entity->$field = $chainFieldValue !== null ? ($fieldValue === $chainFieldValue ? $translation : $typed->getSerializer()->decode($typed, $chainFieldValue)) : null;
  332.         }
  333.     }
  335.     /**
  336.      * @param array<Field> $fields
  337.      *
  338.      * @return array<string, Field>
  339.      */
  340.     protected function getTranslatedFields(EntityDefinition $definition, array $fields): array
  341.     {
  342.         $key = $definition->getEntityName();
  343.         if (isset(self::$translatedFields[$key])) {
  344.             return self::$translatedFields[$key];
  345.         }
  347.         $translatedFields = [];
  348.         /** @var TranslatedField $field */
  349.         foreach ($fields as $field) {
  350.             $translatedFields[$field->getPropertyName()] = EntityDefinitionQueryHelper::getTranslatedField($definition, $field);
  351.         }
  353.         return self::$translatedFields[$key] = $translatedFields;
  354.     }
  356.     /**
  357.      * @param array<mixed> $row
  358.      */
  359.     protected function manyToOne(array $row, string $root, ?Field $field, Context $context): ?Entity
  360.     {
  361.         if ($field === null) {
  362.             throw new \RuntimeException('No field provided');
  363.         }
  365.         if (!$field instanceof AssociationField) {
  366.             throw new \RuntimeException(\sprintf('Provided field %s is no association field', $field->getPropertyName()));
  367.         }
  368.         $pk = $this->getManyToOneProperty($field);
  370.         $association = $root . '.' . $field->getPropertyName();
  372.         $key = $association . '.' . $pk;
  374.         if (!isset($row[$key])) {
  375.             return null;
  376.         }
  378.         if (self::$partial !== [] && !isset(self::$partialFullPaths[$pk])) {
  379.             self::$partialFullPaths[$key] = true;
  380.         }
  382.         return $this->hydrateEntity($field->getReferenceDefinition(), $field->getReferenceDefinition()->getEntityClass(), $row, $association, $context);
  383.     }
  385.     /**
  386.      * @param array<mixed> $row
  387.      */
  388.     protected function customFields(EntityDefinition $definition, array $row, string $root, Entity $entity, ?Field $field, Context $context): void
  389.     {
  390.         if ($field === null) {
  391.             return;
  392.         }
  394.         $inherited = $field->is(Inherited::class) && $context->considerInheritance();
  396.         $propertyName = $field->getPropertyName();
  398.         $value = self::value($row, $root, $propertyName);
  400.         if ($field instanceof TranslatedField) {
  401.             $customField = EntityDefinitionQueryHelper::getTranslatedField($definition, $field);
  403.             $chain = EntityDefinitionQueryHelper::buildTranslationChain($root, $context, $inherited);
  405.             $decoded = $customField->getSerializer()->decode($customField, self::value($row, $chain[0], $propertyName));
  407.             $entity->assign([$propertyName => $decoded]);
  409.             $values = [];
  410.             foreach ($chain as $accessor) {
  411.                 $values[] = self::value($row, $accessor, $propertyName);
  412.             }
  414.             if (empty($values)) {
  415.                 return;
  416.             }
  418.             /**
  419.              * `array_merge`s ordering is reversed compared to the translations array.
  420.              * In other terms: The first argument has the lowest 'priority', so we need to reverse the array
  421.              */
  422.             $merged = $this->mergeJson(array_reverse($values, false));
  423.             $decoded = $customField->getSerializer()->decode($customField, $merged);
  424.             $entity->addTranslated($propertyName, $decoded);
  426.             if ($inherited) {
  427.                 /*
  428.                  * The translations chains array has the structure: [
  429.                  *      main language,
  430.                  *      parent with main language,
  431.                  *      fallback language,
  432.                  *      parent with fallback language,
  433.                  * ]
  434.                  *
  435.                  * We need to join the first two to get the inherited field value of the main translation
  436.                  */
  437.                 $values = [
  438.                     self::value($row, $chain[1], $propertyName),
  439.                     self::value($row, $chain[0], $propertyName),
  440.                 ];
  442.                 $merged = $this->mergeJson($values);
  443.                 $decoded = $customField->getSerializer()->decode($customField, $merged);
  444.                 $entity->assign([$propertyName => $decoded]);
  445.             }
  447.             return;
  448.         }
  450.         // field is not inherited or request should work with raw data? decode child attributes and return
  451.         if (!$inherited) {
  452.             $value = $field->getSerializer()->decode($field, $value);
  453.             $entity->assign([$propertyName => $value]);
  455.             return;
  456.         }
  458.         $parentKey = $root . '.' . $propertyName . '.inherited';
  460.         // parent has no attributes? decode only child attributes and return
  461.         if (!isset($row[$parentKey])) {
  462.             $value = $field->getSerializer()->decode($field, $value);
  464.             $entity->assign([$propertyName => $value]);
  466.             return;
  467.         }
  469.         // merge child attributes with parent attributes and assign
  470.         $mergedJson = $this->mergeJson([$row[$parentKey], $value]);
  472.         $merged = $field->getSerializer()->decode($field, $mergedJson);
  474.         $entity->assign([$propertyName => $merged]);
  475.     }
  477.     /**
  478.      * @param array<mixed> $row
  479.      */
  480.     protected static function value(array $row, string $root, string $property): ?string
  481.     {
  482.         $accessor = $root . '.' . $property;
  484.         return $row[$accessor] ?? null;
  485.     }
  487.     protected function getManyToOneProperty(AssociationField $field): string
  488.     {
  489.         $key = $field->getReferenceDefinition()->getEntityName() . '.' . $field->getReferenceField();
  490.         if (isset(self::$manyToOne[$key])) {
  491.             return self::$manyToOne[$key];
  492.         }
  494.         $reference = $field->getReferenceDefinition()->getFields()->getByStorageName(
  495.             $field->getReferenceField()
  496.         );
  498.         if ($reference === null) {
  499.             throw new \RuntimeException(\sprintf(
  500.                 'Can not find field by storage name %s in definition %s',
  501.                 $field->getReferenceField(),
  502.                 $field->getReferenceDefinition()->getEntityName()
  503.             ));
  504.         }
  506.         return self::$manyToOne[$key] = $reference->getPropertyName();
  507.     }
  509.     /**
  510.      * @param array<string|null> $jsonStrings
  511.      */
  512.     protected function mergeJson(array $jsonStrings): string
  513.     {
  514.         $merged = [];
  515.         foreach ($jsonStrings as $string) {
  516.             if ($string === null) {
  517.                 continue;
  518.             }
  520.             $decoded = json_decode($string, true, 512, \JSON_THROW_ON_ERROR);
  522.             if (!$decoded) {
  523.                 continue;
  524.             }
  526.             foreach ($decoded as $key => $value) {
  527.                 if ($value === null) {
  528.                     continue;
  529.                 }
  531.                 $merged[$key] = $value;
  532.             }
  533.         }
  535.         return json_encode($merged, \JSON_PRESERVE_ZERO_FRACTION | \JSON_THROW_ON_ERROR);
  536.     }
  538.     /**
  539.      * @param array<string, mixed> $fields
  540.      */
  541.     private function mapPartialFieldsToHydrate(array $fields, string $currentPath): void
  542.     {
  543.         foreach ($fields as $field => $values) {
  544.             self::$partialFullPaths[$currentPath . '.' . $field] = true;
  546.             $this->mapPartialFieldsToHydrate($values, $currentPath . '.' . $field);
  547.         }
  548.     }
  550.     /**
  551.      * @param array<mixed> $row
  552.      */
  553.     private function hydrateEntity(EntityDefinition $definition, string $entityClass, array $row, string $root, Context $context): Entity
  554.     {
  555.         $isPartial = self::$partial !== [];
  556.         $hydratorClass = $definition->getHydratorClass();
  557.         $entityClass = $isPartial ? PartialEntity::class : $entityClass;
  559.         if ($isPartial) {
  560.             $hydratorClass = EntityHydrator::class;
  561.         }
  563.         $hydrator = $this->container->get($hydratorClass);
  565.         if (!$hydrator instanceof self) {
  566.             throw new \RuntimeException(\sprintf('Hydrator for entity %s not registered', $definition->getEntityName()));
  567.         }
  569.         $identifier = implode('-', self::buildUniqueIdentifier($definition, $row, $root));
  571.         $cacheKey = $root . '::' . $identifier;
  573.         if (isset(self::$hydrated[$cacheKey])) {
  574.             return self::$hydrated[$cacheKey];
  575.         }
  577.         $entity = new $entityClass();
  579.         if (!$entity instanceof Entity) {
  580.             throw new \RuntimeException(\sprintf('Expected instance of Entity.php, got %s', $entity::class));
  581.         }
  583.         $entity->addExtension(EntityReader::FOREIGN_KEYS, new ArrayStruct([], $definition->getEntityName() . '_foreign_keys_extension'));
  584.         $entity->addExtension(EntityReader::INTERNAL_MAPPING_STORAGE, new ArrayStruct());
  586.         $entity->setUniqueIdentifier($identifier);
  587.         $entity->internalSetEntityData($definition->getEntityName(), $definition->getFieldVisibility());
  589.         $entity = $hydrator->assign($definition, $entity, $root, $row, $context);
  591.         return self::$hydrated[$cacheKey] = $entity;
  592.     }
  593. }