Automation Layer

Vue d'ensemble

L'Automation Layer transforme DIXX en un opérateur autonome de données. Il permet de transformer des opérations manuelles (sauvegardes, nettoyages, rapports) en pipelines intelligents auto-exécutants, capables de fonctionner sans intervention humaine, en continu. Chaque pipeline suit une logique rigoureuse et extensible.

Modèle d'Orchestration Unifié

Chaque pipeline repose sur un modèle standard étendu, avec un niveau de Post-Actions permettant le chaining intelligent entre pipelines.

Typologie des Déclencheurs

Moteur de Conditions Avancé

DIXX embarque un moteur logique complet supportant les conditions simples, combinées (AND/OR) et dynamiques basées sur les sorties des pipelines précédents.

{
  "conditions": [
    {
      "type": "group",
      "config": {
        "op": "AND",
        "items": [
          { "type": "rbac", "config": { "requiredRole": "editor" } },
          { "type": "require_connection" },
          {
            "type": "utc_window",
            "config": { "startHour": 2, "endHour": 4, "days": [1,2,3,4,5] }
          }
        ]
      }
    },
    {
      "type": "last_run_outcome",
      "config": { "expect": "success" }
    }
  ]
}

Les 6 Pipelines Disponibles

Retry Exponentiel & Idempotency

Chaque action critique est protégée par un algorithme de retry avec backoff exponentiel et jitter aléatoire pour éviter les collisions en cas d'exécution simultanée.

// src/lib/services/automation-service.ts
export async function withRetries(
  label: string,
  fn: () => Promise,
  options?: { maxAttempts?: number; baseDelayMs?: number; maxDelayMs?: number }
): Promise {
  const maxAttempts = options?.maxAttempts ?? 3;
  const baseDelayMs = options?.baseDelayMs ?? 1000;
  const maxDelayMs = options?.maxDelayMs ?? 30_000;
  
  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
    try {
      return await fn();
    } catch (e) {
      if (attempt >= maxAttempts) throw e;
      // Exponential Backoff + Jitter anti-collision
      const exp = Math.min(maxDelayMs, baseDelayMs * Math.pow(2, attempt - 1));
      const jitter = Math.floor(Math.random() * 250);
      await sleep(exp + jitter); // ex: 1s, 2s, 4s (+ jitter)
    }
  }
}
// Idempotency : chaque job identifié par idempotencyKey
// → évite les double-exécutions cron simultanées

Système de Notifications Intelligent

La stratégie de notification s'adapte automatiquement au niveau de criticité de l'événement, avec anti-spam via cooldown configurable par pipeline.

// Logique de sélection du canal (automation-service.ts)
// critical → SMS + Email
// standard → Email seulement  
// info     → in-app uniquement

const failureSeverity = onFailureSms ? "critical" : "standard";

Création via Langage Naturel

L'utilisateur peut créer un pipeline complet en une phrase dans le Smart Terminal. L'IA parse la demande et génère automatiquement la configuration JSON du pipeline.

Architecture Queue (DB-Native MVP)

En MVP, DIXX utilise une stratégie de queue 100% native Next.js basée sur la table PostgreSQL automation_queue via Supabase. Aucun service externe Redis ou BullMQ n'est requis.

-- Table automation_queue : source de vérité de tous les jobs
SELECT id, automation_id, status, priority, attempts, retry_after
FROM automation_queue
WHERE status = 'pending'
  AND is_dead_letter = false
  AND retry_after <= NOW()
ORDER BY priority ASC, scheduled_for ASC
LIMIT 10; -- polling toutes les minutes via /api/cron

Limites Institutionnelles MVP

DIXX MVP impose une limite explicite de 10 000 lignes par requête SELECT et par fichier uploadé. Cette limite garantit la performance et la stabilité de la plateforme pour toutes les équipes.