/**
* {@inheritdoc}
*/
public static function deserialize(array $data) : QueryMessage
{
$keys = ['id', 'type', 'timestamp', 'meta_data', 'payload_type', 'payload'];
foreach ($keys as $key) {
if (!isset($data[$key])) {
$message = sprintf('Invalid serialization data: %s', VarPrinter::toString($data));
throw new DomainException($message);
}
}
if ($data['type'] !== MessageType::QUERY) {
$message = sprintf('Invalid message type: %s', $data['type']);
throw new DomainException($message);
}
/** @var MessageId $id */
$id = MessageId::fromString($data['id']);
/** @var DateTime $timestamp */
$timestamp = DateTime::fromString($data['timestamp']);
/** @var MetaData $metaData */
$metaData = MetaData::create($data['meta_data']);
/** @var Type $payloadType */
$payloadType = Type::create($data['payload_type']);
/** @var string $payloadClass */
$payloadClass = $payloadType->toClassName();
assert(Validate::implementsInterface($payloadClass, Query::class), sprintf('Unable to deserialize: %s', $payloadClass));
/** @var Query $payload */
$payload = $payloadClass::fromArray($data['payload']);
return new static($id, $timestamp, $payload, $metaData);
}
/**
* Registers a command handler
*
* @param string $commandClass The full command class name
* @param CommandHandler $handler The command handler
*
* @return void
*
* @throws DomainException When the command class is not valid
*/
public function registerHandler(string $commandClass, CommandHandler $handler)
{
if (!Validate::implementsInterface($commandClass, Command::class)) {
$message = sprintf('Invalid command class: %s', $commandClass);
throw new DomainException($message);
}
$type = Type::create($commandClass)->toString();
$this->handlers[$type] = $handler;
}
/**
* Registers a query handler
*
* @param string $queryClass The full query class name
* @param string $serviceName The handler service name
*
* @return void
*
* @throws DomainException When the query class is not valid
*/
public function registerHandler(string $queryClass, string $serviceName)
{
if (!Validate::implementsInterface($queryClass, Query::class)) {
$message = sprintf('Invalid query class: %s', $queryClass);
throw new DomainException($message);
}
$type = Type::create($queryClass)->toString();
$this->handlers[$type] = $serviceName;
}
/**
* {@inheritdoc}
*/
public function deserialize(string $state) : Serializable
{
$data = json_decode($state, true);
$keys = ['@', '$'];
foreach ($keys as $key) {
if (!isset($data[$key])) {
$message = sprintf('Invalid serialization format: %s', $state);
throw new DomainException($message);
}
}
$class = ClassName::full($data['@']);
assert(Validate::implementsInterface($class, Serializable::class), sprintf('Unable to deserialize: %s', $class));
return $class::deserialize($data['$']);
}
/**
* Registers a subscriber service to handle events
*
* The subscriber class must implement:
* Novuso\Common\Domain\Messaging\Event\EventSubscriber
*
* @param string $className The subscriber class name
* @param string $serviceId The subscriber service ID
*
* @return void
*/
public function registerService(string $className, string $serviceId)
{
assert(Validate::implementsInterface($className, EventSubscriber::class), sprintf('Invalid subscriber class: %s', $className));
/** @var EventSubscriber $className The subscriber class name */
foreach ($className::eventRegistration() as $eventType => $params) {
if (is_string($params)) {
$this->addHandlerService($eventType, $serviceId, $params);
} elseif (is_string($params[0])) {
$priority = isset($params[1]) ? (int) $params[1] : 0;
$this->addHandlerService($eventType, $serviceId, $params[0], $priority);
} else {
foreach ($params as $handler) {
$priority = isset($handler[1]) ? (int) $handler[1] : 0;
$this->addHandlerService($eventType, $serviceId, $handler[0], $priority);
}
}
}
}
/**
* Creates collection of comparable items
*
* If a type is not provided, the item type is dynamic.
*
* The item type must be a fully-qualified class name that implements:
* `Novuso\System\Type\Comparable`
*
* @param string|null $itemType The item type
*
* @return SortedSet
*/
public static function comparable(string $itemType = null) : SortedSet
{
assert(Validate::isNull($itemType) || Validate::implementsInterface($itemType, Comparable::class), sprintf('%s expects $itemType to implement %s', __METHOD__, Comparable::class));
return new static(new ComparableComparator(), $itemType);
}
/**
* @dataProvider invalidImplementsProvider
*/
public function test_that_implements_interface_returns_false_for_invalid_value($value, $interface)
{
$this->assertFalse(Validate::implementsInterface($value, $interface));
}
