GITBOOK-940: No subject

Author: dgafka

SUMMARY.md

@@ -2,17 +2,17 @@
 
 * [About](README.md)
 * [Installation](install-php-service-bus.md)
-* [How to use](quick-start-php-ddd-cqrs-event-sourcing/README.md) - Quick start guides and examples
-  * [CQRS PHP](quick-start-php-ddd-cqrs-event-sourcing/php-cqrs.md) - Command Query Responsibility Segregation
-  * [Event Handling PHP](quick-start-php-ddd-cqrs-event-sourcing/php-event-handling.md) - Event-driven architecture patterns
-  * [Aggregates & Sagas](quick-start-php-ddd-cqrs-event-sourcing/aggregates-and-sagas.md) - Domain modeling building blocks
-  * [Scheduling in PHP](quick-start-php-ddd-cqrs-event-sourcing/scheduling-in-php.md) - Time-based message processing
-  * [Asynchronous PHP](quick-start-php-ddd-cqrs-event-sourcing/asynchronous-php.md) - Background processing and queues
-  * [Event Sourcing PHP](quick-start-php-ddd-cqrs-event-sourcing/event-sourcing-php.md) - Event-based data persistence
-  * [Microservices PHP](quick-start-php-ddd-cqrs-event-sourcing/microservices-php.md) - Distributed system patterns
-  * [Resiliency and Error Handling](quick-start-php-ddd-cqrs-event-sourcing/resiliency-and-error-handling.md) - Fault tolerance strategies
-  * [Laravel Demos](quick-start-php-ddd-cqrs-event-sourcing/laravel-ddd-cqrs-demo-application.md) - Laravel integration examples
-  * [Symfony Demos](quick-start-php-ddd-cqrs-event-sourcing/symfony-ddd-cqrs-demo-application/README.md) - Symfony integration examples
+* [How to use](quick-start-php-ddd-cqrs-event-sourcing/README.md)
+  * [CQRS PHP](quick-start-php-ddd-cqrs-event-sourcing/php-cqrs.md)
+  * [Event Handling PHP](quick-start-php-ddd-cqrs-event-sourcing/php-event-handling.md)
+  * [Aggregates & Sagas](quick-start-php-ddd-cqrs-event-sourcing/aggregates-and-sagas.md)
+  * [Scheduling in PHP](quick-start-php-ddd-cqrs-event-sourcing/scheduling-in-php.md)
+  * [Asynchronous PHP](quick-start-php-ddd-cqrs-event-sourcing/asynchronous-php.md)
+  * [Event Sourcing PHP](quick-start-php-ddd-cqrs-event-sourcing/event-sourcing-php.md)
+  * [Microservices PHP](quick-start-php-ddd-cqrs-event-sourcing/microservices-php.md)
+  * [Resiliency and Error Handling](quick-start-php-ddd-cqrs-event-sourcing/resiliency-and-error-handling.md)
+  * [Laravel Demos](quick-start-php-ddd-cqrs-event-sourcing/laravel-ddd-cqrs-demo-application.md)
+  * [Symfony Demos](quick-start-php-ddd-cqrs-event-sourcing/symfony-ddd-cqrs-demo-application/README.md)
     * [Doctrine ORM](quick-start-php-ddd-cqrs-event-sourcing/symfony-ddd-cqrs-demo-application/doctrine-orm.md)
 * [Tutorial](tutorial-php-ddd-cqrs-event-sourcing/README.md)
   * [Before we start tutorial](tutorial-php-ddd-cqrs-event-sourcing/before-we-start-tutorial.md)
@@ -115,11 +115,11 @@
   * [Sagas: Workflows That Remember](modelling/business-workflows/sagas.md)
   * [Orchestrators: Declarative Workflow Automation](modelling/business-workflows/orchestrators.md)
   * [Handling Failures](modelling/business-workflows/handling-failures.md)
-* [Testing Support](modelling/testing-support/README.md) - Comprehensive testing tools for message-driven applications
-  * [Testing Messaging](modelling/testing-support/testing-messaging.md) - Basic setup and testing fundamentals
-  * [Testing Aggregates and Sagas with Message Flows](modelling/testing-support/testing-aggregates-and-sagas-with-message-flows.md) - Business logic flow testing
-  * [Testing Event Sourcing Applications](modelling/testing-support/testing-event-sourcing-applications.md) - Event sourcing specific patterns
-  * [Testing Asynchronous Messaging](modelling/testing-support/testing-asynchronous-messaging.md) - Async messaging strategies
+* [Testing Support](modelling/testing-support/README.md)
+  * [Testing Messaging](modelling/testing-support/testing-messaging.md)
+  * [Testing Aggregates and Sagas with Message Flows](modelling/testing-support/testing-aggregates-and-sagas-with-message-flows.md)
+  * [Testing Event Sourcing Applications](modelling/testing-support/testing-event-sourcing-applications.md)
+  * [Testing Asynchronous Messaging](modelling/testing-support/testing-asynchronous-messaging.md)
 
 ## Messaging and Ecotone In Depth <a href="#messaging" id="messaging"></a>
 

enterprise.md

@@ -4,9 +4,8 @@
 
 Ecotone comes with two plans:
 
-* **Ecotone Free** comes with [Apache License Version 2.0](https://github.com/ecotoneframework/ecotone-dev/blob/main/LICENSE) for open features. It allows to build message-driven system in PHP, which solves resiliency and scalability at the architecture level. This covers all the features, which are not marked as Enterprise. \
-
-* **Ecotone Enterprise** is based Enterprise licence. It does provides more advanced set of features aim for Enterprise usage. It does bring to the table custom features, additional integrations, and ability to optimization resource usages. 
+* **Ecotone Free** comes with [Apache License Version 2.0](https://github.com/ecotoneframework/ecotone-dev/blob/main/LICENSE) for open features. It allows to build message-driven system in PHP, which solves resiliency and scalability at the architecture level. This covers all the features, which are not marked as Enterprise. \\
+* **Ecotone Enterprise** is based Enterprise licence. It does provides more advanced set of features aim for Enterprise usage. It does bring to the table custom features, additional integrations, and ability to optimization resource usages.
 
 {% hint style="success" %}
 Each Enterprise feature is marked with hint on the documentation page. Enterprise features can only be run with licence key.\
@@ -17,14 +16,15 @@ To subscribe to Enterprise plan, visit [https://ecotone.tech/pricing](https://ec
 ## Available Enterprise Features
 
 * [**Kafka Support**](modules/kafka-support/) - Enables integration with Kafka (Event Streaming Platform) to send, receive from Messages from topics, and to use Kafka in form of Message Channel abstraction for seamless integration into the System.
-* [**Rabbit Consumer**](modules/amqp-support-rabbitmq/rabbit-consumer.md) - Provides ability to set up whole consumption process with single Attribute, and to extend it with resiliency patterns like: instant-retry, dead letter or final failure strategy. 
+* [**Rabbit Consumer**](modules/amqp-support-rabbitmq/rabbit-consumer.md) - Provides ability to set up whole consumption process with single Attribute, and to extend it with resiliency patterns like: instant-retry, dead letter or final failure strategy.
 * [**Dynamic Message Channels**](modelling/asynchronous-handling/dynamic-message-channels.md) - Provides ability to simplify deployment strategy, adjusting asynchronous processing to business scenarios, and configure processing per Client dynamically (which is especially useful in Multi-Tenant and SAAS environments).
 * [**Event Sourcing Handlers with Metadata**](modelling/event-sourcing/event-sourcing-introduction/working-with-metadata.md#enterprise-accessing-metadata-during-event-application) - Provides ability to pass Metadata to Aggregate's Event Sourcing Handlers. This can be used to to adjust Aggregate's reconstruction process, based on Metadata information stored in related Events.
 * [**Asynchronous Message Buses**](modelling/asynchronous-handling/asynchronous-message-bus-gateways.md) **-** This grants ability to build customized Command/Event Buses where Message will first go over given Asynchronous Channel. This can be used to build for example Outbox Command Bus.
 * [**Distributed Bus with Service Map**](modelling/microservices-php/distributed-bus/distributed-bus-with-service-map/) - Provides way to communicate between Services (Applications) with ease and in explicit and decoupled way. Make it possible to use all available Message Channels providers (RabbitMQ, Amazon SQS, Redis, Dbal, Kafka, Symfony Message Channels, Laravel Queues).
-* [**Command Bus Instant Retries**](modelling/recovering-tracing-and-monitoring/resiliency/retries.md#customized-instant-retries) - Provides ability to roll out new Command Bus with custom retry configuration. Allows to help in self-healing from scenarios like during HTTP request - external service went down, or our database connection was interrupted. 
+* [**Command Bus Instant Retries**](modelling/recovering-tracing-and-monitoring/resiliency/retries.md#customized-instant-retries) - Provides ability to roll out new Command Bus with custom retry configuration. Allows to help in self-healing from scenarios like during HTTP request - external service went down, or our database connection was interrupted.
 * [**Command Bus Error Channel** ](modelling/recovering-tracing-and-monitoring/resiliency/error-channel-and-dead-letter/#command-bus-error-channel)- Provides ability to configure Error Channel for Command Bus. This way we can handle with grace synchronous scenarios like failure on receiving webhook, by pushing the Message to Error Channel.
 * [**Instant Aggregate Fetch**](modelling/command-handling/repository/repository.md#instant-fetch-aggregate) - Provides ability to fetch Aggregates directly without the need to access Repositories. This way we can keep the code focused on the business logic instead of orchestration level code.
+* [**Orchestrators**](modelling/business-workflows/orchestrators.md) -  Perfect for building **predefined and dynamic workflows** where the workflow definition is separate from the individual steps.
 * Details about more features coming soon...
 
 ## Materials

modelling/business-workflows/connecting-handlers-with-channels.md

@@ -27,6 +27,7 @@ public function place(PlaceOrder $command): void
 ```
 
 **What happens behind the scenes:**
+
 1. Ecotone creates a channel named `place.order`
 2. Your handler listens to this channel
 3. When you use the Command Bus, it sends messages to this channel
@@ -69,6 +70,7 @@ class ProcessOrder
 ```
 
 **How the flow works:**
+
 1. You send `PlaceOrder` to `verify.order` channel
 2. The `verify()` method processes it and returns the command
 3. Ecotone automatically sends the returned command to `place.order` channel
@@ -107,9 +109,10 @@ class ProcessOrder
 ```
 
 **What this means:**
-- ✅ `verify.order` can be called via Command Bus (entry point)
-- ❌ `place.order` can only be reached through the workflow
-- 🔒 This ensures orders are always verified before being placed
+
+* ✅ `verify.order` can be called via Command Bus (entry point)
+* ❌ `place.order` can only be reached through the workflow
+* 🔒 This ensures orders are always verified before being placed
 
 {% hint style="success" %}
 **Extending Workflows**: You can easily add more steps by adding `outputChannelName` to any handler. To send messages to multiple handlers, use the [Router pattern](../../messaging/messaging-concepts/message-endpoint/message-routing.md).
@@ -118,9 +121,10 @@ class ProcessOrder
 ## Adding Asynchronous Processing
 
 Sometimes you want parts of your workflow to run asynchronously (in the background). This is perfect for:
-- Heavy processing that shouldn't block the user
-- Ensuring messages aren't lost if something goes wrong
-- Scaling parts of your workflow independently
+
+* Heavy processing that shouldn't block the user
+* Ensuring messages aren't lost if something goes wrong
+* Scaling parts of your workflow independently
 
 **Example**: Keep verification synchronous (fast feedback) but make order placement asynchronous (reliable processing):
 
@@ -152,6 +156,7 @@ class ProcessOrder
 ```
 
 **What happens now:**
+
 1. `verify()` runs immediately and returns a response
 2. The message goes to a queue/background processor
 3. `place()` runs later in the background
@@ -166,9 +171,10 @@ class ProcessOrder
 ## Adding Delays and Timeouts
 
 Asynchronous handlers can also be delayed, which is perfect for business scenarios like:
-- Giving customers time to complete actions
-- Implementing timeout behaviors
-- Scheduling follow-up actions
+
+* Giving customers time to complete actions
+* Implementing timeout behaviors
+* Scheduling follow-up actions
 
 **Example**: Give customers 24 hours to pay, then automatically cancel unpaid orders:
 
@@ -219,8 +225,9 @@ class OrderTimeoutHandler
 ```
 
 **Timeline:**
-- ⏰ **T+0**: Order placed, event published
-- ⏰ **T+24h**: Cancellation handler runs automatically
+
+* ⏰ **T+0**: Order placed, event published
+* ⏰ **T+24h**: Cancellation handler runs automatically
 
 ## Controlling Workflow Flow
 
@@ -405,7 +412,7 @@ class ProcessOrder
         $this->placedOrders[] = $command->orderId;
     }
 
-    // Test helpers
+    // In production application you would most likely have some repository
     public function wasOrderVerified(string $orderId): bool
     {
         return in_array($orderId, $this->verifiedOrders);
@@ -457,56 +464,6 @@ class WorkflowChainTest extends TestCase
 }
 ```
 
-### Testing Header Enrichment
-
-Test workflows that modify message headers:
-
-```php
-class HeaderEnrichmentProcessor
-{
-    #[InternalHandler(
-        inputChannelName: 'enrich.headers',
-        outputChannelName: 'use.headers',
-        changingHeaders: true
-    )]
-    public function enrichHeaders(CustomerData $customer): array
-    {
-        return [
-            'customerType' => $customer->isPremium() ? 'premium' : 'standard',
-            'riskScore' => $this->calculateRisk($customer)
-        ];
-    }
-
-    #[InternalHandler('use.headers')]
-    public function useHeaders(
-        CustomerData $customer,
-        #[Header('customerType')] string $customerType,
-        #[Header('riskScore')] int $riskScore
-    ): string {
-        return "Customer: {$customer->name}, Type: {$customerType}, Risk: {$riskScore}";
-    }
-
-    private function calculateRisk(CustomerData $customer): int
-    {
-        return $customer->isPremium() ? 10 : 50;
-    }
-}
-
-public function test_header_enrichment_workflow(): void
-{
-    $processor = new HeaderEnrichmentProcessor();
-    $ecotoneLite = EcotoneLite::bootstrapFlowTesting(
-        [HeaderEnrichmentProcessor::class],
-        [$processor]
-    );
-
-    $premiumCustomer = new CustomerData(name: 'John Doe', premium: true);
-    $result = $ecotoneLite->sendDirectToChannel('enrich.headers', $premiumCustomer);
-
-    $this->assertEquals('Customer: John Doe, Type: premium, Risk: 10', $result);
-}
-```
-
 ### Testing Asynchronous Workflows
 
 Test async workflows in synchronous mode for easier testing:
@@ -563,10 +520,11 @@ public function test_async_workflow_in_sync_mode(): void
 You now understand the fundamentals of connecting handlers with channels in Ecotone:
 
 ### Key Concepts
-- **Channels**: Every handler has an input channel, and can send to output channels
-- **Connection**: Use `outputChannelName` to chain handlers together
-- **Privacy**: Use `InternalHandler` to make handlers private to workflows
-- **Async Processing**: Add `#[Asynchronous]` for background processing
-- **Delays**: Use `#[Delayed]` for time-based workflows
-- **Flow Control**: Return `null` to stop workflows
-- **Data Enrichment**: Transform payloads or add headers
+
+* **Channels**: Every handler has an input channel, and can send to output channels
+* **Connection**: Use `outputChannelName` to chain handlers together
+* **Privacy**: Use `InternalHandler` to make handlers private to workflows
+* **Async Processing**: Add `#[Asynchronous]` for background processing
+* **Delays**: Use `#[Delayed]` for time-based workflows
+* **Flow Control**: Return `null` to stop workflows
+* **Data Enrichment**: Transform payloads or add headers