├── .gitignore
├── phpstan.neon
├── .scrutinizer.yml
├── tests
    ├── bootstrap.php
    ├── Prooph
    │   ├── configs
    │   │   ├── ServiceBusConfiguratorTests
    │   │   │   ├── QueryBusConfiguratorTest.neon
    │   │   │   ├── EventBusConfiguratorTest.neon
    │   │   │   └── CommandBusConfiguratorTest.neon
    │   │   ├── EventStoreConfiguratorTest.neon
    │   │   ├── AsynchronousMessages
    │   │   │   ├── AsynchronousEventProducerTest.neon
    │   │   │   ├── AsynchronousQueryProducerTest.neon
    │   │   │   └── AsynchronousCommandProducerTest.neon
    │   │   ├── EventSourcingConfiguratorTest.neon
    │   │   ├── ProjectionManagerTests
    │   │   │   ├── MysqlProjectionManagerTest.neon
    │   │   │   └── MariaDbProjectionManagerTest.neon
    │   │   └── FullTestConfig.neon
    │   ├── ProjectionManager
    │   │   ├── FakePDOFactory.php
    │   │   ├── MysqlProjectionManagerConfiguratorTest.php
    │   │   └── MariaDbProjectionManagerConfiguratorTest.php
    │   ├── ProophExtensionTest.php
    │   ├── EventStore
    │   │   └── EventStoreConfiguratorTest.php
    │   ├── EventSourcing
    │   │   ├── FakeImplementations
    │   │   │   ├── TestAggregateCreated.php
    │   │   │   ├── TestAggregateRoot.php
    │   │   │   └── MemoryTestRepository.php
    │   │   └── EventSourcingConfiguratorTest.php
    │   ├── ServiceBus
    │   │   └── ServiceBusConfigurators
    │   │   │   ├── CommandBusConfiguratorTest.php
    │   │   │   ├── EventBusConfiguratorTest.php
    │   │   │   └── QueryBusConfiguratorTest.php
    │   ├── AsynchronousMessages
    │   │   ├── FakeImplementations
    │   │   │   └── TestAsynchronousMessageProducerBridge.php
    │   │   ├── Configurators
    │   │   │   ├── AsynchronousEventProducerConfiguratorTest.php
    │   │   │   ├── AsynchronousQueryProducerConfiguratorTest.php
    │   │   │   └── AsynchronousCommandProducerConfiguratorTest.php
    │   │   ├── Factories
    │   │   │   └── AbstractAsynchronousMessageProducerFactoryTest.php
    │   │   └── AsynchronousMessageProducerTest.php
    │   ├── ProophExtensionTestCase.php
    │   └── Common
    │   │   └── NetteContainerWrapperTest.php
    └── phpunit.xml
├── src
    ├── AsynchronousMessages
    │   ├── AsynchronousMessageProducerBridge.php
    │   ├── Factories
    │   │   ├── AsynchronousEventProducerFactory.php
    │   │   ├── AsynchronousQueryProducerFactory.php
    │   │   ├── AsynchronousCommandProducerFactory.php
    │   │   └── AbstractAsynchronousMessageProducerFactory.php
    │   ├── Configurators
    │   │   ├── AsynchronousEventProducerConfigurator.php
    │   │   ├── AsynchronousQueryProducerConfigurator.php
    │   │   ├── AsynchronousCommandProducerConfigurator.php
    │   │   └── AbstractAsynchronousProducerConfigurator.php
    │   ├── AsynchronousMessagesConfigurator.php
    │   └── AsynchronousMessageProducer.php
    ├── Common
    │   ├── Configurator.php
    │   ├── NetteContainerWrapper
    │   │   ├── ContainerException.php
    │   │   └── NotFoundException.php
    │   ├── DefaultConfigurator.php
    │   ├── CompositeConfigurator.php
    │   └── NetteContainerWrapper.php
    ├── ServiceBus
    │   ├── ServiceBusConfigurators
    │   │   ├── EventBusConfigurator.php
    │   │   ├── QueryBusConfigurator.php
    │   │   ├── CommandBusConfigurator.php
    │   │   └── AbstractBusConfigurator.php
    │   └── ServiceBusesConfigurator.php
    ├── ProophExtensionConfigurator.php
    ├── EventStore
    │   └── EventStoreConfigurator.php
    ├── EventSourcing
    │   └── EventSourcingConfigurator.php
    ├── ProjectionManager
    │   └── ProjectionManagerConfigurator.php
    └── ProophExtension.php
├── .travis.yml
├── composer.json
├── LICENSE
├── docs
    ├── KeepLearning.md
    ├── Configuration.md
    └── AsynchronousMessaging.md
└── README.md


/.gitignore:
--------------------------------------------------------------------------------
1 | vendor
2 | .idea
3 | 


--------------------------------------------------------------------------------
/phpstan.neon:
--------------------------------------------------------------------------------
1 | parameters:
2 | 	bootstrap: %rootDir%/../../../tests/bootstrap.php
3 | 


--------------------------------------------------------------------------------
/.scrutinizer.yml:
--------------------------------------------------------------------------------
1 | tools:
2 |     external_code_coverage: true
3 | 
4 | checks:
5 |     php:
6 |         code_rating: true
7 | 


--------------------------------------------------------------------------------
/tests/bootstrap.php:
--------------------------------------------------------------------------------
1 | <?php declare(strict_types = 1);
2 | 
3 | define('TEST_DIR', __DIR__);
4 | define('TEMP_DIR', __DIR__ . '/../temp/');
5 | 
6 | require_once __DIR__ . '/../vendor/autoload.php';
7 | 


--------------------------------------------------------------------------------
/src/AsynchronousMessages/AsynchronousMessageProducerBridge.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace LidskaSila\Prooph\AsynchronousMessages;
 4 | 
 5 | interface AsynchronousMessageProducerBridge
 6 | {
 7 | 
 8 | 	public function publishWithRoutingKey($routingKey, $data): void;
 9 | }
10 | 


--------------------------------------------------------------------------------
/tests/Prooph/configs/ServiceBusConfiguratorTests/QueryBusConfiguratorTest.neon:
--------------------------------------------------------------------------------
 1 | extensions:
 2 |     prooph: LidskaSila\Prooph\ProophExtension
 3 | 
 4 | prooph:
 5 | 	service_bus:
 6 | 		query_bus:
 7 | 			plugins:
 8 | 			router:
 9 | 				routes:
10 | 
11 | services:
12 | 	- Prooph\Common\Messaging\FQCNMessageFactory
13 | 


--------------------------------------------------------------------------------
/src/Common/Configurator.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types = 1);
 2 | 
 3 | namespace LidskaSila\Prooph\Common;
 4 | 
 5 | interface Configurator
 6 | {
 7 | 
 8 | 	public function getConfigKey(): ?string;
 9 | 
10 | 	public function buildDefaultConfig(): array;
11 | 
12 | 	public function loadConfiguration(array $config): void;
13 | }
14 | 


--------------------------------------------------------------------------------
/src/Common/NetteContainerWrapper/ContainerException.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types = 1);
 2 | 
 3 | namespace LidskaSila\Prooph\Common\NetteContainerWrapper;
 4 | 
 5 | use Exception;
 6 | use Psr\Container\NotFoundExceptionInterface;
 7 | 
 8 | class ContainerException extends Exception implements NotFoundExceptionInterface
 9 | {
10 | 
11 | }
12 | 


--------------------------------------------------------------------------------
/src/Common/NetteContainerWrapper/NotFoundException.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types = 1);
 2 | 
 3 | namespace LidskaSila\Prooph\Common\NetteContainerWrapper;
 4 | 
 5 | use Exception;
 6 | use Psr\Container\NotFoundExceptionInterface;
 7 | 
 8 | class NotFoundException extends Exception implements NotFoundExceptionInterface
 9 | {
10 | 
11 | }
12 | 


--------------------------------------------------------------------------------
/tests/Prooph/ProjectionManager/FakePDOFactory.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types = 1);
 2 | 
 3 | namespace LidskaSila\Prooph\Tests\ProjectionManager;
 4 | 
 5 | use Mockery;
 6 | use PDO;
 7 | 
 8 | class FakePDOFactory
 9 | {
10 | 
11 | 	public static function create(): PDO
12 | 	{
13 | 		$fakePDO = Mockery::mock('\PDO');
14 | 		assert($fakePDO instanceof PDO);
15 | 
16 | 		return $fakePDO;
17 | 	}
18 | }
19 | 


--------------------------------------------------------------------------------
/tests/Prooph/configs/ServiceBusConfiguratorTests/EventBusConfiguratorTest.neon:
--------------------------------------------------------------------------------
 1 | extensions:
 2 |     prooph: LidskaSila\Prooph\ProophExtension
 3 | 
 4 | prooph:
 5 | 	service_bus:
 6 | 		event_bus:
 7 | 			plugins:
 8 | 				- Prooph\ServiceBus\Plugin\InvokeStrategy\OnEventStrategy
 9 | 			router:
10 | 				routes:
11 | 
12 | services:
13 | 	- Prooph\ServiceBus\Plugin\InvokeStrategy\OnEventStrategy
14 | 	- Prooph\Common\Messaging\FQCNMessageFactory
15 | 


--------------------------------------------------------------------------------
/tests/Prooph/configs/EventStoreConfiguratorTest.neon:
--------------------------------------------------------------------------------
 1 | extensions:
 2 |     prooph: LidskaSila\Prooph\ProophExtension
 3 | 
 4 | prooph:
 5 | 	event_store:
 6 | 		use:
 7 | 			config: default
 8 | 			factory: Prooph\EventStore\Container\InMemoryEventStoreFactory
 9 | 		default:
10 | 			plugins:
11 | 				- Prooph\EventStoreBusBridge\EventPublisher
12 | services:
13 | 	- Prooph\EventStoreBusBridge\EventPublisher
14 | 	- Prooph\Common\Messaging\FQCNMessageFactory
15 | 


--------------------------------------------------------------------------------
/tests/Prooph/configs/ServiceBusConfiguratorTests/CommandBusConfiguratorTest.neon:
--------------------------------------------------------------------------------
 1 | extensions:
 2 |     prooph: LidskaSila\Prooph\ProophExtension
 3 | 
 4 | prooph:
 5 | 	service_bus:
 6 | 		command_bus:
 7 | 			plugins:
 8 | 				- Prooph\ServiceBus\Plugin\InvokeStrategy\HandleCommandStrategy
 9 | 			router:
10 | 				routes:
11 | 
12 | services:
13 | 	- Prooph\ServiceBus\Plugin\InvokeStrategy\HandleCommandStrategy
14 | 	- Prooph\Common\Messaging\FQCNMessageFactory
15 | 


--------------------------------------------------------------------------------
/src/AsynchronousMessages/Factories/AsynchronousEventProducerFactory.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types = 1);
 2 | 
 3 | namespace LidskaSila\Prooph\AsynchronousMessages\Factories;
 4 | 
 5 | class AsynchronousEventProducerFactory extends AbstractAsynchronousMessageProducerFactory
 6 | {
 7 | 
 8 | 	public const SECTION_CONFIG_ID = 'events';
 9 | 
10 | 	public function __construct(string $configId = self::SECTION_CONFIG_ID)
11 | 	{
12 | 		parent::__construct($configId);
13 | 	}
14 | }
15 | 


--------------------------------------------------------------------------------
/src/AsynchronousMessages/Factories/AsynchronousQueryProducerFactory.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types = 1);
 2 | 
 3 | namespace LidskaSila\Prooph\AsynchronousMessages\Factories;
 4 | 
 5 | class AsynchronousQueryProducerFactory extends AbstractAsynchronousMessageProducerFactory
 6 | {
 7 | 
 8 | 	public const SECTION_CONFIG_ID = 'queries';
 9 | 
10 | 	public function __construct(string $configId = self::SECTION_CONFIG_ID)
11 | 	{
12 | 		parent::__construct($configId);
13 | 	}
14 | }
15 | 


--------------------------------------------------------------------------------
/src/AsynchronousMessages/Factories/AsynchronousCommandProducerFactory.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types = 1);
 2 | 
 3 | namespace LidskaSila\Prooph\AsynchronousMessages\Factories;
 4 | 
 5 | class AsynchronousCommandProducerFactory extends AbstractAsynchronousMessageProducerFactory
 6 | {
 7 | 
 8 | 	public const SECTION_CONFIG_ID = 'commands';
 9 | 
10 | 	public function __construct(string $configId = self::SECTION_CONFIG_ID)
11 | 	{
12 | 		parent::__construct($configId);
13 | 	}
14 | }
15 | 


--------------------------------------------------------------------------------
/tests/Prooph/configs/AsynchronousMessages/AsynchronousEventProducerTest.neon:
--------------------------------------------------------------------------------
 1 | extensions:
 2 |     prooph: LidskaSila\Prooph\ProophExtension
 3 | 
 4 | prooph:
 5 | 	asynchronous_messaging:
 6 | 		events:
 7 | 			bridge: "@producerBridge"
 8 | 			routes:
 9 | 				MessageName: producerRouteKey
10 | 
11 | services:
12 | 	producerBridge: LidskaSila\Prooph\Tests\AsynchronousMessages\FakeImplementations\TestAsynchronousMessageProducerBridge
13 | 	- Prooph\Common\Messaging\NoOpMessageConverter
14 | 


--------------------------------------------------------------------------------
/tests/Prooph/configs/AsynchronousMessages/AsynchronousQueryProducerTest.neon:
--------------------------------------------------------------------------------
 1 | extensions:
 2 |     prooph: LidskaSila\Prooph\ProophExtension
 3 | 
 4 | prooph:
 5 | 	asynchronous_messaging:
 6 | 		queries:
 7 | 			bridge: "@producerBridge"
 8 | 			routes:
 9 | 				MessageName: producerRouteKey
10 | 
11 | services:
12 | 	producerBridge: LidskaSila\Prooph\Tests\AsynchronousMessages\FakeImplementations\TestAsynchronousMessageProducerBridge
13 | 	- Prooph\Common\Messaging\NoOpMessageConverter
14 | 


--------------------------------------------------------------------------------
/tests/Prooph/configs/AsynchronousMessages/AsynchronousCommandProducerTest.neon:
--------------------------------------------------------------------------------
 1 | extensions:
 2 |     prooph: LidskaSila\Prooph\ProophExtension
 3 | 
 4 | prooph:
 5 | 	asynchronous_messaging:
 6 | 		commands:
 7 | 			bridge: "@producerBridge"
 8 | 			routes:
 9 | 				MessageName: producerRouteKey
10 | 
11 | services:
12 | 	producerBridge: LidskaSila\Prooph\Tests\AsynchronousMessages\FakeImplementations\TestAsynchronousMessageProducerBridge
13 | 	- Prooph\Common\Messaging\NoOpMessageConverter
14 | 


--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
 1 | language: php
 2 | 
 3 | cache:
 4 |   directories:
 5 |     - $HOME/.composer/cache
 6 | 
 7 | php:
 8 |   - 7.1
 9 | 
10 | before_script:
11 |   - composer self-update
12 |   - composer update
13 | 
14 | script:
15 |   # run
16 |   - mkdir temp
17 |   - vendor/bin/phpstan analyse -l 7 -c phpstan.neon src tests
18 |   - vendor/bin/phpunit --configuration tests/phpunit.xml tests
19 | 
20 | after_script:
21 |   # upload clover.xml file to Scrutinizer to analyze it
22 |   - |
23 |     wget https://scrutinizer-ci.com/ocular.phar
24 |     php ocular.phar code-coverage:upload --format=php-clover tests/temp/clover.xml
25 | 


--------------------------------------------------------------------------------
/src/AsynchronousMessages/Configurators/AsynchronousEventProducerConfigurator.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types = 1);
 2 | 
 3 | namespace LidskaSila\Prooph\AsynchronousMessages\Configurators;
 4 | 
 5 | use LidskaSila\Prooph\AsynchronousMessages\Factories\AsynchronousEventProducerFactory;
 6 | 
 7 | class AsynchronousEventProducerConfigurator extends AbstractAsynchronousProducerConfigurator
 8 | {
 9 | 
10 | 	public function getProducerFactoryClass(): string
11 | 	{
12 | 		return AsynchronousEventProducerFactory::class;
13 | 	}
14 | 
15 | 	public function getConfigKey(): string
16 | 	{
17 | 		return AsynchronousEventProducerFactory::SECTION_CONFIG_ID;
18 | 	}
19 | }
20 | 


--------------------------------------------------------------------------------
/src/AsynchronousMessages/Configurators/AsynchronousQueryProducerConfigurator.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types = 1);
 2 | 
 3 | namespace LidskaSila\Prooph\AsynchronousMessages\Configurators;
 4 | 
 5 | use LidskaSila\Prooph\AsynchronousMessages\Factories\AsynchronousQueryProducerFactory;
 6 | 
 7 | class AsynchronousQueryProducerConfigurator extends AbstractAsynchronousProducerConfigurator
 8 | {
 9 | 
10 | 	public function getProducerFactoryClass(): string
11 | 	{
12 | 		return AsynchronousQueryProducerFactory::class;
13 | 	}
14 | 
15 | 	public function getConfigKey(): string
16 | 	{
17 | 		return AsynchronousQueryProducerFactory::SECTION_CONFIG_ID;
18 | 	}
19 | }
20 | 


--------------------------------------------------------------------------------
/src/AsynchronousMessages/Configurators/AsynchronousCommandProducerConfigurator.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types = 1);
 2 | 
 3 | namespace LidskaSila\Prooph\AsynchronousMessages\Configurators;
 4 | 
 5 | use LidskaSila\Prooph\AsynchronousMessages\Factories\AsynchronousCommandProducerFactory;
 6 | 
 7 | class AsynchronousCommandProducerConfigurator extends AbstractAsynchronousProducerConfigurator
 8 | {
 9 | 
10 | 	public function getProducerFactoryClass(): string
11 | 	{
12 | 		return AsynchronousCommandProducerFactory::class;
13 | 	}
14 | 
15 | 	public function getConfigKey(): string
16 | 	{
17 | 		return AsynchronousCommandProducerFactory::SECTION_CONFIG_ID;
18 | 	}
19 | }
20 | 


--------------------------------------------------------------------------------
/src/ServiceBus/ServiceBusConfigurators/EventBusConfigurator.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types = 1);
 2 | 
 3 | namespace LidskaSila\Prooph\ServiceBus\ServiceBusConfigurators;
 4 | 
 5 | use Prooph\ServiceBus\Container\EventBusFactory;
 6 | use Prooph\ServiceBus\EventBus;
 7 | 
 8 | class EventBusConfigurator extends AbstractBusConfigurator
 9 | {
10 | 
11 | 	public const KEY_EVENT_BUS = 'event_bus';
12 | 
13 | 	public function getBusClass(): string
14 | 	{
15 | 		return EventBus::class;
16 | 	}
17 | 
18 | 	public function getBusFactoryClass(): string
19 | 	{
20 | 		return EventBusFactory::class;
21 | 	}
22 | 
23 | 	public function getConfigKey(): string
24 | 	{
25 | 		return self::KEY_EVENT_BUS;
26 | 	}
27 | }
28 | 


--------------------------------------------------------------------------------
/src/ServiceBus/ServiceBusConfigurators/QueryBusConfigurator.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types = 1);
 2 | 
 3 | namespace LidskaSila\Prooph\ServiceBus\ServiceBusConfigurators;
 4 | 
 5 | use Prooph\ServiceBus\Container\QueryBusFactory;
 6 | use Prooph\ServiceBus\QueryBus;
 7 | 
 8 | class QueryBusConfigurator extends AbstractBusConfigurator
 9 | {
10 | 
11 | 	public const KEY_QUERY_BUS = 'query_bus';
12 | 
13 | 	public function getBusClass(): string
14 | 	{
15 | 		return QueryBus::class;
16 | 	}
17 | 
18 | 	public function getBusFactoryClass(): string
19 | 	{
20 | 		return QueryBusFactory::class;
21 | 	}
22 | 
23 | 	public function getConfigKey(): string
24 | 	{
25 | 		return self::KEY_QUERY_BUS;
26 | 	}
27 | }
28 | 


--------------------------------------------------------------------------------
/tests/Prooph/ProophExtensionTest.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types = 1);
 2 | 
 3 | namespace LidskaSila\Prooph\Tests;
 4 | 
 5 | use LidskaSila\Prooph\Tests\Configurators\ProophExtensionTestCase;
 6 | use Nette\Configurator;
 7 | use Nette\DI\Compiler;
 8 | 
 9 | class ProophExtensionTest extends ProophExtensionTestCase
10 | {
11 | 
12 | 	public function testGenerateContainer_WithConfiguredExtension_ShouldPass()
13 | 	{
14 | 		$config = $this->givenTestConfig('FullTestConfig.neon');
15 | 
16 | 		$this->whenGenerateContainer($config);
17 | 
18 | 		$this->thenPass();
19 | 	}
20 | 
21 | 	protected function whenGenerateContainer(Configurator $config)
22 | 	{
23 | 		$config->generateContainer(new Compiler());
24 | 	}
25 | }
26 | 


--------------------------------------------------------------------------------
/src/ServiceBus/ServiceBusConfigurators/CommandBusConfigurator.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types = 1);
 2 | 
 3 | namespace LidskaSila\Prooph\ServiceBus\ServiceBusConfigurators;
 4 | 
 5 | use Prooph\ServiceBus\CommandBus;
 6 | use Prooph\ServiceBus\Container\CommandBusFactory;
 7 | 
 8 | class CommandBusConfigurator extends AbstractBusConfigurator
 9 | {
10 | 
11 | 	public const KEY_COMMAND_BUS = 'command_bus';
12 | 
13 | 	public function getBusClass(): string
14 | 	{
15 | 		return CommandBus::class;
16 | 	}
17 | 
18 | 	public function getBusFactoryClass(): string
19 | 	{
20 | 		return CommandBusFactory::class;
21 | 	}
22 | 
23 | 	public function getConfigKey(): string
24 | 	{
25 | 		return self::KEY_COMMAND_BUS;
26 | 	}
27 | }
28 | 


--------------------------------------------------------------------------------
/tests/Prooph/EventStore/EventStoreConfiguratorTest.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types = 1);
 2 | 
 3 | namespace LidskaSila\Prooph\Tests\EventStore;
 4 | 
 5 | use LidskaSila\Prooph\Tests\Configurators\ProophExtensionTestCase;
 6 | use Prooph\EventStore\EventStore;
 7 | 
 8 | class EventStoreConfiguratorTest extends ProophExtensionTestCase
 9 | {
10 | 	private const TEST_CONFIG_PATH = 'EventStoreConfiguratorTest.neon';
11 | 
12 | 	public function testGetEventStoreByType_FromTestContainer_ShouldReturnExpectedInstance()
13 | 	{
14 | 		$this->givenTestContainer(self::TEST_CONFIG_PATH);
15 | 
16 | 		$repository = $this->whenGetServiceByTypeFromContainer(EventStore::class);
17 | 
18 | 		$this->thenIsInstanceOfExpectedClass(EventStore::class, $repository);
19 | 	}
20 | }
21 | 


--------------------------------------------------------------------------------
/tests/phpunit.xml:
--------------------------------------------------------------------------------
 1 | <phpunit
 2 | 		backupGlobals="false"
 3 | 		backupStaticAttributes="false"
 4 | 		colors="true"
 5 | 		convertErrorsToExceptions="true"
 6 | 		convertNoticesToExceptions="true"
 7 | 		convertWarningsToExceptions="true"
 8 | 		processIsolation="false"
 9 | 		stopOnFailure="false"
10 | 		syntaxCheck="false"
11 | 		bootstrap="bootstrap.php"
12 | >
13 | 
14 | 	<filter>
15 | 		<whitelist>
16 | 			<directory suffix=".php">../src</directory>
17 | 		</whitelist>
18 | 	</filter>
19 | 	<logging>
20 | 		<log
21 | 				showOnlySummary="true"
22 | 				showUncoveredFiles="true"
23 | 				target="php://stdout"
24 | 				type="coverage-text"
25 | 		/>
26 | 		<log type="coverage-clover" target="temp/clover.xml"/>
27 | 		<log type="coverage-html" target="temp/coverage-html"/>
28 | 	</logging>
29 | </phpunit>
30 | 


--------------------------------------------------------------------------------
/tests/Prooph/EventSourcing/FakeImplementations/TestAggregateCreated.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types = 1);
 2 | 
 3 | namespace LidskaSila\Prooph\Tests\EventSourcing\FakeImplementations;
 4 | 
 5 | use Prooph\EventSourcing\AggregateChanged;
 6 | use Prooph\ServiceBus\Async\AsyncMessage;
 7 | use Ramsey\Uuid\UuidInterface;
 8 | 
 9 | class TestAggregateCreated extends AggregateChanged implements AsyncMessage
10 | {
11 | 
12 | 	private const TEST_PAYLOAD_KEY   = 'key';
13 | 	private const TEST_PAYLOAD_VALUE = 'value';
14 | 	public const TEST_PAYLOAD = [
15 | 				self::TEST_PAYLOAD_KEY => self::TEST_PAYLOAD_VALUE,
16 | 			];
17 | 
18 | 	public static function create(UuidInterface $uuid): AggregateChanged
19 | 	{
20 | 		return self::occur(
21 | 			$uuid->toString(),
22 | 			self::TEST_PAYLOAD
23 | 		);
24 | 	}
25 | }
26 | 


--------------------------------------------------------------------------------
/src/Common/DefaultConfigurator.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types = 1);
 2 | 
 3 | namespace LidskaSila\Prooph\Common;
 4 | 
 5 | use LidskaSila\Prooph\ProophExtension;
 6 | use Nette\DI\ContainerBuilder;
 7 | 
 8 | abstract class DefaultConfigurator implements Configurator
 9 | {
10 | 
11 | 	/** @var ProophExtension */
12 | 	public $extension;
13 | 
14 | 	public function __construct(ProophExtension $extension)
15 | 	{
16 | 		$this->extension = $extension;
17 | 	}
18 | 
19 | 	protected function getContainerBuilder(): ContainerBuilder
20 | 	{
21 | 		return $this->extension->getContainerBuilder();
22 | 	}
23 | 
24 | 	public function getContainerWrapperServiceId()
25 | 	{
26 | 		$containerBuilder = $this->getContainerBuilder();
27 | 
28 | 		return $containerBuilder->getByType(NetteContainerWrapper::class);
29 | 	}
30 | }
31 | 


--------------------------------------------------------------------------------
/tests/Prooph/EventSourcing/FakeImplementations/TestAggregateRoot.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types = 1);
 2 | 
 3 | namespace LidskaSila\Prooph\Tests\EventSourcing\FakeImplementations;
 4 | 
 5 | use Prooph\EventSourcing\AggregateChanged;
 6 | use Prooph\EventSourcing\AggregateRoot;
 7 | use Ramsey\Uuid\Uuid;
 8 | use Ramsey\Uuid\UuidInterface;
 9 | 
10 | class TestAggregateRoot extends AggregateRoot
11 | {
12 | 
13 | 	public static function create(UuidInterface $uuid = null)
14 | 	{
15 | 		$uuid = $uuid ?: Uuid::uuid4();
16 | 		$instance = new self();
17 | 		$instance->recordThat(TestAggregateCreated::create($uuid));
18 | 
19 | 		return $instance;
20 | 	}
21 | 
22 | 	protected function aggregateId(): string
23 | 	{
24 | 		return 'fake';
25 | 	}
26 | 
27 | 	protected function apply(AggregateChanged $event): void
28 | 	{
29 | 	}
30 | }
31 | 


--------------------------------------------------------------------------------
/tests/Prooph/ServiceBus/ServiceBusConfigurators/CommandBusConfiguratorTest.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types = 1);
 2 | 
 3 | namespace LidskaSila\Prooph\Tests\ServiceBus\ServiceBusConfigurators;
 4 | 
 5 | use LidskaSila\Prooph\Tests\Configurators\ProophExtensionTestCase;
 6 | use Prooph\ServiceBus\CommandBus;
 7 | 
 8 | class CommandBusConfiguratorTest extends ProophExtensionTestCase
 9 | {
10 | 	private const TEST_CONFIG_PATH = 'ServiceBusConfiguratorTests/CommandBusConfiguratorTest.neon';
11 | 
12 | 	public function testGetServiceBusByType_FromTestContainer_ShouldReturnExpectedInstance()
13 | 	{
14 | 		$this->givenTestContainer(self::TEST_CONFIG_PATH);
15 | 
16 | 		$repository = $this->whenGetServiceByTypeFromContainer(CommandBus::class);
17 | 
18 | 		$this->thenIsInstanceOfExpectedClass(CommandBus::class, $repository);
19 | 	}
20 | }
21 | 


--------------------------------------------------------------------------------
/tests/Prooph/ServiceBus/ServiceBusConfigurators/EventBusConfiguratorTest.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types = 1);
 2 | 
 3 | namespace LidskaSila\Prooph\Tests\ServiceBus\Configurators\ServiceBusConfigurators;
 4 | 
 5 | use LidskaSila\Prooph\Tests\Configurators\ProophExtensionTestCase;
 6 | use Prooph\ServiceBus\EventBus;
 7 | 
 8 | class EventBusConfiguratorTest extends ProophExtensionTestCase
 9 | {
10 | 	private const TEST_CONFIG_PATH = 'ServiceBusConfiguratorTests/CommandBusConfiguratorTest.neon';
11 | 
12 | 	public function testGetServiceBusByType_FromTestContainer_ShouldReturnExpectedInstance()
13 | 	{
14 | 		$this->givenTestContainer(self::TEST_CONFIG_PATH);
15 | 
16 | 		$repository = $this->whenGetServiceByTypeFromContainer(EventBus::class);
17 | 
18 | 		$this->thenIsInstanceOfExpectedClass(EventBus::class, $repository);
19 | 	}
20 | }
21 | 


--------------------------------------------------------------------------------
/tests/Prooph/ServiceBus/ServiceBusConfigurators/QueryBusConfiguratorTest.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types = 1);
 2 | 
 3 | namespace LidskaSila\Prooph\Tests\ServiceBus\Configurators\ServiceBusConfigurators;
 4 | 
 5 | use LidskaSila\Prooph\Tests\Configurators\ProophExtensionTestCase;
 6 | use Prooph\ServiceBus\QueryBus;
 7 | 
 8 | class QueryBusConfiguratorTest extends ProophExtensionTestCase
 9 | {
10 | 
11 | 	private const TEST_CONFIG_PATH = 'ServiceBusConfiguratorTests/CommandBusConfiguratorTest.neon';
12 | 
13 | 	public function testGetServiceBusByType_FromTestContainer_ShouldReturnExpectedInstance()
14 | 	{
15 | 		$this->givenTestContainer(self::TEST_CONFIG_PATH);
16 | 
17 | 		$repository = $this->whenGetServiceByTypeFromContainer(QueryBus::class);
18 | 
19 | 		$this->thenIsInstanceOfExpectedClass(QueryBus::class, $repository);
20 | 	}
21 | }
22 | 


--------------------------------------------------------------------------------
/tests/Prooph/EventSourcing/EventSourcingConfiguratorTest.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types = 1);
 2 | 
 3 | namespace LidskaSila\Prooph\Tests\EventSourcing;
 4 | 
 5 | use LidskaSila\Prooph\Tests\Configurators\ProophExtensionTestCase;
 6 | use LidskaSila\Prooph\Tests\EventSourcing\FakeImplementations\MemoryTestRepository;
 7 | 
 8 | class EventSourcingConfiguratorTest extends ProophExtensionTestCase
 9 | {
10 | 
11 | 	private const TEST_CONFIG_PATH = 'EventSourcingConfiguratorTest.neon';
12 | 
13 | 	public function testGetRepositoryByType_FromTestContainer_ShouldReturnExpectedInstance()
14 | 	{
15 | 		$this->givenTestContainer(self::TEST_CONFIG_PATH);
16 | 
17 | 		$repository = $this->whenGetServiceByTypeFromContainer(MemoryTestRepository::class);
18 | 
19 | 		$this->thenIsInstanceOfExpectedClass(MemoryTestRepository::class, $repository);
20 | 	}
21 | }
22 | 


--------------------------------------------------------------------------------
/tests/Prooph/AsynchronousMessages/FakeImplementations/TestAsynchronousMessageProducerBridge.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types = 1);
 2 | 
 3 | namespace LidskaSila\Prooph\Tests\AsynchronousMessages\FakeImplementations;
 4 | 
 5 | use LidskaSila\Prooph\AsynchronousMessages\AsynchronousMessageProducerBridge;
 6 | 
 7 | class TestAsynchronousMessageProducerBridge implements AsynchronousMessageProducerBridge
 8 | {
 9 | 
10 | 	public const KEY_ROUTING_KEY = 'routingKey';
11 | 	public const KEY_DATA        = 'data';
12 | 
13 | 	private $published = [];
14 | 
15 | 	public function publishWithRoutingKey($routingKey, $data): void
16 | 	{
17 | 		$this->published[] = [
18 | 			self::KEY_ROUTING_KEY => $routingKey,
19 | 			self::KEY_DATA        => $data,
20 | 		];
21 | 	}
22 | 
23 | 	public function getPublished()
24 | 	{
25 | 		return $this->published;
26 | 	}
27 | }
28 | 


--------------------------------------------------------------------------------
/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name" : "lidskasila/prooph",
 3 |   "description" : "Nette extension for original Prooph toolbox of CQRS and EventSourcing Infrastructure for PHP.",
 4 |   "license" : "MIT",
 5 |   "autoload" : {
 6 | 	"psr-4" : {
 7 | 	  "LidskaSila\\Prooph\\" : "src/"
 8 | 	}
 9 |   },
10 |   "require" : {
11 | 	"php" : ">=7.0",
12 | 	"prooph/event-sourcing" : "^5.2",
13 | 	"prooph/service-bus": "^6.0",
14 | 	"psr/container": "^1.0",
15 | 	"sandrokeil/interop-config": "^2.1",
16 | 	"prooph/event-store-bus-bridge": "^3.0",
17 | 	"nette/di" : "^2.4",
18 | 	"prooph/pdo-event-store" : "^1.5"
19 |   },
20 |   "autoload-dev" : {
21 | 	"classmap" : [
22 | 	  "tests/"
23 | 	]
24 |   },
25 |   "require-dev": {
26 | 	"mockery/mockery": "^0.9",
27 | 	"phpunit/phpunit": "^6.2",
28 |     "nette/bootstrap": "^2.4",
29 |     "phpstan/phpstan": "^0.7",
30 |     "react/promise": "^2.5"
31 |   }
32 | }
33 | 


--------------------------------------------------------------------------------
/tests/Prooph/ProjectionManager/MysqlProjectionManagerConfiguratorTest.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types = 1);
 2 | 
 3 | namespace LidskaSila\Prooph\Tests\ProjectionManager;
 4 | 
 5 | use LidskaSila\Prooph\Tests\Configurators\ProophExtensionTestCase;
 6 | use Prooph\EventStore\Pdo\Projection\MySqlProjectionManager;
 7 | use Prooph\EventStore\Projection\ProjectionManager;
 8 | 
 9 | class MysqlProjectionManagerConfiguratorTest extends ProophExtensionTestCase
10 | {
11 | 
12 | 	private const TEST_CONFIG_PATH = 'ProjectionManagerTests/MysqlProjectionManagerTest.neon';
13 | 
14 | 	public function testGetEventStoreByType_FromTestContainer_ShouldReturnExpectedInstance()
15 | 	{
16 | 		$this->givenTestContainer(self::TEST_CONFIG_PATH);
17 | 
18 | 		$repository = $this->whenGetServiceByTypeFromContainer(ProjectionManager::class);
19 | 
20 | 		$this->thenIsInstanceOfExpectedClass(MySqlProjectionManager::class, $repository);
21 | 	}
22 | }
23 | 


--------------------------------------------------------------------------------
/tests/Prooph/ProjectionManager/MariaDbProjectionManagerConfiguratorTest.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types = 1);
 2 | 
 3 | namespace LidskaSila\Prooph\Tests\ProjectionManager;
 4 | 
 5 | use LidskaSila\Prooph\Tests\Configurators\ProophExtensionTestCase;
 6 | use Prooph\EventStore\Pdo\Projection\MariaDbProjectionManager;
 7 | use Prooph\EventStore\Projection\ProjectionManager;
 8 | 
 9 | class MariaDbProjectionManagerConfiguratorTest extends ProophExtensionTestCase
10 | {
11 | 
12 | 	private const TEST_CONFIG_PATH = 'ProjectionManagerTests/MariaDbProjectionManagerTest.neon';
13 | 
14 | 	public function testGetEventStoreByType_FromTestContainer_ShouldReturnExpectedInstance()
15 | 	{
16 | 		$this->givenTestContainer(self::TEST_CONFIG_PATH);
17 | 
18 | 		$repository = $this->whenGetServiceByTypeFromContainer(ProjectionManager::class);
19 | 
20 | 		$this->thenIsInstanceOfExpectedClass(MariaDbProjectionManager::class, $repository);
21 | 	}
22 | }
23 | 


--------------------------------------------------------------------------------
/tests/Prooph/configs/EventSourcingConfiguratorTest.neon:
--------------------------------------------------------------------------------
 1 | extensions:
 2 |     prooph: LidskaSila\Prooph\ProophExtension
 3 | 
 4 | prooph:
 5 | 	event_sourcing:
 6 | 		aggregate_repository:
 7 | 			test_repository:
 8 | 				repository_class: LidskaSila\Prooph\Tests\EventSourcing\FakeImplementations\MemoryTestRepository
 9 | 				aggregate_type: LidskaSila\Prooph\Tests\EventSourcing\FakeImplementations\TestAggregateRoot
10 | 				aggregate_translator: Prooph\EventSourcing\EventStoreIntegration\AggregateTranslator
11 | 				one_stream_per_aggregate: true
12 | 
13 | 	event_store:
14 | 		use:
15 | 			config: default
16 | 			factory: Prooph\EventStore\Container\InMemoryEventStoreFactory
17 | 		default:
18 | 			plugins:
19 | 				- Prooph\EventStoreBusBridge\EventPublisher
20 | 
21 | services:
22 | 	- Prooph\EventSourcing\EventStoreIntegration\AggregateTranslator
23 | 	- Prooph\EventStoreBusBridge\EventPublisher
24 | 	- Prooph\Common\Messaging\FQCNMessageFactory
25 | 


--------------------------------------------------------------------------------
/tests/Prooph/AsynchronousMessages/Configurators/AsynchronousEventProducerConfiguratorTest.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types = 1);
 2 | 
 3 | namespace LidskaSila\Prooph\Tests\AsynchronousMessages;
 4 | 
 5 | use LidskaSila\Prooph\AsynchronousMessages\AsynchronousMessageProducer;
 6 | use LidskaSila\Prooph\Tests\Configurators\ProophExtensionTestCase;
 7 | 
 8 | class AsynchronousEventProducerConfiguratorTest extends ProophExtensionTestCase
 9 | {
10 | 
11 | 	const TEST_CONFIG           = 'AsynchronousMessages/AsynchronousEventProducerTest.neon';
12 | 	const EXPECTED_SERVICE_NAME = 'prooph.asynchronous_messaging.events';
13 | 
14 | 	public function testGet_FromTestContainer_ShouldReturnExpectedInstance()
15 | 	{
16 | 		$this->givenTestContainer(self::TEST_CONFIG);
17 | 
18 | 		$producer = $this->whenGetServiceByNameFromContainer(self::EXPECTED_SERVICE_NAME);
19 | 
20 | 		$this->thenIsInstanceOfExpectedClass(AsynchronousMessageProducer::class, $producer);
21 | 	}
22 | }
23 | 


--------------------------------------------------------------------------------
/tests/Prooph/AsynchronousMessages/Configurators/AsynchronousQueryProducerConfiguratorTest.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types = 1);
 2 | 
 3 | namespace LidskaSila\Prooph\Tests\AsynchronousMessages;
 4 | 
 5 | use LidskaSila\Prooph\AsynchronousMessages\AsynchronousMessageProducer;
 6 | use LidskaSila\Prooph\Tests\Configurators\ProophExtensionTestCase;
 7 | 
 8 | class AsynchronousQueryProducerConfiguratorTest extends ProophExtensionTestCase
 9 | {
10 | 
11 | 	const TEST_CONFIG           = 'AsynchronousMessages/AsynchronousQueryProducerTest.neon';
12 | 	const EXPECTED_SERVICE_NAME = 'prooph.asynchronous_messaging.queries';
13 | 
14 | 	public function testGet_FromTestContainer_ShouldReturnExpectedInstance()
15 | 	{
16 | 		$this->givenTestContainer(self::TEST_CONFIG);
17 | 
18 | 		$producer = $this->whenGetServiceByNameFromContainer(self::EXPECTED_SERVICE_NAME);
19 | 
20 | 		$this->thenIsInstanceOfExpectedClass(AsynchronousMessageProducer::class, $producer);
21 | 	}
22 | }
23 | 


--------------------------------------------------------------------------------
/tests/Prooph/AsynchronousMessages/Configurators/AsynchronousCommandProducerConfiguratorTest.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types = 1);
 2 | 
 3 | namespace LidskaSila\Prooph\Tests\AsynchronousMessages;
 4 | 
 5 | use LidskaSila\Prooph\AsynchronousMessages\AsynchronousMessageProducer;
 6 | use LidskaSila\Prooph\Tests\Configurators\ProophExtensionTestCase;
 7 | 
 8 | class AsynchronousCommandProducerConfiguratorTest extends ProophExtensionTestCase
 9 | {
10 | 
11 | 	const TEST_CONFIG           = 'AsynchronousMessages/AsynchronousCommandProducerTest.neon';
12 | 	const EXPECTED_SERVICE_NAME = 'prooph.asynchronous_messaging.commands';
13 | 
14 | 	public function testGet_FromTestContainer_ShouldReturnExpectedInstance()
15 | 	{
16 | 		$this->givenTestContainer(self::TEST_CONFIG);
17 | 
18 | 		$producer = $this->whenGetServiceByNameFromContainer(self::EXPECTED_SERVICE_NAME);
19 | 
20 | 		$this->thenIsInstanceOfExpectedClass(AsynchronousMessageProducer::class, $producer);
21 | 	}
22 | }
23 | 


--------------------------------------------------------------------------------
/tests/Prooph/EventSourcing/FakeImplementations/MemoryTestRepository.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types = 1);
 2 | 
 3 | namespace LidskaSila\Prooph\Tests\EventSourcing\FakeImplementations;
 4 | 
 5 | use Prooph\EventSourcing\Aggregate\AggregateRepository;
 6 | use Prooph\EventStore\TransactionalActionEventEmitterEventStore;
 7 | use Ramsey\Uuid\UuidInterface;
 8 | 
 9 | class MemoryTestRepository extends AggregateRepository
10 | {
11 | 
12 | 	/**
13 | 	 * @var TransactionalActionEventEmitterEventStore
14 | 	 */
15 | 	protected $eventStore;
16 | 
17 | 	public function save(TestAggregateRoot $testAggregateRoot): void
18 | 	{
19 | 		$this->eventStore->beginTransaction();
20 | 		$this->saveAggregateRoot($testAggregateRoot);
21 | 		$this->eventStore->commit();
22 | 	}
23 | 
24 | 	public function load(UuidInterface $uuid): TestAggregateRoot
25 | 	{
26 | 		/** @var TestAggregateRoot $testAggregateRoot */
27 | 		$testAggregateRoot = $this->getAggregateRoot($uuid->toString());
28 | 
29 | 		return $testAggregateRoot;
30 | 	}
31 | }
32 | 
33 | 


--------------------------------------------------------------------------------
/src/ServiceBus/ServiceBusesConfigurator.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types = 1);
 2 | 
 3 | namespace LidskaSila\Prooph\ServiceBus;
 4 | 
 5 | use LidskaSila\Prooph\Common\CompositeConfigurator;
 6 | use LidskaSila\Prooph\Common\Configurator;
 7 | use LidskaSila\Prooph\ServiceBus\ServiceBusConfigurators\CommandBusConfigurator;
 8 | use LidskaSila\Prooph\ServiceBus\ServiceBusConfigurators\EventBusConfigurator;
 9 | use LidskaSila\Prooph\ServiceBus\ServiceBusConfigurators\QueryBusConfigurator;
10 | 
11 | class ServiceBusesConfigurator extends CompositeConfigurator
12 | {
13 | 
14 | 	public const KEY_SERVICE_BUS = 'service_bus';
15 | 
16 | 	public function getConfigKey(): string
17 | 	{
18 | 		return self::KEY_SERVICE_BUS;
19 | 	}
20 | 
21 | 	/**
22 | 	 * @return Configurator[]|string[]
23 | 	 */
24 | 	protected function createConfigurators(): array
25 | 	{
26 | 		return [
27 | 			new CommandBusConfigurator($this->extension),
28 | 			new EventBusConfigurator($this->extension),
29 | 			new QueryBusConfigurator($this->extension),
30 | 		];
31 | 	}
32 | }
33 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | Copyright (c) 2017 Tom?? ???ek
 2 | 
 3 | Permission is hereby granted, free of charge, to any person obtaining a copy of
 4 | this software and associated documentation files (the "Software"), to deal in
 5 | the Software without restriction, including without limitation the rights to
 6 | use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
 7 | of the Software, and to permit persons to whom the Software is furnished to do
 8 | so, subject to the following conditions:
 9 | 
10 | The above copyright notice and this permission notice shall be included in all
11 | copies or substantial portions of the Software.
12 | 
13 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
14 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
15 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
16 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
17 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
18 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
19 | SOFTWARE.
20 | 
21 | 


--------------------------------------------------------------------------------
/tests/Prooph/AsynchronousMessages/Factories/AbstractAsynchronousMessageProducerFactoryTest.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types = 1);
 2 | 
 3 | namespace LidskaSila\Prooph\Tests\AsynchronousMessages;
 4 | 
 5 | use InvalidArgumentException;
 6 | use LidskaSila\Prooph\AsynchronousMessages\Factories\AbstractAsynchronousMessageProducerFactory;
 7 | use PHPUnit\Framework\TestCase;
 8 | 
 9 | class AbstractAsynchronousMessageProducerFactoryTest extends TestCase
10 | {
11 | 
12 | 	public function testCallStatic_WithoutContainerWrapper_ShouldThrowInvalidArgumentException()
13 | 	{
14 | 		$this->willFailWith(InvalidArgumentException::class);
15 | 
16 | 		$this->whenCallStaticWithoutContainerWrapper();
17 | 	}
18 | 
19 | 	private function willFailWith($class)
20 | 	{
21 | 		self::expectException(InvalidArgumentException::class);
22 | 	}
23 | 
24 | 	private function whenCallStaticWithoutContainerWrapper(): void
25 | 	{
26 | 		$factoryClass = $this->getFactoryClass();
27 | 		$factoryClass::testWithoutContainerWrapper();
28 | 	}
29 | 
30 | 	private function getFactoryClass(): string
31 | 	{
32 | 		return AbstractAsynchronousMessageProducerFactory::class;
33 | 	}
34 | }
35 | 


--------------------------------------------------------------------------------
/src/AsynchronousMessages/AsynchronousMessagesConfigurator.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types = 1);
 2 | 
 3 | namespace LidskaSila\Prooph\AsynchronousMessages;
 4 | 
 5 | use LidskaSila\Prooph\AsynchronousMessages\Configurators\AsynchronousCommandProducerConfigurator;
 6 | use LidskaSila\Prooph\AsynchronousMessages\Configurators\AsynchronousEventProducerConfigurator;
 7 | use LidskaSila\Prooph\AsynchronousMessages\Configurators\AsynchronousQueryProducerConfigurator;
 8 | use LidskaSila\Prooph\Common\CompositeConfigurator;
 9 | use LidskaSila\Prooph\Common\Configurator;
10 | 
11 | class AsynchronousMessagesConfigurator extends CompositeConfigurator
12 | {
13 | 
14 | 	public const KEY = 'asynchronous_messaging';
15 | 
16 | 	public function getConfigKey(): string
17 | 	{
18 | 		return self::KEY;
19 | 	}
20 | 
21 | 	/**
22 | 	 * @return Configurator[]|string[]
23 | 	 */
24 | 	protected function createConfigurators(): array
25 | 	{
26 | 		return [
27 | 			new AsynchronousCommandProducerConfigurator($this->extension),
28 | 			new AsynchronousEventProducerConfigurator($this->extension),
29 | 			new AsynchronousQueryProducerConfigurator($this->extension),
30 | 		];
31 | 	}
32 | }
33 | 


--------------------------------------------------------------------------------
/src/ProophExtensionConfigurator.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types = 1);
 2 | 
 3 | namespace LidskaSila\Prooph;
 4 | 
 5 | use LidskaSila\Prooph\AsynchronousMessages\AsynchronousMessagesConfigurator;
 6 | use LidskaSila\Prooph\Common\CompositeConfigurator;
 7 | use LidskaSila\Prooph\Common\Configurator;
 8 | use LidskaSila\Prooph\EventSourcing\EventSourcingConfigurator;
 9 | use LidskaSila\Prooph\EventStore\EventStoreConfigurator;
10 | use LidskaSila\Prooph\ProjectionManager\ProjectionManagerConfigurator;
11 | use LidskaSila\Prooph\ServiceBus\ServiceBusesConfigurator;
12 | 
13 | class ProophExtensionConfigurator extends CompositeConfigurator
14 | {
15 | 
16 | 	public const KEY = 'prooph';
17 | 
18 | 	public function getConfigKey(): ?string
19 | 	{
20 | 		return self::KEY;
21 | 	}
22 | 
23 | 	/**
24 | 	 * @return Configurator[]
25 | 	 */
26 | 	protected function createConfigurators(): array
27 | 	{
28 | 		return [
29 | 			new EventStoreConfigurator($this->extension),
30 | 			new ProjectionManagerConfigurator($this->extension),
31 | 			new EventSourcingConfigurator($this->extension),
32 | 			new ServiceBusesConfigurator($this->extension),
33 | 			new AsynchronousMessagesConfigurator($this->extension),
34 | 		];
35 | 	}
36 | }
37 | 


--------------------------------------------------------------------------------
/src/Common/CompositeConfigurator.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types = 1);
 2 | 
 3 | namespace LidskaSila\Prooph\Common;
 4 | 
 5 | use LidskaSila\Prooph\ProophExtension;
 6 | 
 7 | abstract class CompositeConfigurator extends DefaultConfigurator
 8 | {
 9 | 
10 | 	/** @var Configurator[] */
11 | 	public $configurators = [];
12 | 
13 | 	public function __construct(ProophExtension $extension)
14 | 	{
15 | 		parent::__construct($extension);
16 | 		$this->configurators = $this->createConfigurators();
17 | 	}
18 | 
19 | 	/**
20 | 	 * @return Configurator[]
21 | 	 */
22 | 	abstract protected function createConfigurators(): array;
23 | 
24 | 	abstract public function getConfigKey(): ?string;
25 | 
26 | 	public function buildDefaultConfig(): array
27 | 	{
28 | 		$config = [];
29 | 		foreach ($this->configurators as $configurator) {
30 | 			$config[$configurator->getConfigKey()] = $configurator->buildDefaultConfig();
31 | 		}
32 | 
33 | 		return $config;
34 | 	}
35 | 
36 | 	public function loadConfiguration(array $config): void
37 | 	{
38 | 		foreach ($this->configurators as $configurator) {
39 | 			$serviceConfig = $config[$configurator->getConfigKey()];
40 | 			$configurator->loadConfiguration($serviceConfig);
41 | 		}
42 | 	}
43 | }
44 | 


--------------------------------------------------------------------------------
/tests/Prooph/configs/ProjectionManagerTests/MysqlProjectionManagerTest.neon:
--------------------------------------------------------------------------------
 1 | extensions:
 2 |     prooph: LidskaSila\Prooph\ProophExtension
 3 | 
 4 | prooph:
 5 | 	event_store:
 6 | 		use:
 7 | 			config: default
 8 | 			factory: Prooph\EventStore\Pdo\Container\MySqlEventStoreFactory
 9 | 		default:
10 | 			wrap_action_event_emitter: true
11 | 			plugins:
12 | 				- Prooph\EventStoreBusBridge\EventPublisher
13 | 			connection: @fakePDO
14 | 			persistence_strategy: Prooph\EventStore\Pdo\PersistenceStrategy\MySqlSingleStreamStrategy
15 | 			load_batch_size: 1000
16 | 			event_streams_table: event_streams
17 | 	projection_manager:
18 | 		use:
19 | 			config: default
20 | 			factory: Prooph\EventStore\Pdo\Container\MySqlProjectionManagerFactory
21 | 		default:
22 | 			event_store: @prooph.event_store
23 | 			connection: @fakePDO # service id for the used pdo connection
24 | 			event_streams_table: event_streams # event stream table to use, defaults to `event_streams`
25 | 			projections_table: projections # projection table to use, defaults to `projections`
26 | services:
27 | 	- Prooph\EventStoreBusBridge\EventPublisher
28 | 	fakePDO:
29 | 		factory: LidskaSila\Prooph\Tests\ProjectionManager\FakePDOFactory::create()
30 | 	- Prooph\EventStore\Pdo\PersistenceStrategy\MySqlSingleStreamStrategy
31 | 	- Prooph\ServiceBus\Plugin\InvokeStrategy\HandleCommandStrategy
32 | 	- Prooph\Common\Messaging\FQCNMessageFactory
33 | 


--------------------------------------------------------------------------------
/tests/Prooph/configs/ProjectionManagerTests/MariaDbProjectionManagerTest.neon:
--------------------------------------------------------------------------------
 1 | extensions:
 2 |     prooph: LidskaSila\Prooph\ProophExtension
 3 | 
 4 | prooph:
 5 | 	event_store:
 6 | 		use:
 7 | 			config: default
 8 | 			factory: Prooph\EventStore\Pdo\Container\MariaDbEventStoreFactory
 9 | 		default:
10 | 			wrap_action_event_emitter: true
11 | 			plugins:
12 | 				- Prooph\EventStoreBusBridge\EventPublisher
13 | 			connection: @fakePDO
14 | 			persistence_strategy: Prooph\EventStore\Pdo\PersistenceStrategy\MariaDbSingleStreamStrategy
15 | 			load_batch_size: 1000
16 | 			event_streams_table: event_streams
17 | 
18 | 	projection_manager:
19 | 		use:
20 | 			config: default
21 | 			factory: Prooph\EventStore\Pdo\Container\MariaDbProjectionManagerFactory
22 | 		default:
23 | 			event_store: @prooph.event_store
24 | 			connection: @fakePDO # service id for the used pdo connection
25 | 			event_streams_table: event_streams # event stream table to use, defaults to `event_streams`
26 | 			projections_table: projections # projection table to use, defaults to `projections`
27 | services:
28 | 	- Prooph\EventStoreBusBridge\EventPublisher
29 | 	fakePDO:
30 | 		factory: LidskaSila\Prooph\Tests\ProjectionManager\FakePDOFactory::create()
31 | 	- Prooph\EventStore\Pdo\PersistenceStrategy\MariaDbSingleStreamStrategy
32 | 	- Prooph\ServiceBus\Plugin\InvokeStrategy\HandleCommandStrategy
33 | 	- Prooph\Common\Messaging\FQCNMessageFactory
34 | 


--------------------------------------------------------------------------------
/tests/Prooph/ProophExtensionTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types = 1);
 2 | 
 3 | namespace LidskaSila\Prooph\Tests\Configurators;
 4 | 
 5 | use Nette\Configurator;
 6 | use Nette\DI\Container;
 7 | use PHPUnit\Framework\TestCase;
 8 | 
 9 | abstract class ProophExtensionTestCase extends TestCase
10 | {
11 | 
12 | 	private const CONFIGS_DIR = 'configs';
13 | 	private const DEFAULT_TEST_FILE = 'test.neon';
14 | 
15 | 	/** @var Container */
16 | 	protected $container;
17 | 
18 | 	protected function givenTestConfig($configPath = self::DEFAULT_TEST_FILE)
19 | 	{
20 | 		$config = new Configurator();
21 | 		$config->setTempDirectory(TEMP_DIR);
22 | 		$config->addConfig(__DIR__ . '/' . self::CONFIGS_DIR . '/' . $configPath);
23 | 
24 | 		return $config;
25 | 	}
26 | 
27 | 	protected function givenTestContainer($configPath = self::DEFAULT_TEST_FILE)
28 | 	{
29 | 		$testConfig = $this->givenTestConfig($configPath);
30 | 
31 | 		$this->container = $testConfig->createContainer();
32 | 	}
33 | 
34 | 	protected function whenGetServiceByTypeFromContainer($classType)
35 | 	{
36 | 		return $this->container->getByType($classType);
37 | 	}
38 | 
39 | 	protected function whenGetServiceByNameFromContainer($name)
40 | 	{
41 | 		return $this->container->getService($name);
42 | 	}
43 | 
44 | 	protected function thenIsInstanceOfExpectedClass($expected, $actual): void
45 | 	{
46 | 		self::assertInstanceOf($expected, $actual);
47 | 	}
48 | 
49 | 	protected function thenPass(): void
50 | 	{
51 | 		self::assertTrue(true);
52 | 	}
53 | }
54 | 


--------------------------------------------------------------------------------
/src/EventStore/EventStoreConfigurator.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types = 1);
 2 | 
 3 | namespace LidskaSila\Prooph\EventStore;
 4 | 
 5 | use LidskaSila\Prooph\Common\DefaultConfigurator;
 6 | use Prooph\EventStore\EventStore;
 7 | 
 8 | class EventStoreConfigurator extends DefaultConfigurator
 9 | {
10 | 
11 | 	public const KEY                 = 'event_store';
12 | 	public const KEY_USE             = 'use';
13 | 	public const KEY_USE_CONFIG_NAME = 'config';
14 | 	public const KEY_USE_FACTORY     = 'factory';
15 | 
16 | 	public function buildDefaultConfig(): array
17 | 	{
18 | 		return [
19 | 			self::KEY_USE => [
20 | 				self::KEY_USE_CONFIG_NAME => [],
21 | 				self::KEY_USE_FACTORY     => false,
22 | 			],
23 | 		];
24 | 	}
25 | 
26 | 	public function getConfigKey(): string
27 | 	{
28 | 		return self::KEY;
29 | 	}
30 | 
31 | 	public function loadConfiguration(array $config): void
32 | 	{
33 | 		$eventStoreConfigName = $config[self::KEY_USE][self::KEY_USE_CONFIG_NAME];
34 | 		$factory              = $config[self::KEY_USE][self::KEY_USE_FACTORY];
35 | 
36 | 		$containerWrapperServiceId = $this->getContainerWrapperServiceId();
37 | 
38 | 		$this
39 | 			->getContainerBuilder()
40 | 			->addDefinition($this->getEventStoreServiceId())
41 | 			->setClass(EventStore::class)
42 | 			->setFactory(self::class . '::create', [ $factory, $eventStoreConfigName, '@' . $containerWrapperServiceId ]);
43 | 	}
44 | 
45 | 	public static function create($factory, $eventStoreConfigName, $containerWrapperService): EventStore
46 | 	{
47 | 		return $factory::$eventStoreConfigName($containerWrapperService);
48 | 	}
49 | 
50 | 	private function getEventStoreServiceId()
51 | 	{
52 | 		return $this->extension->prefix('event_store');
53 | 	}
54 | }
55 | 


--------------------------------------------------------------------------------
/src/AsynchronousMessages/Configurators/AbstractAsynchronousProducerConfigurator.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types = 1);
 2 | 
 3 | namespace LidskaSila\Prooph\AsynchronousMessages\Configurators;
 4 | 
 5 | use LidskaSila\Prooph\AsynchronousMessages\AsynchronousMessageProducer;
 6 | use LidskaSila\Prooph\AsynchronousMessages\AsynchronousMessagesConfigurator;
 7 | use LidskaSila\Prooph\AsynchronousMessages\Factories\AbstractAsynchronousMessageProducerFactory;
 8 | use LidskaSila\Prooph\Common\DefaultConfigurator;
 9 | 
10 | abstract class AbstractAsynchronousProducerConfigurator extends DefaultConfigurator
11 | {
12 | 
13 | 	public static function create($factory, $producerSectionConfigName, $containerWrapperService): AsynchronousMessageProducer
14 | 	{
15 | 		return $factory::$producerSectionConfigName($containerWrapperService);
16 | 	}
17 | 
18 | 	abstract public function getProducerFactoryClass(): string;
19 | 
20 | 	public function buildDefaultConfig(): array
21 | 	{
22 | 		return [];
23 | 	}
24 | 
25 | 	public function loadConfiguration(array $config): void
26 | 	{
27 | 		if (empty($config[AbstractAsynchronousMessageProducerFactory::KEY_BRIDGE])) {
28 | 			return;
29 | 		}
30 | 
31 | 		$containerWrapperServiceId = $this->getContainerWrapperServiceId();
32 | 
33 | 		$this
34 | 			->getContainerBuilder()
35 | 			->addDefinition($this->getProducerServiceId())
36 | 			->setClass(AsynchronousMessageProducer::class)
37 | 			->setFactory(static::class . '::create', [ $this->getProducerFactoryClass(), $this->getConfigKey(), '@' . $containerWrapperServiceId ]);
38 | 	}
39 | 
40 | 	private function getProducerServiceId(): string
41 | 	{
42 | 		return $this->extension->prefix(AsynchronousMessagesConfigurator::KEY . '.' . $this->getConfigKey());
43 | 	}
44 | }
45 | 


--------------------------------------------------------------------------------
/src/EventSourcing/EventSourcingConfigurator.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types = 1);
 2 | 
 3 | namespace LidskaSila\Prooph\EventSourcing;
 4 | 
 5 | use LidskaSila\Prooph\Common\DefaultConfigurator;
 6 | use Prooph\EventSourcing\Aggregate\AggregateRepository;
 7 | use Prooph\EventSourcing\Container\Aggregate\AggregateRepositoryFactory;
 8 | 
 9 | class EventSourcingConfigurator extends DefaultConfigurator
10 | {
11 | 
12 | 	public const KEY                        = 'event_sourcing';
13 | 	public const KEY_AGGREGATE_REPOSITORIES = 'aggregate_repository';
14 | 	public const KEY_REPOSITORY_CLASS       = 'repository_class';
15 | 
16 | 	public function buildDefaultConfig(): array
17 | 	{
18 | 		return [
19 | 			self::KEY_AGGREGATE_REPOSITORIES => [],
20 | 		];
21 | 	}
22 | 
23 | 	public function getConfigKey(): string
24 | 	{
25 | 		return self::KEY;
26 | 	}
27 | 
28 | 	public function loadConfiguration(array $config): void
29 | 	{
30 | 		$repositoriesConfigs = $config[self::KEY_AGGREGATE_REPOSITORIES];
31 | 
32 | 		$containerWrapperServiceId = $this->getContainerWrapperServiceId();
33 | 
34 | 		foreach ($repositoriesConfigs as $repositoryConfigName => $repositoryConfig) {
35 | 			$repositoryClass = $repositoryConfig[self::KEY_REPOSITORY_CLASS];
36 | 			$this
37 | 				->getContainerBuilder()
38 | 				->addDefinition($this->extension->prefix($repositoryConfigName))
39 | 				->setClass($repositoryClass)
40 | 				->setFactory(self::class . '::createRepository', [ $repositoryConfigName, '@' . $containerWrapperServiceId ]);
41 | 		}
42 | 	}
43 | 
44 | 	public static function createRepository($repositoryConfigName, $containerWrapperService): AggregateRepository
45 | 	{
46 | 		return AggregateRepositoryFactory::$repositoryConfigName($containerWrapperService);
47 | 	}
48 | }
49 | 


--------------------------------------------------------------------------------
/src/ProjectionManager/ProjectionManagerConfigurator.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types = 1);
 2 | 
 3 | namespace LidskaSila\Prooph\ProjectionManager;
 4 | 
 5 | use LidskaSila\Prooph\Common\DefaultConfigurator;
 6 | use Prooph\EventStore\Projection\ProjectionManager;
 7 | 
 8 | class ProjectionManagerConfigurator extends DefaultConfigurator
 9 | {
10 | 
11 | 	public const KEY                 = 'projection_manager';
12 | 	public const KEY_USE             = 'use';
13 | 	public const KEY_USE_CONFIG_NAME = 'config';
14 | 	public const KEY_USE_FACTORY     = 'factory';
15 | 
16 | 	public static function create($factory, $eventStoreConfigName, $containerWrapperService): ProjectionManager
17 | 	{
18 | 		return $factory::$eventStoreConfigName($containerWrapperService);
19 | 	}
20 | 
21 | 	public function buildDefaultConfig(): array
22 | 	{
23 | 		return [];
24 | 	}
25 | 
26 | 	public function getConfigKey(): string
27 | 	{
28 | 		return self::KEY;
29 | 	}
30 | 
31 | 	public function loadConfiguration(array $config): void
32 | 	{
33 | 		if (!isset($config[self::KEY_USE][self::KEY_USE_CONFIG_NAME])) {
34 | 			return;
35 | 		}
36 | 		$eventStoreConfigName = $config[self::KEY_USE][self::KEY_USE_CONFIG_NAME];
37 | 		$factory              = $config[self::KEY_USE][self::KEY_USE_FACTORY];
38 | 
39 | 		$containerWrapperServiceId = $this->getContainerWrapperServiceId();
40 | 
41 | 		$this
42 | 			->getContainerBuilder()
43 | 			->addDefinition($this->getProjectionManagerServiceId())
44 | 			->setClass(ProjectionManager::class)
45 | 			->setFactory(self::class . '::create', [ $factory, $eventStoreConfigName, '@' . $containerWrapperServiceId ]);
46 | 	}
47 | 
48 | 	private function getProjectionManagerServiceId()
49 | 	{
50 | 		return $this->extension->prefix('projection_manager');
51 | 	}
52 | }
53 | 


--------------------------------------------------------------------------------
/src/ServiceBus/ServiceBusConfigurators/AbstractBusConfigurator.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types = 1);
 2 | 
 3 | namespace LidskaSila\Prooph\ServiceBus\ServiceBusConfigurators;
 4 | 
 5 | use LidskaSila\Prooph\Common\DefaultConfigurator;
 6 | use Prooph\Common\Messaging\MessageFactory;
 7 | use Prooph\ServiceBus\MessageBus;
 8 | 
 9 | abstract class AbstractBusConfigurator extends DefaultConfigurator
10 | {
11 | 
12 | 	protected const KEY_BUS_PLUGINS             = 'plugins';
13 | 	protected const KEY_BUS_ROUTER              = 'router';
14 | 	protected const KEY_BUS_ROUTER_ROUTES       = 'routes';
15 | 	protected const KEY_ENABLE_HANDLER_LOCATION = 'enable_handler_location';
16 | 	protected const KEY_MESSAGE_FACTORY         = 'message_factory';
17 | 
18 | 	abstract public function getBusClass(): string;
19 | 
20 | 	abstract public function getBusFactoryClass(): string;
21 | 
22 | 	public function buildDefaultConfig(): array
23 | 	{
24 | 		return [
25 | 			self::KEY_BUS_PLUGINS             => [],
26 | 			self::KEY_BUS_ROUTER              => [
27 | 				self::KEY_BUS_ROUTER_ROUTES => [],
28 | 			],
29 | 			self::KEY_ENABLE_HANDLER_LOCATION => true,
30 | 			self::KEY_MESSAGE_FACTORY         => MessageFactory::class,
31 | 		];
32 | 	}
33 | 
34 | 	public function loadConfiguration(array $config): void
35 | 	{
36 | 		$containerWrapperServiceId = $this->getContainerWrapperServiceId();
37 | 
38 | 		$this
39 | 			->getContainerBuilder()
40 | 			->addDefinition($this->getBusServiceId())
41 | 			->setClass($this->getBusClass())
42 | 			->setFactory(static::class . '::create', [ $this->getBusFactoryClass(), $this->getConfigKey(), '@' . $containerWrapperServiceId ]);
43 | 	}
44 | 
45 | 	public static function create($factory, $busConfigName, $containerWrapperService): MessageBus
46 | 	{
47 | 		return $factory::$busConfigName($containerWrapperService);
48 | 	}
49 | 
50 | 	private function getBusServiceId(): string
51 | 	{
52 | 		return $this->extension->prefix($this->getConfigKey());
53 | 	}
54 | }
55 | 


--------------------------------------------------------------------------------
/docs/KeepLearning.md:
--------------------------------------------------------------------------------
 1 | # I am new to to prooph
 2 | If you are new to prooph, I recommend: 
 3 | <ol>
 4 | <li>Read <a href="http://getprooph.org/docs/html/">Prooph documentation</a></li>
 5 | <li>Dive deep in code of <a href="https://github.com/prooph/proophessor-do">example real life application</a> built on top of prooph toolbox.</li>
 6 | <li>Join to <a href="https://gitter.im/prooph/improoph">prooph gitter chat</a></li>
 7 | </ol>
 8 | 
 9 | # I am new to whole concept of this weird stuff
10 | If you are new to Domain Driven Design, CQRS or Event Sourcing, I recommend following sources:
11 | 
12 | ### YouTube videos
13 | <ul>
14 | 	<li>
15 | 		<a href="https://www.youtube.com/watch?v=JHGkaShoyNs&t=1s">
16 | 			Greg Young - CQRS and Event Sourcing
17 | 		</a>
18 | 	</li>
19 | 	<li>
20 | 		<a href="https://www.youtube.com/channel/UC3PGn-hQdbtRiqxZK9XBGqQ">
21 | 			Domain-Driven Design Europe Youtube channel
22 | 		</a>
23 | 	</li>
24 | </ul>
25 | 
26 | ### Online reading
27 | <ul>
28 | 	<li>
29 | 		<a href="http://www.cqrs.nu">
30 | 			CQRS STARTER KIT TUTORIAL
31 | 		</a> (with Event Sourcing and DDD in mind)
32 | 	</li>
33 | 	<li>
34 | 		<a href="https://martinfowler.com/">
35 | 			Martin Fowler's blog
36 | 		</a>
37 | 	</li>
38 | </ul>
39 | 
40 | ### Books
41 | 
42 | <ul>
43 | 	<li>
44 | 		<a href="https://www.bookdepository.com/Domain-driven-Design-Eric-Evans/9780321125217">
45 | 			Domain Driven Design
46 | 		</a> by DDD's father Eric Evans
47 | 	</li>
48 | 	<li>
49 | 		<a href="https://www.bookdepository.com/Domain-Driven-Design-Quickly-InfoQ-Team/9781411609259">
50 | 			Domain Driven Design Quickly
51 | 		</a>
52 | 	</li>
53 | 	<li>
54 | 		<a href="https://www.bookdepository.com/Domain-Driven-Design-in-PHP-Carlos-Buenosvinos-Christian-Soronellas-Keyvan-Akbary/9780994608406?ref=grid-view&qid=1501111750188&sr=1-2">
55 | 			Domain-Driven Design in PHP
56 | 		</a>
57 | 	</li>
58 | </ul>
59 | 
60 | Or if you are really hungry, 
61 | <a href="https://github.com/heynickc/awesome-ddd">
62 | 	look at this extended source list
63 | </a>.
64 | 


--------------------------------------------------------------------------------
/docs/Configuration.md:
--------------------------------------------------------------------------------
 1 | # Configuration
 2 | 
 3 | ## Supported prooph libraries
 4 | <ul>
 5 | <li>Event Sourcing (<a href="https://github.com/prooph/event-sourcing">prooph/event-sourcing</a>)</li>
 6 | <li>Event Store (<a href="https://github.com/prooph/event-store">prooph/event-store</a>)</li>
 7 | <li>PDO Event Store (<a href="https://github.com/prooph/pdo-event-store">prooph/pdo-event-store</a>) - support for projection_manager config</li>
 8 | <li>Service Buses (<a href="https://github.com/prooph/service-bus">prooph/service-bus</a>)</li>
 9 | <li>More to come (you can wait or contribute :P)</li>
10 | </ul>
11 | 
12 | ## Basics
13 | <p>
14 | 	Array structure for configuration is exactly same as in original prooph libraries, because
15 | 	extension uses original interop factories from toolbox. 
16 | 	However there is some additional config fields (listed below).
17 | </p>
18 | 
19 | ## Example
20 | <p>
21 | 	Example basic neon configuration can be found <a href="https://github.com/LidskaSila/Prooph/blob/master/tests/Prooph/configs/FullTestConfig.neon">here</a>
22 | 	or you can see other <a href="https://github.com/LidskaSila/Prooph/tree/master/tests/Prooph/configs">working test configs</a> for inspiration.
23 | </p>
24 | 
25 | ## Additional config fields
26 | 
27 | ### `event_store`
28 | <p>
29 | 	There is additional configuration in `event_store` library config. 
30 | 	It has special key `use`, where you need to define which config name and factory should be used:
31 | </p>
32 | 
33 | ```yaml
34 | prooph:
35 |     event_store:
36 |         use:
37 |             config: default
38 |             factory: Prooph\EventStore\Container\InMemoryEventStoreFactory
39 | ```
40 | 
41 | ### `projection_manager`
42 | <p>
43 | 	There is additional configuration in `projection_manager` library config. 
44 | 	It has special key `use`, where you need to define which config name and factory should be used:
45 | </p>
46 | 
47 | ```yaml
48 | prooph:
49 |     projection_manager:
50 |         use:
51 |             config: default
52 |             factory: Prooph\EventStore\Pdo\Container\MySqlProjectionManagerFactory
53 | ```
54 | 


--------------------------------------------------------------------------------
/src/Common/NetteContainerWrapper.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types = 1);
 2 | 
 3 | namespace LidskaSila\Prooph\Common;
 4 | 
 5 | use LidskaSila\Prooph\Common\NetteContainerWrapper\ContainerException;
 6 | use LidskaSila\Prooph\Common\NetteContainerWrapper\NotFoundException;
 7 | use Nette\DI\Container;
 8 | use Nette\DI\MissingServiceException;
 9 | use Psr\Container\ContainerInterface;
10 | use Throwable;
11 | 
12 | class NetteContainerWrapper implements ContainerInterface
13 | {
14 | 
15 | 	/**
16 | 	 * @var Container
17 | 	 */
18 | 	private $container;
19 | 
20 | 	/**
21 | 	 * @var array
22 | 	 */
23 | 	private $config;
24 | 
25 | 	public function __construct(array $extensionConfig, Container $container)
26 | 	{
27 | 		$this->config    = $extensionConfig;
28 | 		$this->container = $container;
29 | 	}
30 | 
31 | 	/**
32 | 	 * {@inheritdoc}
33 | 	 */
34 | 	public function get($key)
35 | 	{
36 | 		try {
37 | 			return $this->tryToGetByKey($key);
38 | 		} catch (MissingServiceException $e) {
39 | 			throw new NotFoundException($e->getMessage());
40 | 		} catch (Throwable $e) {
41 | 			throw new ContainerException($e->getMessage());
42 | 		}
43 | 	}
44 | 
45 | 	/**
46 | 	 * {@inheritdoc}
47 | 	 */
48 | 	public function has($key)
49 | 	{
50 | 		if ($this->isKeyConfig($key)) {
51 | 			return (bool) $this->config;
52 | 		}
53 | 		if ($this->isServiceId($key)) {
54 | 			return $this->container->hasService($this->extractServiceId($key));
55 | 		}
56 | 
57 | 		return (bool) $this->container->getByType($key);
58 | 	}
59 | 
60 | 	private function tryToGetByKey($key)
61 | 	{
62 | 		if ($this->isKeyConfig($key)) {
63 | 			return $this->config;
64 | 		}
65 | 		if ($this->isServiceId($key)) {
66 | 			return $this->container->getService($this->extractServiceId($key));
67 | 		}
68 | 
69 | 		return $this->container->getByType($key);
70 | 	}
71 | 
72 | 	private function isKeyConfig(string $key): bool
73 | 	{
74 | 		return $key === 'config';
75 | 	}
76 | 
77 | 	private function isServiceId(string $key): bool
78 | 	{
79 | 		return strpos($key, '@') === 0;
80 | 	}
81 | 
82 | 	private function extractServiceId(string $key): string
83 | 	{
84 | 		return ltrim($key, '@');
85 | 	}
86 | }
87 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # LidskaSila/Prooph
 2 | 
 3 | [![Build Status](https://img.shields.io/travis/LidskaSila/Prooph.svg?style=flat-square)](https://travis-ci.org/LidskaSila/Prooph)
 4 | [![Quality Score](https://img.shields.io/scrutinizer/g/LidskaSila/Prooph.svg?style=flat-square)](https://scrutinizer-ci.com/g/LidskaSila/Prooph)
 5 | [![Code Coverage](https://img.shields.io/scrutinizer/coverage/g/LidskaSila/Prooph.svg?style=flat-square)](https://scrutinizer-ci.com/g/LidskaSila/Prooph)
 6 | 
 7 | Nette extension for <a href="https://github.com/prooph">prooph</a> toolbox family.
 8 | 
 9 | ## Why bother?
10 | <ol>
11 | 	<li>
12 | 		It allows you to 
13 | 		<a href="https://github.com/LidskaSila/Prooph/blob/master/docs/Configuration.md">
14 | 			configure prooph libraries through Nette *.neon config
15 | 		</a>
16 | 	</li>
17 | 	<li>
18 | 		It allows you to
19 | 		<a href="https://github.com/LidskaSila/Prooph/blob/master/docs/AsynchronousMessaging.md">
20 | 			configure routes for asynchronous messaging
21 | 		</a> with simple bridge interface to adapt your infrastructure.
22 | 	</li>
23 | </ol>
24 | 
25 | <a href="https://github.com/LidskaSila/Prooph/blob/master/docs/KeepLearning.md">
26 | 	New to Prooph, DDD, CQRS or Event Sourcing? Hunting for inspiration and learning sources?
27 | </a>
28 | 
29 | # Quick start
30 | 
31 | ### 1) Install this Nette extension through composer
32 | `composer require lidskasila/prooph`
33 | 
34 | ### 2) Register package in your config.neon
35 | ```yaml
36 | extensions:
37 |     prooph: LidskaSila\Prooph\ProophExtension
38 | ```
39 | 
40 | ## Documentation
41 | 
42 | <ol>
43 | 	<li>
44 | 		<a href="https://github.com/LidskaSila/Prooph/blob/master/docs/Configuration.md">
45 | 			Configuration
46 | 		</a>
47 | 	</li>
48 | 	<li>
49 | 		<a href="https://github.com/LidskaSila/Prooph/blob/master/docs/AsynchronousMessaging.md">
50 | 			Asynchronous messaging
51 | 		</a>
52 | 	</li>
53 | </ol>
54 | 
55 | ## Contribute
56 | 
57 | Please feel free to fork and extend existing or add new features and send a pull request with your changes! 
58 | To establish a consistent code quality, please provide unit tests for all your changes and may adapt the documentation.
59 | 


--------------------------------------------------------------------------------
/src/AsynchronousMessages/AsynchronousMessageProducer.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace LidskaSila\Prooph\AsynchronousMessages;
 4 | 
 5 | use Prooph\Common\Messaging\Message;
 6 | use Prooph\Common\Messaging\MessageConverter;
 7 | use Prooph\Common\Messaging\MessageDataAssertion;
 8 | use Prooph\ServiceBus\Async\MessageProducer;
 9 | use Prooph\ServiceBus\Exception\RuntimeException;
10 | use React\Promise\Deferred;
11 | 
12 | class AsynchronousMessageProducer implements MessageProducer
13 | {
14 | 
15 | 	/* @var AsynchronousMessageProducerBridge */
16 | 	private $producerBridge;
17 | 
18 | 	/** @var MessageConverter */
19 | 	private $messageConverter;
20 | 
21 | 	/** @var array */
22 | 	private $routes;
23 | 
24 | 	public function __construct(AsynchronousMessageProducerBridge $producerBridge, MessageConverter $messageConverter)
25 | 	{
26 | 		$this->producerBridge   = $producerBridge;
27 | 		$this->messageConverter = $messageConverter;
28 | 	}
29 | 
30 | 	public function injectRoutes(array $routes)
31 | 	{
32 | 		$this->routes = $routes;
33 | 	}
34 | 
35 | 	public function __invoke(Message $message, Deferred $deferred = null): void
36 | 	{
37 | 		if ($deferred !== null) {
38 | 			throw new RuntimeException(__CLASS__ . ' cannot handle query messages which require future responses.');
39 | 		}
40 | 		$data = $this->arrayFromMessage($message);
41 | 
42 | 		$producerName = $this->getProducerRouteKey($message);
43 | 
44 | 		$this->producerBridge->publishWithRoutingKey($producerName, $data);
45 | 	}
46 | 
47 | 	private function arrayFromMessage(Message $message): array
48 | 	{
49 | 		$messageData = $this->messageConverter->convertToArray($message);
50 | 		MessageDataAssertion::assert($messageData);
51 | 		$messageData['created_at'] = $message->createdAt()->format('Y-m-d\TH:i:s.u');
52 | 
53 | 		return $messageData;
54 | 	}
55 | 
56 | 	private function getProducerRouteKey(Message $message): string
57 | 	{
58 | 		if (empty($this->routes[$message->messageName()])) {
59 | 			throw new RuntimeException(
60 | 				sprintf(
61 | 					'Producer route key for message of name "%s" in asynchronous routing not found.',
62 | 					$message->messageName()
63 | 				)
64 | 			);
65 | 		}
66 | 		return $this->routes[$message->messageName()];
67 | 	}
68 | }
69 | 


--------------------------------------------------------------------------------
/tests/Prooph/configs/FullTestConfig.neon:
--------------------------------------------------------------------------------
 1 | extensions:
 2 | 	prooph: LidskaSila\Prooph\ProophExtension
 3 | 
 4 | prooph:
 5 | 	event_sourcing:
 6 | 		aggregate_repository:
 7 | 			test_repository:
 8 | 				repository_class: LidskaSila\Prooph\Tests\EventSourcing\FakeImplementations\MemoryTestRepository
 9 | 				aggregate_type: LidskaSila\Prooph\Tests\EventSourcing\FakeImplementations\TestAggregateRoot
10 | 				aggregate_translator: Prooph\EventSourcing\EventStoreIntegration\AggregateTranslator
11 | 				one_stream_per_aggregate: true
12 | 	event_store:
13 | 		use:
14 | 			config: default
15 | 			factory: Prooph\EventStore\Container\InMemoryEventStoreFactory
16 | 		default:
17 | 			plugins:
18 | 				- Prooph\EventStoreBusBridge\EventPublisher
19 | 	projection_manager:
20 | 		use:
21 | 			config: default
22 | 			factory: Prooph\EventStore\Pdo\Container\MySqlProjectionManagerFactory
23 | 		default:
24 | 			event_store: @prooph.event_store
25 | 			connection: @fakePDO # service id for the used pdo connection
26 | 			event_streams_table: event_streams # event stream table to use, defaults to `event_streams`
27 | 			projections_table: projections # projection table to use, defaults to `projections`
28 | 	service_bus:
29 | 		command_bus:
30 | 			plugins:
31 | 				- Prooph\ServiceBus\Plugin\InvokeStrategy\HandleCommandStrategy
32 | 			router:
33 | 				routes:
34 | 		event_bus:
35 | 			plugins:
36 | 				- Prooph\ServiceBus\Plugin\InvokeStrategy\OnEventStrategy
37 | 			router:
38 | 				routes:
39 | 				async_switch: "@prooph.asynchronous_messaging.events"
40 | 		query_bus:
41 | 			plugins:
42 | 			router:
43 | 				routes:
44 | 	asynchronous_messaging:
45 | 		events:
46 | 			bridge: "@producerBridge"
47 | 			routes:
48 | 				LidskaSila\Prooph\Tests\EventSourcing\FakeImplementations\TestAggregateCreated: producerRouteKey
49 | 		commands:
50 | 			bridge: LidskaSila\Prooph\Tests\ServiceBus\AsynchronousMessages\FakeImplementations\TestAsynchronousMessageProducerBridge
51 | 
52 | services:
53 | 	onEventStrategy: Prooph\ServiceBus\Plugin\InvokeStrategy\OnEventStrategy
54 | 	- Prooph\ServiceBus\Plugin\InvokeStrategy\HandleCommandStrategy
55 | 	- Prooph\EventStoreBusBridge\EventPublisher
56 | 	- Prooph\EventSourcing\EventStoreIntegration\AggregateTranslator
57 | 	- Prooph\Common\Messaging\FQCNMessageFactory
58 | 
59 | 	producerBridge: LidskaSila\Prooph\Tests\AsynchronousMessages\FakeImplementations\TestAsynchronousMessageProducerBridge
60 | 	- Prooph\Common\Messaging\NoOpMessageConverter
61 | 


--------------------------------------------------------------------------------
/src/ProophExtension.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types = 1);
 2 | 
 3 | namespace LidskaSila\Prooph;
 4 | 
 5 | use LidskaSila\Prooph\Common\Configurator;
 6 | use LidskaSila\Prooph\Common\NetteContainerWrapper;
 7 | use Nette\DI\CompilerExtension;
 8 | use Nette\DI\Container;
 9 | use Nette\DI\ContainerBuilder;
10 | 
11 | class ProophExtension extends CompilerExtension
12 | {
13 | 
14 | 	/** @var array */
15 | 	public $defaults = [];
16 | 
17 | 	/** @var Configurator */
18 | 	public $configurator;
19 | 
20 | 	public function __construct()
21 | 	{
22 | 		$this->configurator = new ProophExtensionConfigurator($this);
23 | 	}
24 | 
25 | 	public function loadConfiguration(): void
26 | 	{
27 | 		$this->defaults = $this->configurator->buildDefaultConfig();
28 | 		$this->config   = $this->mergeConfigIntoDefaults($this->config, $this->defaults);
29 | 
30 | 		$this->registerContainerWrapper();
31 | 
32 | 		$this->configurator->loadConfiguration($this->config);
33 | 	}
34 | 
35 | 	private function mergeConfigIntoDefaults($original, $default): array
36 | 	{
37 | 		return array_replace_recursive($default, $original);
38 | 	}
39 | 
40 | 	/**
41 | 	 * Container wrapper is needed in every interop factory, so we register it first.
42 | 	 */
43 | 	private function registerContainerWrapper(): void
44 | 	{
45 | 		/** @var ContainerBuilder $containerBuilder */
46 | 		$containerBuilder = $this->getContainerBuilder();
47 | 
48 | 		if (!$containerBuilder->getByType(NetteContainerWrapper::class)) {
49 | 			$jsonConfig         = $this->determineJsonConfig();
50 | 			$containerServiceId = $this->getContainerServiceId($containerBuilder);
51 | 
52 | 			$containerBuilder
53 | 				->addDefinition($this->getNetteContainerWrapperDefinitionId())
54 | 				->setClass(NetteContainerWrapper::class)
55 | 				->setFactory(static::class . '::createContainerWrapper', [ $jsonConfig, '@' . $containerServiceId ]);
56 | 		}
57 | 	}
58 | 
59 | 	public static function createContainerWrapper(string $jsonConfig, $container): NetteContainerWrapper
60 | 	{
61 | 		$config = json_decode($jsonConfig, true);
62 | 
63 | 		return new NetteContainerWrapper($config, $container);
64 | 	}
65 | 
66 | 	private function getNetteContainerWrapperDefinitionId(): string
67 | 	{
68 | 		return $this->prefix('NetteContainerWrapper');
69 | 	}
70 | 
71 | 	private function determineJsonConfig(): string
72 | 	{
73 | 		// Putting config array to json, because we want keep service links (@serviceId) in config as string.
74 | 		// If it would be array, Nette would replace all these string based links with real services.
75 | 		$config     = [ $this->configurator->getConfigKey() => $this->config ];
76 | 		return json_encode($config);
77 | 	}
78 | 
79 | 	private function getContainerServiceId(ContainerBuilder $containerBuilder): string
80 | 	{
81 | 		return (string) $containerBuilder->getByType(Container::class);
82 | 	}
83 | }
84 | 
85 | 


--------------------------------------------------------------------------------
/tests/Prooph/Common/NetteContainerWrapperTest.php:
--------------------------------------------------------------------------------
  1 | <?php declare(strict_types = 1);
  2 | 
  3 | namespace LidskaSila\Prooph\Tests\Configurators;
  4 | 
  5 | use LidskaSila\Prooph\Common\NetteContainerWrapper;
  6 | use LidskaSila\Prooph\Common\NetteContainerWrapper\ContainerException;
  7 | use LidskaSila\Prooph\Common\NetteContainerWrapper\NotFoundException;
  8 | use Prooph\ServiceBus\Plugin\InvokeStrategy\OnEventStrategy;
  9 | 
 10 | class NetteContainerWrapperTest extends ProophExtensionTestCase
 11 | {
 12 | 
 13 | 	private const FAKE_CONFIG = [ 'key' => 'value' ];
 14 | 
 15 | 	/** @var NetteContainerWrapper */
 16 | 	protected $containerWrapper;
 17 | 
 18 | 	public function setUp()
 19 | 	{
 20 | 		parent::setUp();
 21 | 		$this->givenNetteContainerWrapper('FullTestConfig.neon');
 22 | 	}
 23 | 
 24 | 	public function testGet_NotExistingService_ShouldThrowNotFoundException()
 25 | 	{
 26 | 		$this->willThrowException(NotFoundException::class);
 27 | 
 28 | 		$this->whenGetByKey('not_existing');
 29 | 	}
 30 | 
 31 | 	public function testGet_WithInvalidParameter_ShouldThrowContainerException()
 32 | 	{
 33 | 		$this->willThrowException(ContainerException::class);
 34 | 
 35 | 		$this->whenGetByKey(new \DateTime());
 36 | 	}
 37 | 
 38 | 	public function testGet_ExistingServiceByType_ShouldReturnExpectedInstance()
 39 | 	{
 40 | 		$service = $this->whenGetByKey(OnEventStrategy::class);
 41 | 
 42 | 		$this->thenIsInstanceOfExpectedClass(OnEventStrategy::class, $service);
 43 | 	}
 44 | 
 45 | 	public function testGet_ExistingServiceById_ShouldReturnExpectedInstance()
 46 | 	{
 47 | 		$service = $this->whenGetByKey('@onEventStrategy');
 48 | 
 49 | 		$this->thenIsInstanceOfExpectedClass(OnEventStrategy::class, $service);
 50 | 	}
 51 | 
 52 | 	public function testGet_Config_ShouldReturnExpectedConfig()
 53 | 	{
 54 | 		$actualConfig = $this->whenGetByKey('config');
 55 | 
 56 | 		$this->thenIsExpectedConfig($actualConfig);
 57 | 	}
 58 | 
 59 | 	public function testHas_ExistingServiceByType_ShouldReturnTrue()
 60 | 	{
 61 | 		$has = $this->whenAskIfHasKey(OnEventStrategy::class);
 62 | 
 63 | 		$this->thenResultIsTrue($has);
 64 | 	}
 65 | 
 66 | 	public function testHas_ExistingServiceById_ShouldReturnTrue()
 67 | 	{
 68 | 		$has = $this->whenAskIfHasKey('@onEventStrategy');
 69 | 
 70 | 		$this->thenResultIsTrue($has);
 71 | 	}
 72 | 
 73 | 	public function testHas_Config_ShouldReturnTrue()
 74 | 	{
 75 | 		$has = $this->whenAskIfHasKey('config');
 76 | 
 77 | 		$this->thenResultIsTrue($has);
 78 | 	}
 79 | 
 80 | 	private function givenNetteContainerWrapper(string $configName)
 81 | 	{
 82 | 		$this->givenTestContainer($configName);
 83 | 		$config                 = $this->givenFakeConfig();
 84 | 		$this->containerWrapper = new NetteContainerWrapper($config, $this->container);
 85 | 	}
 86 | 
 87 | 	private function givenFakeConfig()
 88 | 	{
 89 | 		return self::FAKE_CONFIG;
 90 | 	}
 91 | 
 92 | 	private function whenGetByKey($key)
 93 | 	{
 94 | 		return $this->containerWrapper->get($key);
 95 | 	}
 96 | 
 97 | 	private function whenAskIfHasKey($key)
 98 | 	{
 99 | 		return $this->containerWrapper->has($key);
100 | 	}
101 | 
102 | 	private function thenIsExpectedConfig($actualConfig)
103 | 	{
104 | 		self::assertEquals(self::FAKE_CONFIG, $actualConfig);
105 | 	}
106 | 
107 | 	private function willThrowException($class)
108 | 	{
109 | 		self::expectException($class);
110 | 	}
111 | 
112 | 	private function thenResultIsTrue($has)
113 | 	{
114 | 		self::assertTrue($has);
115 | 	}
116 | }
117 | 


--------------------------------------------------------------------------------
/src/AsynchronousMessages/Factories/AbstractAsynchronousMessageProducerFactory.php:
--------------------------------------------------------------------------------
  1 | <?php declare(strict_types = 1);
  2 | 
  3 | namespace LidskaSila\Prooph\AsynchronousMessages\Factories;
  4 | 
  5 | use Interop\Config\ConfigurationTrait;
  6 | use Interop\Config\ProvidesDefaultOptions;
  7 | use Interop\Config\RequiresConfigId;
  8 | use InvalidArgumentException;
  9 | use LidskaSila\Prooph\AsynchronousMessages\AsynchronousMessageProducer;
 10 | use LidskaSila\Prooph\AsynchronousMessages\AsynchronousMessageProducerBridge;
 11 | use Prooph\Common\Messaging\MessageConverter;
 12 | use Psr\Container\ContainerInterface;
 13 | 
 14 | abstract class AbstractAsynchronousMessageProducerFactory implements RequiresConfigId, ProvidesDefaultOptions
 15 | {
 16 | 
 17 | 	use ConfigurationTrait;
 18 | 	public const KEY_BRIDGE = 'bridge';
 19 | 	public const KEY_ROUTES = 'routes';
 20 | 
 21 | 	/**
 22 | 	 * @var string
 23 | 	 */
 24 | 	private $configId;
 25 | 
 26 | 	public function __construct(string $configId)
 27 | 	{
 28 | 		$this->configId = $configId;
 29 | 	}
 30 | 
 31 | 	/**
 32 | 	 * Creates a new instance from a specified config, specifically meant to be used as static factory.
 33 | 	 *
 34 | 	 * @throws InvalidArgumentException
 35 | 	 */
 36 | 	public static function __callStatic(string $name, array $arguments): AsynchronousMessageProducer
 37 | 	{
 38 | 		if (!isset($arguments[0]) || !$arguments[0] instanceof ContainerInterface) {
 39 | 			throw new InvalidArgumentException(
 40 | 				sprintf('The first argument must be of type %s', ContainerInterface::class)
 41 | 			);
 42 | 		}
 43 | 
 44 | 		return (new static($name))->__invoke($arguments[0]);
 45 | 	}
 46 | 
 47 | 	public function __invoke(ContainerInterface $container): AsynchronousMessageProducer
 48 | 	{
 49 | 		$producerConfig = $this->getProducerconfg($container);
 50 | 
 51 | 		$producer = $this->createMessageProducer($container, $producerConfig);
 52 | 
 53 | 		$this->injectRoutesToProducer($producerConfig, $producer);
 54 | 
 55 | 		return $producer;
 56 | 	}
 57 | 
 58 | 	public function dimensions(): iterable
 59 | 	{
 60 | 		return [ 'prooph', 'asynchronous_messaging' ];
 61 | 	}
 62 | 
 63 | 	public function defaultOptions(): iterable
 64 | 	{
 65 | 		return [];
 66 | 	}
 67 | 
 68 | 	private function getProducerconfg(ContainerInterface $container): array
 69 | 	{
 70 | 		$config = $container->get('config');
 71 | 
 72 | 		return $this->optionsWithFallback($config, $this->configId);
 73 | 	}
 74 | 
 75 | 	private function createMessageProducer(ContainerInterface $container, array $producerConfig): AsynchronousMessageProducer
 76 | 	{
 77 | 		$producerBridge   = $this->getProducerBridge($container, $producerConfig);
 78 | 		$messageConverter = $this->getMessageConverter($container);
 79 | 
 80 | 		return new AsynchronousMessageProducer($producerBridge, $messageConverter);
 81 | 	}
 82 | 
 83 | 	private function getProducerBridge(ContainerInterface $container, $producerConfig): AsynchronousMessageProducerBridge
 84 | 	{
 85 | 		$producerBridgeKey = $this->getProducerBridgeServiceKey($producerConfig);
 86 | 
 87 | 		return $container->get($producerBridgeKey);
 88 | 	}
 89 | 
 90 | 	private function getProducerBridgeServiceKey(array $producerConfig): string
 91 | 	{
 92 | 		return $producerConfig[self::KEY_BRIDGE];
 93 | 	}
 94 | 
 95 | 	private function getMessageConverter(ContainerInterface $container): MessageConverter
 96 | 	{
 97 | 		return $container->get(MessageConverter::class);
 98 | 	}
 99 | 
100 | 	private function injectRoutesToProducer(array $producerConfig, AsynchronousMessageProducer $producer): void
101 | 	{
102 | 		$routes = is_array($producerConfig[self::KEY_ROUTES]) ? $producerConfig[self::KEY_ROUTES] : [];
103 | 		$producer->injectRoutes($routes);
104 | 	}
105 | }
106 | 


--------------------------------------------------------------------------------
/tests/Prooph/AsynchronousMessages/AsynchronousMessageProducerTest.php:
--------------------------------------------------------------------------------
  1 | <?php declare(strict_types = 1);
  2 | 
  3 | namespace LidskaSila\Prooph\Tests\AsynchronousMessages;
  4 | 
  5 | use LidskaSila\Prooph\AsynchronousMessages\AsynchronousMessageProducer;
  6 | use LidskaSila\Prooph\Tests\AsynchronousMessages\FakeImplementations\TestAsynchronousMessageProducerBridge;
  7 | use LidskaSila\Prooph\Tests\EventSourcing\FakeImplementations\TestAggregateCreated;
  8 | use Mockery;
  9 | use PHPUnit\Framework\TestCase;
 10 | use Prooph\Common\Messaging\Message;
 11 | use Prooph\Common\Messaging\NoOpMessageConverter;
 12 | use Prooph\ServiceBus\Exception\RuntimeException;
 13 | use Ramsey\Uuid\Uuid;
 14 | use React\Promise\Deferred;
 15 | 
 16 | class AsynchronousMessageProducerTest extends TestCase
 17 | {
 18 | 
 19 | 	const TEST_PRODUCER_ROUTE_KEY = 'producerRouteKey';
 20 | 
 21 | 	/** @var TestAsynchronousMessageProducerBridge */
 22 | 	private $testProducerBridge;
 23 | 
 24 | 	/** @var AsynchronousMessageProducer */
 25 | 	private $testProducer;
 26 | 
 27 | 	public function setUp()
 28 | 	{
 29 | 		parent::setUp();
 30 | 		$this->givenTestProducerBridge();
 31 | 		$this->givenAsynchronousMessageProducer();
 32 | 	}
 33 | 
 34 | 	public function testInvoke_WithDeferredParam_ShouldThrowRuntimeException()
 35 | 	{
 36 | 		$testMessage = $this->givenTestMessage();
 37 | 		$deffered    = $this->givenMockedDeffered();
 38 | 
 39 | 		$this->willFailWith(RuntimeException::class);
 40 | 
 41 | 		$this->whenInvokeProducerWith($testMessage, $deffered);
 42 | 	}
 43 | 
 44 | 	public function testInvoke_WithoutRoutes_ShouldThrowRuntimeException()
 45 | 	{
 46 | 		$testMessage = $this->givenTestMessage();
 47 | 
 48 | 		$this->willFailWith(RuntimeException::class);
 49 | 
 50 | 		$this->whenInvokeProducerWith($testMessage);
 51 | 	}
 52 | 
 53 | 	public function testInvoke_WithProperRoute_ShouldPublishExpectedMessageToExpectedProducerRouteKey()
 54 | 	{
 55 | 		$this->givenTestProducerHasInjectedTestRoute();
 56 | 
 57 | 		$testMessage = $this->givenTestMessage();
 58 | 
 59 | 		$this->whenInvokeProducerWith($testMessage);
 60 | 
 61 | 		$this->thenShouldPublishExpectedMessageToExpectedProducerRouteKey(self::TEST_PRODUCER_ROUTE_KEY);
 62 | 	}
 63 | 
 64 | 	private function givenTestProducerBridge(): void
 65 | 	{
 66 | 		$this->testProducerBridge = new TestAsynchronousMessageProducerBridge();
 67 | 	}
 68 | 
 69 | 	private function givenAsynchronousMessageProducer(): void
 70 | 	{
 71 | 		$messageConverter   = new NoOpMessageConverter();
 72 | 		$this->testProducer = new AsynchronousMessageProducer($this->testProducerBridge, $messageConverter);
 73 | 	}
 74 | 
 75 | 	private function givenMockedDeffered(): Deferred
 76 | 	{
 77 | 		$deffered = Mockery::mock('React\Promise\Deferred');
 78 | 		assert($deffered instanceof Deferred);
 79 | 
 80 | 		return $deffered;
 81 | 	}
 82 | 
 83 | 	private function givenTestProducerHasInjectedTestRoute()
 84 | 	{
 85 | 		$this->testProducer->injectRoutes(
 86 | 			[
 87 | 				TestAggregateCreated::class => self::TEST_PRODUCER_ROUTE_KEY,
 88 | 			]
 89 | 		);
 90 | 	}
 91 | 
 92 | 	private function givenTestMessage(): Message
 93 | 	{
 94 | 		return TestAggregateCreated::create(Uuid::uuid4());
 95 | 	}
 96 | 
 97 | 	private function willFailWith($class)
 98 | 	{
 99 | 		self::expectException($class);
100 | 	}
101 | 
102 | 	private function whenInvokeProducerWith(Message $message, Deferred $deferred = null): void
103 | 	{
104 | 		$producer = $this->testProducer;
105 | 		$producer($message, $deferred);
106 | 	}
107 | 
108 | 	private function thenShouldPublishExpectedMessageToExpectedProducerRouteKey($expectedProducerRouteKey): void
109 | 	{
110 | 		$publishedMessagesDump = $this->getPublishedEventsFromTestBridge();
111 | 
112 | 		self::assertCount(1, $publishedMessagesDump);
113 | 		$publishedProducerRouteKey = $publishedMessagesDump[0][TestAsynchronousMessageProducerBridge::KEY_ROUTING_KEY];
114 | 		$publishedMessageData      = $publishedMessagesDump[0][TestAsynchronousMessageProducerBridge::KEY_DATA];
115 | 		self::assertEquals($publishedProducerRouteKey, $expectedProducerRouteKey);
116 | 		self::assertEquals($publishedMessageData['message_name'], TestAggregateCreated::class);
117 | 		self::assertEquals($publishedMessageData['payload'], TestAggregateCreated::TEST_PAYLOAD);
118 | 	}
119 | 
120 | 	private function getPublishedEventsFromTestBridge(): array
121 | 	{
122 | 		return $this->testProducerBridge->getPublished();
123 | 	}
124 | }
125 | 


--------------------------------------------------------------------------------
/docs/AsynchronousMessaging.md:
--------------------------------------------------------------------------------
  1 | # AsynchronousMessaging
  2 | 
  3 | <p>
  4 |     If you want integrate prooph with some asynchronous messaging library
  5 |     of your choice (for example <a href="https://github.com/Kdyby/RabbitMq">Kdyby/RabbitMq</a>),
  6 |     you need to write whole implementation of `Prooph\ServiceBus\Async\MessageProducer` on your own. 
  7 |     And you need to make it so that you can configure what message to what producer/exchange should go, right?
  8 |     But hang on boy.
  9 | </p>
 10 | 
 11 | ## This package is shipped with configurable MessageProducer
 12 | <p>
 13 |     Implemented with 
 14 |     `LidskaSila\Prooph\AsynchronousMessages\AsynchronousMessageProducer`,
 15 |     to make it little bit easier for you. It is automatically 
 16 |     registered in Nette container with special id for each bus (if you provide 
 17 |     special config for it).
 18 | </p>
 19 | 
 20 | <p>
 21 |     In this config (example for asynchronous events configuration):
 22 | </p>
 23 | 
 24 | ```yaml
 25 | prooph:
 26 |     asynchronous_messaging:
 27 |         events:
 28 |             bridge: "@producerBridge"
 29 |             routes:
 30 |                 LidskaSila\Prooph\Tests\EventSourcing\FakeImplementations\TestAggregateCreated: producerRouteKey
 31 | ```
 32 | 
 33 | <p>
 34 |     you set your routes and type/id of your service that implements bridge interface 
 35 |     (`LidskaSila\Prooph\AsynchronousMessages\AsynchronousMessageProducerBridge`)
 36 |     (Yes, damn, you still have to implement something but I will show you, it's easy!).
 37 | </p>
 38 | 
 39 | <p>
 40 |     This will register service `LidskaSila\Prooph\AsynchronousMessages\AsynchronousMessageProducer` 
 41 |     with container id "prooph.asynchronous_messaging.events".
 42 | </p>
 43 | 
 44 | <p>
 45 |     But to make it work, you need to have registered two services:
 46 | </p>
 47 | <ol>
 48 |     <li>
 49 |         Your implementation of `LidskaSila\Prooph\AsynchronousMessages\AsynchronousMessageProducerBridge` 
 50 |         with ID you provided in asynchronous_messaging config (you can have it type based).
 51 |     </li>
 52 |     <li>
 53 |         Some `Prooph\Common\Messaging\MessageConverter` implementation - it is strategy of how 
 54 |         your Message will be converted to array.
 55 |         There is default NoOpMessageConverter or you can implement your own. ;)
 56 |     </li>
 57 | </ol>
 58 | 
 59 | For example:
 60 | 
 61 | ```yaml
 62 | services:
 63 |     producerBridge: LidskaSila\Prooph\Tests\AsynchronousMessages\FakeImplementations\TestAsynchronousMessageProducerBridge
 64 |     - Prooph\Common\Messaging\NoOpMessageConverter
 65 | ```
 66 | 
 67 | <br>
 68 | 
 69 | Then, you can set async_switch router at Command, Event and/or Query bus configuration with
 70 | that special id. To stick to our example:
 71 | ```yaml
 72 | prooph:
 73 |     service_bus:
 74 |         event_bus:
 75 |             router:
 76 |                 async_switch: "@prooph.asynchronous_messaging.events"
 77 | ```
 78 | 
 79 | ## Final working example config might be:
 80 | 
 81 | ```yaml
 82 | prooph:
 83 |     asynchronous_messaging:
 84 |         events:
 85 |             bridge: "@producerBridge"
 86 |             routes:
 87 |                 LidskaSila\Prooph\Tests\EventSourcing\FakeImplementations\TestAggregateCreated: producerRouteKey
 88 |     service_bus:
 89 |         event_bus:
 90 |             router:
 91 |                 async_switch: "@prooph.asynchronous_messaging.events"
 92 |                 
 93 | services:
 94 |     producerBridge: LidskaSila\Prooph\Tests\AsynchronousMessages\FakeImplementations\TestAsynchronousMessageProducerBridge
 95 |     - Prooph\Common\Messaging\NoOpMessageConverter
 96 |     - Prooph\Common\Messaging\FQCNMessageFactory
 97 | ```
 98 | 
 99 | <p>
100 |     Now, your messages emmited from bus will go through your implementation of bridge you set.
101 | </p>
102 | 
103 | <p>
104 |     Note: messages are routed based on message-name parameter, not class name! 
105 |     It's just that by default message-name parameter equals message class name.
106 | </p>
107 | 
108 | <br>
109 | 
110 | ## Example `AsynchronousMessageProducerBridge` implementation
111 | <p>
112 |     Implementing `LidskaSila\Prooph\AsynchronousMessages\AsynchronousMessageProducerBridge` is very easy,
113 |     it has just one method: 
114 | </p>
115 | 
116 | ```php
117 | <?php
118 | 
119 | namespace LidskaSila\Prooph\AsynchronousMessages;
120 | 
121 | interface AsynchronousMessageProducerBridge
122 | {
123 | 
124 |     public function publishWithRoutingKey($routingKey, $data): void;
125 | }
126 | ```
127 | 
128 | <p>
129 |     So in case of Kdyby/Rabbit, for example, it can be implemented as easy as:
130 | </p>
131 | 
132 | 
133 | ```php
134 | <?php
135 | 
136 | namespace Example\Infrastructure;
137 | 
138 | use Kdyby\RabbitMq\Connection;
139 | use LidskaSila\Prooph\AsynchronousMessages\AsynchronousMessageProducerBridge;
140 | 
141 | class AsynchronousMessageProducer implements AsynchronousMessageProducerBridge
142 | {
143 | 
144 |     /* @var Connection */
145 |     private $rabbit;
146 | 
147 |     public function __construct(Connection $rabbit)
148 |     {
149 |         $this->rabbit = $rabbit;
150 |     }
151 | 
152 |     public function publishWithRoutingKey($producerName, $data): void
153 |     {
154 |         $jsonData = json_encode($data);
155 |         $this->rabbit->getProducer($producerName)->publish($jsonData, $producerName);
156 |     }
157 | }
158 | 
159 | ```
160 | 


--------------------------------------------------------------------------------