## Flux de travail dans un seul fichier

Un flux de travail peut être entièrement autonome dans un seul fichier PHP. Définissez ensemble les classes d’étape et le générateur, placez le fichier dans un répertoire, puis chargez ce répertoire avec `Queuety::load_workflows()` (comme indiqué ci-dessous). Queuety n’analyse aucun répertoire de lui-même.

```php
// workflows/onboard-user.php
use Queuety\Queuety;

class CreateAccount implements \Queuety\Step {
    public function handle(array $state): array {
        $user = create_user($state['email']);
        return ['user_id' => $user->id, 'user_name' => $user->name];
    }
    public function config(): array {
        return ['max_attempts' => 3];
    }
}

class SendWelcome implements \Queuety\Step {
    public function handle(array $state): array {
        wp_mail($state['email'], 'Welcome ' . $state['user_name'], '...');
        return ['welcomed' => true];
    }
    public function config(): array {
        return [];
    }
}

return Queuety::define_workflow('onboard_user')
    ->then(CreateAccount::class, 'create_account')
    ->then(SendWelcome::class, 'send_welcome');
```

Le fichier renvoie un `WorkflowBuilder`. Chaque classe d’étape est définie en ligne. Une fois le fichier chargé, les classes sont disponibles et le flux de travail est enregistré comme modèle.

## Charger des flux de travail

Chargez tous les fichiers de flux de travail d’un répertoire :

```php
// Load all .php files from the workflows directory
$count = Queuety::load_workflows(__DIR__ . '/workflows/');
```

Ou chargez un seul fichier :

```php
$template = Queuety::load_workflow_file(__DIR__ . '/workflows/onboard-user.php');
```

Ensuite, lancez le flux par son nom :

```php
$workflow_id = Queuety::run_workflow('onboard_user', ['email' => 'user@example.com']);
```

## Chargement récursif

Passez `true` comme deuxième argument pour analyser les sous-répertoires :

```php
Queuety::load_workflows(__DIR__ . '/workflows/', recursive: true);
```

Cela permet d’organiser les flux de travail en dossiers :

```
workflows/
├── onboarding/
│   ├── new-user.php
│   └── trial-upgrade.php
├── reports/
│   ├── daily-summary.php
│   └── weekly-digest.php
└── notifications/
    └── digest-email.php
```

## Utiliser toutes les fonctionnalités des flux de travail

Les flux de travail en fichiers prennent en charge tout ce que permet le générateur, sauf `idempotency_key()`, qui n’est pas enregistré dans le modèle ; transmettez-le plutôt à chaque lancement avec `Queuety::run_workflow( $name, $payload, [ 'idempotency_key' => '...' ] )`. Les pauses, les signaux, les étapes parallèles, le branchement conditionnel, les lancements de flux, les gestionnaires d’annulation et l’élagage de l’état sont tous pris en charge :

```php
// workflows/approval-flow.php
use Queuety\Queuety;

class SubmitRequest implements \Queuety\Step {
    public function handle(array $state): array {
        return ['submitted_at' => date('Y-m-d H:i:s')];
    }
    public function config(): array { return []; }
}

class ProcessApproval implements \Queuety\Step {
    public function handle(array $state): array {
        return [
            'approved_by' => $state['approved_by'],
            'processed' => true,
        ];
    }
    public function config(): array { return []; }
}

class CleanupRequest implements \Queuety\Handler {
    public function handle(array $payload): void {
        delete_pending_request($payload['request_id']);
    }
    public function config(): array { return []; }
}

return Queuety::define_workflow('approval_flow')
    ->then(SubmitRequest::class)
    ->delay(hours: 24)
    ->wait_for_signal('approved')
    ->then(ProcessApproval::class)
    ->on_cancel(CleanupRequest::class)
    ->prune_state_after(2);
```

## Quand utiliser des flux de travail en fichiers

Les flux de travail en fichiers sont idéaux lorsque :

- Un LLM ou un générateur de code crée des flux de travail par programmation
- Le flux de travail est assez simple pour tenir dans un seul fichier
- Vous souhaitez garder la logique des étapes près de la définition du flux
- Vous créez un prototype et souhaitez itérer rapidement

Pour les flux plus importants, avec des classes d’étape partagées, des intergiciels complexes ou des étapes réutilisées dans plusieurs flux, l’approche standard consistant à séparer les classes dans des fichiers avec chargement automatique PSR-4 est plus facile à maintenir.

## Fonctionnement

En coulisses, les flux de fichiers utilisent exactement le même moteur que le constructeur API. Chaque étape est un travail distinct dans la base de données. L’état transite par la table `queuety_workflows`. Il n’y a ni rejeu, ni exigence de déterminisme, ni différence de performances.

Chaque appel à load `require` le fichier (pas `require_once`) : chargez donc chaque fichier une seule fois par requête. Le charger deux fois redéclare ses classes et provoque une erreur. Le `WorkflowBuilder` renvoyé est converti en `WorkflowTemplate` et stocké dans le `WorkflowRegistry`. La répartition et l’exécution sont identiques à celles de tout autre flux de travail.