README

$ composer require whsv26/mediator

Bundle configuration

// config/packages/mediator.php

return static function (MediatorConfig $config) {
 $config->bus()
 ->query('query.bus') // query bus service id
 ->command('command.bus') // command bus service id
 ->event('event.bus'); // event bus service id
};

Enable psalm plugin (optional)

To check command and query return type compatibility with corresponding handler return type

$ vendor/bin/psalm-plugin enable Whsv26\\Mediator\\Psalm\\Plugin

Commands

/**
 * @implements CommandInterface<UserId>
 */
class CreateUserCommand implements CommandInterface
{
 public function __construct(
 public readonly string $email,
 public readonly string $password,
 ) { }
}

class CreateUserCommandHandler implements MessageHandlerInterface
{
 public function __construct(
 private readonly UserRepository $users,
 private readonly HasherInterface $hasher,
 private readonly ClockInterface $clock,
 private readonly MediatorInterface $mediator,
 ) { }

 public function __invoke(CreateUserCommand $command): UserId
 {
 $user = new User(
 UserId::next(),
 new Email($command->email),
 new PlainPassword($command->password),
 $this->hasher,
 $this->clock
 );

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

 // Publish domain events to subscribers 
 $this->mediator->publish($user->pullDomainEvents());

 return $user->getId();
 }
}

class CreateUserAction
{
 public function __construct(
 private readonly MediatorInterface $mediator
 ) { }

 #[Route(path: '/users', name: self::class, methods: ['POST'])]
 public function __invoke(CreateUserCommand $createUser): string
 {
 // $createUser deserialized from request body
 // via custom controller argument value resolver
 
 return $this->mediator
 ->sendCommand($createUser)
 ->value;
 }
}

Queries

/**
 * @implements QueryInterface<Option<User>>
 */
class FindUserQuery implements QueryInterface
{
 public function __construct(
 public readonly ?string $id = null,
 public readonly ?string $email = null,
 ) { }
}

class FindUserQueryHandler implements MessageHandlerInterface
{
 public function __construct(
 private readonly UserRepository $users,
 ) { }

 /**
 * @param FindUserQuery $query
 * @return Option<User>
 */
 public function __invoke(FindUserQuery $query): Option
 {
 return Option::fromNullable($query->id)
 ->map(fn(string $id) => new UserId($id))
 ->flatMap(fn(UserId $id) => $this->users->findById($id))
 ->orElse(fn() => Option::fromNullable($query->email)
 ->map(fn(string $email) => new Email($email))
 ->flatMap(fn(Email $email) => $this->users->findByEmail($email))
 );
 }
}