@hostwebhook/node-sdk 0.4.0 → 0.6.0

package/dist/execute-with-iteration.d.ts

@@ -5,14 +5,7 @@
  * _meta.iterable and automatically iterates, aggregating results.
  * Nodes never see _meta — they receive clean individual payloads.
  */
-type SingleExecutor = (payload: Record<string, unknown>) => Promise<{
-    statusCode: number;
-    responseBody: string;
-    latencyMs: number;
-}>;
-export declare function executeWithIteration(payload: Record<string, unknown>, executeSingle: SingleExecutor): Promise<{
-    statusCode: number;
-    responseBody: string;
-    latencyMs: number;
-}>;
+import type { NodeResult } from './retry-transient';
+type SingleExecutor = (payload: Record<string, unknown>) => Promise<NodeResult>;
+export declare function executeWithIteration(payload: Record<string, unknown>, executeSingle: SingleExecutor): Promise<NodeResult>;
 export {};

package/dist/execute-with-iteration.js

@@ -14,7 +14,46 @@ async function executeWithIteration(payload, executeSingle) {
         const items = payload[meta.iterateField] ?? [];
         const results = [];
         let totalLatency = 0;
-        let lastStatus = 200;
+        /* El estado que se reporta hacia arriba.
+         *
+         * ⚠️ Antes se guardaba el del ÚLTIMO item, a secas. Cuatro llamadas donde
+         * la 2ª daba 500 y la 4ª daba 200 se reportaban como ÉXITO —el fallo
+         * desaparecía sin dejar rastro— y al revés, tres éxitos y un fallo al final
+         * teñían de rojo la tanda entera.
+         *
+         * Ahora manda el PRIMER fallo; si no hubo ninguno se conserva el último
+         * estado, que es exactamente lo que ya se devolvía cuando todo iba bien.
+         *
+         * ## Lo que esto NO pisa, y lo que sí
+         *
+         * NO pisa el «Never error on non-2xx» del nodo HTTP, y el motivo es el
+         * orden de anidamiento, no una casualidad: la máscara vive en
+         * `executeOnce`, la función MÁS interna —dentro del retry, que a su vez
+         * está dentro de este bucle—, y axios va con `validateStatus: () => true`,
+         * así que TODO código de estado pasa por ella antes de que nadie más lo
+         * vea. Aquí llega un 200 y `primerFallo` no se marca.
+         *
+         * ⚠️ Lo que sí cambia, y conviene saberlo: el ajuste sólo enmascara
+         * `response.status >= 400`. Un timeout, un DNS caído o un fallo de
+         * configuración salen por otro camino (500 del `catch`, 520 del guion de
+         * pre-petición o del firmado) sin pasar por la máscara. Antes esos se
+         * tragaban si no eran el último item; ahora detienen la tanda aunque el
+         * ajuste esté encendido. Es el comportamiento correcto —un timeout no es
+         * «un non-2xx que quiero ignorar»— pero es un cambio observable. */
+        let ultimoStatus = 200;
+        let primerFallo = null;
+        /* Plano de control. No viaja en el payload, pero decide qué hace el Loop
+         * cuando una iteración falla.
+         *
+         * ⚠️ La agregación construía un objeto literal nuevo y estos dos campos se
+         * caían por el camino. Daba casi igual mientras el fallo de enmedio se
+         * perdía, porque esa rama no se alcanzaba; en cuanto manda el primer
+         * fallo, `node-lifecycle` lee `_retriedTransient` para degradar la política
+         * `retry` a `skip`, y sin él RE-DESPACHA la iteración entera: se reenvían
+         * también los items que ya habían salido bien. Un 429 que ya quemó sus
+         * tres intentos le llegaba al Loop como «esto ni se ha reintentado». */
+        let algunoReintento = false;
+        let esperaPedida;
         for (const item of items) {
             const clean = typeof item === 'object' && item !== null
                 ? { ...item }
@@ -22,7 +61,17 @@ async function executeWithIteration(payload, executeSingle) {
             delete clean._meta;
             const res = await executeSingle(clean);
             totalLatency += res.latencyMs;
-            lastStatus = res.statusCode;
+            ultimoStatus = res.statusCode;
+            if (primerFallo === null && res.statusCode >= 400) {
+                primerFallo = res.statusCode;
+            }
+            if (res._retriedTransient)
+                algunoReintento = true;
+            if (typeof res.retryAfterMs === 'number') {
+                /* El mayor de los que se pidieron: esperar MENOS de lo que el servidor
+                   dijo sólo quema un intento. */
+                esperaPedida = Math.max(esperaPedida ?? 0, res.retryAfterMs);
+            }
             try {
                 const parsed = JSON.parse(res.responseBody);
                 // If executor returns an array, spread its items instead of nesting [[...]]
@@ -38,15 +87,23 @@ async function executeWithIteration(payload, executeSingle) {
                 results.push(res.responseBody);
             }
         }
+        const estadoDeLaTanda = primerFallo ?? ultimoStatus;
+        /* Se omiten cuando no hay nada que decir, para no ensuciar el resultado con
+           `_retriedTransient: false` donde antes no había clave ninguna. */
+        const planoDeControl = {
+            ...(algunoReintento ? { _retriedTransient: true } : {}),
+            ...(esperaPedida !== undefined ? { retryAfterMs: esperaPedida } : {}),
+        };
         // Single result from single iteration → unwrap as plain object
         if (results.length === 1 &&
             typeof results[0] === 'object' &&
             results[0] !== null) {
             const single = { _meta: { iterable: false, count: 1 }, ...results[0] };
             return {
-                statusCode: lastStatus,
+                statusCode: estadoDeLaTanda,
                 responseBody: JSON.stringify(single),
                 latencyMs: totalLatency,
+                ...planoDeControl,
             };
         }
         const aggregated = {
@@ -54,9 +111,10 @@ async function executeWithIteration(payload, executeSingle) {
             results,
         };
         return {
-            statusCode: lastStatus,
+            statusCode: estadoDeLaTanda,
             responseBody: JSON.stringify(aggregated),
             latencyMs: totalLatency,
+            ...planoDeControl,
         };
     }
     // Single item — strip _meta and execute

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hostwebhook/node-sdk",
-  "version": "0.4.0",
+  "version": "0.6.0",
   "description": "El SDK de un nodo de HostWebhook: ciclo de vida, ejecución con iteración, reintentos, filtros y validación de esquema — lo que comparten la api y el futuro servicio de nodos",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -19,21 +19,29 @@
   ],
   "license": "MIT",
   "peerDependencies": {
-    "@hostwebhook/platform-contracts": ">=0.2.0",
-    "@hostwebhook/node-types": ">=1.67.0",
-    "@hostwebhook/template-engine": ">=2.0.0",
-    "@nestjs/common": ">=11.0.0",
-    "class-transformer": ">=0.5.0",
-    "express": ">=5.0.0",
-    "mongodb": ">=6.0.0",
-    "mongoose": ">=8.0.0",
-    "re2": ">=1.20.0",
-    "undici": ">=7.0.0",
-    "class-validator": ">=0.14.0"
+    "@hostwebhook/platform-contracts": ">=0.2.0 <1",
+    "@hostwebhook/node-types": ">=1.67.0 <2",
+    "@hostwebhook/template-engine": ">=2.0.0 <3",
+    "@nestjs/common": ">=11.0.0 <12",
+    "class-transformer": ">=0.5.0 <0.6",
+    "express": ">=5.0.0 <6",
+    "mongodb": ">=7.0.0 <8",
+    "mongoose": ">=9.2.0 <10",
+    "re2": ">=1.20.0 <2",
+    "undici": ">=7.25.0 <8",
+    "class-validator": ">=0.14.3 <0.15"
   },
   "devDependencies": {
+    "@hostwebhook/platform-contracts": "^0.2.0",
+    "@nestjs/common": "11.1.14",
+    "class-transformer": "0.5.1",
+    "class-validator": "0.14.3",
+    "express": "5.2.1",
+    "mongodb": "7.0.0",
+    "mongoose": "9.2.1",
+    "re2": "1.24.0",
     "typescript": "^5.0.0",
-    "vitest": "^3.0.0",
-    "@hostwebhook/platform-contracts": "^0.2.0"
+    "undici": "7.25.0",
+    "vitest": "^3.0.0"
   }
 }