Recording events from AggregatePartial

[giorgiopogliani]

Hello, to give some context the scenario I was in is: trying to send a notification when a user is tagged in some content.

I created the EntryAggregateRoot which has a method to update the content updateEntryContent(string $content).

class EntryAggregateRoot extends AggregateRoot 
{
    public function updateEntryContent(string $content): self
    {
        $this->recordThat(new EntryContentUpdated($content));
        
        return $this;
    }
}

Next I created a MentionsAggregatePartial to keep things separated because I might use it on some other content column

class MentionsAggregatePartial extends AggregatePartial
{
    protected array $mentionedUsersId = [];

    public function onMentionsAdded(EntryContentUpdated $event)
    {
         // When user is tagged in content for the first time
         $this->recordThat(new UserMentioned($userId));
    }
}

Also, to be able to add partials from packages I overrode the method resolvePartials like so:

class EntryAggregateRoot extends AggregateRoot 
{
    protected function resolvePartials(): Collection
    {
        if (! isset($this->entities)) {
            return collect(static::$partials)->map(function ($partial) {
                return new $partial($this);
            });
        }
    
        return $this->entities;
    }
    // ....
}

Everything seemed to work perfectly! But only the first time, the second update triggered the exception: Could not persist aggregate EntryAggregateRoot .... because it seems to be changed by another process after it was retrieved in the current process. Expect to persist events after version 21, but version 20 was already persisted.

So I inspected the source code and I come up this change that fixed the problem:

abstract class AggregateRoot
{
    // ...
    public function recordThat(ShouldBeStored $domainEvent): static
    {
        $domainEvent
            ->setAggregateRootUuid($this->uuid)
            ->setCreatedAt(CarbonImmutable::now());
    
        $this->recordedEvents[] = $domainEvent;
    
        $this->apply($domainEvent);
    
        $domainEvent->setAggregateRootVersion($this->aggregateVersion);
    
        // Moved here the apply on the aggregate partials outside the main apply and 
        // after the set for the aggregate root version above
        foreach ($this->resolvePartials() as $partial) {
            $partial->apply($domainEvent);
        }
    
        return $this;
    }
   // ...
}

Now everything works but I am not sure if this has some consequences. Also, I cannot really do that change without reflection magic because some property on the abstract class are private.

I'll wait some comments/feedbacks, thanks!

[giorgiopogliani]

@freekmurze is recording events from partials not supported by the package? Shouldn't it work?

[giorgiopogliani]

Ok, investigating the issue more I realized that the event was recorded during the reconstitution, I guess that's the reason of conflict in the first place. First time was working because there were no past events and then error.

So, I am trying another solution, I added a boolean during the reconstitution and I'm using it to record the event only when is false, when the reconstitution is completed. Now, It seems to work as expected.

    protected function reconstituteFromEvents(): static
    {
        $storedEventRepository = $this->getStoredEventRepository();

        $this->isReconstituting = true;

        $parentUuid = new \ReflectionProperty(parent::class, 'uuid');

        if ($snapshot = $this->getSnapshotRepository()->retrieve($parentUuid->getValue($this))) {
            $this->aggregateVersion = $snapshot->aggregateVersion;
            $this->useState($snapshot->state);

            $events = $storedEventRepository->retrieveAllAfterVersion($this->aggregateVersion, $parentUuid->getValue($this));
        } else {
            $events = $storedEventRepository->retrieveAll($parentUuid->getValue($this));
        }

        $events->each(function (StoredEvent $storedEvent) {
            $this->apply($storedEvent->event);
        });

        $this->aggregateVersionAfterReconstitution = $this->aggregateVersion;

        $this->isReconstituting = false;

        return $this;
    }

[sebastiandedeyne]

Good catch on the reconstitution recording. You shouldn't trigger additional events while reconstituting, reconstituting shouldn't have any side effects.

You could record the additional event in updateEntryContent. Another option is to write a MentionsReactor to trigger a userMentioned event on the EntryAggregateRoot. Reactors only get run once.

[giorgiopogliani]

Thanks @sebastiandedeyne for the reply. I need the last event to trigger the event so I need to add the event handler in an aggregate, and I want to separate the logic thus the partial. In the end, I extended AggregatePartial and AggregateRoot added my custom methods and it's working really well:

class MentionsAggregatePartial extends AggregatePartial 
{
    public function onMentionsAdded(EntryContentUpdated $event)
    {
        $ids = $this->getMentions($event->content);
        $state = $this->getAggregateState();

        if ($this->isReconstitutingEvents()) {
            $state = collect($ids)->unique()->toArray();
            $this->setAggregateState($state);
        } else {
            foreach ($ids as $userId) {
                if (! collect($state)->contains($userId)) {
                    $this->recordThat(new UserMentioned($userId, Auth::id()));
                }
            }
        }
    }
}