Praktické příklady

src/
├── Cart/                      # Bounded Context: Košík
│   ├── Domain/
│   │   ├── Model/Cart.php          # Aggregate Root
│   │   ├── Model/CartItem.php
│   │   ├── ValueObject/CartId.php, ProductId.php, Quantity.php, Money.php
│   │   ├── Event/ItemAddedToCart.php, CartCheckedOut.php
│   │   └── Repository/CartRepository.php
│   ├── Infrastructure/Repository/DoctrineCartRepository.php
│   ├── AddItem/{Command, Controller}/  # Feature slice
│   ├── GetCart/{Query, ViewModel}/     # Feature slice
│   └── Checkout/Controller/             # Feature slice
├── Order/                     # Bounded Context: Objednávky
│   ├── Domain/Model/Order.php          # Aggregate Root
│   ├── Domain/Event/OrderCreated.php
│   └── CreateOrder/{Command, Controller}/
└── Shared/Domain/Exception/DomainException.php

final class Cart extends AggregateRoot
{
    public readonly CartId $id;
    public readonly UserId $userId;
    /** @var Collection<int, CartItem> */
    private Collection $items;

    public static function open(CartId $id, UserId $userId): self { /* ... */ }

    public function addItem(ProductId $productId, Quantity $quantity, Money $price): void
    {
        // Invariant: pokud productId existuje, zvyš quantity; jinak přidej nový item.
        // Vyemituje ItemAddedToCart event.
    }

    public function removeItem(ProductId $productId): void { /* ... */ }
    public function totalAmount(): Money { /* sumace přes items */ }
    public function checkout(): void { /* invariant: cart nesmí být prázdný */ }
}

#[AsMessageHandler]
final class AddItemToCartHandler
{
    public function __construct(
        private CartRepository $cartRepository,
        private ProductRepository $productRepository,
    ) {}

    public function __invoke(AddItemToCart $command): void
    {
        $cart = $this->cartRepository->findByIdOrFail(new CartId($command->cartId));
        $product = $this->productRepository->findByIdOrFail(new ProductId($command->productId));

        $cart->addItem($product->id(), new Quantity($command->quantity), $product->price());

        $this->cartRepository->save($cart);
    }
}

src/
└── Blog/                      # Bounded Context: Blog
    ├── Domain/
    │   ├── Model/Post.php           # Aggregate Root
    │   ├── Model/Comment.php
    │   ├── ValueObject/PostId.php, CommentId.php, AuthorId.php
    │   ├── Event/PostCreated.php, CommentAdded.php
    │   └── Repository/PostRepository.php
    ├── Infrastructure/Repository/DoctrinePostRepository.php
    ├── CreatePost/{Command, Controller}/
    ├── GetPost/{Query, Controller, ViewModel}/
    └── GetPosts/{Query, Controller, ViewModel}/

final class Post extends AggregateRoot
{
    private function __construct(
        public readonly PostId $id,
        private string $title,
        private string $content,
        public readonly AuthorId $authorId,
        public readonly \DateTimeImmutable $createdAt,
    ) {
        $this->record(new PostCreated($id, $title, $authorId));
    }

    public static function create(PostId $id, string $title, string $content, AuthorId $authorId): self
    {
        // Invarianty: title 3–255 znaků, content nesmí být prázdný
        return new self($id, $title, $content, $authorId, new \DateTimeImmutable());
    }

    public function updateTitle(string $newTitle): void { /* ... */ }
    public function updateContent(string $newContent): void { /* ... */ }
}

#[AsMessageHandler]
final class CreatePostHandler
{
    public function __construct(private PostRepository $posts) {}

    public function __invoke(CreatePost $command): string
    {
        $post = Post::create(
            PostId::generate(),
            $command->title,
            $command->content,
            new AuthorId($command->authorId),
        );

        $this->posts->save($post);

        return $post->id->value();
    }
}

src/
└── UserManagement/            # Bounded Context: Správa uživatelů
    ├── Domain/
    │   ├── Model/User.php           # Aggregate Root
    │   ├── ValueObject/UserId.php, Email.php, HashedPassword.php
    │   ├── Event/UserRegistered.php
    │   └── Repository/UserRepository.php
    ├── Infrastructure/Repository/DoctrineUserRepository.php
    ├── Registration/{RegisterUser, RegisterUserHandler, RegistrationController}.php
    ├── Authentication/SecurityController.php
    └── Profile/{GetUserProfile, GetUserProfileHandler, ProfileController}.php

final class User extends AggregateRoot implements UserInterface, PasswordAuthenticatedUserInterface
{
    private function __construct(
        public readonly UserId $id,
        private string $name,
        private Email $email,
        private HashedPassword $password,
        public readonly \DateTimeImmutable $createdAt,
    ) {
        $this->record(new UserRegistered($id, $email));
    }

    public static function register(UserId $id, string $name, Email $email, HashedPassword $password): self
    {
        return new self($id, $name, $email, $password, new \DateTimeImmutable());
    }

    public function changeEmail(Email $newEmail): void { /* invariant: nový != starý */ }
    public function changeName(string $newName): void { /* ... */ }

    // UserInterface
    public function getRoles(): array { return ['ROLE_USER']; }
    public function getUserIdentifier(): string { return $this->email->value(); }
    public function getPassword(): ?string { return $this->password->hash(); }
    public function eraseCredentials(): void {}
}

#[AsMessageHandler]
final class RegisterUserHandler
{
    public function __construct(
        private UserRepository $users,
        private UserPasswordHasherInterface $passwordHasher,
    ) {}

    public function __invoke(RegisterUser $command): void
    {
        $email = new Email($command->email);

        // Invariant na úrovni handleru: email musí být unikátní (DB unique constraint
        // je pojistka pro race condition, viz Implementace v Symfony, sekce 11.13).
        if ($this->users->findByEmail($email) !== null) {
            throw new \DomainException('User with this email already exists.');
        }

        $user = User::register(
            UserId::generate(),
            $command->name,
            $email,
            HashedPassword::fromHasher($this->passwordHasher, $command->password),
        );

        $this->users->save($user);
    }
}