Případová studie

src/
├── UserManagement/            # Bounded Context: Správa uživatelů
│   ├── Domain/                # Doménová vrstva
│   │   ├── Model/             # Doménové modely
│   │   │   └── User.php        # Entita uživatele (Aggregate Root)
│   │   ├── ValueObject/       # Hodnotové objekty
│   │   │   ├── UserId.php      # Identifikátor uživatele
│   │   │   └── Email.php       # Email uživatele
│   │   ├── Event/             # Doménové události
│   │   │   └── UserRegistered.php  # Událost registrace uživatele
│   │   └── Repository/        # Repozitáře (rozhraní)
│   │       └── UserRepository.php  # Rozhraní pro práci s uživateli
│   ├── Infrastructure/        # Infrastrukturní vrstva
│   │   └── Repository/        # Implementace repozitářů
│   │       └── DoctrineUserRepository.php  # Doctrine implementace
│   ├── Registration/          # Feature: Registrace uživatele
│   │   ├── Command/           # Příkazy
│   │   │   ├── RegisterUser.php  # Příkaz pro registraci uživatele
│   │   │   └── RegisterUserHandler.php  # Handler příkazu
│   │   └── Controller/        # Kontrolery
│   │       └── RegistrationController.php  # Kontroler pro registraci
│   ├── Authentication/        # Feature: Autentizace
│   │   └── Controller/        # Kontrolery
│   │       └── SecurityController.php  # Kontroler pro autentizaci
│   └── GetUser/               # Feature: Získání uživatele
│       ├── Query/             # Dotazy
│       │   ├── GetUser.php      # Dotaz pro získání uživatele
│       │   └── GetUserHandler.php  # Handler dotazu
│       └── ViewModel/         # View modely
│           └── UserViewModel.php  # View model uživatele
├── ProjectManagement/         # Bounded Context: Správa projektů
│   ├── Domain/                # Doménová vrstva
│   │   ├── Model/             # Doménové modely
│   │   │   ├── Project.php     # Entita projektu (Aggregate Root)
│   │   │   └── ProjectMember.php  # Entita člena projektu
│   │   ├── ValueObject/       # Hodnotové objekty
│   │   │   ├── ProjectId.php    # Identifikátor projektu
│   │   │   └── ProjectStatus.php  # Status projektu
│   │   ├── Event/             # Doménové události
│   │   │   ├── ProjectCreated.php  # Událost vytvoření projektu
│   │   │   └── MemberAdded.php  # Událost přidání člena
│   │   └── Repository/        # Repozitáře (rozhraní)
│   │       └── ProjectRepository.php  # Rozhraní pro práci s projekty
│   ├── Infrastructure/        # Infrastrukturní vrstva
│   │   └── Repository/        # Implementace repozitářů
│   │       └── DoctrineProjectRepository.php  # Doctrine implementace
│   ├── CreateProject/         # Feature: Vytvoření projektu
│   │   ├── Command/           # Příkazy
│   │   │   ├── CreateProject.php  # Příkaz pro vytvoření projektu
│   │   │   └── CreateProjectHandler.php  # Handler příkazu
│   │   └── Controller/        # Kontrolery
│   │       └── ProjectController.php  # Kontroler pro vytvoření projektu
│   └── GetProjects/           # Feature: Seznam projektů
│       ├── Query/             # Dotazy
│       │   ├── GetProjects.php  # Dotaz pro získání projektů
│       │   └── GetProjectsHandler.php  # Handler dotazu
│       ├── Controller/        # Kontrolery
│       │   └── ProjectsController.php  # Kontroler pro seznam projektů
│       └── ViewModel/         # View modely
│           └── ProjectViewModel.php  # View model projektu
├── TaskManagement/            # Bounded Context: Správa úkolů
│   ├── Domain/                # Doménová vrstva
│   │   ├── Model/             # Doménové modely
│   │   │   └── Task.php        # Entita úkolu (Aggregate Root)
│   │   ├── ValueObject/       # Hodnotové objekty
│   │   │   ├── TaskId.php      # Identifikátor úkolu
│   │   │   └── TaskStatus.php  # Status úkolu
│   │   ├── Event/             # Doménové události
│   │   │   ├── TaskCreated.php  # Událost vytvoření úkolu
│   │   │   ├── TaskAssigned.php  # Událost přiřazení úkolu
│   │   │   └── TaskStatusChanged.php  # Událost změny stavu
│   │   ├── Service/           # Doménové služby
│   │   │   └── TaskAssignmentService.php  # Služba pro přiřazení úkolu
│   │   └── Repository/        # Repozitáře (rozhraní)
│   │       └── TaskRepository.php  # Rozhraní pro práci s úkoly
│   ├── Infrastructure/        # Infrastrukturní vrstva
│   │   └── Repository/        # Implementace repozitářů
│   │       └── DoctrineTaskRepository.php  # Doctrine implementace
│   ├── CreateTask/            # Feature: Vytvoření úkolu
│   │   ├── Command/           # Příkazy
│   │   │   ├── CreateTask.php   # Příkaz pro vytvoření úkolu
│   │   │   └── CreateTaskHandler.php  # Handler příkazu
│   │   └── Controller/        # Kontrolery
│   │       └── TaskController.php  # Kontroler pro úkoly
│   ├── AssignTask/            # Feature: Přiřazení úkolu
│   │   ├── Command/           # Příkazy
│   │   │   ├── AssignTask.php   # Příkaz pro přiřazení úkolu
│   │   │   └── AssignTaskHandler.php  # Handler příkazu
│   │   └── Controller/        # Kontrolery
│   │       └── AssignController.php  # Kontroler pro přiřazení
│   ├── ChangeStatus/          # Feature: Změna stavu úkolu
│   │   ├── Command/           # Příkazy
│   │   │   ├── ChangeTaskStatus.php  # Příkaz pro změnu stavu
│   │   │   └── ChangeTaskStatusHandler.php  # Handler příkazu
│   │   └── Controller/        # Kontrolery
│   │       └── StatusController.php  # Kontroler pro změnu stavu
│   └── GetTask/               # Feature: Získání úkolu
│       ├── Query/             # Dotazy
│       │   ├── GetTask.php      # Dotaz pro získání úkolu
│       │   └── GetTaskHandler.php  # Handler dotazu
│       └── ViewModel/         # View modely
│           └── TaskViewModel.php  # View model úkolu
├── CommentManagement/         # Bounded Context: Správa komentářů
│   ├── Domain/                # Doménová vrstva
│   │   ├── Model/             # Doménové modely
│   │   │   └── Comment.php     # Entita komentáře
│   │   ├── ValueObject/       # Hodnotové objekty
│   │   │   └── CommentId.php   # Identifikátor komentáře
│   │   ├── Event/             # Doménové události
│   │   │   └── CommentAdded.php  # Událost přidání komentáře
│   │   └── Repository/        # Repozitáře (rozhraní)
│   │       └── CommentRepository.php  # Rozhraní pro práci s komentáři
│   ├── Infrastructure/        # Infrastrukturní vrstva
│   │   └── Repository/        # Implementace repozitářů
│   │       └── DoctrineCommentRepository.php  # Doctrine implementace
│   └── AddComment/            # Feature: Přidání komentáře
│       ├── Command/           # Příkazy
│       │   ├── AddComment.php   # Příkaz pro přidání komentáře
│       │   └── AddCommentHandler.php  # Handler příkazu
│       └── Controller/        # Kontrolery
│           └── CommentController.php  # Kontroler pro komentáře
├── ActivityTracking/          # Bounded Context: Sledování aktivity
│   ├── Domain/                # Doménová vrstva
│   │   ├── Model/             # Doménové modely
│   │   │   └── Activity.php    # Entita aktivity
│   │   ├── ValueObject/       # Hodnotové objekty
│   │   │   └── ActivityId.php  # Identifikátor aktivity
│   │   └── Repository/        # Repozitáře (rozhraní)
│   │       └── ActivityRepository.php  # Rozhraní pro práci s aktivitami
│   ├── Infrastructure/        # Infrastrukturní vrstva
│   │   └── Repository/        # Implementace repozitářů
│   │       └── DoctrineActivityRepository.php  # Doctrine implementace
│   └── RecordActivity/        # Feature: Zaznamenání aktivity
│       ├── Command/           # Příkazy
│       │   ├── RecordActivity.php  # Příkaz pro zaznamenání aktivity
│       │   └── RecordActivityHandler.php  # Handler příkazu
│       └── Controller/        # Kontrolery
│           └── ActivityController.php  # Kontroler pro aktivity
└── Shared/                    # Sdílené komponenty
    ├── Domain/                # Sdílená doménová logika
    │   ├── Exception/         # Výjimky
    │   │   └── DomainException.php  # Základní doménová výjimka
    │   └── Bus/               # Rozhraní pro message bus
    │       ├── CommandBus.php   # Rozhraní pro command bus
    │       └── QueryBus.php     # Rozhraní pro query bus
    └── Infrastructure/        # Sdílená infrastruktura
        ├── Bus/               # Implementace message bus
        │   ├── MessengerCommandBus.php  # Implementace command bus
        │   └── MessengerQueryBus.php  # Implementace query bus
        └── Persistence/        # Sdílená persistence
            └── DoctrineTypes/    # Vlastní Doctrine typy
                └── UuidType.php    # Typ pro UUID

<?php

declare(strict_types=1);

namespace App\ProjectManagement\Domain\Model;

use App\ProjectManagement\Domain\Event\MemberAdded;
use App\ProjectManagement\Domain\Event\MemberRemoved;
use App\ProjectManagement\Domain\Event\ProjectCreated;
use App\ProjectManagement\Domain\ValueObject\ProjectId;
use App\Shared\Domain\AggregateRoot;
// UserId je sdílený v Shared Kernelu (viz sekci 25.07.2)
use App\UserManagement\Domain\ValueObject\UserId;
use Doctrine\ORM\Mapping as ORM;

#[ORM\Entity]
#[ORM\Table(name: 'projects')]
final class Project extends AggregateRoot
{
    #[ORM\Id]
    #[ORM\Column(type: 'project_id')]
    public readonly ProjectId $id;

    #[ORM\Column(type: 'string', length: 255)]
    private string $name;

    #[ORM\Column(type: 'text', nullable: true)]
    private ?string $description;

    #[ORM\Column(type: 'user_id')]
    public readonly UserId $ownerId;

    /** @var list<UserId> */
    #[ORM\Column(type: 'user_id_list')]
    private array $memberIds = [];

    #[ORM\Column(type: 'datetime_immutable')]
    public readonly \DateTimeImmutable $createdAt;

    #[ORM\Column(type: 'datetime_immutable', nullable: true)]
    private ?\DateTimeImmutable $updatedAt = null;

    #[ORM\Version]
    #[ORM\Column(type: 'integer')]
    private int $version = 1;

    private function __construct(ProjectId $id, string $name, ?string $description, UserId $ownerId)
    {
        $this->id = $id;
        $this->name = $name;
        $this->description = $description;
        $this->ownerId = $ownerId;
        $this->memberIds = [$ownerId];
        $this->createdAt = new \DateTimeImmutable();

        $this->record(new ProjectCreated($id, $name, $ownerId));
    }

    public static function create(ProjectId $id, string $name, ?string $description, UserId $ownerId): self
    {
        return new self($id, $name, $description, $ownerId);
    }

    public function name(): string
    {
        return $this->name;
    }

    public function description(): ?string
    {
        return $this->description;
    }

    /** @return list<UserId> */
    public function memberIds(): array
    {
        return $this->memberIds;
    }

    public function addMember(UserId $userId): void
    {
        foreach ($this->memberIds as $existingId) {
            if ($existingId->equals($userId)) {
                return; // již je členem – idempotentní operace
            }
        }
        $this->memberIds[] = $userId;
        $this->updatedAt = new \DateTimeImmutable();

        $this->record(new MemberAdded($this->id, $userId));
    }

    public function removeMember(UserId $userId): void
    {
        if ($this->ownerId->equals($userId)) {
            throw new \DomainException('Vlastníka projektu nelze odebrat z členů.');
        }

        $before = count($this->memberIds);
        $this->memberIds = array_values(array_filter(
            $this->memberIds,
            fn(UserId $id) => !$id->equals($userId),
        ));

        if (count($this->memberIds) === $before) {
            return; // nebyl členem – idempotentní operace
        }

        $this->updatedAt = new \DateTimeImmutable();
        $this->record(new MemberRemoved($this->id, $userId));
    }

    public function rename(string $newName): void
    {
        if ($this->name === $newName) {
            return;
        }
        $this->name = $newName;
        $this->updatedAt = new \DateTimeImmutable();
    }

    public function changeDescription(?string $newDescription): void
    {
        if ($this->description === $newDescription) {
            return;
        }
        $this->description = $newDescription;
        $this->updatedAt = new \DateTimeImmutable();
    }

    public function updatedAt(): ?\DateTimeImmutable
    {
        return $this->updatedAt;
    }
}

<?php

declare(strict_types=1);

namespace App\TaskManagement\Domain\Model;

use App\TaskManagement\Domain\Event\TaskCreated;
use App\TaskManagement\Domain\Event\TaskAssigned;
use App\TaskManagement\Domain\Event\TaskStatusChanged;
use App\TaskManagement\Domain\ValueObject\TaskId;
use App\TaskManagement\Domain\ValueObject\TaskStatus;
// ProjectId a UserId jsou sdílené v Shared Kernelu (viz sekci 25.07.2)
use App\ProjectManagement\Domain\ValueObject\ProjectId;
use App\UserManagement\Domain\ValueObject\UserId;

class Task
{
    private readonly TaskId $id;
    private string $title;
    private ?string $description;
    private readonly ProjectId $projectId;
    private ?UserId $assigneeId = null;
    private TaskStatus $status;
    private readonly \DateTimeImmutable $createdAt;
    private ?\DateTimeImmutable $updatedAt = null;

    private array $domainEvents = [];

    private function __construct(TaskId $id, string $title, ?string $description, ProjectId $projectId)
    {
        $this->id = $id;
        $this->title = $title;
        $this->description = $description;
        $this->projectId = $projectId;
        $this->status = TaskStatus::TODO;
        $this->createdAt = new \DateTimeImmutable();

        $this->recordEvent(new TaskCreated($id, $title, $projectId));
    }

    public static function create(TaskId $id, string $title, ?string $description, ProjectId $projectId): self
    {
        return new self($id, $title, $description, $projectId);
    }

    public function id(): TaskId
    {
        return $this->id;
    }

    public function title(): string
    {
        return $this->title;
    }

    public function description(): ?string
    {
        return $this->description;
    }

    public function projectId(): ProjectId
    {
        return $this->projectId;
    }

    public function assigneeId(): ?UserId
    {
        return $this->assigneeId;
    }

    public function status(): TaskStatus
    {
        return $this->status;
    }

    public function assign(UserId $assigneeId): void
    {
        $this->assigneeId = $assigneeId;
        $this->updatedAt = new \DateTimeImmutable();

        $this->recordEvent(new TaskAssigned($this->id, $assigneeId));
    }

    public function unassign(): void
    {
        $this->assigneeId = null;
        $this->updatedAt = new \DateTimeImmutable();
    }

    public function changeStatus(TaskStatus $status): void
    {
        $oldStatus = $this->status;
        $this->status = $status;
        $this->updatedAt = new \DateTimeImmutable();

        $this->recordEvent(new TaskStatusChanged($this->id, $oldStatus, $status));
    }

    public function updateTitle(string $title): void
    {
        $this->title = $title;
        $this->updatedAt = new \DateTimeImmutable();
    }

    public function updateDescription(?string $description): void
    {
        $this->description = $description;
        $this->updatedAt = new \DateTimeImmutable();
    }

    public function createdAt(): \DateTimeImmutable
    {
        return $this->createdAt;
    }

    public function updatedAt(): ?\DateTimeImmutable
    {
        return $this->updatedAt;
    }

    private function recordEvent(object $event): void
    {
        $this->domainEvents[] = $event;
    }

    public function releaseDomainEvents(): array
    {
        $events = $this->domainEvents;
        $this->domainEvents = [];

        return $events;
    }
}

<?php

declare(strict_types=1);

namespace App\ProjectManagement\Domain\Event;

use App\ProjectManagement\Domain\ValueObject\ProjectId;
use App\UserManagement\Domain\ValueObject\UserId;

final readonly class ProjectCreated
{
    public function __construct(
        public ProjectId $projectId,
        public string $name,
        public UserId $ownerId,
        public \DateTimeImmutable $occurredAt = new \DateTimeImmutable(),
    ) {
    }
}

<?php

declare(strict_types=1);

namespace App\ProjectManagement\Domain\Event;

use App\ProjectManagement\Domain\ValueObject\ProjectId;
use App\UserManagement\Domain\ValueObject\UserId;

final readonly class MemberAdded
{
    public function __construct(
        public ProjectId $projectId,
        public UserId $userId,
        public \DateTimeImmutable $occurredAt = new \DateTimeImmutable(),
    ) {
    }
}

final readonly class MemberRemoved
{
    public function __construct(
        public ProjectId $projectId,
        public UserId $userId,
        public \DateTimeImmutable $occurredAt = new \DateTimeImmutable(),
    ) {
    }
}

<?php

declare(strict_types=1);

namespace App\TaskManagement\Domain\Event;

use App\ProjectManagement\Domain\ValueObject\ProjectId;
use App\TaskManagement\Domain\ValueObject\TaskId;
use App\TaskManagement\Domain\ValueObject\TaskStatus;
use App\UserManagement\Domain\ValueObject\UserId;

final readonly class TaskCreated
{
    public function __construct(
        public TaskId $taskId,
        public string $title,
        public ProjectId $projectId,
        public \DateTimeImmutable $occurredAt = new \DateTimeImmutable(),
    ) {
    }
}

final readonly class TaskAssigned
{
    public function __construct(
        public TaskId $taskId,
        public UserId $assigneeId,
        public \DateTimeImmutable $occurredAt = new \DateTimeImmutable(),
    ) {
    }
}

final readonly class TaskStatusChanged
{
    public function __construct(
        public TaskId $taskId,
        public TaskStatus $oldStatus,
        public TaskStatus $newStatus,
        public \DateTimeImmutable $occurredAt = new \DateTimeImmutable(),
    ) {
    }
}

<?php

declare(strict_types=1);

namespace App\ProjectManagement\Domain\ValueObject;

use Symfony\Component\Uid\Uuid;

final class ProjectId
{
    private readonly string $value;

    public function __construct(string $value = '')
    {
        $resolved = $value === '' ? Uuid::v7()->toRfc4122() : $value;
        if (!Uuid::isValid($resolved)) {
            throw new \InvalidArgumentException('ProjectId must be a valid UUID');
        }
        $this->value = $resolved;
    }

    public function value(): string
    {
        return $this->value;
    }

    public function equals(self $other): bool
    {
        return $this->value === $other->value;
    }
}

<?php

declare(strict_types=1);

namespace App\TaskManagement\Domain\ValueObject;

enum TaskStatus: string
{
    case TODO        = 'todo';
    case IN_PROGRESS = 'in_progress';
    case DONE        = 'done';

    public function canTransitionTo(self $next): bool
    {
        return match ([$this, $next]) {
            [self::TODO,        self::IN_PROGRESS] => true,
            [self::IN_PROGRESS, self::DONE]        => true,
            [self::IN_PROGRESS, self::TODO]        => true,
            default                                 => false,
        };
    }
}

<?php

declare(strict_types=1);

namespace App\ProjectManagement\CreateProject\Command;

use Symfony\Component\Validator\Constraints as Assert;

class CreateProject
{
    public function __construct(
        #[Assert\NotBlank]
        #[Assert\Length(min: 3, max: 255)]
        public readonly string $name,

        public readonly ?string $description,

        #[Assert\NotBlank]
        #[Assert\Uuid]
        public readonly string $ownerId
    ) {
    }
}

<?php

declare(strict_types=1);

namespace App\ProjectManagement\CreateProject\Command;

use App\ProjectManagement\Domain\Model\Project;
use App\ProjectManagement\Domain\Repository\ProjectRepository;
use App\ProjectManagement\Domain\ValueObject\ProjectId;
use App\UserManagement\Domain\ValueObject\UserId;
use Symfony\Component\Messenger\Attribute\AsMessageHandler;

#[AsMessageHandler]
class CreateProjectHandler
{
    public function __construct(
        private readonly ProjectRepository $projectRepository
    ) {
    }

    public function __invoke(CreateProject $command): string
    {
        $projectId = new ProjectId();

        $project = Project::create(
            $projectId,
            $command->name,
            $command->description,
            new UserId($command->ownerId)
        );

        $this->projectRepository->save($project);

        return $projectId->value();
    }
}

<?php

declare(strict_types=1);

namespace App\TaskManagement\AssignTask\Command;

use Symfony\Component\Validator\Constraints as Assert;

class AssignTask
{
    public function __construct(
        #[Assert\NotBlank]
        #[Assert\Uuid]
        public readonly string $taskId,

        #[Assert\NotBlank]
        #[Assert\Uuid]
        public readonly string $assigneeId
    ) {
    }
}

<?php

declare(strict_types=1);

namespace App\TaskManagement\AssignTask\Command;

use App\ProjectManagement\Domain\ValueObject\ProjectId;
use App\TaskManagement\Domain\Port\ProjectChecker;
use App\TaskManagement\Domain\Repository\TaskRepository;
use App\TaskManagement\Domain\Service\TaskAssignmentService;
use App\TaskManagement\Domain\ValueObject\TaskId;
use App\UserManagement\Domain\ValueObject\UserId;
use Symfony\Component\Messenger\Attribute\AsMessageHandler;

/**
 * Port ProjectChecker tvoří hranici (Anti-Corruption Layer) mezi TaskManagement
 * a ProjectManagement. TaskManagement nezná interní model ProjectManagement;
 * adaptér v infrastruktuře přeloží dotaz na konkrétní volání upstream kontextu.
 *
 * Skutečné rozhraní:
 *   interface ProjectChecker {
 *       public function exists(ProjectId $projectId): bool;
 *       public function isMember(ProjectId $projectId, UserId $userId): bool;
 *   }
 */
#[AsMessageHandler]
class AssignTaskHandler
{
    public function __construct(
        private readonly TaskRepository $taskRepository,
        private readonly ProjectChecker $projectChecker,
        private readonly TaskAssignmentService $taskAssignmentService
    ) {
    }

    public function __invoke(AssignTask $command): void
    {
        $task = $this->taskRepository->findById(new TaskId($command->taskId));

        if (!$task) {
            throw new \DomainException('Task not found');
        }

        $assigneeId = new UserId($command->assigneeId);

        // Ověření přes port - bez přímé závislosti na ProjectManagement
        if (!$this->projectChecker->exists($task->projectId())) {
            throw new \DomainException('Project not found');
        }

        if (!$this->projectChecker->isMember($task->projectId(), $assigneeId)) {
            throw new \DomainException('Assignee is not a member of the project');
        }

        // Použití doménové služby pro přiřazení úkolu
        $this->taskAssignmentService->assignTask($task, $assigneeId);

        // Uložení úkolu
        $this->taskRepository->save($task);
    }
}

<?php

declare(strict_types=1);

namespace App\ProjectManagement\GetProjects\Query;

use Symfony\Component\Validator\Constraints as Assert;

class GetProjects
{
    public function __construct(
        #[Assert\NotBlank]
        #[Assert\Uuid]
        public readonly string $userId
    ) {
    }
}

<?php

declare(strict_types=1);

namespace App\ProjectManagement\GetProjects\Query;

use App\ProjectManagement\Domain\Repository\ProjectRepository;
use App\ProjectManagement\GetProjects\ViewModel\ProjectViewModel;
use App\UserManagement\Domain\ValueObject\UserId;
use Symfony\Component\Messenger\Attribute\AsMessageHandler;

#[AsMessageHandler]
class GetProjectsHandler
{
    public function __construct(
        private readonly ProjectRepository $projectRepository
    ) {
    }

    public function __invoke(GetProjects $query): array
    {
        $projects = $this->projectRepository->findByMemberId(new UserId($query->userId));

        $result = [];

        foreach ($projects as $project) {
            $result[] = new ProjectViewModel(
                $project->id()->value(),
                $project->name(),
                $project->description(),
                $project->ownerId()->value(),
                count($project->memberIds()),
                $project->createdAt()
            );
        }

        return $result;
    }
}

<?php

declare(strict_types=1);

namespace App\TaskManagement\Domain\Service;

use App\TaskManagement\Domain\Model\Task;
use App\UserManagement\Domain\ValueObject\UserId;

class TaskAssignmentService
{
    // Doménová služba pracuje výhradně s objekty vlastního bounded contextu.
    // Ověření příslušnosti k projektu zajišťuje handler přes ProjectChecker port.
    public function assignTask(Task $task, UserId $assigneeId): void
    {
        $task->assign($assigneeId);
    }
}

<?php

declare(strict_types=1);

namespace App\ProjectManagement\Infrastructure\ReadModel;

use Doctrine\DBAL\Types\Types;
use Doctrine\ORM\Mapping as ORM;

#[ORM\Entity(readOnly: true)]
#[ORM\Table(name: 'project_list_view')]
#[ORM\Index(columns: ['owner_id'], name: 'idx_owner')]
#[ORM\Index(columns: ['member_ids'], name: 'idx_members', flags: ['gin'])]
class ProjectListView
{
    #[ORM\Id]
    #[ORM\Column(type: Types::GUID)]
    public string $projectId;

    #[ORM\Column(type: Types::STRING, length: 255)]
    public string $name;

    #[ORM\Column(type: Types::TEXT, nullable: true)]
    public ?string $description = null;

    #[ORM\Column(type: Types::GUID)]
    public string $ownerId;

    #[ORM\Column(type: Types::JSON)]
    public array $memberIds = [];

    #[ORM\Column(type: Types::INTEGER)]
    public int $memberCount = 0;

    #[ORM\Column(type: Types::INTEGER)]
    public int $taskCount = 0;

    #[ORM\Column(type: Types::DATETIME_IMMUTABLE)]
    public \DateTimeImmutable $createdAt;

    #[ORM\Column(type: Types::DATETIME_IMMUTABLE)]
    public \DateTimeImmutable $updatedAt;
}

<?php

declare(strict_types=1);

namespace App\ProjectManagement\Infrastructure\ReadModel;

use App\ProjectManagement\Domain\Event\MemberAdded;
use App\ProjectManagement\Domain\Event\MemberRemoved;
use App\ProjectManagement\Domain\Event\ProjectCreated;
use App\TaskManagement\Domain\Event\TaskCreated;
use Doctrine\ORM\EntityManagerInterface;
use Symfony\Component\Messenger\Attribute\AsMessageHandler;

#[AsMessageHandler]
class ProjectListProjection
{
    public function __construct(
        private readonly EntityManagerInterface $em
    ) {
    }

    public function __invoke(object $event): void
    {
        match (true) {
            $event instanceof ProjectCreated => $this->onProjectCreated($event),
            $event instanceof MemberAdded    => $this->onMemberAdded($event),
            $event instanceof MemberRemoved  => $this->onMemberRemoved($event),
            $event instanceof TaskCreated    => $this->onTaskCreated($event),
            default                          => null,
        };
    }

    private function onProjectCreated(ProjectCreated $event): void
    {
        $now = new \DateTimeImmutable();
        $view = new ProjectListView();
        $view->projectId = $event->projectId->value();
        $view->name = $event->name;
        $view->ownerId = $event->ownerId->value();
        $view->memberIds = [$event->ownerId->value()];
        $view->memberCount = 1;
        $view->taskCount = 0;
        $view->createdAt = $now;
        $view->updatedAt = $now;
        $this->em->persist($view);
        $this->em->flush();
    }

    private function onMemberAdded(MemberAdded $event): void
    {
        $view = $this->em->find(ProjectListView::class, $event->projectId->value());
        if ($view === null) {
            // Out-of-order delivery: MemberAdded přišlo dřív než ProjectCreated.
            // Reconciler (sekce 25.06.5) dohledá zaostalou view a obnoví ji
            // ze zdrojových agregátů.
            return;
        }
        $userId = $event->userId->value();
        if (!in_array($userId, $view->memberIds, strict: true)) {
            $view->memberIds[] = $userId;
            $view->memberCount++;
            $view->updatedAt = new \DateTimeImmutable();
            $this->em->flush();
        }
    }

    private function onMemberRemoved(MemberRemoved $event): void
    {
        $view = $this->em->find(ProjectListView::class, $event->projectId->value());
        if ($view === null) {
            return;
        }
        $userId = $event->userId->value();
        $view->memberIds = array_values(array_filter(
            $view->memberIds,
            static fn(string $id): bool => $id !== $userId
        ));
        $view->memberCount = count($view->memberIds);
        $view->updatedAt = new \DateTimeImmutable();
        $this->em->flush();
    }

    private function onTaskCreated(TaskCreated $event): void
    {
        $view = $this->em->find(ProjectListView::class, $event->projectId->value());
        if ($view === null) {
            return;
        }
        $view->taskCount++;
        $view->updatedAt = new \DateTimeImmutable();
        $this->em->flush();
    }
}

<?php

declare(strict_types=1);

namespace App\ProjectManagement\GetProjects\Query;

use App\ProjectManagement\GetProjects\ViewModel\ProjectViewModel;
use Doctrine\DBAL\Connection;
use Symfony\Component\Messenger\Attribute\AsMessageHandler;

#[AsMessageHandler]
class GetProjectsHandler
{
    public function __construct(
        private readonly Connection $db
    ) {
    }

    /** @return ProjectViewModel[] */
    public function __invoke(GetProjects $query): array
    {
        $rows = $this->db->fetchAllAssociative(
            'SELECT project_id, name, description, owner_id, member_count, task_count, created_at
             FROM project_list_view
             WHERE member_ids @> :userId
             ORDER BY updated_at DESC',
            ['userId' => json_encode([$query->userId])]
        );

        return array_map(
            static fn(array $row): ProjectViewModel => new ProjectViewModel(
                projectId:   $row['project_id'],
                name:        $row['name'],
                description: $row['description'],
                ownerId:     $row['owner_id'],
                memberCount: (int) $row['member_count'],
                taskCount:   (int) $row['task_count'],
                createdAt:   new \DateTimeImmutable($row['created_at']),
            ),
            $rows
        );
    }
}

<?php

declare(strict_types=1);

namespace App\ProjectManagement\Infrastructure\ReadModel;

use App\ProjectManagement\Domain\Repository\ProjectRepository;
use Doctrine\ORM\EntityManagerInterface;
use Symfony\Component\Console\Attribute\AsCommand;
use Symfony\Component\Console\Command\Command;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Output\OutputInterface;

#[AsCommand(
    name: 'project-list:reconcile',
    description: 'Dorovná zaostalý read model project_list_view ze zdrojových agregátů.',
)]
final class ReconcileProjectListView extends Command
{
    public function __construct(
        private readonly ProjectRepository $projects,
        private readonly EntityManagerInterface $em,
    ) {
        parent::__construct();
    }

    protected function execute(InputInterface $input, OutputInterface $output): int
    {
        $now = new \DateTimeImmutable();
        $repaired = 0;

        foreach ($this->projects->all() as $project) {
            $view = $this->em->find(ProjectListView::class, $project->id()->value());
            $expectedMembers = array_map(
                static fn($id) => $id->value(),
                $project->memberIds(),
            );

            if ($view === null) {
                $view = new ProjectListView();
                $view->projectId  = $project->id()->value();
                $view->ownerId    = $project->ownerId()->value();
                $view->createdAt  = $project->createdAt();
                $this->em->persist($view);
            }

            $needsRepair = $view->name !== $project->name()
                || $view->memberIds !== $expectedMembers
                || $view->memberCount !== count($expectedMembers);

            if (!$needsRepair) {
                continue;
            }

            $view->name        = $project->name();
            $view->description = $project->description();
            $view->memberIds   = $expectedMembers;
            $view->memberCount = count($expectedMembers);
            $view->updatedAt   = $now;
            $repaired++;
        }

        $this->em->flush();
        $output->writeln(sprintf('Dorovnáno %d projektů.', $repaired));

        return Command::SUCCESS;
    }
}