hobots 5.2.0 → 6.0.0

package/README.md

@@ -112,7 +112,7 @@ A opção passada em `register()`/`start()` tem precedência sobre a env — út
 | --- | --- |
 | `hobots.log.debug/info/warn/error/success(msg, ...rest)` | Log da execução, enviado incrementalmente ao app (e ecoado no terminal como `[hobots] INFO …`). Aceita vários argumentos como `console.log` — `hobots.log.info('nota', numero, 'ok')` — cada um vira texto, unidos por espaço. Um `hobots.image(...)` como **último** argumento pendura um print na linha. **Nunca lança** — pode ir em `finally`. |
 | `hobots.items.succeeded(payload?, { id, image }?)` · `.failed(msg, payload?, …)` · `.occurrence(msg, payload?, …)` · `.add({...})` | **A entrega do robô**: cada item processado, com status e atributos (viram colunas no app — declare-as com a opção `items: { columns: [...] }` do `register`/`start`). `image` pendura um print no item. Bufferizado, em lotes. |
-| `hobots.items.each(lista, async (el, item) => …, { id: 'campo', payload, retries: 1, retryDelayMs: 5000, skipDone: true }?)` | **Loop com o contrato garantido**: cada elemento vira etapa + item; exceção no handler = nova tentativa e, esgotada, item `failed` com a mensagem e o loop **segue** até o fim; `throw new Occurrence(msg)` = item `occurrence`, sem repetir; na reexecução do mesmo trabalho pula o que já deu `succeeded`/`occurrence`; progresso automático; `hobots.flush()` ao fim de cada ciclo (`flush: false` desliga). Só cancelamento/timeout interrompem. No handler, `item.data({ nf: 123 })` vai guardando os atributos do item sem decidir o desfecho — entram no `succeeded`/`failed`/`occurrence`, inclusive nos implícitos. |
+| `hobots.items.each(lista, async (item, index?) => …, { id: 'campo', payload, retries: 1, retryDelayMs: 5000, skipDone: true }?)` | **Loop com o contrato garantido**: o handler recebe o handle do item (e, se declarar, o índice) — o elemento é `item.value` e a posição, `item.index`; sem `payload`, os campos do elemento (objeto simples) viram as colunas do item (`payload: false` desliga); cada elemento vira etapa + item; exceção no handler = nova tentativa e, esgotada, item `failed` com a mensagem e o loop **segue** até o fim; `throw new Occurrence(msg)` = item `occurrence`, sem repetir; na reexecução do mesmo trabalho pula o que já deu `succeeded`/`occurrence`; progresso automático; `hobots.flush()` ao fim de cada ciclo (`flush: false` desliga). Só cancelamento/timeout interrompem. No handler, `item.data({ nf: 123 })` vai guardando os atributos do item sem decidir o desfecho — entram no `succeeded`/`failed`/`occurrence`, inclusive nos implícitos. |
 | `hobots.progress.total(n)` · `.advance(k = 1)` · `.set(atual, total?)` · `.current` · `.snapshot` | Barra, percentual e tempo restante na execução. Sem `total()` nada é enviado. |
 | `hobots.flush(timeoutMs?)` | **Entrega já** o que a execução fez: as etapas raiz finalizadas viram transactions parciais (waterfall na Central sem esperar a run terminar) e itens, logs e progresso pendentes saem sem esperar o throttle. `step` (raiz) e cada ciclo do `items.each` já chamam sozinhos; à mão, para o resto da rodada de um agente `start()`. Aguarda com teto (15 s) e nunca lança. |
 | `hobots.step(nome, async etapa => …, { retries = 1, retryDelayMs = 5_000, flush = true }?)` | Uma **etapa** no waterfall de performance da execução: roda a função, **tenta de novo** se ela lançar (`retries: 0` desliga — use em etapas não idempotentes) e fecha a etapa. Resolve com o retorno da função. `hobots.step` dentro de outra vira sub-etapa. A etapa raiz faz `flush()` ao terminar (`flush: false` desliga). O handle `etapa` tem `warning(motivo, { image }?)`, `image(png)` e `data(chave, valor)`. |
@@ -231,6 +231,7 @@ Sem handler próprio de sinal, um `SIGINT`/`SIGTERM` (ou erro fatal) com execuç
 
 ## Changelog resumido
 
+- **6.0.0** — **breaking**: o handler de `items.each` recebe o handle do item, `async (item, index) => …` (`index` opcional); o elemento da lista é `item.value` e a posição, `item.index`. Migração: `async (conta, item, i) => …` → `async (item, i) => { const conta = item.value; … }`. `options.id`/`payload`/`description` continuam recebendo `(element, index)`. **Payload padrão:** sem `options.payload`, os campos do elemento (objeto simples, cópia rasa) viram o payload base do item; `options.payload` substitui, `payload: false` desliga. Detalhes no [CHANGELOG](./CHANGELOG.md).
 - **5.2.0** — **`item.data(payload)`** no handle do `items.each`: guarda atributos do item sem registrar desfecho; mescla a cada chamada e entra em qualquer desfecho (inclusive nos implícitos), entre o `options.payload` do `each` e o payload da chamada de desfecho; zera na nova tentativa. Detalhes no [CHANGELOG](./CHANGELOG.md).
 - **5.1.0** — `items.each` com **nova tentativa por item** (`retries: 1`, `retryDelayMs: 5000`; uma etapa só por elemento, `warning` quando a repetição deu certo, `error` + item `failed` quando esgotou), **`Occurrence`** exportada (`throw new Occurrence(msg, payload?, { image }?)` no handler = item `occurrence`, sem repetir), `id` por campo (`'numero'`), chave composta (`['cnpj', 'competencia']`) ou função — padrão: o campo `id` do elemento — e **reexecução sem repetir**: ao executar novamente o trabalho, pula os ids já `succeeded`/`occurrence` (`skipDone: true`; `POST /v1/runs/{id}/items/done`); resultado com `skipped`; `item.id` sempre `string`, `item.attempt`. Detalhes no [CHANGELOG](./CHANGELOG.md).
 - **5.0.0** — **uma API só de etapas** (breaking): `hobots.step(nome, fn, { retries, retryDelayMs }?)` abre a etapa, tenta de novo quando `fn` lança (default 1 tentativa extra) e fecha; `fn` recebe o handle `etapa` (`warning`/`image`/`data`); `hobots.step` dentro de outra (ou do handler do `items.each`) vira sub-etapa. `hobots.transaction`, `ctx.transaction` e os tipos `Transaction`/`Step`/`StepOutcomeOptions` foram removidos; `item.step` é o handle novo. Modo local ecoa `[hobots:step] FINISH …`. Nomes de etapa são recortados em 2048 no cliente. Flush automático ao fim da etapa raiz e de cada ciclo do `items.each` (`flush: false` desliga). Antes/depois no [CHANGELOG](./CHANGELOG.md).

package/dist/index.cjs

@@ -45,7 +45,7 @@ module.exports = __toCommonJS(src_exports);
 
 // src/utils.ts
 var SDK_NAME = "hobots";
-var SDK_VERSION = true ? "5.2.0" : "0.0.0-dev";
+var SDK_VERSION = true ? "6.0.0" : "0.0.0-dev";
 function isNode() {
   return typeof process !== "undefined" && typeof process.versions?.node === "string";
 }
@@ -1925,13 +1925,15 @@ function thrownMessage(error) {
   return safeString(error);
 }
 var ItemHandle = class {
-  constructor(index, id, step, basePayload, sink) {
+  constructor(value, index, id, step, basePayload2, sink) {
+    this.value = value;
     this.index = index;
     this.step = step;
-    this.basePayload = basePayload;
+    this.basePayload = basePayload2;
     this.sink = sink;
     this.id = id ?? uuid4();
   }
+  value;
   index;
   step;
   basePayload;
@@ -1974,6 +1976,18 @@ var ItemHandle = class {
     this.sink.report(status, message, Object.keys(merged).length > 0 ? merged : void 0, this.id, image3);
   }
 };
+function defaultPayload(element) {
+  if (typeof element !== "object" || element === null) return void 0;
+  const proto = Object.getPrototypeOf(element);
+  if (proto !== Object.prototype && proto !== null) return void 0;
+  const copy = { ...element };
+  return Object.keys(copy).length > 0 ? copy : void 0;
+}
+function basePayload(spec, element, index) {
+  if (spec === false) return void 0;
+  if (spec === void 0) return defaultPayload(element);
+  return spec(element, index);
+}
 function field(element, name) {
   if (typeof element !== "object" || element === null) return { present: false, value: void 0 };
   const record = element;
@@ -2034,7 +2048,7 @@ async function eachItem(list, handler, options, sink) {
     }
     const description = options.description?.(element, index) ?? id ?? `#${index + 1}`;
     const step = sink.startStep(options.op ?? "item", description);
-    const handle = new ItemHandle(index, id, step, options.payload?.(element, index), sink);
+    const handle = new ItemHandle(element, index, id, step, basePayload(options.payload, element, index), sink);
     const current = index;
     let attempts = 0;
     let lastFailure;
@@ -2043,7 +2057,7 @@ async function eachItem(list, handler, options, sink) {
         (attempt) => {
           attempts = attempt;
           if (attempt > 1) handle._nextAttempt(attempt);
-          return sink.stepScope(step, async () => handler(element, handle, current));
+          return sink.stepScope(step, async () => handler(handle, current));
         },
         {
           retries: totalRetries,