Accès aux données

Les fonctions d'accès aux données vous permettent de rechercher et récupérer des objets depuis votre base de données directement dans vos formules.

Recherche d'objets

findObject(typeObjet, requete)

Recherche et retourne un seul objet correspondant aux critères. Si plusieurs correspondent, seul le premier est retourné.

JavaScript

// Rechercher un client par son nom
findObject(client, { name: "ACME Corp" })

// Rechercher un client lié à la commande
findObject(client, { id: "{{commande.clientId}}" })

// Rechercher une facture spécifique
findObject(facture, { numero: "FAC-2025-001" })

// Utiliser l'objet trouvé
let monClient = findObject(client, { email: "contact@acme.com" });
monClient.nom

Attention : Si aucun objet n'est trouvé, cette fonction peut générer une erreur. Utilisez exists pour vérifier ou ifError pour gérer ce cas.

findObjects(typeObjet, requete)

Recherche et retourne tous les objets correspondant aux critères sous forme de tableau.

JavaScript

 // Récupérer tous les projets
findObjects(projet, {})

// Récupérer les commandes d'un client
findObjects(commande, { clientId: "{{client.id}}" })

// Accéder aux champs de tous les objets trouvés
findObjects(produit, {}).nom        // Tableau des noms

// Combiner avec d'autres fonctions
let commandes = findObjects(commande, {});
client.commandes.map(commande => commande.total).sum()

Bon à savoir : Une requête vide {}retourne tous les objets du type spécifié. C'est utile pour obtenir une liste complète.

Syntaxe des requêtes

Les requêtes utilisent une syntaxe inspirée de MongoDB (MEL Query). Voici les opérateurs disponibles.

Égalité simple

La forme la plus simple : { champ: valeur }

JavaScript

// Rechercher par nom
findObject(client, { name: "ACME Corp" })

// Rechercher par statut
findObjects(commande, { statut: "validée" })

// Rechercher par booléen
findObjects(facture, { payee: true })

Opérateur $eq

Forme explicite de l'égalité. Utile avec des valeurs dynamiques.

JavaScript

// Égalité explicite
findObject(facture, { order: { $eq: "{{order}}" } })

// Équivalent à la forme simple
findObject(facture, { order: "{{order}}" })

Critères multiples

Combinez plusieurs critères (tous doivent correspondre - ET implicite).

JavaScript

// Rechercher avec plusieurs critères
findObjects(commande, {
  clientId: "{{client.id}}",
  statut: "validée"
})

// Client actif dans une ville
findObjects(client, {
  ville: "Paris",
  actif: true
})

Valeurs dynamiques

Vous pouvez utiliser l'interpolation "{{objet.champ}}" dans les requêtes pour passer des valeurs dynamiques. Enveloppez-les dans des guillemets si nécessaire.

Statut d'un objet

objet.status, objet.status.name, objet.status.label

objet.status rend le nom du statut courant, celui que vous comparez dans une condition. objet.status.name rend la même chose, écrit en toutes lettres, et objet.status.label rend son libellé, celui que l'écran affiche. Les trois sont du texte.

JavaScript

// Pour comparer : le nom
commande.status === "validée" ? 1 : 0
commande.status.name === "validée" ? 1 : 0

// Pour afficher : le libellé
commande.status.label           // "Validée"

// Sur une liste d'objets, une liste de libellés
projet.taches.status.label      // ["À faire", "Terminée", …]

Bon à savoir : un statut ne porte que name et label. Tout autre champ est refusé à l'écriture (« couleur » n'existe pas sur un statut), comme tout champ écrit derrière un texte, un nombre ou une date. Si l'objet porte un statut que son flux ne connaît plus, le libellé est une chaîne vide.

Identifiant d'entreprise

objet.siret, objet.siret.value, objet.siret.identifierType

Un champ Identifiant d'entreprise garde le numéro et son type (SIREN, SIRET…). societe.siret rend l'identifiant comme un texte, sans espaces quand la valeur porte son type. societe.siret.value rend la même chose, écrit en toutes lettres, et societe.siret.identifierType rend le code du type (FR_SIREN, FR_SIRET). Les trois sont du texte.

JavaScript

// L'identifiant, comme un texte
societe.siret                       // "54205276600012"
societe.siret.value                 // "54205276600012"
societe.siret.slice(0, 9)           // "542052766"

// Le type, pour décider
societe.siret.identifierType        // "FR_SIRET", ou null si vide ou sans type
societe.siret.identifierType === "FR_SIREN" ? "Entreprise" : "Établissement"

// Au travers d'une référence, et sur une liste
facture.client.siret.identifierType
findObjects(societe, {}).siret.identifierType   // ["FR_SIRET", "FR_SIREN", …]

Bon à savoir : identifierType vaut null si le champ est vide, ou si sa valeur n'a pas de type (une valeur reprise d'un ancien champ texte) : jamais le type proposé par défaut. Une valeur sans type se lit telle qu'elle a été saisie, espaces compris ("542 052 766") : testez son type avant de découper ou de comparer l'identifiant. Un identifiant ne porte que value et identifierType : tout autre champ est refusé à l'écriture (« code » n'existe pas sur un identifiant d'entreprise).

Filtrer par identifiant ou par type

Dans une requête de findObjects, visez siret.value pour l'identifiant (écrit sans espaces) et siret.identifierType pour le type. Le chemin nu siret compare l'identifiant, comme siret.value. La comparaison porte sur l'identifiant tel qu'il est enregistré : une valeur sans type garde son écriture d'origine et ne se retrouve qu'écrite de la même façon.

JavaScript

// Les sociétés identifiées par un SIRET
findObjects(societe, { siret.identifierType: "FR_SIRET" })

// Une société par son identifiant
findObject(societe, { siret.value: "54205276600012" })

// Au travers d'une référence : les factures des clients identifiés par un SIREN
findObjects(facture, { client.siret.identifierType: "FR_SIREN" }).count()

Historique des statuts

objet.statusChangedAt(nomStatut)

Retourne la date à laquelle un objet est passé à un statut spécifique. Utile pour calculer des délais ou afficher des dates clés.

JavaScript

// Date de validation d'une commande
commande.statusChangedAt("validée")

// Date d'envoi d'une facture
facture.statusChangedAt("envoyée")

// Calculer le délai de traitement
let dateCreation = commande.dateCreation;
let dateValidation = commande.statusChangedAt("validée");
dateCreation.daysBetweenInclusive(dateValidation)

Bon à savoir : Cette fonction recherche dans l'historique des changements de statut. Si l'objet n'a jamais eu ce statut, elle retourne une erreur.

Bonnes pratiques

✓ Stocker dans une variable

Si vous utilisez le résultat plusieurs fois, stockez-le dans une variable.

JavaScript

// ✓ Bon : une seule recherche
let client = findObject(client, { id: "{{commande.clientId}}" });
client.nom.concat(" - ", client.email)

// ✗ À éviter : deux recherches pour le même objet
findObject(client, { id: "{{commande.clientId}}" }).nom.concat(" - ",
  findObject(client, { id: "{{commande.clientId}}" }).email
)

✓ Filtrer après la recherche

Parfois il est plus clair de chercher puis filtrer.

JavaScript

// Récupérer puis filtrer
let commandes = findObjects(commande, {});
let commandesValidees = client.commandes.filter(commande => commande.statut === "validée");
let commandesRecentes = commandesValidees.filter(commandesValidee => commandesValidee.date > today() - 30
);

⚠ Gérer l'absence de résultat

Vérifiez toujours si un objet a été trouvé avant de l'utiliser.

JavaScript

let client = findObject(client, { email: "{{email}}" }).ifError(null
);

client.exists()
? client.nom
: "Client non trouvé"

Exemples pratiques

Calculer le chiffre d'affaires d'un client

JavaScript

let commandes = findObjects(commande, { clientId: "{{client.id}}" });
let commandesPayees = client.commandes.filter(commande => commande.statut === "payée");
let totaux = commandesPayees.map(commandesPayee => commandesPayee.totalTTC);
totaux.sum()

Vérifier l'unicité d'un email

JavaScript

let emailExistant = findObject(client, { email: "{{nouveauClient.email}}" }).ifError(null
);

emailExistant.exists()
? "Cet email est déjà utilisé par " + emailExistant.nom
: "Email disponible"

Trouver la dernière facture d'un client

JavaScript

let factures = findObjects(facture, { clientId: "{{client.id}}" });
let dates = client.factures.map(facture => facture.date);
let datePlusRecente = max(dates);
let derniereFacture = client.factures.find(facture => facture.date === datePlusRecente);

derniereFacture.exists()
? "Dernière facture : ".concat(derniereFacture.numero)
: "Aucune facture"

Calculer le délai moyen de paiement

JavaScript

let factures = findObjects(facture, { payee: true });
let delais = client.factures.map(facture => facture.dateEmission.daysBetweenInclusive(facture.statusChangedAt("payée")
  )
);
delais.average()

Prochaine étape

Apprenez maintenant à gérer les erreurs et les valeurs manquantes pour des formules robustes.

Gestion des erreurs →← Fonctions booléennes