# Workflowafhankelijkheden

Gebruik wachttijden voor workflowafhankelijkheden wanneer één workflow op hoofdniveau pas verder mag gaan nadat andere workflows zijn voltooid. Zo coördineer je verschillende workflows zonder alles in één enorme workflowdefinitie te stoppen.

Deze wachttijden werken bijzonder goed samen met [Asynchrone overdrachten](https://queuety.inline0.dev/nl/docs/workflows/async-handoffs), waarbij één workflow eerst onafhankelijke onderliggende workflows start en er later op wacht.

Zie [Agentorkestratie](https://queuety.inline0.dev/nl/docs/workflows/agent-orchestration) voor uitgebreidere voorbeelden van planner en executor.

Queuety biedt drie buildermethoden:

- `wait_for_workflow()` voor één workflow
- `wait_for_workflows()` voor meerdere workflows met de semantiek van `all`, `any` of `quorum`
- `wait_for_workflow_group()` wanneer de workflow-ID's afkomstig zijn van een eerder gestarte groep

## Wachten op één workflow

```php
$research_id = Queuety::workflow( 'research_run' )
    ->then( PlanResearchStep::class )
    ->for_each( 'tasks', ExecuteResearchTask::class, 'results' )
    ->dispatch( [ 'brief_id' => 42 ] );

$editorial_id = Queuety::workflow( 'editorial_run' )
    ->wait_for_workflow( $research_id, 'research' )
    ->then( DraftBriefStep::class )
    ->dispatch();
```

Wanneer `research_run` is voltooid, wordt `editorial_run` hervat. Als `result_key` is ingesteld, wordt de status van de voltooide afhankelijkheid onder die sleutel opgeslagen:

```php
$state['research']; // public state from the completed research workflow
```

Zonder `result_key` wordt de openbare status van de afhankelijke workflow samengevoegd met de status op hoofdniveau van de wachtende workflow.

## Wachten op meerdere workflows

```php
use Queuety\Enums\WaitMode;

Queuety::workflow( 'synthesis_run' )
    ->wait_for_workflows(
        [ $research_id, $editorial_id, $legal_id ],
        WaitMode::All,
        'dependencies'
    )
    ->then( PublishPacketStep::class )
    ->dispatch();
```

- `WaitMode::All` wordt pas hervat wanneer alle vermelde workflows zijn voltooid.
- `WaitMode::Any` wordt hervat zodra de eerste vermelde workflow is voltooid.
- `WaitMode::Quorum` wordt hervat zodra het vereiste aantal workflows succesvol is voltooid.

```php
Queuety::workflow( 'synthesis_run' )
    ->wait_for_workflows(
        [ $research_id, $editorial_id, $legal_id ],
        WaitMode::Quorum,
        'dependencies',
        quorum: 2,
    )
    ->then( PublishPacketStep::class )
    ->dispatch();
```

Met `result_key` wordt de status van voltooide afhankelijkheden bij wachttijden voor meerdere workflows opgeslagen onder de workflow-ID:

```php
[
    '42' => [ 'summary' => '...' ],
    '43' => [ 'summary' => '...' ],
]
```

Zonder `result_key` wordt de status van voltooide afhankelijkheden in de volgorde van de afhankelijkheden samengevoegd met de status op hoofdniveau van de wachtende workflow.

## Afhankelijkheids-ID's uit de workflowstatus ophalen

Je kunt de lijst met afhankelijkheden uitstellen tot runtime door workflow-ID's uit de openbare status te lezen:

```php
Queuety::workflow( 'agent_follow_up' )
    ->wait_for_workflow( 'parent_workflow_id', 'parent' )
    ->then( FinalizeAgentRunStep::class )
    ->dispatch( [ 'parent_workflow_id' => $workflow_id ] );
```

Voor meerdere afhankelijkheden:

```php
Queuety::workflow( 'aggregator' )
    ->wait_for_workflows( 'dependency_ids', WaitMode::Any, 'winner' )
    ->dispatch( [ 'dependency_ids' => [ 12, 18, 22 ] ] );
```

## Wachten op een gestarte workflowgroep

Als een eerdere stap `start_workflows()` of `start_agents()` een duurzame groepssleutel heeft opgeslagen, kun je rechtstreeks op die groep wachten in plaats van workflow-ID's zelf door de openbare status door te geven.

```php
Queuety::workflow( 'brief_research' )
    ->then( PlanTopicsStep::class )
    ->start_agents( 'agent_tasks', $agent_run, group_key: 'researchers' )
    ->wait_for_agent_group( 'researchers', WaitMode::Quorum, 2, 'agent_results' )
    ->then( SynthesizeBriefStep::class )
    ->dispatch();
```

## Wat gebeurt er tijdens het wachten

Wanneer een workflow een van deze stappen bereikt, krijgt deze de status `waiting_for_workflows`. Tijdens het wachten blijft er geen worker aan gekoppeld.

```php
$state = Queuety::workflow_status( $workflow_id );
echo $state->status->value; // 'waiting_for_workflows'
echo $state->wait_type;     // 'workflow'
print_r( $state->waiting_for ); // ['42', '43']
```

Als een afhankelijkheid al is voltooid voordat de wachtstap wordt bereikt, gaat de workflow onmiddellijk verder.

## Foutsemantiek

Wachttijden voor workflowafhankelijkheden zijn gericht op succes:

- `wait_for_workflow()` en `WaitMode::All` mislukken als een vereiste afhankelijkheid mislukt of wordt geannuleerd.
- `WaitMode::Any` mislukt alleen wanneer elke afhankelijkheid een eindstatus heeft bereikt en geen enkele succesvol is voltooid.
- `WaitMode::Quorum` mislukt wanneer de resterende actieve workflows niet langer aan het vereiste quorum kunnen voldoen.

Hierdoor zijn wachttijden voor workflows nuttig in planner- en executorsystemen, waarin de ene workflow werk kan verdelen en een andere kan wachten op resultaten `all` of op de eerste succesvolle vertakking die klaar is.