Aller au contenu principal

Nœud Code

Le nœud Code permet d'exécuter du code JavaScript personnalisé dans votre workflow.

Vue d'ensemble​

Ce nœud est utilisé pour :

  • Traiter des données avec une logique personnalisée
  • Transformer des données
  • Effectuer des calculs complexes
  • Implémenter une logique métier spécifique

Configuration​

Code JavaScript​

Écrivez votre code JavaScript dans l'éditeur :

  • Accès au contexte via l'objet context
  • Retournez le résultat avec return
  • Utilisez les fonctions JavaScript standard

Structure de base​

// Accéder aux données du contexte
const inputData = context.trigger.body;

// Traitement
const processedData = {
  // Votre logique ici
};

// Retourner le résultat
return processedData;

Librairies disponibles​

Des librairies JavaScript sont mises à disposition dans l'objet libs (par exemple lodash, axios, dayjs, uuid ; plus de 20 librairies au total selon la version d’Ecosystem).

Exemple d'utilisation :

// Générer un UUID
context.yId = libs.uuid();

// Manipuler des dates
const now = libs.dayjs().format('YYYY-MM-DD');

// Calculer un hash MD5
const hash = libs.md5('my-string');
📚 Librairies disponibles

Ecosystem met à disposition plus de 20 librairies JavaScript populaires (lodash, axios, dayjs, uuid, etc.). Les exemples ci-dessus illustrent quelques usages courants via libs.

Accès au contexte​

Variables disponibles​

Le contexte contient toutes les données des nœuds précédents :

// Données du trigger
context.trigger.body
context.trigger.headers
context.trigger.query

// Résultats des nœuds précédents
context.httpRequest.body
context.condition.result
context.forEach.item

// Variables globales
context.variables.myVariable

Exemple d'utilisation​

// Récupérer les données
const order = context.trigger.body;
const user = context.httpRequest.body;

// Traitement
const total = order.items.reduce((sum, item) => {
  return sum + (item.price * item.quantity);
}, 0);

const discount = user.plan === 'premium' ? total * 0.1 : 0;
const finalTotal = total - discount;

// Retourner le résultat
return {
  orderId: order.id,
  total: finalTotal,
  discount: discount,
  items: order.items
};

Fonctions disponibles​

Fonctions JavaScript standard​

Toutes les fonctions JavaScript sont disponibles :

  • JSON.parse(), JSON.stringify()
  • Array.map(), Array.filter(), Array.reduce()
  • String.split(), String.replace()
  • Date, Math, etc.

Exemples​

// Parsing JSON
const data = JSON.parse(context.trigger.body.rawData);

// Manipulation de tableaux
const activeItems = context.items.filter(item => item.active);

// Formatage de dates
const date = new Date(context.timestamp);
const formattedDate = date.toISOString();

// Calculs
const average = context.numbers.reduce((a, b) => a + b) / context.numbers.length;

Gestion des erreurs​

Try/Catch​

Utilisez try/catch pour gérer les erreurs :

try {
  const result = processData(context.data);
  return result;
} catch (error) {
  // L'erreur sera gérée par le nœud On Error
  throw error;
}

Validation​

Validez les données avant traitement :

if (!context.trigger.body || !context.trigger.body.orderId) {
  throw new Error('Order ID is required');
}

// Traitement...

Retourner des données​

Retour simple​

return {
  success: true,
  data: processedData
};

Retour conditionnel​

if (condition) {
  return { status: 'approved' };
} else {
  return { status: 'rejected' };
}

Exemples d'utilisation​

Exemple 1 : Transformation de données​

const input = context.trigger.body;

const transformed = {
  id: input.order_id,
  customer: {
    name: `${input.first_name} ${input.last_name}`,
    email: input.email_address
  },
  items: input.products.map(product => ({
    sku: product.product_sku,
    quantity: product.qty,
    price: product.price
  }))
};

return transformed;

Exemple 2 : Calcul complexe​

const order = context.trigger.body;

// Calcul du total
const subtotal = order.items.reduce((sum, item) => {
  return sum + (item.price * item.quantity);
}, 0);

// Calcul des taxes
const taxRate = 0.20; // 20%
const tax = subtotal * taxRate;

// Calcul des frais de livraison
const shipping = order.shippingMethod === 'express' ? 15 : 5;

// Total final
const total = subtotal + tax + shipping;

return {
  subtotal: subtotal,
  tax: tax,
  shipping: shipping,
  total: total
};

Exemple 3 : Validation et transformation​

const data = context.trigger.body;

// Validation
if (!data.email || !data.email.includes('@')) {
  throw new Error('Invalid email address');
}

// Transformation
const normalized = {
  email: data.email.toLowerCase().trim(),
  name: data.name.trim(),
  age: parseInt(data.age, 10)
};

// Validation de l'âge
if (isNaN(normalized.age) || normalized.age < 0) {
  throw new Error('Invalid age');
}

return normalized;

Bonnes pratiques​

  • Simplicité : Gardez le code simple et lisible
  • Documentation : Commentez le code complexe
  • Validation : Validez toujours les données d'entrée
  • Gestion d'erreurs : Utilisez try/catch pour les opérations risquées
  • Performance : Évitez les boucles complexes ou les opérations lourdes
  • Test : Testez votre code avec différents scénarios

Limitations​

  • Temps d'exécution : Le code doit s'exécuter rapidement
  • Mémoire : Évitez les opérations consommant beaucoup de mémoire
  • APIs externes : Utilisez des nœuds HTTP Request pour les appels API
  • Fichiers : Utilisez les nœuds FTP pour les opérations sur fichiers

Prochaines étapes​