cycle / orm

src/Relation/HasOne.php

<?php
/**
 * Cycle DataMapper ORM
 *
 * @license   MIT
 * @author    Anton Titov (Wolfy-J)
 */
declare(strict_types=1);

namespace Cycle\ORM\Relation;

use Cycle\ORM\Command\Branch\Condition;
use Cycle\ORM\Command\Branch\ContextSequence;
use Cycle\ORM\Command\Branch\Nil;
use Cycle\ORM\Command\CommandInterface;
use Cycle\ORM\Command\ContextCarrierInterface as CC;
use Cycle\ORM\Heap\Node;
use Cycle\ORM\Promise\ReferenceInterface;
use Cycle\ORM\Relation\Traits\PromiseOneTrait;

/**
 * Provides the ability to own and forward context values to child entity.
 */
class HasOne extends AbstractRelation
{
    use PromiseOneTrait;

    /**
     * @inheritdoc
     */
    public function queue(CC $parentStore, $parentEntity, Node $parentNode, $related, $original): CommandInterface
    {
        if ($original instanceof ReferenceInterface) {
            $original = $this->resolve($original);
        }

        if ($related instanceof ReferenceInterface) {
            $related = $this->resolve($related);
        }

        if (is_null($related)) {
            if ($related === $original) {
                // no changes
                return new Nil();
            }

            if (!is_null($original)) {
                return $this->deleteOriginal($original);
            }
        }

        $resStore = $this->orm->queueStore($related);
        $relNode = $this->getNode($related, +1);
        $this->assertValid($relNode);

It seems like $relNode can also be of type null; however, parameter $relNode of Cycle\ORM\Relation\AbstractRelation::assertValid() does only seem to accept Cycle\ORM\Heap\Node, maybe add an additional type check?

        // store command with mounted context paths
        $relStore = $this->forwardContext($parentNode, $this->innerKey, $resStore, $relNode, $this->outerKey);

        if (is_null($original)) {
            return $relStore;
        }

        $sequence = new ContextSequence();
        $sequence->addCommand($this->deleteOriginal($original));
        $sequence->addPrimary($relStore);

        return $sequence;
    }

    /**
     * Delete original related entity of no other objects reference to it.
     *
     * @param object $original
     * @return CommandInterface
     */
    protected function deleteOriginal($original): CommandInterface
    {
        $relNode = $this->getNode($original);

        if (!$this->isRequired()) {
            $store = $this->orm->queueStore($original);
            $store->register($this->outerKey, null, true);
            $relNode->getState()->decClaim();

            return new Condition($store, function () use ($relNode) {
                return !$relNode->getState()->hasClaims();
            });
        }

        // only delete original child when no other objects claim it
        return new Condition($this->orm->queueDelete($original), function () use ($relNode) {
            return !$relNode->getState()->hasClaims();
        });
    }
}