Cycle\ORM\Transaction\CommandGenerator

Complexity

Total Complexity

17

Size/Duplication

Total Lines	108
Duplicated Lines	0 %

Test Coverage

Coverage

98.18%

Importance

Changes	1
Bugs	0	Features	0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	storeParents()	0	17	4
A	generateDeleteCommand()	0	4	1
A	deleteEntity()	0	3	1
A	storeEntity()	0	5	2
A	generateStoreCommand()	0	16	3
A	generateParentStoreCommand()	0	10	2
A	buildStoreSequence()	0	29	4

<?php

declare(strict_types=1);

namespace Cycle\ORM\Transaction;

use Cycle\ORM\Command\CommandInterface;
use Cycle\ORM\Command\Special\Sequence;
use Cycle\ORM\Command\Special\WrappedStoreCommand;
use Cycle\ORM\Command\StoreCommandInterface;
use Cycle\ORM\Heap\Node;
use Cycle\ORM\ORMInterface;
use Cycle\ORM\SchemaInterface;

/**
 * @internal
 */
class CommandGenerator implements CommandGeneratorInterface
{
    public function generateStoreCommand(ORMInterface $orm, Tuple $tuple): ?CommandInterface
    {
        $isNew = $tuple->node->getStatus() === Node::NEW;
        $tuple->state->setStatus($isNew ? Node::SCHEDULED_INSERT : Node::SCHEDULED_UPDATE);
        $schema = $orm->getSchema();

        $commands = $this->storeParents($orm, $tuple, $isNew);
        $entityCommand = $this->storeEntity($orm, $tuple, $isNew);
        if ($entityCommand !== null) {
            $commands[$tuple->node->getRole()] = $entityCommand;
        }

        return match (\count($commands)) {
            0 => null,
            1 => \current($commands),
            default => $this->buildStoreSequence($schema, $commands, $tuple)
        };
    }

    public function generateDeleteCommand(ORMInterface $orm, Tuple $tuple): ?CommandInterface
    {
        // currently we rely on db to delete all nested records (or soft deletes)
        return $this->deleteEntity($orm, $tuple);
    }

    /**
     * @return array<string, CommandInterface>
     */
    protected function storeParents(ORMInterface $orm, Tuple $tuple, bool $isNew): array
    {
        $schema = $orm->getSchema();
        $parents = $commands = [];
        $parent = $schema->define($tuple->node->getRole(), SchemaInterface::PARENT);
        while (is_string($parent)) {
            \array_unshift($parents, $parent);
            $parent = $schema->define($parent, SchemaInterface::PARENT);
        }
        foreach ($parents as $parent) {
            $command = $this->generateParentStoreCommand($orm, $tuple, $parent, $isNew);
            if ($command !== null) {
                $commands[$parent] = $command;
            }
        }

        return $commands;
    }

    protected function storeEntity(ORMInterface $orm, Tuple $tuple, bool $isNew): ?CommandInterface

The parameter $orm is not used and could be removed.

    {
        return $isNew
            ? $tuple->mapper->queueCreate($tuple->entity, $tuple->node, $tuple->state)
            : $tuple->mapper->queueUpdate($tuple->entity, $tuple->node, $tuple->state);
    }

    protected function deleteEntity(ORMInterface $orm, Tuple $tuple): ?CommandInterface

The parameter $orm is not used and could be removed.

    {
        return $tuple->mapper->queueDelete($tuple->entity, $tuple->node, $tuple->state);
    }

    /**
     * @param non-empty-string $parentRole

The doc comment non-empty-string at position 0 could not be parsed: Unknown type name 'non-empty-string' at position 0 in non-empty-string.

     */
    protected function generateParentStoreCommand(
        ORMInterface $orm,
        Tuple $tuple,
        string $parentRole,
        bool $isNew
    ): ?CommandInterface {
        $parentMapper = $orm->getMapper($parentRole);
        return $isNew
            ? $parentMapper->queueCreate($tuple->entity, $tuple->node, $tuple->state)
            : $parentMapper->queueUpdate($tuple->entity, $tuple->node, $tuple->state);
    }

    /**
     * @param array<string, StoreCommandInterface> $commands
     */
    private function buildStoreSequence(SchemaInterface $schema, array $commands, Tuple $tuple): CommandInterface
    {
        $parent = null;
        $result = [];
        foreach ($commands as $role => $command) {
            // Current parent has no parent
            if ($parent === null) {
                $result[] = $command;
                $parent = $role;
                continue;
            }

            $command = WrappedStoreCommand::wrapStoreCommand($command);

            // Transact PK from previous parent to current
            $parentKey = (array)($schema->define($role, SchemaInterface::PARENT_KEY)
                ?? $schema->define($parent, SchemaInterface::PRIMARY_KEY));

$parent of type null is incompatible with the type string expected by parameter $role of Cycle\ORM\SchemaInterface::define().

            $primaryKey = (array)$schema->define($role, SchemaInterface::PRIMARY_KEY);
            $result[] = $command->withBeforeExecution(
                static function (StoreCommandInterface $command) use ($tuple, $parentKey, $primaryKey): void {
                    foreach ($primaryKey as $i => $pk) {
                        $command->registerAppendix($pk, $tuple->state->getValue($parentKey[$i]));
                    }
                }
            );
            $parent = $role;
        }

        return (new Sequence())->addCommand(...$result);
    }
}