# Workflows ausführen

Ein Workflow kann einen untergeordneten Workflow als einen seiner Schritte starten. Der übergeordnete Workflow pausiert, bis der Run-Workflow abgeschlossen ist. Anschließend wird der Endzustand des untergeordneten Workflows mit dem Zustand des übergeordneten Workflows zusammengeführt.

## Die Methode `->run_workflow()`

```php
use Queuety\Queuety;

$enrichment = Queuety::workflow( 'enrich_user' )
    ->then( FetchSocialHandler::class )
    ->then( FetchCreditScoreHandler::class );

Queuety::workflow( 'onboarding' )
    ->then( CreateAccountHandler::class )
    ->run_workflow( 'enrich_user', $enrichment )
    ->then( SendWelcomeEmailHandler::class )
    ->dispatch( [ 'email' => 'user@example.com' ] );
```

Die Methode `run_workflow()` nimmt zwei Argumente entgegen:
1. Einen Namen für den Run-Workflow
2. Eine `WorkflowBuilder`-Instanz, die die Schritte des Run-Workflows definiert

## So funktioniert es

Wenn der übergeordnete Workflow einen `run_workflow`-Schritt erreicht:

1. Wird der Run-Workflow als unabhängiger Workflow mit eigener ID gestartet
2. Pausiert der übergeordnete Workflow
3. Durchläuft der Run-Workflow seine Schritte wie gewohnt
4. Wird nach Abschluss des Run-Workflows dessen Endzustand mit dem Zustand des übergeordneten Workflows zusammengeführt
5. Wird der übergeordnete Workflow mit dem nächsten Schritt fortgesetzt

## Zustand von übergeordnetem und untergeordnetem Workflow

Der Run-Workflow erhält den aktuell angesammelten Zustand des übergeordneten Workflows als initiale Nutzlast. So können untergeordnete Schritte auf alle Daten zugreifen, die frühere Schritte des übergeordneten Workflows erzeugt haben:

```php
class CreateAccountHandler implements Step {
    public function handle( array $state ): array {
        $user_id = wp_create_user( $state['email'], wp_generate_password() );
        return [ 'user_id' => $user_id ];
    }

    public function config(): array {
        return [];
    }
}

// This run-workflow step can access 'user_id' from the parent
class FetchSocialHandler implements Step {
    public function handle( array $state ): array {
        $profile = fetch_social_profile( $state['user_id'] );
        return [ 'social_data' => $profile ];
    }

    public function config(): array {
        return [];
    }
}
```

## Status zusammenführen

Nach Abschluss des Run-Workflows wird sein Endzustand (ohne interne Schlüssel wie `_steps`, `_queue`, `_priority`, `_max_attempts`) mit dem Zustand des übergeordneten Workflows zusammengeführt. Der nächste Schritt des übergeordneten Workflows sieht alle Daten aus den früheren Schritten des übergeordneten Workflows und dem Run-Workflow:

```php
class SendWelcomeEmailHandler implements Step {
    public function handle( array $state ): array {
        // Has access to:
        // - $state['email'] (from initial dispatch)
        // - $state['user_id'] (from CreateAccountHandler)
        // - $state['social_data'] (from run-workflow's FetchSocialHandler)
        // - $state['credit_score'] (from run-workflow's FetchCreditScoreHandler)

        send_welcome_email( $state['email'], $state['social_data'] );
        return [ 'welcome_sent' => true ];
    }

    public function config(): array {
        return [];
    }
}
```

## Optionen für Run-Workflows

`on_queue()`, `with_priority()` und `max_attempts()` des Run-Workflow-Builders gelten für den untergeordneten Workflow. Andere Workflow-Optionen des untergeordneten Builders, etwa `on_cancel()`, `prune_state_after()`, `must_complete_within()`, `version()`, `idempotency_key()`, die `max_*()`-Budgets und `compensate_on_failure()`, werden nicht übernommen:

```php
$sub = Queuety::workflow( 'heavy_processing' )
    ->on_queue( 'background' )
    ->with_priority( Priority::Normal )
    ->max_attempts( 5 )
    ->then( StepA::class )
    ->then( StepB::class );

Queuety::workflow( 'parent' )
    ->run_workflow( 'heavy', $sub )
    ->then( FinalStep::class )
    ->dispatch( $payload );
```

## Verschachtelte Run-Workflows

Run-Workflows können ihrerseits Run-Workflows enthalten, sodass beliebige Verschachtelungen möglich sind:

```php
$inner = Queuety::workflow( 'inner' )
    ->then( InnerStepA::class )
    ->then( InnerStepB::class );

$middle = Queuety::workflow( 'middle' )
    ->then( MiddleStepA::class )
    ->run_workflow( 'inner', $inner )
    ->then( MiddleStepB::class );

Queuety::workflow( 'outer' )
    ->then( OuterStepA::class )
    ->run_workflow( 'middle', $middle )
    ->then( OuterStepB::class )
    ->dispatch( $payload );
```