src/Core/Framework/DataAbstractionLayer/Write/EntityWriter.php line 223

  1. <?php declare(strict_types=1);
  3. namespace Shopware\Core\Framework\DataAbstractionLayer\Write;
  5. use Shopware\Core\Framework\Api\Exception\IncompletePrimaryKeyException;
  6. use Shopware\Core\Framework\Api\Exception\InvalidSyncOperationException;
  7. use Shopware\Core\Framework\Api\Sync\SyncOperation;
  8. use Shopware\Core\Framework\DataAbstractionLayer\Dbal\EntityForeignKeyResolver;
  9. use Shopware\Core\Framework\DataAbstractionLayer\Dbal\EntityHydrator;
  10. use Shopware\Core\Framework\DataAbstractionLayer\DefinitionInstanceRegistry;
  11. use Shopware\Core\Framework\DataAbstractionLayer\EntityDefinition;
  12. use Shopware\Core\Framework\DataAbstractionLayer\EntityWriteResult;
  13. use Shopware\Core\Framework\DataAbstractionLayer\Field\AssociationField;
  14. use Shopware\Core\Framework\DataAbstractionLayer\Field\Field;
  15. use Shopware\Core\Framework\DataAbstractionLayer\Field\Flag\SetNullOnDelete;
  16. use Shopware\Core\Framework\DataAbstractionLayer\Field\ReferenceVersionField;
  17. use Shopware\Core\Framework\DataAbstractionLayer\Field\StorageAware;
  18. use Shopware\Core\Framework\DataAbstractionLayer\Field\VersionField;
  19. use Shopware\Core\Framework\DataAbstractionLayer\MappingEntityDefinition;
  20. use Shopware\Core\Framework\DataAbstractionLayer\Write\Command\CascadeDeleteCommand;
  21. use Shopware\Core\Framework\DataAbstractionLayer\Write\Command\DeleteCommand;
  22. use Shopware\Core\Framework\DataAbstractionLayer\Write\Command\InsertCommand;
  23. use Shopware\Core\Framework\DataAbstractionLayer\Write\Command\SetNullOnDeleteCommand;
  24. use Shopware\Core\Framework\DataAbstractionLayer\Write\Command\UpdateCommand;
  25. use Shopware\Core\Framework\DataAbstractionLayer\Write\Command\WriteCommandQueue;
  26. use Shopware\Core\Framework\DataAbstractionLayer\Write\Validation\RestrictDeleteViolation;
  27. use Shopware\Core\Framework\DataAbstractionLayer\Write\Validation\RestrictDeleteViolationException;
  28. use Shopware\Core\Framework\Log\Package;
  29. use Shopware\Core\Framework\Uuid\Uuid;
  30. use Shopware\Core\System\Language\LanguageLoaderInterface;
  32. /**
  33.  * @internal
  34.  *
  35.  * Handles all write operations in the system.
  36.  * Builds first a command queue over the WriteCommandExtractor and let execute this queue
  37.  * over the EntityWriteGateway (sql implementation in default).
  38.  */
  39. #[Package('core')]
  40. class EntityWriter implements EntityWriterInterface
  41. {
  42.     /**
  43.      * @internal
  44.      */
  45.     public function __construct(
  46.         private readonly WriteCommandExtractor $commandExtractor,
  47.         private readonly EntityForeignKeyResolver $foreignKeyResolver,
  48.         private readonly EntityWriteGatewayInterface $gateway,
  49.         private readonly LanguageLoaderInterface $languageLoader,
  50.         private readonly DefinitionInstanceRegistry $registry,
  51.         private readonly EntityWriteResultFactory $factory
  52.     ) {
  53.     }
  55.     // TODO: prefetch
  56.     /**
  57.      * @param SyncOperation[] $operations
  58.      * @throw InvalidSyncOperationException
  59.      */
  60.     public function sync(array $operations, WriteContext $context): WriteResult
  61.     {
  62.         $commandQueue = new WriteCommandQueue();
  64.         $context->setLanguages(
  65.             $this->languageLoader->loadLanguages()
  66.         );
  68.         $writes = [];
  69.         $notFound = [];
  70.         $deletes = [];
  72.         foreach ($operations as $operation) {
  73.             if (!$operation instanceof SyncOperation) {
  74.                 continue;
  75.             }
  77.             $this->validateSyncOperationInput($operation);
  79.             $definition = $this->registry->getByEntityName($operation->getEntity());
  81.             $this->validateWriteInput($operation->getPayload());
  83.             if ($operation->getAction() === SyncOperation::ACTION_DELETE) {
  84.                 $deletes[] = $this->factory->resolveDelete($definition, $operation->getPayload());
  86.                 $notFound[] = $this->extractDeleteCommands($definition, $operation->getPayload(), $context, $commandQueue);
  88.                 continue;
  89.             }
  91.             if ($operation->getAction() === SyncOperation::ACTION_UPSERT) {
  92.                 $parameters = new WriteParameterBag($definition, $context, '', $commandQueue);
  94.                 $payload = $this->commandExtractor->normalize($definition, $operation->getPayload(), $parameters);
  95.                 $this->gateway->prefetchExistences($parameters);
  97.                 $key = $operation->getKey();
  99.                 foreach ($payload as $index => $row) {
  100.                     $parameters->setPath('/' . $key . '/' . $index);
  101.                     $context->resetPaths();
  102.                     $this->commandExtractor->extract($row, $parameters);
  103.                 }
  105.                 $writes[] = $this->factory->resolveWrite($definition, $payload);
  106.             }
  107.         }
  109.         $context->getExceptions()->tryToThrow();
  111.         $this->gateway->execute($commandQueue->getCommandsInOrder(), $context);
  113.         $result = $this->factory->build($commandQueue);
  115.         $notFound = array_merge_recursive(...$notFound);
  117.         $writes = array_merge_recursive(...$writes);
  119.         $deletes = array_merge_recursive(...$deletes);
  121.         $result = $this->factory->addParentResults($result, $writes);
  123.         $result = $this->factory->addDeleteResults($result, $notFound, $deletes);
  125.         return $result;
  126.     }
  128.     /**
  129.      * @param array<mixed> $rawData
  130.      *
  131.      * @return array<mixed>
  132.      */
  133.     public function upsert(EntityDefinition $definition, array $rawData, WriteContext $writeContext): array
  134.     {
  135.         return $this->write($definition, $rawData, $writeContext);
  136.     }
  138.     /**
  139.      * @param array<mixed> $rawData
  140.      *
  141.      * @return array<mixed>
  142.      */
  143.     public function insert(EntityDefinition $definition, array $rawData, WriteContext $writeContext): array
  144.     {
  145.         return $this->write($definition, $rawData, $writeContext, InsertCommand::class);
  146.     }
  148.     /**
  149.      * @param array<mixed> $rawData
  150.      *
  151.      * @return array<mixed>
  152.      */
  153.     public function update(EntityDefinition $definition, array $rawData, WriteContext $writeContext): array
  154.     {
  155.         return $this->write($definition, $rawData, $writeContext, UpdateCommand::class);
  156.     }
  158.     /**
  159.      * @param array<mixed> $ids
  160.      *
  161.      * @throws IncompletePrimaryKeyException
  162.      * @throws RestrictDeleteViolationException
  163.      */
  164.     public function delete(EntityDefinition $definition, array $ids, WriteContext $writeContext): WriteResult
  165.     {
  166.         $this->validateWriteInput($ids);
  168.         $parents = [];
  169.         if (!$writeContext->hasState('merge-scope')) {
  170.             $parents = $this->factory->resolveDelete($definition, $ids);
  171.         }
  173.         $commandQueue = new WriteCommandQueue();
  174.         $notFound = $this->extractDeleteCommands($definition, $ids, $writeContext, $commandQueue);
  176.         $writeContext->setLanguages($this->languageLoader->loadLanguages());
  177.         $this->gateway->execute($commandQueue->getCommandsInOrder(), $writeContext);
  179.         $result = $this->factory->build($commandQueue);
  181.         $parents = array_merge_recursive($parents, $this->factory->resolveMappings($result));
  183.         return $this->factory->addDeleteResults($result, $notFound, $parents);
  184.     }
  186.     /**
  187.      * @param array<mixed> $rawData
  188.      *
  189.      * @return array<mixed>
  190.      */
  191.     private function write(EntityDefinition $definition, array $rawData, WriteContext $writeContext, ?string $ensure = null): array
  192.     {
  193.         $this->validateWriteInput($rawData);
  195.         if (!$rawData) {
  196.             return [];
  197.         }
  199.         $commandQueue = new WriteCommandQueue();
  200.         $parameters = new WriteParameterBag($definition, $writeContext, '', $commandQueue);
  202.         $writeContext->setLanguages($this->languageLoader->loadLanguages());
  204.         $rawData = $this->commandExtractor->normalize($definition, $rawData, $parameters);
  205.         $writeContext->getExceptions()->tryToThrow();
  207.         $this->gateway->prefetchExistences($parameters);
  209.         foreach ($rawData as $index => $row) {
  210.             $parameters->setPath('/' . $index);
  211.             $writeContext->resetPaths();
  212.             $this->commandExtractor->extract($row, $parameters);
  213.         }
  215.         if ($ensure) {
  216.             $commandQueue->ensureIs($definition, $ensure);
  217.         }
  219.         $writeContext->getExceptions()->tryToThrow();
  221.         $ordered = $commandQueue->getCommandsInOrder();
  223.         $this->gateway->execute($ordered, $writeContext);
  225.         $result = $this->factory->build($commandQueue);
  227.         $parents = array_merge(
  228.             $this->factory->resolveWrite($definition, $rawData),
  229.             $this->factory->resolveMappings($result)
  230.         );
  232.         return $this->factory->addParentResults($result, $parents);
  233.     }
  235.     /**
  236.      * @param array<mixed> $data
  237.      *
  238.      * @throws \InvalidArgumentException
  239.      */
  240.     private function validateWriteInput(array $data): void
  241.     {
  242.         $valid = array_keys($data) === range(0, \count($data) - 1) || $data === [];
  244.         if (!$valid) {
  245.             throw new \InvalidArgumentException('Expected input to be non associative array.');
  246.         }
  247.     }
  249.     /**
  250.      * @throws InvalidSyncOperationException
  251.      */
  252.     private function validateSyncOperationInput(SyncOperation $operation): void
  253.     {
  254.         $errors = $operation->validate();
  255.         if (\count($errors)) {
  256.             throw new InvalidSyncOperationException(sprintf('Invalid sync operation. %s', implode(' ', $errors)));
  257.         }
  258.     }
  260.     /**
  261.      * @param array<mixed> $resolved
  262.      */
  263.     private function addReverseInheritedCommands(WriteCommandQueue $queue, EntityDefinition $definition, WriteContext $writeContext, array $resolved): void
  264.     {
  265.         if ($definition instanceof MappingEntityDefinition) {
  266.             return;
  267.         }
  268.         $cascades = $this->foreignKeyResolver->getAllReverseInherited($definition, $resolved, $writeContext->getContext());
  270.         foreach ($cascades as $affectedDefinitionClass => $keys) {
  271.             $affectedDefinition = $this->registry->getByEntityName($affectedDefinitionClass);
  273.             foreach ($keys as $key) {
  274.                 if (!\is_array($key)) {
  275.                     $key = ['id' => $key];
  276.                 }
  278.                 $primary = EntityHydrator::encodePrimaryKey($affectedDefinition, $key, $writeContext->getContext());
  280.                 $existence = new EntityExistence($affectedDefinition->getEntityName(), $primary, true, false, false, []);
  282.                 $queue->add($affectedDefinition, new UpdateCommand($affectedDefinition, [], $primary, $existence, ''));
  283.             }
  284.         }
  285.     }
  287.     /**
  288.      * @param array<mixed> $resolved
  289.      */
  290.     private function addDeleteCascadeCommands(WriteCommandQueue $queue, EntityDefinition $definition, WriteContext $writeContext, array $resolved): void
  291.     {
  292.         if ($definition instanceof MappingEntityDefinition) {
  293.             return;
  294.         }
  295.         $cascades = $this->foreignKeyResolver->getAffectedDeletes($definition, $resolved, $writeContext->getContext());
  297.         foreach ($cascades as $affectedDefinitionClass => $keys) {
  298.             $affectedDefinition = $this->registry->getByEntityName($affectedDefinitionClass);
  300.             foreach ($keys as $key) {
  301.                 if (!\is_array($key)) {
  302.                     $key = ['id' => $key];
  303.                 }
  305.                 $primary = EntityHydrator::encodePrimaryKey($affectedDefinition, $key, $writeContext->getContext());
  307.                 $existence = new EntityExistence($affectedDefinition->getEntityName(), $primary, true, false, false, []);
  309.                 $queue->add($affectedDefinition, new CascadeDeleteCommand($affectedDefinition, $primary, $existence));
  310.             }
  311.         }
  312.     }
  314.     /**
  315.      * @param array<mixed> $resolved
  316.      */
  317.     private function addSetNullOnDeletesCommands(WriteCommandQueue $queue, EntityDefinition $definition, WriteContext $writeContext, array $resolved): void
  318.     {
  319.         if ($definition instanceof MappingEntityDefinition) {
  320.             return;
  321.         }
  323.         $setNullFields = $definition->getFields()->filterByFlag(SetNullOnDelete::class);
  325.         $setNulls = $this->foreignKeyResolver->getAffectedSetNulls($definition, $resolved, $writeContext->getContext());
  327.         foreach ($setNulls as $affectedDefinitionClass => $restrictions) {
  328.             [$entity, $field] = explode('.', $affectedDefinitionClass);
  330.             $affectedDefinition = $this->registry->getByEntityName($entity);
  332.             /** @var AssociationField $associationField */
  333.             $associationField = $setNullFields
  334.                 ->filter(fn (Field $setNullField) => $setNullField instanceof AssociationField && $setNullField->getReferenceField() === $field)
  335.                 ->first();
  337.             /** @var SetNullOnDelete $flag */
  338.             $flag = $associationField->getFlag(SetNullOnDelete::class);
  340.             foreach ($restrictions as $key) {
  341.                 $payload = ['id' => Uuid::fromHexToBytes($key), $field => null];
  343.                 $primary = EntityHydrator::encodePrimaryKey($affectedDefinition, ['id' => $key], $writeContext->getContext());
  345.                 $existence = new EntityExistence($affectedDefinition->getEntityName(), $primary, true, false, false, []);
  347.                 if ($definition->isVersionAware()) {
  348.                     $versionField = str_replace('_id', '_version_id', $field);
  349.                     $payload[$versionField] = null;
  350.                 }
  352.                 $queue->add($affectedDefinition, new SetNullOnDeleteCommand($affectedDefinition, $payload, $primary, $existence, '', $flag->isEnforcedByConstraint()));
  353.             }
  354.         }
  355.     }
  357.     /**
  358.      * @param array<mixed> $ids
  359.      *
  360.      * @return array<mixed>
  361.      */
  362.     private function resolvePrimaryKeys(array $ids, EntityDefinition $definition, WriteContext $writeContext): array
  363.     {
  364.         $fields = $definition->getPrimaryKeys();
  366.         $resolved = [];
  367.         foreach ($ids as $raw) {
  368.             $mapped = [];
  370.             foreach ($fields as $field) {
  371.                 $property = $field->getPropertyName();
  372.                 if (!($field instanceof StorageAware)) {
  373.                     continue;
  374.                 }
  376.                 if (\array_key_exists($property, $raw)) {
  377.                     $mapped[$property] = $raw[$property];
  379.                     continue;
  380.                 }
  382.                 if ($field instanceof ReferenceVersionField) {
  383.                     $mapped[$property] = $writeContext->getContext()->getVersionId();
  385.                     continue;
  386.                 }
  388.                 if ($field instanceof VersionField) {
  389.                     $mapped[$property] = $writeContext->getContext()->getVersionId();
  391.                     continue;
  392.                 }
  394.                 $fieldKeys = $fields
  395.                     ->filter(
  396.                         fn (Field $field) => !$field instanceof VersionField && !$field instanceof ReferenceVersionField
  397.                     )
  398.                     ->map(
  399.                         fn (Field $field) => $field->getPropertyName()
  400.                     );
  402.                 throw new IncompletePrimaryKeyException($fieldKeys);
  403.             }
  405.             $resolved[] = $mapped;
  406.         }
  408.         return $resolved;
  409.     }
  411.     /**
  412.      * @param array<mixed> $ids
  413.      *
  414.      * @return array<mixed>
  415.      */
  416.     private function extractDeleteCommands(EntityDefinition $definition, array $ids, WriteContext $writeContext, WriteCommandQueue $commandQueue): array
  417.     {
  418.         $parameters = new WriteParameterBag($definition, $writeContext, '', $commandQueue);
  419.         $ids = $this->commandExtractor->normalize($definition, $ids, $parameters);
  420.         $this->gateway->prefetchExistences($parameters);
  422.         $resolved = $this->resolvePrimaryKeys($ids, $definition, $writeContext);
  424.         if (!$definition instanceof MappingEntityDefinition) {
  425.             $restrictions = $this->foreignKeyResolver->getAffectedDeleteRestrictions($definition, $resolved, $writeContext->getContext(), true);
  427.             if (!empty($restrictions)) {
  428.                 throw new RestrictDeleteViolationException($definition, [new RestrictDeleteViolation($restrictions)]);
  429.             }
  430.         }
  432.         $skipped = [];
  433.         foreach ($resolved as $primaryKey) {
  434.             $mappedBytes = [];
  435.             /**
  436.              * @var string $key
  437.              * @var string $value
  438.              */
  439.             foreach ($primaryKey as $key => $value) {
  440.                 /** @var StorageAware $field */
  441.                 $field = $definition->getFields()->get($key);
  443.                 $mappedBytes[$field->getStorageName()] = Uuid::fromHexToBytes($value);
  444.             }
  446.             $existence = $this->gateway->getExistence($definition, $mappedBytes, [], $commandQueue);
  448.             if ($existence->exists()) {
  449.                 $commandQueue->add($definition, new DeleteCommand($definition, $mappedBytes, $existence));
  451.                 continue;
  452.             }
  454.             $stripped = [];
  455.             /**
  456.              * @var string $key
  457.              * @var string $value
  458.              */
  459.             foreach ($primaryKey as $key => $value) {
  460.                 $field = $definition->getFields()->get($key);
  462.                 if ($field instanceof VersionField || $field instanceof ReferenceVersionField) {
  463.                     continue;
  464.                 }
  465.                 $stripped[$key] = $value;
  466.             }
  468.             $skipped[$definition->getEntityName()][] = new EntityWriteResult(
  469.                 \count($stripped) === 1 ? array_shift($stripped) : $stripped,
  470.                 $stripped,
  471.                 $definition->getEntityName(),
  472.                 EntityWriteResult::OPERATION_DELETE,
  473.                 $existence
  474.             );
  475.         }
  477.         // we had some logic in the command layer (pre-validate, post-validate, indexer which listens to this events)
  478.         // to trigger this logic for cascade deletes or set nulls, we add a fake commands for the affected rows
  479.         $this->addReverseInheritedCommands($commandQueue, $definition, $writeContext, $resolved);
  481.         $this->addDeleteCascadeCommands($commandQueue, $definition, $writeContext, $resolved);
  483.         $this->addSetNullOnDeletesCommands($commandQueue, $definition, $writeContext, $resolved);
  485.         return $skipped;
  486.     }
  487. }