Contexte d'évaluation

Le contexte d'évaluation est le cœur de MEL. Il détermine comment vos expressions sont résolues et évaluées à l'exécution. Comprendre ce mécanisme vous aidera à créer des filtres plus efficaces.

Rôle du contexte

Le MelContext est responsable de transformer vos expressions abstraites en résultats concrets. Il effectue plusieurs opérations essentielles :

Résolution des chemins : Transforme $form.order.provider.name en valeur réelle
Récupération d'objets : Charge les objets référencés par leur ID
Récupération d'utilisateurs : Charge les informations utilisateur par ID
Résolution de formules : Calcule les propriétés formulaires si nécessaire
Accès aux métadonnées : Navigue dans les payloads d'énumérations

Bon à savoir

Le contexte est créé automatiquement par Miel. Vous n'avez pas à le manipuler directement, mais comprendre son fonctionnement vous aide à écrire des expressions plus efficaces.

Structure du contexte

Le contexte reçoit un dictionnaire de données qui contient toutes les sources disponibles pour vos expressions :

TypeScript

{
  $form: {
    // Données du formulaire en cours
    status: "pending",
    selectedTypes: ["CDI", "CDD"],
    order: {
      id: "order-123",
      provider: { name: "NETKIN" }
    }
  },
  $object: {
    // Objet actuellement affiché
    id: "obj-456",
    project: "proj-789",
    createdAt: "2024-01-15"
  },
  $selector: {
    // Données du sélecteur (widgets)
    beneficiary: 2,
    status: "validated"
  },
  $user: {
    // Utilisateur actuellement sélectionné
    id: "user-001",
    role: "admin",
    department: "engineering"
  },
  $context: {
    // Contexte d'exécution global
    date: "2024-01-20",
    environment: "production"
  },
  $selfUser: "user-001"  // ID de l'utilisateur connecté
}

Chaque préfixe ($form, $object, etc.) correspond à une clé de ce dictionnaire.

Résolution des chemins

Quand vous écrivez un chemin comme $form.order.provider.name, le contexte le résout étape par étape :

Étapes de résolution

Parse le chemin : Sépare en segments ["$form", "order", "provider", "name"]
Accède à la source : Trouve la racine $form
Navigue récursivement : Parcourt order → provider → name
Charge les références : Si une valeur est un ID, charge l'objet correspondant
Résout les formules : Calcule les propriétés dynamiques si nécessaire
Retourne la valeur : "NETKIN"

Exemple de résolution

JSON

// Expression MEL
{ "providerName": { "$eq": "$form.order.provider.name" } }

// Le contexte contient :
$form = {
  order: {
    provider: { name: "NETKIN" }
  }
}

// Résolution :
// 1. $form → { order: { provider: { name: "NETKIN" } } }
// 2. $form.order → { provider: { name: "NETKIN" } }
// 3. $form.order.provider → { name: "NETKIN" }
// 4. $form.order.provider.name → "NETKIN"

// Expression résolue :
{ "providerName": { "$eq": "NETKIN" } }

Chargement automatique des références

Si $form.order contient un ID plutôt qu'un objet complet, le contexte chargera automatiquement l'objet correspondant depuis la base de données. Ce mécanisme est transparent pour vous.

Algorithme d'évaluation

Une fois les chemins résolus, MEL évalue l'expression selon cet algorithme :

text

evaluateExpression(expression, context):

  SI expression contient '$or':
    RETOURNER true SI AU MOINS UNE sous-expression est vraie

  SI expression contient '$and':
    RETOURNER true SI TOUTES les sous-expressions sont vraies

  SINON:
    RETOURNER evaluateCondition(expression, context)

Évaluation des comparaisons

Chaque opérateur a sa propre logique d'évaluation :

Opérateur	Logique d'évaluation
`$eq`	Gère les tableaux singleton et l'égalité directe
`$ne`	Inverse de $eq
`$gt, $gte, $lt, $lte`	Comparaisons numériques standard
`$in`	Vérifie l'intersection de tableaux ou l'inclusion
`$nin`	Inverse de $in
`$exists`	Vérifie la présence/absence d'une propriété
`$regex`	Test de correspondance avec expression régulière

Gestion spéciale des tableaux

Le contexte gère intelligemment les comparaisons impliquant des tableaux :

Tableau vs tableau : Vérifie s'il y a une intersection
Tableau vs valeur : Vérifie si la valeur est dans le tableau
Valeur vs valeur : Comparaison directe

Correspondance avec les objets

La fonction principale du contexte est de vérifier si un objet correspond à une expression MEL. Voici comment les chemins sont résolus dans un objet :

Résolution dans un CustomObject

JSON

// L'objet à tester
{
  "id": "obj-123",
  "status": "active",
  "props": {
    "priority": { "value": 1 },
    "category": { "value": "premium" }
  }
}

// Expression MEL
{ "status": { "$eq": "active" } }

// Résolution :
// 1. Cherche "status" directement sur l'objet → "active"
// 2. Compare "active" == "active" → true

Accès aux propriétés (props)

JSON

// Expression MEL
{ "priority": { "$eq": 1 } }

// Résolution :
// 1. "priority" n'existe pas directement sur l'objet
// 2. Cherche dans props: object.props.priority.value → 1
// 3. Compare 1 == 1 → true

Bon à savoir

Le contexte essaie d'abord de trouver la propriété directement sur l'objet, puis dans props[key].value. Cela vous permet d'utiliser la même syntaxe pour les propriétés système et les propriétés personnalisées.

Prochaine étape

Vous comprenez maintenant le fonctionnement interne de MEL. Passez aux exemples pratiques pour voir tout cela en action avec des cas d'usage réels.

Exemples pratiques →← Expressions imbriquées