Concurso de licencias n8n en Platzi: cómo participar y ganar

Clase 1 de 2 • Concurso para ganar una licencia de n8n por 1 año

Contenido del curso

Concurso n8n y Platzi

Resumen

Aprende, paso a paso, cómo ganar una de las 200 licencias de n8n por un año en Platzi. Aquí verás qué completar, cómo presentar tu flujo de automatización y qué requisitos cumplir para que la comunidad te vote.

¿Cómo ganar una licencia de n8n en Platzi?

Para participar debes cumplir tres acciones claras. La clave es demostrar un flujo útil y compartirlo con detalle para que otros estudiantes puedan reutilizarlo.

¿Qué debes completar antes de participar?

Termina uno de los tres nuevos cursos de n8n en Platzi.
Asegúrate de que tu progreso esté completo.

¿Cómo crear y presentar tu flujo de automatización?

Construye un flujo en n8n que sea útil y funcional.
Publica tu flujo en la sección de comentarios del curso.
Incluye una descripción detallada: qué problema resuelve y cómo lo hace.
Adjunta el archivo JSON del flujo para que otros puedan usarlo.

¿Cómo se eligen los ganadores?

Tu comentario debe quedar entre los 200 más votados por la comunidad de Platzi.
Si entras en ese grupo, ganas una licencia de n8n por un año.

¿Qué es n8n y por qué automatizar tareas?

Con n8n puedes automatizar flujos de trabajo en muy poco tiempo. La interfaz es intuitiva y visual, lo que facilita conectar herramientas y páginas web sin fricción.

¿Qué problemas puedes resolver con automatización?

Tareas repetitivas que haces más de una vez.
Procesos que consumen tiempo manual.
Integraciones entre múltiples servicios y sitios web.

¿Qué habilidades desarrollas al participar?

Diseño de flujos de automatización basados en objetivos.
Integración de herramientas y páginas web.
Documentación clara de problema y solución.
Compartir y versionar flujos mediante archivo JSON.
Participación en una comunidad con votación colaborativa.

¿Cuáles son las fechas, requisitos y dónde participar?

Toma nota de los plazos y condiciones para que tu participación sea válida desde el inicio hasta el anuncio de ganadores.

¿Qué fechas debes tener presentes?

Participación: desde hoy hasta el 30 de septiembre.
Anuncio de ganadores: 3 de octubre.

¿Qué requisitos son obligatorios?

Contar con suscripción anual activa de Platzi.
Máximo una licencia por persona.

¿Dónde encuentras los cursos y publicas tu participación?

Ingresa a la ruta: Platzi.com/n8n.
Ahí verás los tres cursos, el curso donde debes publicar tu comentario y los términos y condiciones.

¿Tienes dudas o quieres feedback de la comunidad? Publica tu flujo con su JSON y comparte tu experiencia en los comentarios.

Obtén respuestas inmediatasProfundiza lo que acabas de ver

Carlos Hernández

student•

¡Hola, comunidad de Platzi! 🚀

Les comparto mi proyecto para el concurso, que no es solo un flujo, sino un Patrón de Arquitectura de Resiliencia 3-en-1 para llevar sus automatizaciones a un nivel profesional.

¿El Problema? 😩

Todos hemos sufrido por APIs que fallan, conexiones que se caen o servicios que se saturan. Un flujo que no maneja estos errores es un flujo frágil que puede dejar de funcionar en el peor momento.

Mi Solución: Un Kit de Herramientas Reutilizable 🛠️

Inspirado en los principios de diseño de software que vemos en la industria, he creado una arquitectura de 3 capas que pueden aplicar a CUALQUIER API que quieran consumir desde n8n.

Les adjunto 3 flujos que trabajan juntos:

El Cerebro 🧠 (Manejador_CircuitBreaker.json): Un micro-servicio que centraliza el patrón Circuit Breaker. Monitorea fallos de cualquier servicio y, si un API falla repetidamente, "abre el circuito" para evitar que nuestro sistema siga intentando y gastando recursos. Después de un tiempo, intenta de nuevo para ver si el servicio se ha recuperado. Todo de forma atómica usando Redis.

El Músculo 💪 (TIL-Resilient-API-Executor-v1.json): ¡La joya de la corona! Un sub-workflow genérico que actúa como un wrapper o "envoltorio" para cualquier llamada HTTP. Solo tienes que pasarle la URL, método, body, etc., y él se encarga de todo:

Aplica el patrón Cache-Aside: Guarda respuestas exitosas en Redis para no volver a preguntar lo mismo, ahorrando tiempo y dinero (¡ideal para APIs de paga!).
Integra el Circuit Breaker: Antes de llamar a cualquier API, le pregunta al "Cerebro" si es seguro proceder. Si el servicio está caído, falla inmediatamente sin esperar, haciendo nuestro flujo más rápido y resiliente.
Manejo de Errores Estandarizado: Devuelve respuestas predecibles, ya sea de éxito o de error, para que tus flujos principales (orquestadores) sean limpios y fáciles de leer.

El Ejemplo Práctico 🏥 (Herramienta_DirectorioMedico_BuscarServicios_v1.json): Una "Herramienta" que demuestra cómo usar el ejecutor resiliente. Este flujo tiene su propia lógica de negocio (buscar servicios médicos), pero en lugar de hacer la llamada HTTP directamente, prepara los datos y se los pasa al "Músculo". ¡Así, la lógica de negocio queda separada de la lógica de resiliencia!

¿Por qué es útil para la comunidad? 🤔

Con este patrón, dejas de preocuparte por el cómo hacer llamadas a APIs de forma segura en cada flujo y te centras en el qué (la lógica de tu negocio). Es un framework reutilizable, escalable y mantenible que te ayudará a construir automatizaciones de nivel empresarial.

¡Espero que les sirva para sus propios proyectos! Si creen que construir flujos robustos y a prueba de fallos es importante, les agradecería mucho su voto. ✨

¡A seguir automatizando! 🤖

- El Cerebro 🧠

{
  "name": "Manejador_CircuitBreaker",
  "nodes": [
    {
      "parameters": {
        "workflowInputs": {
          "values": [
            {
              "name": "serviceName"
            },
            {
              "name": "failureThreshold"
            },
            {
              "name": "resetTimeoutSeconds"
            },
            {
              "name": "mode"
            }
          ]
        }
      },
      "type": "n8n-nodes-base.executeWorkflowTrigger",
      "typeVersion": 1.1,
      "position": [
        0,
        80
      ],
      "id": "1956230e-80bf-4481-a023-658a1971a2ef",
      "name": "Disparador: Recibir Fallo"
    },
    {
      "parameters": {
        "jsCode": "// =================================================================\n// Manejador de Circuit Breaker\n// =================================================================\nconst Redis = require('ioredis');\n\nasync function main() {\n  // --- 1. Entrada y Configuración ---\n  const input = $input.first()?.json ?? {};\n  const { serviceName } = input;\n  \n  // Usamos el operador '??' para asignar valores por defecto si el input es null O undefined.\n  const mode = input.mode ?? 'CHECK';\n  const failureThreshold = input.failureThreshold ?? 5;\n  const resetTimeoutSeconds = input.resetTimeoutSeconds ?? 60;\n\n  if (!serviceName) {\n    throw new Error(\"Input error: 'serviceName' debe ser proporcionado.\");\n  }\n\n  // Usamos un Hash de Redis para almacenar todo el estado del servicio de forma agrupada.\n  const redisKey = `cb:${serviceName}`;\n\n  // --- 2. Conexión a Redis ---\n  // Se utilizan las variables de entorno configuradas en Docker.\n  const redis = new Redis({\n    host: $env.REDIS_HOST,\n    port: parseInt($env.REDIS_PORT),\n    password: $env.REDIS_PASSWORD,\n    lazyConnect: true,\n    enableOfflineQueue: false, // Falla rápido si no puede conectar.\n  });\n\n  let result = {};\n\n  try {\n    await redis.connect();\n\n    // --- 3. Lógica de Modos ---\n    switch (mode) {\n      case 'SUCCESS':\n        // En un éxito, especialmente desde HALF-OPEN, cerramos el circuito.\n        // multi() asegura que los dos comandos se ejecuten atómicamente.\n        await redis.multi()\n          .hset(redisKey, 'state', 'CLOSED')\n          .hset(redisKey, 'failureCount', 0)\n          .exec();\n        result = { state: 'CLOSED', details: 'Éxito reportado. El circuito ahora está cerrado.' };\n        break;\n\n      case 'FAILURE':\n        // En un fallo, incrementamos el contador atómicamente.\n        const newFailureCount = await redis.hincrby(redisKey, 'failureCount', 1);\n\n        if (newFailureCount >= failureThreshold) {\n          // Umbral alcanzado. Abrimos el circuito y establecemos el timestamp de apertura.\n          const opensAt = Date.now() + (resetTimeoutSeconds * 1000);\n          await redis.multi()\n            .hset(redisKey, 'state', 'OPEN')\n            .hset(redisKey, 'opensAt', opensAt)\n            .exec();\n          result = { state: 'OPEN', details: `Umbral de fallos (${newFailureCount}) alcanzado. El circuito ahora está abierto.` };\n        } else {\n          result = { state: 'CLOSED', details: `Fallo reportado. Nuevo contador: ${newFailureCount}.` };\n        }\n        break;\n\n      case 'CHECK':\n      default:\n        const circuit = await redis.hgetall(redisKey);\n        const state = circuit.state ?? 'CLOSED';\n\n        if (state === 'OPEN') {\n          const opensAt = parseInt(circuit.opensAt ?? '0', 10);\n          if (Date.now() > opensAt) {\n            // El tiempo de espera ha pasado. Movemos a HALF-OPEN para permitir una llamada de prueba.\n            await redis.hset(redisKey, 'state', 'HALF_OPEN');\n            result = { state: 'PROCEED', currentState: 'HALF-OPEN', details: 'Timeout expirado. Permitiendo una llamada de prueba.' };\n          } else {\n            result = { state: 'FAIL_FAST', currentState: 'OPEN', details: 'El circuito está abierto. Llamada bloqueada.' };\n          }\n        } else { // El estado es CLOSED o HALF-OPEN\n          const failureCount = parseInt(circuit.failureCount ?? '0', 10);\n          result = { state: 'PROCEED', currentState: state, details: `El circuito está ${state}. Llamada permitida. Fallos actuales: ${failureCount}.` };\n        }\n        break;\n    }\n\n  } catch (error) {\n    // Para producción, retornamos un objeto de error estructurado.\n    return [{ json: { error: true, message: error.message, serviceName: serviceName } }];\n  } finally {\n    // Siempre cerramos la conexión para liberar recursos.\n    if (redis.status === 'ready') {\n      await redis.quit();\n    }\n  }\n\n  // Retornamos el resultado en el formato que n8n espera.\n  return [{ json: { ...result, serviceName: serviceName } }];\n}\n\nreturn main();"
      },
      "type": "n8n-nodes-base.code",
      "typeVersion": 2,
      "position": [
        224,
        80
      ],
      "id": "34755afb-e975-43a7-9923-8afae1a50cb3",
      "name": "Code: Atomically Report Failure"
    },
    {
      "parameters": {
        "content": "# 📑 Workflow: Manejador de Circuit Breaker Atómico\n\nEste workflow implementa un patrón de diseño de software **Circuit Breaker** utilizando Redis para gestionar el estado de los servicios de manera atómica y resiliente. Su propósito es prevenir que una aplicación intente ejecutar repetidamente una operación que es propensa a fallar, evitando la saturación de recursos y mejorando la experiencia del usuario.\n\n---\n\n## 🚀 Propósito del Workflow\n\nEl patrón **Circuit Breaker** actúa como un proxy o intermediario para operaciones que pueden fallar, como las llamadas a servicios externos. Monitorea las fallas y, si superan un umbral, \"abre\" el circuito, haciendo que las llamadas posteriores fallen inmediatamente (`FAIL_FAST`) sin ejecutar la lógica principal. Después de un tiempo de espera, el circuito pasa a un estado de \"medio abierto\" (`HALF-OPEN`) para permitir una llamada de prueba. Si esta tiene éxito, el circuito se \"cierra\" (`CLOSED`) y el servicio vuelve a la normalidad.\n\nEste manejador centraliza la lógica del Circuit Breaker para que cualquier otro servicio o workflow pueda consultarlo y reportar fallos o éxitos de manera sencilla.\n\n---\n\n## 🧩 Nodos del Workflow\n\nEl workflow se compone de dos nodos principales.\n\n### 1. ⚡️ Disparador: Recibir Fallo (`ExecuteWorkflowTrigger`)\n\nEste es el punto de entrada del workflow. Está configurado para recibir datos de entrada que definen la operación a realizar.\n\n* **Nombre del Nodo**: `Disparador: Recibir Fallo`\n* **ID del Nodo**: `1956230e-80bf-4481-a023-658a1971a2ef`\n* **Función**: Activa la ejecución del workflow cuando es llamado, pasando los parámetros de entrada al siguiente nodo.\n\n### 2. 🤖 Código: Lógica Principal (`Code`)\n\nEste nodo contiene toda la lógica del Circuit Breaker. Se conecta a Redis para almacenar y gestionar el estado de cada servicio de forma atómica y segura.\n\n* **Nombre del Nodo**: `Code: Atomically Report Failure`\n* **ID del Nodo**: `34755afb-e975-43a7-9923-8afae1a50cb3`\n* **Función**: Ejecuta el código JavaScript que implementa los diferentes modos y estados del Circuit Breaker.\n\n---\n\n## ⚙️ Parámetros de Entrada (Inputs)\n\nPara invocar este workflow, necesitas proporcionar un objeto JSON con los siguientes campos.\n\n| Parámetro | Tipo | Obligatorio | Por Defecto | Descripción |\n| :--- | :--- | :--- | :--- | :--- |\n| `serviceName` | `String` | **Sí** | `N/A` | El identificador único del servicio que se está monitoreando (e.g., `api-pagos`, `servicio-notificaciones`). |\n| `mode` | `String` | No | `'CHECK'` | El modo de operación. Define la acción que el workflow debe realizar. |\n| `failureThreshold` | `Number` | No | `5` | El número de fallos consecutivos necesarios para abrir el circuito. |\n| `resetTimeoutSeconds` | `Number` | No | `60` | El tiempo en segundos que el circuito permanecerá abierto antes de pasar a `HALF-OPEN`. |\n\n---\n\n## 🕹️ Modos de Operación\n\nEl parámetro `mode` determina el comportamiento del workflow.\n\n### `CHECK` (Modo por defecto)\nVerifica el estado actual del circuito para un servicio y determina si la llamada debe proceder.\n* **Si el circuito está `CLOSED` o `HALF-OPEN`**: Devuelve `PROCEED`, permitiendo la ejecución de la llamada.\n* **Si el circuito está `OPEN` y el timeout no ha expirado**: Devuelve `FAIL_FAST`, bloqueando la llamada.\n* **Si el circuito está `OPEN` y el timeout ya expiró**: Cambia el estado a `HALF-OPEN` y devuelve `PROCEED` para permitir una llamada de prueba.\n\n### `FAILURE`\nReporta un fallo para el servicio.\n* Incrementa el contador de fallos de forma atómica (`hincrby`).\n* Si el contador alcanza el `failureThreshold`, el estado cambia a `OPEN` y se establece un timestamp para la reapertura.\n\n### `SUCCESS`\nReporta una ejecución exitosa para el servicio.\n* Resetea el estado del circuito a `CLOSED` y el contador de fallos a `0`.\n* Es especialmente útil cuando una llamada de prueba en el estado `HALF-OPEN` tiene éxito, cerrando el circuito de nuevo.\n\n---\n\n## 📤 Salidas del Workflow (Outputs)\n\nEl workflow siempre devuelve un objeto JSON con el resultado de la operación, proporcionando información clara sobre el estado del circuito.\n\nEjemplo de Salida (`CHECK` en estado `OPEN`):\n```json\n{\n  \"state\": \"FAIL_FAST\",\n  \"currentState\": \"OPEN\",\n  \"details\": \"El circuito está abierto. Llamada bloqueada.\",\n  \"serviceName\": \"api-pagos\"\n}\n```\n\nEjemplo de Salida (FAILURE sin alcanzar el umbral):\n```json\n{\n  \"state\": \"CLOSED\",\n  \"details\": \"Fallo reportado. Nuevo contador: 2.\",\n  \"serviceName\": \"api-pagos\"\n}\n```\n\nEjemplo de Salida (SUCCESS):\n```json\n{\n  \"state\": \"CLOSED\",\n  \"details\": \"Éxito reportado. El circuito ahora está cerrado.\",\n  \"serviceName\": \"api-pagos\"\n}\n```\n\nEjemplo de Salida (Error):\n```json\n{\n  \"error\": true,\n  \"message\": \"Input error: 'serviceName' debe ser proporcionado.\",\n  \"serviceName\": null\n}\n```\n\n---\n\n🔑 Variables de Entorno\n\nPara que el workflow funcione correctamente, es necesario configurar las siguientes variables de entorno en tu instancia de n8n para la conexión a Redis:\n\n- REDIS_HOST: La dirección del servidor de Redis.\n- REDIS_PORT: El puerto del servidor de Redis.\n- REDIS_PASSWORD: La contraseña para autenticarse en Redis.\n\n---\n\n🛠️ Lógica de Implementación y Dependencias\n\nRedis: Se utiliza Redis como almacén de estado por su velocidad y sus operaciones atómicas. Cada servicio se guarda en un Hash de Redis con la clave `cb:serviceName`. Esto agrupa toda la información de un servicio (`state`, `failureCount`, `opensAt`) en una única clave, mejorando la organización.\n\nAtomicidad: Las operaciones críticas, como reportar un éxito o alcanzar el umbral de fallo, se ejecutan dentro de una transacción `multi()` de Redis. Esto garantiza que los comandos se ejecuten de forma atómica, evitando condiciones de carrera.\n\nDependencias: El nodo de código utiliza la librería `ioredis` para interactuar con Redis.",
        "height": 3504,
        "width": 992,
        "color": 7
      },
      "type": "n8n-nodes-base.stickyNote",
      "position": [
        -1088,
        -288
      ],
      "typeVersion": 1,
      "id": "cbeb8ddb-0cdb-4233-9748-3bd130b906a4",
      "name": "Sticky Note"
    }
  ],
  "pinData": {},
  "connections": {
    "Disparador: Recibir Fallo": {
      "main": [
        [
          {
            "node": "Code: Atomically Report Failure",
            "type": "main",
            "index": 0
          }
        ]
      ]
    }
  },
  "active": false,
  "settings": {
    "executionOrder": "v1"
  },
  "versionId": "cccf02fe-f1af-48f3-8119-eb952c384b63",
  "meta": {
    "instanceId": "c44159ad241c0d6d40c4f5053f46c53c8d2c806950fcbaf71270c9d0c4993311"
  },
  "id": "hX5n6drNEZEdcuER",
  "tags": []
}

El Músculo 💪

{
  "name": "TIL-Resilient-API-Executor-v1",
  "nodes": [
    {
      "parameters": {
        "workflowInputs": {
          "values": [
            {
              "name": "url"
            },
            {
              "name": "method"
            },
            {
              "name": "options",
              "type": "object"
            },
            {
              "name": "headers",
              "type": "object"
            },
            {
              "name": "body",
              "type": "object"
            },
            {
              "name": "queryParams",
              "type": "object"
            }
          ]
        }
      },
      "type": "n8n-nodes-base.executeWorkflowTrigger",
      "typeVersion": 1.1,
      "position": [
        0,
        240
      ],
      "id": "4bca53d5-f470-4da3-b10e-b67bf22cd970",
      "name": "When Executed by Another Workflow"
    },
    {
      "parameters": {
        "jsCode": "// Paso 1: Recoger los datos de entrada del disparador.\nconst input = $input.first().json;\nconst errors = [];\n\n// Paso 2: Definir los campos que son absolutamente obligatorios para esta utilidad.\nconst requiredFields = ['url', 'method'];\n\n// Paso 3: Verificar que cada campo requerido exista y no esté vacío.\nrequiredFields.forEach(field => {\n  if (!input[field] || String(input[field]).trim() === '') {\n    errors.push(`Error de Validación: El parámetro requerido '${field}' está ausente o vacío.`);\n  }\n});\n\n// Puedes añadir más validaciones aquí en el futuro (ej. validar que 'method' sea uno de [GET, POST...])\n\n// Paso 4: Devolver un resultado estructurado y predecible.\nreturn [{\n  json: {\n    isValid: errors.length === 0,\n    errors: errors,\n    validatedInput: input\n  }\n}];"
      },
      "type": "n8n-nodes-base.code",
      "typeVersion": 2,
      "position": [
        224,
        240
      ],
      "id": "923288ef-d21d-41f4-8359-63ac26edc2da",
      "name": "Validar Entradas Requeridas"
    },
    {
      "parameters": {
        "conditions": {
          "options": {
            "caseSensitive": true,
            "leftValue": "",
            "typeValidation": "strict",
            "version": 2
          },
          "conditions": [
            {
              "id": "1af75126-a8b0-4470-b4e1-90bc3c71ea96",
              "leftValue": "={{ $('Validar Entradas Requeridas').item.json.isValid }}",
              "rightValue": "",
              "operator": {
                "type": "boolean",
                "operation": "true",
                "singleValue": true
              }
            }
          ],
          "combinator": "and"
        },
        "options": {}
      },
      "type": "n8n-nodes-base.if",
      "typeVersion": 2.2,
      "position": [
        448,
        240
      ],
      "id": "480267fc-c782-449e-b44c-c168eaec1a2f",
      "name": "¿Entrada Válida?"
    },
    {
      "parameters": {
        "mode": "raw",
        "jsonOutput": "={\n  \"status\": \"error\",\n  \"error\": {\n    \"code\": \"VALIDATION_ERROR\",\n    \"message\": \"{{ $('Validar Entradas Requeridas').item.json.errors.join(' ') }}\",\n    \"details\": {\n      \"validationErrors\": {{ $('Validar Entradas Requeridas').item.json.errors }}\n    }\n  }\n}",
        "options": {}
      },
      "type": "n8n-nodes-base.set",
      "typeVersion": 3.4,
      "position": [
        3360,
        768
      ],
      "id": "eaab14be-5d06-47e8-9d87-352f29979760",
      "name": "Formatear Error de Validación"
    },
    {
      "parameters": {},
      "type": "n8n-nodes-base.merge",
      "typeVersion": 3.2,
      "position": [
        3584,
        288
      ],
      "id": "566618e6-0bfb-4e33-8aea-7fb9ec4d2341",
      "name": "Unificar Salida"
    },
    {
      "parameters": {},
      "type": "n8n-nodes-base.noOp",
      "typeVersion": 1,
      "position": [
        3808,
        288
      ],
      "id": "f422b2a0-4328-4277-b708-f447e6ba3ebf",
      "name": "Salida Final"
    },
    {
      "parameters": {
        "assignments": {
          "assignments": [
            {
              "id": "7f7b18bc-3f94-4142-a7b9-5ac1b6c86a98",
              "name": "cacheKey",
              "value": "={{ $json.validatedInput.options?.resilience?.cacheKey }}",
              "type": "string"
            }
          ]
        },
        "options": {}
      },
      "type": "n8n-nodes-base.set",
      "typeVersion": 3.4,
      "position": [
        672,
        144
      ],
      "id": "3824767d-6a3d-4a32-8c8f-2cc8cfd9ab0e",
      "name": "Generar Clave de Caché"
    },
    {
      "parameters": {
        "operation": "get",
        "propertyName": "data",
        "key": "={{ $('Generar Clave de Caché').item.json.cacheKey }}",
        "options": {
          "dotNotation": false
        }
      },
      "type": "n8n-nodes-base.redis",
      "typeVersion": 1,
      "position": [
        896,
        144
      ],
      "id": "6c31cebb-f8a3-4fa8-9fb0-4f95bbbd9d3f",
      "name": "Redis: Get Cache",
      "alwaysOutputData": true,
      "credentials": {
        "redis": {
          "id": "LL0wbjODiDgesNTq",
          "name": "Redis Docker Compose Local"
        }
      },
      "onError": "continueErrorOutput"
    },
    {
      "parameters": {
        "conditions": {
          "options": {
            "caseSensitive": true,
            "leftValue": "",
            "typeValidation": "strict",
            "version": 2
          },
          "conditions": [
            {
              "id": "9cb32898-66b8-4761-8bee-a62972a9faf2",
              "leftValue": "={{ $('Redis: Get Cache').item.json.data }}",
              "rightValue": "",
              "operator": {
                "type": "string",
                "operation": "notEmpty",
                "singleValue": true
              }
            }
          ],
          "combinator": "and"
        },
        "options": {}
      },
      "type": "n8n-nodes-base.if",
      "typeVersion": 2.2,
      "position": [
        1120,
        144
      ],
      "id": "9ab0d418-e078-475f-8965-077c937867f6",
      "name": "IF: Cache Hit?"
    },
    {
      "parameters": {
        "workflowId": {
          "__rl": true,
          "value": "hX5n6drNEZEdcuER",
          "mode": "list",
          "cachedResultName": "Manejador_CircuitBreaker"
        },
        "workflowInputs": {
          "mappingMode": "defineBelow",
          "value": {
            "resetTimeoutSeconds": "60",
            "failureThreshold": "5",
            "serviceName": "={{ $('Validar Entradas Requeridas').item.json.validatedInput.options?.resilience?.circuitBreakerKey }}",
            "mode": "CHECK"
          },
          "matchingColumns": [],
          "schema": [
            {
              "id": "serviceName",
              "displayName": "serviceName",
              "required": false,
              "defaultMatch": false,
              "display": true,
              "canBeUsedToMatch": true,
              "type": "string"
            },
            {
              "id": "failureThreshold",
              "displayName": "failureThreshold",
              "required": false,
              "defaultMatch": false,
              "display": true,
              "canBeUsedToMatch": true,
              "type": "string"
            },
            {
              "id": "resetTimeoutSeconds",
              "displayName": "resetTimeoutSeconds",
              "required": false,
              "defaultMatch": false,
              "display": true,
              "canBeUsedToMatch": true,
              "type": "string"
            },
            {
              "id": "mode",
              "displayName": "mode",
              "required": false,
              "defaultMatch": false,
              "display": true,
              "canBeUsedToMatch": true,
              "type": "string"
            }
          ],
          "attemptToConvertTypes": false,
          "convertFieldsToString": true
        },
        "options": {
          "waitForSubWorkflow": true
        }
      },
      "type": "n8n-nodes-base.executeWorkflow",
      "typeVersion": 1.2,
      "position": [
        1344,
        384
      ],
      "id": "a45a6294-011f-4f81-a146-2693f899fd83",
      "name": "CB: Verificar Estado"
    },
    {
      "parameters": {
        "conditions": {
          "options": {
            "caseSensitive": true,
            "leftValue": "",
            "typeValidation": "strict",
            "version": 2
          },
          "conditions": [
            {
              "id": "d3f9bdc2-7961-484c-8343-780d4566f082",
              "leftValue": "={{ $('CB: Verificar Estado').item.json.state }}",
              "rightValue": "PROCEED",
              "operator": {
                "type": "string",
                "operation": "equals",
                "name": "filter.operator.equals"
              }
            }
          ],
          "combinator": "and"
        },
        "options": {}
      },
      "type": "n8n-nodes-base.if",
      "typeVersion": 2.2,
      "position": [
        1568,
        384
      ],
      "id": "28ca3649-2b76-4862-a11f-5c1ed945e89c",
      "name": "IF: ¿Circuito Permite Proceder?"
    },
    {
      "parameters": {
        "mode": "raw",
        "jsonOutput": "={\n  \"status\": \"error\",\n  \"error\": {\n    \"code\": \"CIRCUIT_BREAKER_OPEN\",\n    \"message\": \"El servicio no está disponible temporalmente. Por favor, inténtelo de nuevo más tarde.\",\n    \"details\": {\n      \"diagnosticMessage\": \"{{ $('CB: Verificar Estado').item.json.details }}\"\n    }\n  }\n}",
        "options": {}
      },
      "type": "n8n-nodes-base.set",
      "typeVersion": 3.4,
      "position": [
        3360,
        576
      ],
      "id": "56cdf0c9-20a6-4d15-86b6-46646f0330d4",
      "name": "Formatear Error de Circuito Abierto"
    },
    {
      "parameters": {
        "rules": {
          "values": [
            {
              "conditions": {
                "options": {
                  "caseSensitive": true,
                  "leftValue": "",
                  "typeValidation": "strict",
                  "version": 2
                },
                "conditions": [
                  {
                    "leftValue": "={{ $json.statusCode?.toString() }}",
                    "rightValue": "2",
                    "operator": {
                      "type": "string",
                      "operation": "startsWith"
                    },
                    "id": "5057a7f9-a69c-4367-a3f6-344d5521c8ce"
                  }
                ],
                "combinator": "and"
              },
              "renameOutput": true,
              "outputKey": "Éxito 2xx"
            },
            {
              "conditions": {
                "options": {
                  "caseSensitive": true,
                  "leftValue": "",
                  "typeValidation": "strict",
                  "version": 2
                },
                "conditions": [
                  {
                    "id": "01841ae9-ced5-4cef-94ef-72cba6073952",
                    "leftValue": "={{ ($json.statusCode ?? $json.error?.status)?.toString() }}",
                    "rightValue": "5",
                    "operator": {
                      "type": "string",
                      "operation": "startsWith"
                    }
                  }
                ],
                "combinator": "and"
              },
              "renameOutput": true,
              "outputKey": "Error Servidor (5xx)"
            }
          ]
        },
        "options": {
          "fallbackOutput": "extra",
          "renameFallbackOutput": "Error de Cliente (4xx)"
        }
      },
      "type": "n8n-nodes-base.switch",
      "typeVersion": 3.2,
      "position": [
        2240,
        176
      ],
      "id": "dc8ec6be-8321-484f-8613-327f787be1f8",
      "name": "Switch: Resultado de API"
    },
    {
      "parameters": {
        "operation": "set",
        "key": "={{ $('Generar Clave de Caché').item.json.cacheKey }}",
        "value": "={{ JSON.stringify($('Formatear Salida de Éxito').item.json) }}",
        "expire": true,
        "ttl": "={{ $('Validar Entradas Requeridas').item.json.validatedInput.options?.resilience?.cacheTTL ?? 3600 }}"
      },
      "type": "n8n-nodes-base.redis",
      "typeVersion": 1,
      "position": [
        2912,
        -128
      ],
      "id": "ba73591a-c084-42b0-84f8-6ce3bbf2c566",
      "name": "Redis: Set Cache",
      "credentials": {
        "redis": {
          "id": "LL0wbjODiDgesNTq",
          "name": "Redis Docker Compose Local"
        }
      }
    },
    {
      "parameters": {
        "workflowId": {
          "__rl": true,
          "value": "hX5n6drNEZEdcuER",
          "mode": "list",
          "cachedResultName": "Manejador_CircuitBreaker"
        },
        "workflowInputs": {
          "mappingMode": "defineBelow",
          "value": {
            "resetTimeoutSeconds": "60",
            "failureThreshold": "5",
            "mode": "SUCCESS",
            "serviceName": "={{ $('Validar Entradas Requeridas').item.json.validatedInput.options?.resilience?.circuitBreakerKey }}"
          },
          "matchingColumns": [],
          "schema": [
            {
              "id": "serviceName",
              "displayName": "serviceName",
              "required": false,
              "defaultMatch": false,
              "display": true,
              "canBeUsedToMatch": true,
              "type": "string"
            },
            {
              "id": "failureThreshold",
              "displayName": "failureThreshold",
              "required": false,
              "defaultMatch": false,
              "display": true,
              "canBeUsedToMatch": true,
              "type": "string"
            },
            {
              "id": "resetTimeoutSeconds",
              "displayName": "resetTimeoutSeconds",
              "required": false,
              "defaultMatch": false,
              "display": true,
              "canBeUsedToMatch": true,
              "type": "string"
            },
            {
              "id": "mode",
              "displayName": "mode",
              "required": false,
              "defaultMatch": false,
              "display": true,
              "canBeUsedToMatch": true,
              "type": "string"
            }
          ],
          "attemptToConvertTypes": false,
          "convertFieldsToString": true
        },
        "options": {}
      },
      "type": "n8n-nodes-base.executeWorkflow",
      "typeVersion": 1.2,
      "position": [
        3136,
        -128
      ],
      "id": "56c44db1-e8b8-474e-a25f-14dd0f1f3ec9",
      "name": "CB: Reportar Éxito"
    },
    {
      "parameters": {
        "mode": "raw",
        "jsonOutput": "={\n  \"status\": \"success\",\n  \"data\": {{ $('API: Llamada Dinámica').item.json }}\n}",
        "options": {}
      },
      "type": "n8n-nodes-base.set",
      "typeVersion": 3.4,
      "position": [
        2464,
        -48
      ],
      "id": "f63e9ae0-7ce9-46b3-90fd-4229a5357ceb",
      "name": "Formatear Salida de Éxito"
    },
    {
      "parameters": {
        "conditions": {
          "options": {
            "caseSensitive": true,
            "leftValue": "",
            "typeValidation": "strict",
            "version": 2
          },
          "conditions": [
            {
              "id": "0afabb10-57e6-49cb-8a09-d4016e7bdef2",
              "leftValue": "={{ $('Generar Clave de Caché').item.json.cacheKey }}",
              "rightValue": "",
              "operator": {
                "type": "string",
                "operation": "notEmpty",
                "singleValue": true
              }
            }
          ],
          "combinator": "and"
        },
        "options": {}
      },
      "type": "n8n-nodes-base.if",
      "typeVersion": 2.2,
      "position": [
        2688,
        -48
      ],
      "id": "7e9034b8-89d9-4d0b-a6f5-274ddf551335",
      "name": "IF: ¿Caché Habilitado?"
    },
    {
      "parameters": {
        "mode": "raw",
        "jsonOutput": "={{ $('Formatear Salida de Éxito').item.json }}",
        "options": {}
      },
      "type": "n8n-nodes-base.set",
      "typeVersion": 3.4,
      "position": [
        3360,
        -48
      ],
      "id": "f9a33f8f-5eac-4ad9-ad51-d12ced08d84e",
      "name": "Preparar Salida Final de Éxito"
    },
    {
      "parameters": {
        "workflowId": {
          "__rl": true,
          "value": "hX5n6drNEZEdcuER",
          "mode": "list",
          "cachedResultName": "Manejador_CircuitBreaker"
        },
        "workflowInputs": {
          "mappingMode": "defineBelow",
          "value": {
            "resetTimeoutSeconds": "60",
            "failureThreshold": "5",
            "mode": "FAILURE",
            "serviceName": "={{ $('Validar Entradas Requeridas').item.json.validatedInput.options?.resilience?.circuitBreakerKey }}"
          },
          "matchingColumns": [],
          "schema": [
            {
              "id": "serviceName",
              "displayName": "serviceName",
              "required": false,
              "defaultMatch": false,
              "display": true,
              "canBeUsedToMatch": true,
              "type": "string"
            },
            {
              "id": "failureThreshold",
              "displayName": "failureThreshold",
              "required": false,
              "defaultMatch": false,
              "display": true,
              "canBeUsedToMatch": true,
              "type": "string"
            },
            {
              "id": "resetTimeoutSeconds",
              "displayName": "resetTimeoutSeconds",
              "required": false,
              "defaultMatch": false,
              "display": true,
              "canBeUsedToMatch": true,
              "type": "string"
            },
            {
              "id": "mode",
              "displayName": "mode",
              "required": false,
              "defaultMatch": false,
              "display": true,
              "canBeUsedToMatch": true,
              "type": "string"
            }
          ],
          "attemptToConvertTypes": false,
          "convertFieldsToString": true
        },
        "options": {}
      },
      "type": "n8n-nodes-base.executeWorkflow",
      "typeVersion": 1.2,
      "position": [
        3136,
        192
      ],
      "id": "b7e75aa3-704d-4423-bd7b-306956055e0d",
      "name": "CB: Reportar Fallo"
    },
    {
      "parameters": {
        "mode": "raw",
        "jsonOutput": "={\n  \"status\": \"error\",\n  \"error\": {\n    \"code\": \"API_SERVER_ERROR\",\n    \"message\": \"La petición falló debido a un error temporal en el servidor. Podría funcionar si se reintenta.\",\n    \"details\": {\n      \"httpStatusCode\": {{ $('API: Llamada Dinámica').item.json.error?.status ?? \"N/A\" }},\n      \"responseBody\": \"{{ $('API: Llamada Dinámica').item.json.error?.message?.replace(/\"/g, '\\\\\"') ?? \"No body available\" }}\",\n      \"circuitBreakerInfo\": {{ $('CB: Reportar Fallo').item.json }}\n    }\n  }\n}",
        "options": {}
      },
      "type": "n8n-nodes-base.set",
      "typeVersion": 3.4,
      "position": [
        3360,
        192
      ],
      "id": "c6d0ffe7-ce01-4f74-af52-a1cca943fcbd",
      "name": "Formatear Error de Servidor"
    },
    {
      "parameters": {
        "mode": "raw",
        "jsonOutput": "={\n  \"status\": \"error\",\n  \"error\": {\n    \"code\": \"API_CLIENT_ERROR\",\n    \"message\": \"La petición falló debido a un error en los datos enviados (ej. no autorizado o no encontrado).\",\n    \"details\": {\n      \"httpStatusCode\": {{ $('API: Llamada Dinámica').item.json.error?.status ?? \"N/A\" }},\n      \"responseBody\": \"{{ $('API: Llamada Dinámica').item.json.error?.message?.replace(/\"/g, '\\\\\"') ?? \"No body available\" }}\"\n    }\n  }\n}",
        "options": {}
      },
      "type": "n8n-nodes-base.set",
      "typeVersion": 3.4,
      "position": [
        3360,
        384
      ],
      "id": "8db0bd7c-d97d-4fcc-8a05-3ae5252a4e02",
      "name": "Formatear Error de Cliente"
    },
    {
      "parameters": {
        "content": "# 🏛️ Workflow: Generic & Resilient API Executor (TIL-Resilient-API-Executor-v1)\n\nEste sub-workflow actúa como una **capa de ejecución de API genérica y centralizada**. Su propósito es abstraer la complejidad de realizar llamadas HTTP, decorándolas en tiempo de ejecución con patrones de resiliencia de nivel empresarial como **Cache-Aside** y **Circuit Breaker**.\n\n---\n\n## 🚀 Propósito y Arquitectura\n\nEste workflow es la capa de **Utilidad Genérica** en una arquitectura de tres capas (Orquestador -> Herramienta -> Utilidad). Su única responsabilidad es ejecutar llamadas API de manera segura y eficiente, permitiendo que las \"Herramientas\" (otros sub-workflows) se centren exclusivamente en la lógica de negocio.\n\n- **Proxy Pattern**: Intercepta las solicitudes API para añadir lógica de resiliencia y caché.  \n- **Decorator Pattern**: \"Decora\" una simple llamada HTTP con funcionalidades avanzadas sin alterar la lógica de la herramienta que la invoca.  \n- **Single Responsibility Principle**: Se encarga del \"cómo\" (la ejecución técnica), mientras que la herramienta que lo llama se encarga del \"qué\" (la lógica de negocio).\n\n---\n\n## 📥 Contrato de Entrada (Universal API Request DTO)\n\nPara invocar este workflow, se debe proporcionar un objeto JSON que cumpla con el siguiente contrato. Cualquier campo no especificado aquí será ignorado.\n\n| Campo | Tipo | Requerido | Descripción |\n| :--- | :--- | :---: | :--- |\n| `url` | `String` | Sí | La URL completa del endpoint al que se llamará. |\n| `method` | `String` | Sí | El método HTTP a utilizar (e.g., `GET`, `POST`, `PUT`, `DELETE`). |\n| `headers` | `Object` | No | Un objeto con los encabezados HTTP de la solicitud. |\n| `body` | `Object` | No | El cuerpo de la solicitud, típicamente un objeto JSON. |\n| `queryParams` | `Object` | No | Un objeto con los parámetros de consulta para la URL. |\n| `options.resilience.cacheKey` | `String` | No | Clave única para buscar/guardar la respuesta en Redis. Si se omite, se salta el caché. |\n| `options.resilience.cacheTTL` | `Number` | No | Tiempo de vida (en segundos) para la entrada de caché. Por defecto `3600`. |\n| `options.resilience.circuitBreakerKey`| `String` | No | Identificador único del servicio para el Circuit Breaker. Si se omite, no se verifica. |\n\n**Ejemplo de Invocación:**\n```json\n{\n  \"url\": \"https://api.example.com/users\",\n  \"method\": \"POST\",\n  \"headers\": {\n    \"Content-Type\": \"application/json\",\n    \"X-API-Key\": \"your-secret-key\"\n  },\n  \"body\": {\n    \"name\": \"John Doe\",\n    \"email\": \"john.doe@example.com\"\n  },\n  \"options\": {\n    \"resilience\": {\n      \"cacheKey\": \"users:john.doe@example.com\",\n      \"cacheTTL\": 86400,\n      \"circuitBreakerKey\": \"example-api-users\"\n    }\n  }\n}\n```\n\n---\n\n## 📤 Contrato de Salida (Standardized Response)\n\nEl workflow siempre devuelve un objeto JSON estructurado y predecible para que el workflow llamador pueda manejar el resultado de forma consistente.\n\n### ✅ Salida Exitosa (status: \"success\")\n\nSi la validación, caché, circuit breaker y la llamada API son exitosos, la salida tendrá la siguiente estructura. El objeto `data` contiene la respuesta completa de la API.\n\n```json\n{\n  \"status\": \"success\",\n  \"data\": {\n    \"statusCode\": 201,\n    \"headers\": {\n      \"content-type\": \"application/json\"\n    },\n    \"body\": {\n      \"id\": \"usr_12345\",\n      \"message\": \"User created successfully\"\n    }\n  }\n}\n```\n\n### ❌ Salida de Error (status: \"error\")\n\nSi ocurre cualquier tipo de error, la salida contendrá un objeto `error` estructurado para facilitar el debugging y la recuperación.\n\n| error.code | Origen | Descripción |\n| :--- | :--- | :--- |\n| VALIDATION_ERROR | Validación de Entrada | Los parámetros requeridos (`url`, `method`) faltan o están vacíos. |\n| CIRCUIT_BREAKER_OPEN | Circuit Breaker | El servicio externo está marcado como no disponible y la llamada fue bloqueada. |\n| API_CLIENT_ERROR | Llamada HTTP (4xx) | La API respondió con un error de cliente (e.g., 400, 401, 404). La solicitud no debe reintentarse. |\n| API_SERVER_ERROR | Llamada HTTP (5xx) | La API respondió con un error de servidor (e.g., 500, 503). La solicitud podría funcionar si se reintenta. |\n\n**Ejemplo de Salida de Error:**\n```json\n{\n  \"status\": \"error\",\n  \"error\": {\n    \"code\": \"API_CLIENT_ERROR\",\n    \"message\": \"La petición falló debido a un error en los datos enviados (ej. no autorizado o no encontrado).\",\n    \"details\": {\n      \"httpStatusCode\": 404,\n      \"responseBody\": {\n        \"error\": \"User not found\"\n      }\n    }\n  }\n}\n```\n\n---\n\n## 🧩 Dependencias\n\n- Redis: Se requiere una conexión a Redis configurada para las funcionalidades de Caché y Circuit Breaker.  \n- Sub-workflow `Manejador_CircuitBreaker`: Este workflow debe existir en la instancia de n8n, ya que es invocado para gestionar el estado del Circuit Breaker.\n",
        "height": 2848,
        "width": 832,
        "color": 7
      },
      "type": "n8n-nodes-base.stickyNote",
      "position": [
        -960,
        -688
      ],
      "typeVersion": 1,
      "id": "e9f02341-8352-4ca2-b0fc-6bbb55047075",
      "name": "Sticky Note"
    },
    {
      "parameters": {
        "method": "={{ $('Validar Entradas Requeridas').item.json.validatedInput.method }}",
        "url": "={{ $('Validar Entradas Requeridas').item.json.validatedInput.url }}",
        "sendQuery": true,
        "specifyQuery": "json",
        "jsonQuery": "={{ JSON.stringify($('Preparar Solicitud Dinámica').item.json.finalQueryParams) }}",
        "sendHeaders": true,
        "specifyHeaders": "json",
        "jsonHeaders": "={{ JSON.stringify($('Preparar Solicitud Dinámica').item.json.finalHeaders) }}",
        "sendBody": true,
        "specifyBody": "json",
        "jsonBody": "={{ $('Preparar Solicitud Dinámica').item.json.finalBody }}",
        "options": {
          "response": {
            "response": {
              "fullResponse": true
            }
          }
        }
      },
      "type": "n8n-nodes-base.httpRequest",
      "typeVersion": 4.2,
      "position": [
        2016,
        192
      ],
      "id": "8c624170-d71a-453e-9dfd-729d4b2af53f",
      "name": "API: Llamada Dinámica",
      "onError": "continueErrorOutput"
    },
    {
      "parameters": {
        "jsCode": "// Obtener la entrada validada del primer nodo\nconst validatedInput = $('Validar Entradas Requeridas').first().json.validatedInput;\n\n// Inicializar objetos limpios para la salida\nconst finalQueryParams = {};\nconst finalHeaders = {};\nconst finalBody = {}; // Inicializar un body vacío por defecto\n\n// --- Procesar Query Params Opcionales ---\nif (validatedInput.queryParams != null && typeof validatedInput.queryParams === 'object') {\n  for (const key in validatedInput.queryParams) {\n    const value = validatedInput.queryParams[key];\n    if (value != null) {\n      finalQueryParams[key] = value;\n    }\n  }\n}\n\n// --- Procesar Headers Opcionales ---\nif (validatedInput.headers != null && typeof validatedInput.headers === 'object') {\n  for (const key in validatedInput.headers) {\n    const value = validatedInput.headers[key];\n    if (value != null) {\n      finalHeaders[key] = value;\n    }\n  }\n}\n\n// --- Procesar Body Opcional ---\n// Solo si el body es un objeto y no es nulo, lo pasamos. Si no, se queda como objeto vacío {}.\nif (validatedInput.body != null && typeof validatedInput.body === 'object') {\n  Object.assign(finalBody, validatedInput.body);\n}\n\n// Devolver un objeto que contiene los datos originales Y los objetos limpios\nreturn [{\n  json: {\n    ...validatedInput,\n    finalQueryParams: finalQueryParams,\n    finalHeaders: finalHeaders,\n    finalBody: finalBody\n  } \n}];"
      },
      "type": "n8n-nodes-base.code",
      "typeVersion": 2,
      "position": [
        1792,
        192
      ],
      "id": "9535014d-5b70-4a07-a675-7d1285de6852",
      "name": "Preparar Solicitud Dinámica"
    },
    {
      "parameters": {
        "jsCode": "// 1. Obtener el string JSON guardado en el caché\nconst cachedString = $('Redis: Get Cache').first().json.data;\n\n// 2. Convertir (parsear) ese string de vuelta a un objeto JavaScript\nconst cachedObject = JSON.parse(cachedString);\n\n// 3. Devolver el objeto parseado directamente como la nueva salida del nodo.\n// Esto asegura que la estructura sea idéntica a la del camino de \"cache miss\".\nreturn [{\n  json: cachedObject\n}];"
      },
      "type": "n8n-nodes-base.code",
      "typeVersion": 2,
      "position": [
        3360,
        -288
      ],
      "id": "f4937fdf-3ccb-437d-b7fb-190d2205c02c",
      "name": "Procesar Salida de Caché"
    }
  ],
  "pinData": {
    "When Executed by Another Workflow": [
      {
        "json": {
          "url": "https://tu-url",
          "method": "POST",
          "options": {
            "resilience": {
              "cacheKey": "getAfiliadoCore:CC-000",
              "circuitBreakerKey": "getAfiliadoCore",
              "cacheTTL": 3600
            }
          },
          "headers": {
            "Content-Type": "application/json"
          },
          "body": {
            "sistema": "APPMP",
            "nombreClave": "getAfiliadoCore",
            "token": "xyz",
            "jsonParametros": "{ \"tipo_id\":  \"CC\", \"id\":  \"000\" }"
          },
          "queryParams": null
        }
      }
    ]
  },
  "connections": {
    "When Executed by Another Workflow": {
      "main": [
        [
          {
            "node": "Validar Entradas Requeridas",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Validar Entradas Requeridas": {
      "main": [
        [
          {
            "node": "¿Entrada Válida?",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "¿Entrada Válida?": {
      "main": [
        [
          {
            "node": "Generar Clave de Caché",
            "type": "main",
            "index": 0
          }
        ],
        [
          {
            "node": "Formatear Error de Validación",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Formatear Error de Validación": {
      "main": [
        [
          {
            "node": "Unificar Salida",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Unificar Salida": {
      "main": [
        [
          {
            "node": "Salida Final",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Generar Clave de Caché": {
      "main": [
        [
          {
            "node": "Redis: Get Cache",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Redis: Get Cache": {
      "main": [
        [
          {
            "node": "IF: Cache Hit?",
            "type": "main",
            "index": 0
          }
        ],
        [
          {
            "node": "IF: Cache Hit?",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "IF: Cache Hit?": {
      "main": [
        [
          {
            "node": "Procesar Salida de Caché",
            "type": "main",
            "index": 0
          }
        ],
        [
          {
            "node": "CB: Verificar Estado",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "CB: Verificar Estado": {
      "main": [
        [
          {
            "node": "IF: ¿Circuito Permite Proceder?",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "IF: ¿Circuito Permite Proceder?": {
      "main": [
        [
          {
            "node": "Preparar Solicitud Dinámica",
            "type": "main",
            "index": 0
          }
        ],
        [
          {
            "node": "Formatear Error de Circuito Abierto",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Formatear Error de Circuito Abierto": {
      "main": [
        [
          {
            "node": "Unificar Salida",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Redis: Set Cache": {
      "main": [
        [
          {
            "node": "CB: Reportar Éxito",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "CB: Reportar Éxito": {
      "main": [
        [
          {
            "node": "Preparar Salida Final de Éxito",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Switch: Resultado de API": {
      "main": [
        [
          {
            "node": "Formatear Salida de Éxito",
            "type": "main",
            "index": 0
          }
        ],
        [
          {
            "node": "CB: Reportar Fallo",
            "type": "main",
            "index": 0
          }
        ],
        [
          {
            "node": "Formatear Error de Cliente",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Formatear Salida de Éxito": {
      "main": [
        [
          {
            "node": "IF: ¿Caché Habilitado?",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "IF: ¿Caché Habilitado?": {
      "main": [
        [
          {
            "node": "Redis: Set Cache",
            "type": "main",
            "index": 0
          }
        ],
        [
          {
            "node": "Preparar Salida Final de Éxito",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Preparar Salida Final de Éxito": {
      "main": [
        [
          {
            "node": "Unificar Salida",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "CB: Reportar Fallo": {
      "main": [
        [
          {
            "node": "Formatear Error de Servidor",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Formatear Error de Servidor": {
      "main": [
        [
          {
            "node": "Unificar Salida",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Formatear Error de Cliente": {
      "main": [
        [
          {
            "node": "Unificar Salida",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "API: Llamada Dinámica": {
      "main": [
        [
          {
            "node": "Switch: Resultado de API",
            "type": "main",
            "index": 0
          }
        ],
        [
          {
            "node": "Switch: Resultado de API",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Preparar Solicitud Dinámica": {
      "main": [
        [
          {
            "node": "API: Llamada Dinámica",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Procesar Salida de Caché": {
      "main": [
        [
          {
            "node": "Unificar Salida",
            "type": "main",
            "index": 0
          }
        ]
      ]
    }
  },
  "active": false,
  "settings": {
    "executionOrder": "v1"
  },
  "versionId": "77ae3010-3ed4-409a-9d27-93ee9ed16a0c",
  "meta": {
    "instanceId": "c44159ad241c0d6d40c4f5053f46c53c8d2c806950fcbaf71270c9d0c4993311"
  },
  "id": "o4o1rEmGsKQktiHT",
  "tags": []
}

El Ejemplo Práctico 🏥

{
  "name": "Herramienta_DirectorioMedico_BuscarServicios_v1",
  "nodes": [
    {
      "parameters": {
        "workflowInputs": {
          "values": [
            {
              "name": "ciudad"
            },
            {
              "name": "desAgrupa"
            }
          ]
        }
      },
      "type": "n8n-nodes-base.executeWorkflowTrigger",
      "typeVersion": 1.1,
      "position": [
        480,
        720
      ],
      "id": "7c57493c-f8d4-4579-996f-0dc4d8095609",
      "name": "Disparador: Recibir Datos"
    },
    {
      "parameters": {
        "method": "POST",
        "url": "=https://oficinavirtualmp.coomeva.com.co/saludmp-ws/jax-rs/saludmp-appFrontController",
        "authentication": "genericCredentialType",
        "genericAuthType": "httpCustomAuth",
        "sendBody": true,
        "bodyParameters": {
          "parameters": [
            {
              "name": "sistema",
              "value": "={{ $json.sistema }}"
            },
            {
              "name": "nombreClave",
              "value": "={{ $json.nombreClave }}"
            },
            {
              "name": "jsonParametros",
              "value": "={{ $json.jsonParametros }}"
            }
          ]
        },
        "options": {
          "response": {
            "response": {}
          }
        }
      },
      "type": "n8n-nodes-base.httpRequest",
      "typeVersion": 4.2,
      "position": [
        480,
        304
      ],
      "id": "379d9102-db86-41f3-a868-4174e44a8957",
      "name": "API: GetAgrupadores1",
      "credentials": {
        "httpCustomAuth": {
          "id": "Giu2BvZ1oYBtcOEr",
          "name": "DirectorioMedico Custom Auth"
        }
      },
      "onError": "continueErrorOutput"
    },
    {
      "parameters": {
        "mode": "raw",
        "jsonOutput": "={\n  \"status\": \"error\",\n  \"error\": {\n    \"code\": \"VALIDATION_ERROR\",\n    \"message\": \"{{ $('Validar y Estructurar Entradas').item.json.errors.join(' ') }}\",\n    \"details\": {\n      \"validationErrors\": {{ $('Validar y Estructurar Entradas').item.json.errors }}\n    }\n  }\n}",
        "options": {}
      },
      "type": "n8n-nodes-base.set",
      "typeVersion": 3.4,
      "position": [
        1824,
        912
      ],
      "id": "aadeb5a5-f9b5-443a-ae64-03f336c8a86d",
      "name": "Formatear Error de Validación"
    },
    {
      "parameters": {
        "jsCode": "// Paso 1: Definir el Contrato de la Herramienta\nconst requiredFields = ['ciudad', 'desAgrupa'];\n\n// Paso 2: Recoger los datos de entrada\nconst input = $input.first().json;\nconst errors = [];\n\n// Paso 3: Ejecutar las Validaciones\nrequiredFields.forEach(field => {\n  // Validamos que el campo exista (no sea nulo ni indefinido).\n  // Permitimos explícitamente que 'desAgrupa' sea una cadena vacía.\n  if (input[field] === undefined || input[field] === null) {\n     errors.push(`Error de Validación: El parámetro requerido '${field}' está ausente.`);\n  }\n});\n\n// Paso 4: Devolver un resultado estructurado\nreturn [{\n  json: {\n    isValid: errors.length === 0,\n    errors: errors,\n    validatedInput: input\n  }\n}];"
      },
      "type": "n8n-nodes-base.code",
      "typeVersion": 2,
      "position": [
        704,
        720
      ],
      "id": "cd6519a9-c5d9-4489-a718-59f0f359d43b",
      "name": "Validar y Estructurar Entradas"
    },
    {
      "parameters": {
        "conditions": {
          "options": {
            "caseSensitive": true,
            "leftValue": "",
            "typeValidation": "strict",
            "version": 2
          },
          "conditions": [
            {
              "id": "3e587118-8ee7-41ec-b12d-ead5f21f9798",
              "leftValue": "={{ $json.isValid }}",
              "rightValue": "",
              "operator": {
                "type": "boolean",
                "operation": "true",
                "singleValue": true
              }
            }
          ],
          "combinator": "and"
        },
        "options": {}
      },
      "type": "n8n-nodes-base.if",
      "typeVersion": 2.2,
      "position": [
        928,
        720
      ],
      "id": "3e2a1824-133d-4395-9062-a712da016c31",
      "name": "¿Entrada Válida?"
    },
    {
      "parameters": {},
      "type": "n8n-nodes-base.merge",
      "typeVersion": 3.2,
      "position": [
        2048,
        720
      ],
      "id": "3dec828f-d15d-44fd-9113-3472f89b9832",
      "name": "Unificar Salida"
    },
    {
      "parameters": {
        "mode": "raw",
        "jsonOutput": "={\n  \"url\": \"https://tu-url\",\n  \"method\": \"POST\",\n  \"headers\": {\n    \"Content-Type\": \"application/json\"\n  },\n  \"body\": {\n    \"sistema\": \"APPMP\",\n    \"token\": \"xyz\",\n    \"nombreClave\": \"getAgrupadores\",\n    \"jsonParametros\": \"{\\\"desAgrupa\\\": \\\"{{ $('Validar y Estructurar Entradas').item.json.validatedInput.desAgrupa }}\\\",\\\"tipoAgrupa\\\": \\\"AMB\\\", \\\"ciudad\\\": \\\"{{ $('Validar y Estructurar Entradas').item.json.validatedInput.ciudad }}\\\"}\"\n  },\n  \"queryParams\": null,\n  \"options\": {\n    \"resilience\": {\n      \"cacheKey\": \"buscarServicios:{{ $('Validar y Estructurar Entradas').item.json.validatedInput.ciudad }}:{{ $('Validar y Estructurar Entradas').item.json.validatedInput.desAgrupa }}\",\n      \"circuitBreakerKey\": \"buscarServicios\",\n      \"cacheTTL\": 3600\n    }\n  }\n}",
        "options": {}
      },
      "type": "n8n-nodes-base.set",
      "typeVersion": 3.4,
      "position": [
        1152,
        624
      ],
      "id": "3db96db1-c683-4d34-a183-c44c4de86882",
      "name": "Ensamblar DTO para la Utilidad"
    },
    {
      "parameters": {
        "workflowId": {
          "__rl": true,
          "value": "o4o1rEmGsKQktiHT",
          "mode": "list",
          "cachedResultName": "TIL-Resilient-API-Executor-v1"
        },
        "workflowInputs": {
          "mappingMode": "defineBelow",
          "value": {
            "url": "={{ $('Ensamblar DTO para la Utilidad').item.json.url }}",
            "headers": "={{ $('Ensamblar DTO para la Utilidad').item.json.headers }}",
            "method": "={{ $('Ensamblar DTO para la Utilidad').item.json.method }}",
            "options": "={{ $('Ensamblar DTO para la Utilidad').item.json.options }}",
            "body": "={{ $('Ensamblar DTO para la Utilidad').item.json.body }}",
            "queryParams": "={{ $('Ensamblar DTO para la Utilidad').item.json.queryParams }}"
          },
          "matchingColumns": [],
          "schema": [
            {
              "id": "url",
              "displayName": "url",
              "required": false,
              "defaultMatch": false,
              "display": true,
              "canBeUsedToMatch": true,
              "type": "string",
              "removed": false
            },
            {
              "id": "method",
              "displayName": "method",
              "required": false,
              "defaultMatch": false,
              "display": true,
              "canBeUsedToMatch": true,
              "type": "string",
              "removed": false
            },
            {
              "id": "options",
              "displayName": "options",
              "required": false,
              "defaultMatch": false,
              "display": true,
              "canBeUsedToMatch": true,
              "type": "object",
              "removed": false
            },
            {
              "id": "headers",
              "displayName": "headers",
              "required": false,
              "defaultMatch": false,
              "display": true,
              "canBeUsedToMatch": true,
              "type": "object",
              "removed": false
            },
            {
              "id": "body",
              "displayName": "body",
              "required": false,
              "defaultMatch": false,
              "display": true,
              "canBeUsedToMatch": true,
              "type": "object",
              "removed": false
            },
            {
              "id": "queryParams",
              "displayName": "queryParams",
              "required": false,
              "defaultMatch": false,
              "display": true,
              "canBeUsedToMatch": true,
              "type": "object",
              "removed": false
            }
          ],
          "attemptToConvertTypes": false,
          "convertFieldsToString": true
        },
        "options": {
          "waitForSubWorkflow": true
        }
      },
      "type": "n8n-nodes-base.executeWorkflow",
      "typeVersion": 1.2,
      "position": [
        1376,
        624
      ],
      "id": "3e0cd4cd-2f20-4e17-b886-2e5990290202",
      "name": "Llamar a la Utilidad Resiliente"
    },
    {
      "parameters": {
        "conditions": {
          "options": {
            "caseSensitive": true,
            "leftValue": "",
            "typeValidation": "strict",
            "version": 2
          },
          "conditions": [
            {
              "id": "c5e2cff1-bfb3-4053-ae6a-1ea5d1113451",
              "leftValue": "={{ $('Llamar a la Utilidad Resiliente').item.json.status }}",
              "rightValue": "success",
              "operator": {
                "type": "string",
                "operation": "equals",
                "name": "filter.operator.equals"
              }
            }
          ],
          "combinator": "and"
        },
        "options": {}
      },
      "type": "n8n-nodes-base.if",
      "typeVersion": 2.2,
      "position": [
        1600,
        624
      ],
      "id": "e548ba82-8eb9-4aff-aefc-aee5c4dc9518",
      "name": "IF: ¿Utilidad Exitosa?"
    },
    {
      "parameters": {
        "mode": "raw",
        "jsonOutput": "=={\n  \"status\": \"error\",\n  \"error\": {{ $('Llamar a la Utilidad Resiliente').item.json.error }}\n}",
        "options": {}
      },
      "type": "n8n-nodes-base.set",
      "typeVersion": 3.4,
      "position": [
        1824,
        720
      ],
      "id": "e44a69e9-b4fa-4bcb-9e70-81b2ae42bf89",
      "name": "Formatear Salida Final de Error"
    },
    {
      "parameters": {},
      "type": "n8n-nodes-base.noOp",
      "typeVersion": 1,
      "position": [
        2272,
        720
      ],
      "id": "c58ab81f-5345-48e3-a3d7-67bd5671e684",
      "name": "Salida Final"
    },
    {
      "parameters": {
        "jsCode": "// --- CÓDIGO FINAL CON REPARACIÓN AUTOMÁTICA DE JSON ---\n\n/**\n * Esta función intenta reparar un string JSON malformado de la API.\n * Específicamente, busca todos los campos \"descripcion\" y escapa cualquier\n * comilla doble (\") que encuentre dentro de su valor de texto.\n * @param {string} str - El string JSON potencialmente dañado.\n * @returns {string} - El string JSON reparado.\n */\nfunction repairJsonString(str) {\n    // Dividimos el string usando el inicio del campo \"descripcion\" como separador.\n    // Esto nos permite aislar el contenido de cada descripción.\n    const parts = str.split(',\"descripcion\":\"');\n    if (parts.length <= 1) {\n        return str; // No se encontraron descripciones, no hay nada que reparar.\n    }\n\n    // La primera parte del string (antes de la primera descripción) no se modifica.\n    let repairedString = parts[0];\n\n    // Iteramos sobre cada fragmento que contiene una descripción.\n    for (let i = 1; i < parts.length; i++) {\n        let chunk = parts[i];\n        \n        // El final de un campo \"descripcion\" casi siempre es '\",\"nivel_auditoria\":'.\n        // Usamos este patrón para saber dónde termina el texto de la descripción.\n        const endOfDescPattern = '\",\"nivel_auditoria\":';\n        const endOfDescIndex = chunk.indexOf(endOfDescPattern);\n\n        if (endOfDescIndex !== -1) {\n            let descriptionText = chunk.substring(0, endOfDescIndex);\n            const restOfChunk = chunk.substring(endOfDescIndex);\n            \n            // --- LA REPARACIÓN ---\n            // Reemplazamos todas las comillas dobles por comillas escapadas (e.g., \" -> \\\")\n            // dentro del texto de la descripción.\n            descriptionText = descriptionText.replace(/\"/g, '\\\\\"');\n            \n            // Reconstruimos el string con la descripción ya reparada.\n            repairedString += ',\"descripcion\":\"' + descriptionText + restOfChunk;\n        } else {\n            // Si no encontramos el patrón final, no podemos reparar con seguridad este fragmento.\n            // Lo añadimos tal cual para no perder datos.\n            repairedString += ',\"descripcion\":\"' + chunk;\n        }\n    }\n    return repairedString;\n}\n\n\n// --- LÓGICA PRINCIPAL DEL NODO ---\n\nconst responseItem = $('Llamar a la Utilidad Resiliente').first();\nlet finalData = [];\n\nif (responseItem && responseItem.json && responseItem.json.data && responseItem.json.data.body) {\n    const body = responseItem.json.data.body;\n\n    // CASO A: La respuesta ya viene parseada y con datos en 'jsonRespuesta'.\n    if (Array.isArray(body.jsonRespuesta) && body.jsonRespuesta.length > 0) {\n        finalData = body.jsonRespuesta;\n    }\n    // CASO B: Los datos vienen como un string en 'respuesta'.\n    else if (typeof body.respuesta === 'string' && body.respuesta.trim().startsWith('[')) {\n        \n        // ¡Paso Clave! Primero reparamos el string de la API.\n        const repairedJson = repairJsonString(body.respuesta);\n\n        try {\n            // Ahora parseamos el string ya reparado.\n            const parsedData = JSON.parse(repairedJson);\n            if (Array.isArray(parsedData)) {\n                finalData = parsedData;\n            }\n        } catch (e) {\n            console.error(\"El parseo falló incluso después de intentar la reparación. Error:\", e.message);\n            // Si todo falla, devolvemos un array vacío para no detener el workflow.\n        }\n    }\n}\n\n// Devolver la salida final estandarizada y correcta.\nreturn [{\n  json: {\n    status: 'success',\n    data: finalData\n  }\n}];"
      },
      "type": "n8n-nodes-base.code",
      "typeVersion": 2,
      "position": [
        1824,
        528
      ],
      "id": "fa21c269-9782-4e8b-a127-65e6300480ef",
      "name": "Formatear Salida Inteligente"
    }
  ],
  "pinData": {
    "Disparador: Recibir Datos": [
      {
        "json": {
          "ciudad": "76001",
          "desAgrupa": ""
        }
      }
    ]
  },
  "connections": {
    "Disparador: Recibir Datos": {
      "main": [
        [
          {
            "node": "Validar y Estructurar Entradas",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Formatear Error de Validación": {
      "main": [
        [
          {
            "node": "Unificar Salida",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Validar y Estructurar Entradas": {
      "main": [
        [
          {
            "node": "¿Entrada Válida?",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "¿Entrada Válida?": {
      "main": [
        [
          {
            "node": "Ensamblar DTO para la Utilidad",
            "type": "main",
            "index": 0
          }
        ],
        [
          {
            "node": "Formatear Error de Validación",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Unificar Salida": {
      "main": [
        [
          {
            "node": "Salida Final",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Ensamblar DTO para la Utilidad": {
      "main": [
        [
          {
            "node": "Llamar a la Utilidad Resiliente",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Llamar a la Utilidad Resiliente": {
      "main": [
        [
          {
            "node": "IF: ¿Utilidad Exitosa?",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "IF: ¿Utilidad Exitosa?": {
      "main": [
        [
          {
            "node": "Formatear Salida Inteligente",
            "type": "main",
            "index": 0
          }
        ],
        [
          {
            "node": "Formatear Salida Final de Error",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Formatear Salida Final de Error": {
      "main": [
        [
          {
            "node": "Unificar Salida",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Formatear Salida Inteligente": {
      "main": [
        [
          {
            "node": "Unificar Salida",
            "type": "main",
            "index": 0
          }
        ]
      ]
    }
  },
  "active": false,
  "settings": {
    "executionOrder": "v1"
  },
  "versionId": "55f6d133-8f58-4bcf-a46e-a612e3c2f3ad",
  "meta": {
    "instanceId": "c44159ad241c0d6d40c4f5053f46c53c8d2c806950fcbaf71270c9d0c4993311"
  },
  "id": "4aB1w4iocxhHRNE4",
  "tags": []
}

Concurso de licencias n8n en Platzi: cómo participar y ganar

Concurso n8n y Platzi

Concurso de licencias n8n en Platzi: cómo participar y ganar

Términos y condiciones del concurso