Lesson 3: Converters

Blog Documentation Github Support and Contact
Search…
PHP Conversion
Not having code for Lesson 3? 

git checkout lesson-3
Conversion
Command, queries and events are not always objects. When they travel via different channels, coming from outside, they are mostly converted to simplified format, like JSON or XML.  
At the level of application however we want to deal with it in PHP format, as objects or arrays.
Moving from one format to another requires conversion. Ecotone does provide extension point in which we can integrate different Media Type converters. 
Let's build our first converter from JSON to our PHP format. In order to do that, we will need to implement Converter interface and mark it with MediaTypeConverter().
1
<?php
2
​
3
namespace App\Domain\Product;
4
​
5
use Ecotone\Messaging\Attribute\MediaTypeConverter;
6
use Ecotone\Messaging\Conversion\Converter;
7
use Ecotone\Messaging\Conversion\MediaType;
8
use Ecotone\Messaging\Handler\TypeDescriptor;
9
​
10
#[MediaTypeConverter]
11
class JsonToPHPConverter implements Converter
12
{
13
    public function matches(TypeDescriptor $sourceType, MediaType $sourceMediaType, TypeDescriptor $targetType, MediaType $targetMediaType): bool
14
    {
15
​
16
    }
17
​
18
    public function convert($source, TypeDescriptor $sourceType, MediaType $sourceMediaType, TypeDescriptor $targetType, MediaType $targetMediaType)
19
    {
20
​
21
    }
22
}
Copied!
1.TypeDescriptor - Describes type in PHP format. This can be class, scalar (int, string), array etc. 
2.MediaType - Describes Media type format. This can be application/json, application/xml etc. 
3.$source - is the actual data to be converted. 
Let's start with implementing matches method. Which tells us, if this converter can do conversion from one type to another.
1
public function matches(TypeDescriptor $sourceType, MediaType $sourceMediaType, TypeDescriptor $targetType, MediaType $targetMediaType): bool
2
{
3
    return $sourceMediaType->isCompatibleWith(MediaType::createApplicationJson()) // if source media type is JSON
4
        && $targetMediaType->isCompatibleWith(MediaType::createApplicationXPHP()); // and target media type is PHP
5
}
Copied!
This will tell Ecotone that in case source media type is JSON and target media type is PHP, then it should use this converter. 
Now we need to implement the convert method now. We will do it with pretty naive solution, just to proof the concept. 
1
public function convert($source, TypeDescriptor $sourceType, MediaType $sourceMediaType, TypeDescriptor $targetType, MediaType $targetMediaType)
2
{
3
    $data = \json_decode($source, true, 512, JSON_THROW_ON_ERROR);
4
    // $targetType hold the class, which we will convert to
5
    switch ($targetType->getTypeHint()) {
6
        case RegisterProductCommand::class: {
7
            return RegisterProductCommand::fromArray($data);
8
        }
9
        case GetProductPriceQuery::class: {
10
            return GetProductPriceQuery::fromArray($data);
11
        }
12
        default: {
13
            throw new \InvalidArgumentException("Unknown conversion type");
14
        }
15
    }
16
}
Copied!
Normally you would inject into Converter class, some kind of serializer used within your application for example JMS Serializer or Symfony Serializer to make the conversion.
And let's add fromArray method to RegisterProductCommand and GetProductPriceQuery.
1
class GetProductPriceQuery
2
{
3
    private int $productId;
4
​
5
    public function __construct(int $productId)
6
    {
7
        $this->productId = $productId;
8
    }
9
​
10
    public static function fromArray(array $data) : self
11
    {
12
        return new self($data['productId']);
13
    }
Copied!
1
class RegisterProductCommand
2
{
3
    private int $productId;
4
​
5
    private int $cost;
6
​
7
    public function __construct(int $productId, int $cost)
8
    {
9
        $this->productId = $productId;
10
        $this->cost = $cost;
11
    }
12
​
13
    public static function fromArray(array $data) : self
14
    {
15
        return new self($data['productId'], $data['cost']);
16
    }
Copied!
Let's run our testing command:
1
bin/console ecotone:quickstart
2
Running example...
3
Product with id 1 was registered!
4
100
5
Good job, scenario ran with success!
Copied!
If we call our testing command now, everything is going fine, but we still send PHP objects instead of JSON, right?
In order to start sending commands and queries in different format, we need to provide our handlers with routing key. So Command and Query buses will know, where to route the message. 
You may think now of routing key, as a message name used in different CQRS frameworks in order to route the message to specific handler. This is yet much more powerful, and we will see why in next lessons. 
1
#[CommandHandler("product.register")]
2
public static function register(RegisterProductCommand $command) : self
3
{
4
    return new self($command->getProductId(), $command->getCost());
5
}
6
​
7
#[QueryHandler("product.getCost")] 
8
public function getCost(GetProductPriceQuery $query) : int
9
{
10
    return $this->cost;
11
}
Copied!
Let's change our Testing class, so we call buses with JSON format.
1
(...)
2
​
3
public function run() : void
4
{
5
    $this->commandBus->sendWithRouting("product.register", \json_encode(["productId" => 1, "cost" => 100]), "application/json");
6
​
7
    echo $this->queryBus->sendWithRouting("product.getCost", \json_encode(["productId" => 1]), "application/json");
8
}
Copied!
We make use of different method now convertAndSend. 
It takes as first argument routing key to which we want to send the message. 
The second argument describes the format of message we send.
Third is the data to send itself, in this case command formatted as JSON.
Let's run our testing command:
1
bin/console ecotone:quickstart
2
Running example...
3
Product with id 1 was registered!
4
100
5
Good job, scenario ran with success!
Copied!
Ecotone JMS Converter
Ecotone comes with integration with JMS Serializer and extending it with extra features.
Let's replace our own written Converter with JMS Serializer integration. 
Let's download the Converter using Composer. 
composer require ecotone/jms-converter
Let's remove __construct andfromArray methods from RegisterProductCommand GetProductPriceQuery and the App\Domain\Product\JsonToPHPConverter class completely, as we won't need it anymore.
Let's run our testing command:
1
bin/console ecotone:quickstart
2
Running example...
3
Product with id 1 was registered!
4
100
5
Good job, scenario ran with success!
Copied!
Do you wonder, how come, that we just deserialized our Command and Query classes without any additional code?
Well we already described those classes using type hints or docblocks. 
Ecotone JMS reads properties and deserializes according to type hint or docblock if it is array. 
1
Conversion Table examples:
2
​
3
private int $productId => int
4
​
5
private string $data => string
6
​
7
private \stdClass $data => \stdClass
8
 
9
/**
10
* @var \stdClass[] 
11
*/
12
private array $data => array<\stdClass>
Copied!
​
Let's imagine we found out, that we have bug in our software. Our system users have registered product with negative price, which in result lowered the bill. 
Product should be registered only with positive cost

We could put constraint in Product, validating the Cost amount. But this would assure us only in that place, that this constraint is met and we want to be sure, that the Cost is correct, whenever we make use of it, so we can avoid potential future bugs. 
To achieve that we will create Value Object named Costthat will handle the validation, during the construction. 
1
namespace App\Domain\Product;
2
​
3
class Cost
4
{
5
    private int $amount;
6
​
7
    public function __construct(int $amount)
8
    {
9
        if ($amount <= 0) {
10
            throw new \InvalidArgumentException("The cost cannot be negative or zero, {$amount} given.");
11
        }
12
        
13
        $this->amount = $amount;
14
    }
15
​
16
    public function getAmount() : int
17
    {
18
        return $this->amount;
19
    }
20
    
21
    public function __toString()
22
    {
23
        return (string)$this->amount;
24
    }
25
}
Copied!
Great, but where to convert the integer to the Cost class? We really don't want to burden our business logic with conversions. Ecotone JMS does provide extension points, so we can tell him, how to convert specific classes. 
Normally you will like to delegate conversion to Converters, as we want to get our domain classes converted as fast as we can. The business logic should stay clean, so it can focus on the domain problems, not technical problems.
Let's create class App\Infrastructure\Converter\CostConverter. We will put it in different namespace, to separate it from the domain.
1
namespace App\Infrastructure\Converter;
2
​
3
use App\Domain\Product\Cost;
4
use Ecotone\Messaging\Attribute\Converter;
5
​
6
class CostConverter
7
{
8
    #[Converter]
9
    public function convertFrom(Cost $cost) : int
10
    {
11
        return $cost->getAmount();
12
    }
13
​
14
    #[Converter]
15
    public function convertTo(int $amount) : Cost
16
    {
17
        return new Cost($amount);
18
    }
19
}
Copied!
We mark the methods withConverter(), so Ecotone can read parameter type and return type in order to know, how he can convert from scalar/array to specific class and vice versa.

Let's change our command and aggregate class, so it can use the Cost directly.
1
class RegisterProductCommand
2
{
3
    private int $productId;
4
​
5
    private Cost $cost;
6
​
7
    public function getProductId() : int
8
    {
9
        return $this->productId;
10
    }
11
​
12
    public function getCost() : Cost
13
    {
14
        return $this->cost;
15
    }
16
}
Copied!
The $cost class property will be automatically converted from integer to Costafter calling Command Bus.
1
class Product
2
{
3
    use WithAggregateEvents;
4
​
5
    #[AggregateIdentifier]
6
    private int $productId;
7
​
8
    private Cost $cost;
9
​
10
    private function __construct(int $productId, Cost $cost)
11
    {
12
        $this->productId = $productId;
13
        $this->cost = $cost;
14
​
15
        $this->recordThat(new ProductWasRegisteredEvent($productId));
16
    }
17
​
18
    #[CommandHandler("product.register")]
19
    public static function register(RegisterProductCommand $command) : self
20
    {
21
        return new self($command->getProductId(), $command->getCost());
22
    }
23
​
24
    #[QueryHandler("product.getCost")]
25
    public function getCost(GetProductPriceQuery $query) : Cost
26
    {
27
        return $this->cost;
28
    }
29
}
Copied!
Let's run our testing command:
1
bin/console ecotone:quickstart
2
Running example...
3
Product with id 1 was registered!
4
100
5
Good job, scenario ran with success!
Copied!
We have used Converter in order to construct the Cost object using constructor from string, to validate correctness of the incoming data. 
However you may find Native Conversion enough in your case without the need to create conversion methods.
To get more information, read Native Conversion​
The command which we send from outside (to the Command Bus) is still the same, as before. 
We changed the internals of the domain, without affecting consumers of our API. 
In this Lesson we learned how to make use of Converters.

Great, we just finished Lesson 3! 

In next Lesson we will learn and Method Invocation and Metadata
Lesson 2: Tactical DDD
Lesson 4: Metadata and Method Invocation
Last modified 1yr ago
Export as PDF
Copy link
Contents
Conversion
Ecotone JMS Converter