Transformación de datos avanzada con Code node

El Code node en n8n permite ejecutar código JavaScript personalizado para manipular datos. Es la herramienta para resolver transformaciones complejas que los nodos estándar no cubren, ofreciendo flexibilidad total sobre la estructura y el contenido de la información.

Cuándo usar el Code node

El Code node no es la primera opción. Se utiliza cuando las capacidades de los nodos nativos de n8n (Set, Split In Batches, Merge, etc.) son insuficientes para la lógica de transformación requerida. Esto incluye escenarios donde se necesita:

• Lógica condicional compleja: Múltiples condiciones anidadas o dependencias para determinar el formato de salida.
• Manipulación de arreglos y objetos: Filtrado, mapeo, reducción o reestructuración de colecciones de datos de forma dinámica.
• Integración con librerías externas: Aunque n8n tiene un entorno limitado, permite usar funciones JavaScript estándar para procesar datos.
• Generación de datos sintéticos o calculados: Crear nuevos campos a partir de la combinación o cálculo de datos existentes.

Estructura y entorno del Code node

El Code node ejecuta JavaScript. Accede a los datos de los nodos anteriores a través del objeto `$` y debe retornar un arreglo de objetos que representen los ítems de salida. Cada objeto en el arreglo de retorno será un ítem procesado por el siguiente nodo.

Los datos de entrada están disponibles en `$` y se estructuran como un arreglo de objetos, donde cada objeto representa un ítem de entrada. Para acceder a un campo específico del primer ítem de entrada, se usaría `$('NombreNodoAnterior').first().json.nombreCampo`.

// Ejemplo básico: Acceder a datos y transformar
const items = [];

for (const item of $input.all()) {
  const originalName = item.json.name;
  const originalEmail = item.json.email;

  // Lógica de transformación
  const transformedName = originalName.toUpperCase();
  const domain = originalEmail.split('@')[1];

  items.push({
    json: {
      transformedName: transformedName,
      emailDomain: domain,
      originalData: item.json // Mantener datos originales si es necesario
    }
  });
}

return items;

El objeto `item.json` contiene los datos del ítem actual. Se debe retornar un arreglo de objetos, donde cada objeto tiene una propiedad `json` con los datos de salida.

Manipulación avanzada de arreglos

JavaScript ofrece métodos potentes para manipular arreglos, útiles para reestructurar datos complejos. Algunos de los más comunes son `map`, `filter`, `reduce` y `forEach`.

• `map()`: Transforma cada elemento de un arreglo y devuelve un nuevo arreglo con los resultados. Útil para cambiar el formato de cada ítem.
• `filter()`: Crea un nuevo arreglo con todos los elementos que pasan una prueba implementada por la función proporcionada. Útil para seleccionar ítems basados en condiciones.
• `reduce()`: Ejecuta una función reductora sobre cada elemento de un arreglo, devolviendo un único valor. Útil para agregaciones o para construir un objeto complejo a partir de un arreglo.
• `forEach()`: Ejecuta una función proporcionada una vez por cada elemento del arreglo. Útil para realizar acciones secundarias o para construir un arreglo de salida manualmente.

// Ejemplo: Filtrar y mapear datos
const inputItems = $input.all();

const processedItems = inputItems
  .filter(item => item.json.isActive === true)
  .map(item => ({
    json: {
      id: item.json.id,
      fullName: `${item.json.firstName} ${item.json.lastName}`,
      creationDate: new Date(item.json.createdAt).toISOString()
    }
  }));

return processedItems;

Manejo de errores y depuración en Code node

Los errores en el Code node detendrán la ejecución del workflow si no se manejan. Es crucial incluir bloques `try...catch` para capturar excepciones dentro del código y decidir cómo proceder. Se puede registrar el error, generar un ítem de salida con el estado de error o lanzar una excepción personalizada para que sea capturada por un Error Workflow.

Para depurar, se puede usar `console.log()` dentro del Code node. Los mensajes aparecerán en la vista de ejecución del workflow en n8n, bajo la sección 'Output' del Code node. Esto permite inspeccionar el valor de variables y el flujo de ejecución.

// Ejemplo: Manejo de errores y logging
const items = [];

for (const item of $input.all()) {
  try {
    const value = item.json.someValue;
    if (typeof value !== 'number') {
      throw new Error('someValue no es un número.');
    }
    items.push({
      json: { processedValue: value * 2 }
    });
  } catch (error) {
    console.error(`Error procesando ítem ID ${item.json.id || 'N/A'}: ${error.message}`);
    // Opcional: registrar el error y continuar, o re-lanzar
    items.push({
      json: {
        originalData: item.json,
        error: error.message,
        status: 'failed'
      }
    });
  }
}

return items;

Consideraciones de rendimiento y seguridad

El Code node, al ejecutar JavaScript, consume recursos. Un código ineficiente, especialmente con grandes volúmenes de datos, puede impactar el rendimiento del workflow. Optimiza los algoritmos y evita operaciones costosas dentro de bucles si es posible.

En entornos de n8n autohospedados, el Code node se ejecuta en un sandbox para aislarlo del sistema operativo. Sin embargo, el código malicioso o ineficiente aún puede afectar la estabilidad del servidor de n8n. Siempre valida las entradas y minimiza la complejidad del código.

Aplicación práctica: Preparando datos para un sistema de reportes

El lunes, identifica un workflow existente donde se estén realizando transformaciones de datos repetitivas o con lógica condicional compleja utilizando múltiples nodos Set o If. Evalúa si consolidar esa lógica en un Code node mejoraría la legibilidad y mantenibilidad del workflow.

Ejemplo: Tienes datos de ventas con campos `product_category`, `price`, `quantity` y `region`. Necesitas generar un campo `total_revenue` (price * quantity), categorizar la `region` en 'Norte', 'Centro', 'Sur' y 'Internacional', y aplicar un descuento del 10% si `product_category` es 'Electrónica' y la `region` es 'Norte'.

Intenta implementar esta lógica en un Code node, utilizando `map` o un bucle `forEach` para procesar cada ítem. Utiliza `console.log()` para verificar los valores intermedios y el resultado final. Compara la complejidad visual de esta solución con una implementación basada solo en nodos estándar.