# Actions de contrôle de flux

Les actions de contrôle de flux modifient la **forme** d'un workflow plutôt que ses données : elles branchent, itèrent, interrompent et composent d'autres automatisations en sous-workflows.

## Groupes de conditions

Les branches `path` et le filtre `filter/continue` évaluent des **groupes de conditions** — une ou plusieurs comparaisons combinées avec `and`/`or`.

| Élément      | Description                                                                               |
| ------------ | ----------------------------------------------------------------------------------------- |
| `logic`      | `and` (toutes doivent correspondre, par défaut) ou `or` (au moins une doit correspondre). |
| `conditions` | Tableau de `{ field, operator, value? }` (minimum 1).                                     |

**Opérateurs de comparaison :** `equals`, `notEquals`, `contains`, `notContains`, `startsWith`, `endsWith`, `greaterThan`, `greaterThanOrEqual`, `lessThan`, `lessThanOrEqual`, `isEmpty`, `isNotEmpty`, `isNull`, `isNotNull`, `matches`.

```yaml
condition:
  logic: and
  conditions:
    - { field: '{{trigger.data.status}}', operator: equals, value: paid }
    - { field: '{{trigger.data.amount}}', operator: greaterThan, value: 100 }
```

## Path — Branchement

L'operator `path/branch` achemine l'exécution vers des branches nommées. Chaque branche possède sa propre `condition` et ses `actions` imbriquées.

| Prop    | Description                                                                                                             |
| ------- | ----------------------------------------------------------------------------------------------------------------------- |
| `paths` | Tableau de branches : `{ name, condition?, actions[] }`.                                                                |
| `mode`  | `first-match` (exécute la première branche correspondante) ou `all-matching` (exécute toutes celles qui correspondent). |

```yaml
- name: route
  type: path
  operator: branch
  props:
    mode: first-match
    paths:
      - name: vip
        condition:
          conditions: [{ field: '{{trigger.data.tier}}', operator: equals, value: vip }]
        actions:
          - {
              name: vipEmail,
              type: email,
              operator: send,
              props: { to: '{{trigger.data.email}}', subject: 'VIP welcome', body: 'Thanks!' },
            }
      - name: standard
        actions:
          - {
              name: stdEmail,
              type: email,
              operator: send,
              props: { to: '{{trigger.data.email}}', subject: 'Welcome', body: 'Hi!' },
            }
```

## Loop — Itération

L'operator `loop/each` itère sur un tableau, exécutant ses `actions` imbriquées par élément.

| Prop                  | Description                                                            |
| --------------------- | ---------------------------------------------------------------------- |
| `items`               | Gabarit se résolvant en le tableau à itérer.                           |
| `actions`             | Actions imbriquées exécutées pour chaque élément.                      |
| `maxIterations`       | Plafond sur le nombre d'itérations.                                    |
| `continueOnItemError` | Lorsqu'il vaut `true`, un élément en échec n'interrompt pas la boucle. |

```yaml
- name: notifyEach
  type: loop
  operator: each
  props:
    items: '{{fetchSubscribers.result}}'
    maxIterations: 500
    continueOnItemError: true
    actions:
      - name: send
        type: email
        operator: send
        props: { to: '{{item.email}}', subject: 'Update', body: 'Hi {{item.name}}' }
```

## Flow — Arrêt

L'operator `flow/stop` interrompt immédiatement l'exécution avec un statut et une sortie optionnels.

| Prop      | Description                                     |
| --------- | ----------------------------------------------- |
| `message` | Raison de l'arrêt de l'exécution (templatable). |
| `status`  | `success` ou `error` (par défaut `error`).      |
| `output`  | Sortie clé-valeur renvoyée à l'appelant.        |

```yaml
- name: bail
  type: flow
  operator: stop
  props: { status: success, message: 'Nothing to do', output: { processed: 0 } }
```

## Automation — Call et Return (sous-workflows)

La famille `automation` compose des workflows. `call` invoque une autre automatisation (une avec un déclencheur `automation-call`) ; `return` renvoie une sortie à l'appelant.

| Operator | Props                                                  | Description                                                                                                                                                           |
| -------- | ------------------------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `call`   | `name`, `inputData?`, `waitForCompletion?`, `timeout?` | Invoque une sous-automatisation par `name` ; attend éventuellement sa fin et expire au bout d'un délai.                                                               |
| `return` | `output`                                               | Renvoie une sortie clé-valeur à l'automatisation appelante (uniquement avec un déclencheur `automation-call`). Accessible via `steps.{name}.result.*` dans le parent. |

```yaml
# Parent: invoke a reusable sub-workflow and wait
- name: enrich
  type: automation
  operator: call
  props:
    name: enrich-lead
    inputData: { email: '{{trigger.data.email}}' }
    waitForCompletion: true
    timeout: 30000

# Sub-workflow (trigger: { type: automation-call }): return result
- name: done
  type: automation
  operator: return
  props: { output: { score: '{{computeScore.result}}' } }
```

:::callout
**Sous-workflow vs gestion d'échec.** `automation/call` invoque une cible qui déclare un déclencheur `automation-call`. Pour réagir à un workflow qui _échoue_, utilisez plutôt le [déclencheur `automation-failure`](/fr/docs/automation-triggers).
:::

## Pages connexes

- [Vue d'ensemble des actions](/fr/docs/automation-actions-overview) — propriétés de base et carte des familles.
- [Déclencheurs](/fr/docs/automation-triggers) — déclencheurs `automation-call` et `automation-failure`.
- [Actions de données et d'état](/fr/docs/automation-data-actions) — filtrage conditionnel `filter/continue`.
- [Approbation et délai](/fr/docs/automation-approval-delay) — mise en pause d'une exécution pour des humains ou du temps.