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.

// 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 :

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

Ou chargez un seul fichier :

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

Ensuite, lancez le flux par son nom :

$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 :

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 :

// 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.