@adatechnology/conversations-ui 0.2.0 → 0.2.1

package/dist/index.js

@@ -4256,6 +4256,16 @@ function sameUploadIds(a, b) {
   if (a.length !== b.length) return false;
   return a.every((id, index) => id === b[index]);
 }
+function hasSentEveryStoredUpload(storedUploadIds, sentAttachmentKeys) {
+  if (storedUploadIds.length === 0) return true;
+  const sentKeys = new Set(sentAttachmentKeys);
+  return storedUploadIds.every((uploadId) => sentKeys.has(uploadId));
+}
+function shouldResetRetryKey(params) {
+  const { current, attempted, sentAttachmentKeys, uploadId } = params;
+  if (!sentAttachmentKeys.includes(uploadId)) return false;
+  return current === attempted;
+}
 function attachmentSendStatusOf(status) {
   if (status === "sent") return "sent";
   if (status === "skipped") return "skipped";
@@ -5497,6 +5507,14 @@ function useComposerAttachmentRetry(params) {
           if (isSameConversation()) setAttachmentStatus((current) => ({ ...current, [statusKey]: status }));
         }
       });
+      if (shouldResetRetryKey({
+        current: retryIdempotencyKeyRef.current,
+        attempted: idempotencyState,
+        sentAttachmentKeys: result.sentAttachmentKeys,
+        uploadId: item.uploadId
+      })) {
+        retryIdempotencyKeyRef.current = void 0;
+      }
       setQueue(
         (current) => resolveRetryOutcome({
           conversationIdAtRetry,
@@ -5621,15 +5639,14 @@ function useComposerQueue(params) {
       if (!isSameConversation()) return;
       if (!result.textSent) return;
       const sentKeys = new Set(result.sentAttachmentKeys);
-      let queueEmptyAfterSend = false;
-      setQueue((current) => {
-        const next = current.filter((item) => !sentKeys.has(attachmentKey(item)));
-        queueEmptyAfterSend = next.length === 0;
+      setQueue((current) => current.filter((item) => !sentKeys.has(attachmentKey(item))));
+      setAttachmentStatus((current) => {
+        const next = { ...current };
+        for (const key of sentKeys) delete next[key];
         return next;
       });
-      if (queueEmptyAfterSend) {
+      if (idempotencyKeyRef.current === idempotencyState && hasSentEveryStoredUpload(idempotencyState.uploadIds, result.sentAttachmentKeys)) {
         idempotencyKeyRef.current = void 0;
-        setAttachmentStatus({});
       }
       if (draft.trim()) setDraft("");
       await refetch();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adatechnology/conversations-ui",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "WhatsApp conversation UI components — parametrizável por endpoint, tema e feature flags",
   "publishConfig": {
     "access": "public"

package/src/quickReplies/quickReplyAttachments.test.ts

@@ -5,6 +5,7 @@ import {
   attachmentKey,
   canAddAttachments,
   excludeRetryingItems,
+  hasSentEveryStoredUpload,
   orderOutgoingItems,
   queuedAttachmentsFromQuickReply,
   resolveIdempotencyKey,
@@ -12,6 +13,8 @@ import {
   resolveRetryOutcome,
   retryStoredAttachments,
   sendQueuedMessage,
+  shouldResetRetryKey,
+  type IdempotencyKeyState,
 } from './quickReplyAttachments'
 import type { QueuedAttachment } from './quickReply.types'
 
@@ -261,6 +264,74 @@ describe('resolveIdempotencyKey', () => {
   })
 })
 
+describe('hasSentEveryStoredUpload', () => {
+  it('true quando não havia guardado nenhum nesta tentativa', () => {
+    expect(hasSentEveryStoredUpload([], [])).toBe(true)
+    expect(hasSentEveryStoredUpload([], ['a'])).toBe(true)
+  })
+
+  it('true quando todo uploadId da tentativa saiu', () => {
+    expect(hasSentEveryStoredUpload(['a', 'b'], ['a', 'b'])).toBe(true)
+    expect(hasSentEveryStoredUpload(['a', 'b'], ['b', 'a'])).toBe(true)
+  })
+
+  it('true mesmo com chave extra em sentAttachmentKeys (ex: anexo local também enviado)', () => {
+    expect(hasSentEveryStoredUpload(['a'], ['a', 'local-1'])).toBe(true)
+  })
+
+  it('falso quando um uploadId falhou ou foi pulado', () => {
+    expect(hasSentEveryStoredUpload(['a', 'b'], ['a'])).toBe(false)
+  })
+
+  it('falso quando nada saiu', () => {
+    expect(hasSentEveryStoredUpload(['a', 'b'], [])).toBe(false)
+  })
+})
+
+describe('shouldResetRetryKey', () => {
+  const stateA: IdempotencyKeyState = { key: 'key-a', uploadIds: ['upload-1'] }
+  const stateB: IdempotencyKeyState = { key: 'key-b', uploadIds: ['upload-1'] }
+
+  it('descarta quando o item saiu e o ref ainda é o mesmo da tentativa (duas tentativas seguidas do mesmo uploadId recebem chaves diferentes)', () => {
+    expect(
+      shouldResetRetryKey({
+        current: stateA,
+        attempted: stateA,
+        sentAttachmentKeys: ['upload-1'],
+        uploadId: 'upload-1',
+      }),
+    ).toBe(true)
+  })
+
+  it('mantém a chave quando o retry falhou (uploadId não está em sentAttachmentKeys)', () => {
+    expect(
+      shouldResetRetryKey({ current: stateA, attempted: stateA, sentAttachmentKeys: [], uploadId: 'upload-1' }),
+    ).toBe(false)
+  })
+
+  it('mantém a chave quando um retry concorrente já trocou o ref por identidade', () => {
+    expect(
+      shouldResetRetryKey({
+        current: stateB,
+        attempted: stateA,
+        sentAttachmentKeys: ['upload-1'],
+        uploadId: 'upload-1',
+      }),
+    ).toBe(false)
+  })
+
+  it('mantém a chave quando o ref já foi limpo (undefined) por outra resolução', () => {
+    expect(
+      shouldResetRetryKey({
+        current: undefined,
+        attempted: stateA,
+        sentAttachmentKeys: ['upload-1'],
+        uploadId: 'upload-1',
+      }),
+    ).toBe(false)
+  })
+})
+
 describe('retryStoredAttachments', () => {
   it('reenvia só o uploadId pedido, sem tocar no resto da fila', async () => {
     const calls: { uploadIds: readonly string[]; idempotencyKey: string }[] = []

package/src/quickReplies/quickReplyAttachments.ts

@@ -112,6 +112,45 @@ function sameUploadIds(a: readonly string[], b: readonly string[]): boolean {
   return a.every((id, index) => id === b[index])
 }
 
+/**
+ * Decide se a chave de idempotência pode ser descartada depois de um envio (M3-bug): todo
+ * `uploadId` da tentativa saiu com sucesso. `setState` com updater NÃO roda de forma síncrona
+ * dentro do handler — uma variável `let` atualizada por ele e lida logo em seguida sempre lê o
+ * valor antigo. Esta decisão usa só os parâmetros da própria tentativa (nunca o estado da fila),
+ * então não depende de nenhum `setState` ter aplicado.
+ */
+export function hasSentEveryStoredUpload(
+  storedUploadIds: readonly string[],
+  sentAttachmentKeys: readonly string[],
+): boolean {
+  if (storedUploadIds.length === 0) return true
+  const sentKeys = new Set(sentAttachmentKeys)
+  return storedUploadIds.every((uploadId) => sentKeys.has(uploadId))
+}
+
+export type ShouldResetRetryKeyParams = {
+  /** Valor corrente do ref no momento da checagem — lido depois do `await`. */
+  readonly current: IdempotencyKeyState | undefined
+  /** Estado usado NESTA tentativa, capturado antes do `await`. */
+  readonly attempted: IdempotencyKeyState
+  readonly sentAttachmentKeys: readonly string[]
+  readonly uploadId: string
+}
+
+/**
+ * Decide se a chave de idempotência do retry avulso pode ser descartada (M3-retry-bug): o item
+ * saiu com sucesso E ninguém trocou o ref por identidade desde então. A checagem de identidade
+ * (`current === attempted`) importa porque um retry avulso reusa `uploadId` de itens guardados
+ * (mensagens prontas) — um segundo retry do MESMO `uploadId` pode começar e sobrescrever o ref
+ * antes desta tentativa terminar; sem a checagem, o `undefined` desta tentativa apagaria a chave
+ * da tentativa mais nova, e o próximo envio dela reusaria uma chave já consumida pelo servidor.
+ */
+export function shouldResetRetryKey(params: ShouldResetRetryKeyParams): boolean {
+  const { current, attempted, sentAttachmentKeys, uploadId } = params
+  if (!sentAttachmentKeys.includes(uploadId)) return false
+  return current === attempted
+}
+
 export type SendQueuedMessageParams = {
   readonly text: string
   readonly queue: readonly QueuedAttachment[]

package/src/workspace/useComposerAttachmentRetry.ts

@@ -18,6 +18,7 @@ import {
   resolveIdempotencyKey,
   resolveRetryOutcome,
   retryStoredAttachments,
+  shouldResetRetryKey,
   type AttachmentSendStatus,
   type IdempotencyKeyState,
 } from '../quickReplies/quickReplyAttachments'
@@ -116,6 +117,19 @@ export function useComposerAttachmentRetry(params: UseComposerAttachmentRetryPar
           if (isSameConversation()) setAttachmentStatus((current) => ({ ...current, [statusKey]: status }))
         },
       })
+      // Descarta a chave só se este retry a enviou E nenhum retry mais novo do mesmo `uploadId`
+      // já trocou o ref por identidade (ver `shouldResetRetryKey`) — senão um segundo retry rápido
+      // do mesmo anexo (mensagens prontas reusam `uploadId`) reenviaria com chave já consumida.
+      if (
+        shouldResetRetryKey({
+          current: retryIdempotencyKeyRef.current,
+          attempted: idempotencyState,
+          sentAttachmentKeys: result.sentAttachmentKeys,
+          uploadId: item.uploadId,
+        })
+      ) {
+        retryIdempotencyKeyRef.current = undefined
+      }
       setQueue(
         (current) =>
           resolveRetryOutcome({

package/src/workspace/useComposerQueue.ts

@@ -7,6 +7,7 @@ import { useCallback, useEffect, useRef, useState } from 'react'
 import {
   attachmentKey,
   excludeRetryingItems,
+  hasSentEveryStoredUpload,
   resolveIdempotencyKey,
   sendQueuedMessage,
   type AttachmentSendStatus,
@@ -162,17 +163,25 @@ export function useComposerQueue(params: UseComposerQueueParams): UseComposerQue
       // Filtra por chave sobre a fila CORRENTE, não sobrescreve com `result.remainingQueue` (que foi
       // calculado sobre a fila capturada antes do `await` e perderia item adicionado durante o envio).
       const sentKeys = new Set(result.sentAttachmentKeys)
-      // Decide "tudo saiu" sobre a fila CORRENTE dentro do updater, não sobre `result.remainingQueue`
-      // (snapshot de antes do `await` — ficaria obsoleto se algo mudou a fila durante o envio).
-      let queueEmptyAfterSend = false
-      setQueue((current) => {
-        const next = current.filter((item) => !sentKeys.has(attachmentKey(item)))
-        queueEmptyAfterSend = next.length === 0
+      setQueue((current) => current.filter((item) => !sentKeys.has(attachmentKey(item))))
+      // Decide sobre os `uploadId` desta TENTATIVA (`idempotencyState.uploadIds`), nunca sobre o
+      // `setQueue` acima: o updater de `setQueue` não roda de forma síncrona (só no próximo render),
+      // então ler uma variável escrita por ele aqui sempre pegaria o valor antigo (bug real em
+      // produção — a chave nunca era descartada e o segundo envio do mesmo anexo era recusado pelo
+      // servidor como replay).
+      setAttachmentStatus((current) => {
+        const next = { ...current }
+        for (const key of sentKeys) delete next[key]
         return next
       })
-      if (queueEmptyAfterSend) {
+      // Descarta a chave só se ninguém a trocou por identidade desde o `await` (mesmo cuidado do
+      // retry avulso em `shouldResetRetryKey`) — senão um envio concorrente que já trocou o ref
+      // teria sua chave nova apagada por esta tentativa mais antiga.
+      if (
+        idempotencyKeyRef.current === idempotencyState &&
+        hasSentEveryStoredUpload(idempotencyState.uploadIds, result.sentAttachmentKeys)
+      ) {
         idempotencyKeyRef.current = undefined
-        setAttachmentStatus({})
       }
       if (draft.trim()) setDraft('')
       await refetch()