Ubiquitous Language

File structure

Application

Domain

Infra

UI

Controllers, Console commands, Form types, DTOs

Symfony Kernel, CQRS Commands/Handlers, ...

Your domain logic ... the most important part.

Doctrine, Redis, Guzzle, ....

File structure

.
├── App
│   ├── Command
│   │   └── CreateUserCommand.php
│   ├── CommandHandler
│   │   └── CreateUser.php
│   └── SymfonyBundle
│       └── MyBundle.php
├── Domain
│   ├── User.php
│   └── UserRepositoryInterface.php
├── Infra
│   └── DoctrineORM
│       ├── Resources
│       │   └── User.orm.xml
│       └── UserRepository.php
└── UI
    ├── Controller
    │   └── UserController.php
    └── Rest
        └── UserNormalizer.php

Model driven design

The model should express your domain

class User
{
    private $firstname;
    private $lastname;
    private $enabled;

    public function setFirstname(string $firstname): User
    {
        $this->firstname = $firstname;
        return $this;
    }

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

    public function setLastname(string $lastname): User
    {
        $this->lastname = $lastname;
        return $this;
    }

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

    public function setEnabled(bool $enabled): User
    {
        $this->enabled = $enabled;
        return $this;
    }

    public function getEnabled(): bool
    {
        return $this->enabled;
    }
}

<?php

// user creation
$user = new User();
$user->setFirstname('Chuck');
$user->setLastname('Norris');
$user->setEnabled(false);

// user rename
$user->setFirstname('Bruce');
$user->setLastname('Lee');

// user enable
$user->setEnabled(true);

User state can be inconsistent

Do not express the intention

SGBD automatism ?

class User
{
    private $firstname;
    private $lastname;
    private $enabled;

    public function __construct(string $firstname, string $lastname)
    {
        $this->firstname = $firstname;
        $this->lastname = $lastname;
        $this->enabled = false;
    }

    public function rename(string $firstname, string $lastname): void
    {
        $this->firstname = $firstname;
        $this->lastname = $lastname;
    }

    public function enable(): void
    {
        $this->enabled = true;
    }

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

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

    public function isEnabled(): bool
    {
        return $this->enabled;
    }
}

<?php

// user creation
$user = new User('Chuck', 'Norris');

// user rename
$user->rename('Bruce', 'Lee');

// user enable
$user->enable();

User state is always consistent

Express the domain

At this moment, we can't disable an user ? It's ok ...

Please ... don't be lazy

Value object

• Model without an identity.
• Immutable state
• Edition should create a new instance
• Some examples: (dates, prices, addresses, ...)

$start = new \DateTime('08:00:00');
$end = $start->modify('12:00:00');

var_dump($start); // ... 12:00:00 <--- OOPS

$start = new \DateTimeImmutable('08:00:00');
$end = $start->modify('12:00:00');

var_dump($start); // ... 08:00:00

Entity

• Model with an identity.
• Avoid auto-generated Ids

use Ramsey\Uuid\UuidInterface;

class User
{
    private $id;
    private $firstname;

    public function __construct(UuidInterface $id, $firstname, ...)
    {
        $this->id = $id;
        $this->firstname = $firstname;
    }
}

Aggregate

Group models around an aggregate root

Create relation only between aggregate roots

EventSourcing needs

Bounded contexts

It's a subdomain

Bounded contexts

Models can be different between bounded contexts

Microservice approach

Isolated: A model cannot communicate with a model outside of its BC.

Communication between BC via Events/Commands/Queries (SAGA)

Models are lighter 

Responsability separation

Easier to find a feature

• 1st commit in 2014
• +70 repositories in github
• Active collaborators
• Can be used with Symfony/Laravel
• Great documentation

Trending repositories

prooph/service-bus

prooph/event-store

prooph/event-sourcing

prooph/proophessor-do

Separate writes and reads in your application.

Title Text

Buses

In computer architecture, a bus is a communication system that transfers data between components inside a computer, or between computers. 

Command bus: 1 handler which returns nothing

Query bus: 1 finder which returns a promise

Event bus: 0,n handler which returns nothing

Can be executed through 

• direct
• amqp
• http
• ...

prooph_service_bus:
  command_buses:
    synchronous_command_bus: ~
    asynchronous_command_bus:
      router:
        # Should implement Prooph\ServiceBus\Async\MessageProducer
        async_switch: 'your_producer_service' 

<?php
$bus = $container->get('prooph_service_bus.asynchronous_command_bus');
$bus->dispatch(
    Acme\Command\RegisterUser::withData('uuid ...', 'chuck', 'chuck@norris.tld')
);

Async producer through bernard/bernard in

wakeonweb/service-bus-bundle

Command

<?php

namespace Prooph\ProophessorDo\Model\User\Command;

/** uses **/

final class RegisterUser extends Command implements PayloadConstructable
{
    use PayloadTrait;

    public static function withData(UuidInterface $userId, string $name, string $email): RegisterUser
    {
        return new self([
            'user_id' => (string) $userId,
            'name' => $name,
            'email' => $email,
        ]);
    }

    public function userId(): UuidInterface
    {
        return Uuid::fromString($this->payload['user_id']);
    }

    protected function setPayload(array $payload): void
    {
        Assertion::keyExists($payload, 'user_id');
        Assertion::uuid($payload['user_id']);
        Assertion::keyExists($payload, 'name');
        Assertion::string($payload['name']);
        Assertion::keyExists($payload, 'email');
        $validator = new EmailAddressValidator();
        Assertion::true($validator->isValid($payload['email']));

        $this->payload = $payload;
    }
}

Command Handler

<?php

declare(strict_types=1);

namespace Prooph\ProophessorDo\Model\User\Handler;

/** uses **/

class RegisterUserHandler
{
    public function __invoke(RegisterUser $command): void
    {
        // Do your logic here.
    }
}

Prooph\ProophessorDo\Model\User\Handler\RegisterUserHandler:
        arguments:
        public: true
        tags:
            - { name: 'prooph_service_bus.synchronous_command_bus.route_target', message_detection: true }

Define the command handler as service.

Route it on your bus

Query finder

<?php

namespace Prooph\ProophessorDo\Model\User\Handler;

/** uses **/

class GetAllUsersHandler
{
    public function __invoke(GetAllUsers $query, Deferred $deferred = null)
    {
        //$users = ...;

        if (null === $deferred) {
            return $users;
        }

        $deferred->resolve($users);
    }
}

<?php

$users = [];
$this->queryBus
    ->dispatch(new GetAllUsers())
    ->then(
        function (\stdClass $result = null) use (&$users) {
            $users = $result;
        }
    );

Usage:

Why ?

- Separate Write & Read (Apps do 90% of read)

- Async/Sync writes, switch is easy.

- Reuse your commands/queries

- Writes depends only on a bus

- Cache management

Store events to define the present

1. added 2 “Product 1“ to its cart
2. added 1 “Product 2“ to its cart
3. removed “Product 1“ from its cart 

Legacy approach

It misses a lot of informations

What happens if business ask how many Product 1 has been added to a cart ?

Database storage:

ES approach

[{
    "uuid": "956b8f20-818f-4cd7-af42-6f97e20a7c77",
    "event": "ProductAddedToCart",
    "created_at": "2018-02-26T13:37:00Z",
    "payload": {"product": "product 1", "quantity": "2"}}
},
{
    "uuid": "956b8f20-818f-4cd7-af42-6f97e20a7c77",
    "event": "ProductAddedToCart",
    "created_at": "2018-02-26T15:38:00Z",
    "payload": {"product": "product 2", "quantity": "1"}}
},
{
    "uuid": "956b8f20-818f-4cd7-af42-6f97e20a7c77",
    "event": "ProductRemovedFromCart",
    "created_at": "2018-02-26T15:39:00Z",
    "payload": {"product": "product 1"}}
}]

Event store

+

Projection(s)

Read: Projections

Write: Reconstitute the aggregate root

“What about performances ?

If I have 5000 events by aggregate root“

You can drop then recreate your snapshots ...

Create a snapshot of your aggregate root each X events ...

Snapshots

Create as many projections as you want

Projections

Updated asynchronously

On demand: Create, update, reconstruct ...

Without ES

Client: Yesterday at 08:30pm client X had

a 500 when he tried to add product Y to its cart

• logs
• database
• ...
• var_dump($x); exit;

With ES

Client: Yesterday at 08:30pm client X had

a 500 when he tried to add product Y to its cart

• logs
• replay all events until failing event
• reproduce error ...
• Add a test with this scenario ...

In Prooph

All theses concepts are implemented \o/

EventStore (product) not implemented

PDO event store driver available

A bit of code to use it.

In Prooph

1 event stream per aggregate

1 event stream per aggregate type

1 event stream for all

With PDO

1 event stream = 1 table

Strategies:

prooph_event_store:
    stores:
        cart_store:
            event_store: Prooph\EventStore\Pdo\MySqlEventStore
            repositories:
                cart_list:
                    repository_class: Acme\Cart\Infra\Repository\EventStoreCartList
                    aggregate_type: Acme\Cart\Domain\Cart
                    aggregate_translator: prooph_event_sourcing.aggregate_translator

    projection_managers:
        cart_projection_manager:
            event_store: Prooph\EventStore\Pdo\MySqlEventStore
            connection: 'doctrine.pdo.connection'
            projections:
                cart_projection:
                    read_model: Acme\Cart\Infra\Projection\CartReadModel
                    projection: Acme\Cart\Infra\Projection\CartProjection

Projections

Aggregate root

Symfony

final class Cart extends AggregateRoot implements Entity
{
    // ....

    public function addProduct(
        UuidInterface $productId,
        int $quantity
    ): User {
        $self->recordThat(ProductWasAddedToCart::withData(
            $this->cartId, 
            $productId, 
            $quantity
        ));
    }

    protected function whenProductWasAddedToCart(ProductWasAddedToCart $event): void
    {
        if ($this->products->has($event->getProductId()) {
            $this->products->get($event->getProductId())->incrementQuantity($event->getQuantity());
            return;
        }

        $this->products->add($event->getProductId(), $event->getQuantity());
    }

    //....
}

Aggregate root

final class ProductWasAddedToCart extends AggregateChanged
{
    public static function withData(UuidInterface $cartId, UuidInterface $productId, int $quantity)
    {
        return self::occur($cartId->toString(), [
            'product_id' => $productId->toString(),
            'quantity' => $quantity
        ]);

        return $event;
    }

    public function getCartId(): UuidInterface
    {
        return Uuid::fromString($this->aggregateId());
    }

    public function getProductId(): UuidInterface
    {
        return Uuid::fromString($this->payload['user_id']);
    }

    // ....
}

Event

<?php

namespace Acme\Cart\Infra\Repository;

final class EventStoreCartList extends AggregateRepository implements CartList
{
    public function save(Cart $cart): void
    {
        $this->saveAggregateRoot($cart);
        // store all new events raised into event store.
    }

    public function get(UuidInterface $uuid): ?Cart
    {
        return $this->getAggregateRoot($uuid->toString());
        // fetch all events from event store then handle them.
    }
}

Cart list (repository)

<?php

namespace Acme\Cart\Domain\Repository;

interface CartList
{
    public function save(Cart $cart): void;

    public function get(UuidInterface $uuid): ?Cart;
}

class AddProductToCartHandler
{
    private $cartList;

    public function __construct(CartList $cartList)
    {
        $this->cartList = $cartList;
    }

    public function __invoke(AddProductToCart $command): void
    {
        $cart = $this->cartList->get($command->getCartId());

        if (!$cart) {
            throw CartNotFound::withCartId($command->getCartId());
        }

        $cart->addProduct($command->getProductId(), $command->getQuantity());

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

Command handler

<?php

final class CartReadModel extends AbstractReadModel
{
    public function init(): void
    {
        $sql = <<<EOF
CREATE TABLE `cart_items` (
  `cart_id` varchar(36) COLLATE utf8_unicode_ci NOT NULL,
  `product_id` varchar(36) COLLATE utf8_unicode_ci NOT NULL,
  // .........
EOF;

        $statement = $this->connection->prepare($sql);
        $statement->execute();
    }

    public function isInitialized(): bool {} // is table exists
    public function reset(): void {} // truncate
    public function delete(): void {} // drop table

    protected function insert(array $data): void
    {
        $this->connection->insert('cart_items', $data);
    }

    protected function delete(array $data, array $identifier): void {} // do delete
}

Projections: read model

final class CartProjection implements ReadModelProjection
{

    public function project(ReadModelProjector $projector): ReadModelProjector
    {
        $projector->fromStream('event_stream')
            ->when([
                ProductWasAddedToCart::class => function ($state, ProductWasAddedToCart $event) {
                    $readModel = $this->readModel();
                    $readModel->stack('insert', [
                        'cart_id' => $event->getCartId()->toString(),
                        'product_id' => $event->getProductId()->toString(),
                        'quantity' => $event->getQuantity()
                    ]);
                },
                ProductWasRemovedFromCart::class => function ($state, ProductWasRemovedFromCart $event) {
                    $readModel = $this->readModel();
                    $readModel->stack(
                        'delete',
                        [
                            'cart_id' => $event->getCartId()->toString(),
                            'product_id' => $event->getProductId()->toString(),
                        ],
                    );
                },
            ]);

        return $projector;
    }
}

Projections

Projections

Projection listening ...

php bin/console event-store:projection:run cart_projection

Projection states in your data storage

Documentation

Domain Driven Design by Eric Evans

DDD vite fait (en français)

VIP: @martin fowler,  @eric evans, @mathias verraes

Sagas with prooph

Distributed SAGAS

Event Sourcing by Matthieu Moquet