Expressions imbriquées

MEL supporte l'imbrication arbitraire des expressions, vous permettant de créer des filtres aussi complexes que nécessaire. Voyons comment construire et comprendre ces expressions avancées.

Principe de l'imbrication

L'imbrication consiste à placer une expression MEL à l'intérieur d'une autre. Chaque niveau d'imbrication ajoute une couche de logique à votre filtre.

Voici comment visualiser une expression imbriquée :

JSON

{
  "$and": [                              // Niveau 1 : ET principal
    { "status": { "$eq": "active" } },   // Condition simple
    {
      "$or": [                           // Niveau 2 : OU imbriqué
        { "type": { "$eq": "A" } },
        { "type": { "$eq": "B" } }
      ]
    }
  ]
}

Cette expression se lit de l'intérieur vers l'extérieur :

D'abord le $or : type est A OU type est B
Puis le $and : status est active ET (résultat du $or)

Bon à savoir

MEL n'a pas de limite technique sur le nombre de niveaux d'imbrication, mais au-delà de 10 niveaux, l'interface visuelle (mode humain) ne pourra plus représenter l'expression.

Exemples progressifs

Niveau 1 : Deux conditions simples

Trouver les commandes validées du bénéficiaire 2 :

JSON

{
  "$and": [
    { "beneficiary": { "$eq": 2 } },
    { "status": { "$eq": "validated" } }
  ]
}

Niveau 2 : Ajout d'alternatives

Même filtre, mais en acceptant les factures OU les dépenses :

JSON

{
  "$and": [
    { "beneficiary": { "$eq": 2 } },
    { "status": { "$eq": "validated" } },
    {
      "$or": [
        { "type": { "$eq": "invoice" } },
        { "type": { "$eq": "expense" } }
      ]
    }
  ]
}

Niveau 3 : Groupes multiples

Un filtre plus élaboré avec plusieurs groupes logiques :

JSON

{
  "$and": [
    {
      "$and": [
        { "beneficiary": { "$eq": 2 } },
        { "status": { "$eq": "validated" } }
      ]
    },
    {
      "$or": [
        { "type": { "$eq": "invoice" } },
        { "type": { "$eq": "expense" } }
      ]
    },
    { "status": { "$not": { "$eq": "draft" } } }
  ]
}

Conseil de lisibilité

Indentez correctement votre JSON et ajoutez des commentaires mentaux pour chaque bloc. Cela vous aidera à comprendre et maintenir vos expressions.

Références dynamiques

Les expressions imbriquées deviennent encore plus puissantes quand vous utilisez des références dynamiques à la place de valeurs fixes.

Référence à l'objet courant

Trouver les éléments liés à l'objet actuellement affiché :

JSON

{
  "$and": [
    { "project": { "$eq": "$object.project" } },
    { "status": { "$in": ["active", "pending"] } },
    { "id": { "$ne": "$object.id" } }
  ]
}

Cette expression trouve les éléments du même projet, actifs ou en attente, en excluant l'objet lui-même.

Référence à l'utilisateur connecté

Afficher les tâches assignées à l'utilisateur connecté OU urgentes :

JSON

{
  "$or": [
    { "assignedTo": { "$in": ["$selfUser"] } },
    { "isUrgent": { "$eq": true } }
  ]
}

Combinaison de sources

Vous pouvez combiner plusieurs sources de données dans une même expression :

JSON

{
  "$and": [
    { "department": { "$eq": "$user.department" } },
    { "status": { "$in": "$form.selectedStatuses" } },
    { "createdBy": { "$ne": "$selfUser" } }
  ]
}

Fusion d'expressions

Dans certains contextes (comme les widgets de tableau de bord), Miel fusionne automatiquement plusieurs expressions MEL. Comprendre cette logique vous aide à prévoir le comportement de vos filtres.

Fusion de champs différents

Quand deux expressions portent sur des champs différents, elles sont simplement combinées :

JSON

// Expression du widget
{ "status": { "$eq": "active" } }

// Expression du dashboard
{ "assignedTo": { "$eq": "$selfUser" } }

// Résultat fusionné
{
  "status": { "$eq": "active" },
  "assignedTo": { "$eq": "$selfUser" }
}

Conflit sur le même champ

Quand les deux expressions portent sur le même champ, le dashboard a la priorité :

JSON

// Expression du widget
{ "status": { "$eq": "active" } }

// Expression du dashboard
{ "status": { "$eq": "pending" } }

// Résultat : le dashboard gagne
{ "status": { "$eq": "pending" } }

Fusion avec $and

Quand les deux expressions ont des $and, leurs conditions sont concaténées :

JSON

// Expression du widget
{
  "$and": [
    { "status": { "$eq": "active" } }
  ]
}

// Expression du dashboard
{
  "$and": [
    { "type": { "$eq": "invoice" } }
  ]
}

// Résultat fusionné
{
  "$and": [
    { "status": { "$eq": "active" } },
    { "type": { "$eq": "invoice" } }
  ]
}

Bon à savoir

La fusion est conçue pour permettre aux utilisateurs de personnaliser les filtres prédéfinis sans les casser. Les filtres du dashboard s'ajoutent à ceux du widget plutôt que de les remplacer complètement.

MEL simple vs complexe

Miel distingue les expressions "simples" des expressions "complexes". Cette distinction affecte les fonctionnalités disponibles.

Expressions simples

Une expression est considérée comme simple si elle peut être décomposée en filtres individuels par champ :

JSON

// Simple : une seule comparaison
{ "status": { "$eq": "active" } }

// Simple : $and avec des comparaisons simples
{
  "$and": [
    { "status": { "$eq": "active" } },
    { "type": { "$eq": "invoice" } }
  ]
}

Expressions complexes

Une expression est complexe dès qu'elle contient des structures non décomposables :

JSON

// Complexe : $or imbriqué
{
  "$or": [
    { "status": { "$eq": "active" } },
    { "type": { "$eq": "urgent" } }
  ]
}

// Complexe : $not imbriqué
{ "status": { "$not": { "$eq": "draft" } } }

// Complexe : structures récursives profondes
{
  "$and": [
    {
      "$or": [
        { "a": { "$eq": 1 } },
        { "b": { "$eq": 2 } }
      ]
    }
  ]
}

Implications pratiques

Fonctionnalité	MEL Simple	MEL Complexe
Mode humain (visuel)	Disponible	Limité ou indisponible
Extraction de filtres	Possible	Non supportée
Modification par l'interface	Facile	Édition JSON uniquement

Recommandation

Préférez les expressions simples quand c'est possible. Réservez les expressions complexes aux cas où la logique métier l'exige vraiment.

Prochaine étape

Vous maîtrisez maintenant les expressions complexes. Découvrez comment MEL évalue ces expressions grâce au contexte d'exécution.

Contexte d'évaluation →← Opérateurs logiques