# Duurzame vertragingen

Workflows kunnen tussen stappen gedurende een vaste tijd worden gepauzeerd met de buildermethode `delay()`. Vertragingsstappen zijn duurzaam: de vertraging wordt in de database opgeslagen, zodat deze behouden blijft bij herstarts van workers, implementaties en serverherstarts.

## De methode `->delay()`

Voeg overal in de workflowketen een vertragingsstap toe:

```php
use Queuety\Queuety;

Queuety::workflow( 'drip_campaign' )
    ->then( SendWelcomeEmailHandler::class )
    ->delay( days: 1 )
    ->then( SendFollowUpEmailHandler::class )
    ->delay( days: 3 )
    ->then( SendFinalEmailHandler::class )
    ->dispatch( [ 'user_id' => 42 ] );
```

De workflow zal:

1. `SendWelcomeEmailHandler` uitvoeren
2. 1 day wachten
3. `SendFollowUpEmailHandler` uitvoeren
4. 3 days wachten
5. `SendFinalEmailHandler` uitvoeren

## Duurparameters

De methode `delay()` accepteert elke combinatie van benoemde duurparameters:

| Parameter | Type | Beschrijving |
|---|---|---|
| `$seconds` | `int` | Aantal seconden wachten |
| `$minutes` | `int` | Aantal minuten wachten |
| `$hours` | `int` | Aantal uren wachten |
| `$days` | `int` | Aantal dagen wachten |

Alle waarden worden bij elkaar opgeteld. Deze zijn gelijkwaardig:

```php
->delay( seconds: 3600 )
->delay( minutes: 60 )
->delay( hours: 1 )
```

Je kunt ze combineren:

```php
->delay( hours: 1, minutes: 30 ) // 90 minutes total
```

## Hoe vertragingsstappen werken

Wanneer een workflow een vertragingsstap bereikt, verzendt Queuety een interne taak `__queuety_delay` met de kolom `available_at` ingesteld op de huidige tijd plus de vertragingsduur. De taak staat in de database en wordt pas door een worker opgepakt nadat de vertraging is verstreken.

Dit betekent:

- **Geen polling.** Workers controleren de vertraging niet herhaaldelijk. De taak komt gewoon beschikbaar zodra de tijd is verstreken.
- **Geen geheugengebruik.** Tijdens het wachten draait er niets. De vertraging bestaat alleen als een databaseregel.
- **Bestand tegen herstarts.** Als de worker opnieuw start, staat de vertragingstaak nog in de wachtrij met de juiste tijdstempel `available_at`.

Wanneer de vertragingstaak na de vertraging wordt opgepakt, gaat de workflow automatisch verder met de volgende stap.

## Voorbeeld: uitgestelde meldingen

Stuur 1 uur nadat een gebruiker zich heeft aangemeld een herinnering, maar alleen als die de onboarding niet heeft voltooid:

```php
Queuety::workflow( 'onboarding_reminder' )
    ->then( CreateAccountHandler::class )
    ->delay( hours: 1 )
    ->then( CheckOnboardingHandler::class )
    ->then( SendReminderHandler::class )
    ->dispatch( [ 'email' => 'user@example.com' ] );
```

De stap `CheckOnboardingHandler` kan de status controleren en [voorwaardelijke vertakkingen](https://queuety.inline0.dev/nl/docs/workflows/conditional) gebruiken om de herinnering over te slaan als de onboarding al is voltooid.

## Voorbeeld: nieuwe poging met wachttijd

Voeg opzettelijke vertragingen in tussen stappen die op nieuwe pogingen lijken:

```php
Queuety::workflow( 'poll_external_api' )
    ->then( CheckStatusHandler::class, 'check' )
    ->delay( minutes: 5 )
    ->then( CheckStatusHandler::class, 'recheck' )
    ->delay( minutes: 15 )
    ->then( CheckStatusHandler::class, 'final_check' )
    ->then( ProcessResultHandler::class )
    ->dispatch( [ 'external_id' => 'abc-123' ] );
```

## Meerdere vertragingen

Een workflow kan elk aantal vertragingsstappen bevatten. Elke vertraging is onafhankelijk en wordt bijgehouden met een opeenvolgende naam (`delay_0`, `delay_1`, enzovoort) in de workflowstatus.

```php
Queuety::workflow( 'multi_step_drip' )
    ->then( StepA::class )
    ->delay( hours: 2 )
    ->then( StepB::class )
    ->delay( days: 1 )
    ->then( StepC::class )
    ->delay( minutes: 30 )
    ->then( StepD::class )
    ->dispatch( $payload );
```