@adatechnology/meta-whatsapp-module 0.2.0-rc.30 → 0.2.0-rc.31

package/dist/index.js

@@ -251,6 +251,14 @@ var flowMedia = metaWhatsAppSchema.table("flow_media", {
   // Desligar sem desanexar: trocar o material da campanha é o caso comum, e apagar a linha
   // perderia a ordem e a legenda já ajustadas.
   active: boolean("active").notNull().default(true),
+  // Id do arquivo já subido para a Meta, por número remetente. Sem isto, o MESMO binário subia de
+  // novo para cada cliente que passava pelo nó: a Meta aceita reusar o id por 30 dias.
+  //
+  // Mapa por `phone_number_id`, e não coluna única: o id é escopado ao número que envia, e uma
+  // instalação com dois números mandaria o id de um pelo outro. A validade não é gravada de
+  // propósito — confiar em "30 dias" calculados erra nos casos de borda, e quem decide é a
+  // recusa da Meta, que devolve ao caminho de subir o binário.
+  metaMediaIds: jsonb("meta_media_ids").$type().notNull().default({}),
   createdAt: timestamp("created_at", {
     withTimezone: true
   }).notNull().defaultNow(),
@@ -1692,6 +1700,43 @@ function mediaTypeFor2(mimeType) {
   return "document";
 }
 __name(mediaTypeFor2, "mediaTypeFor");
+async function sendAttachment(params) {
+  const { attachment, channel, to, cache } = params;
+  const common = {
+    to,
+    mimeType: attachment.mimeType,
+    filename: attachment.filename,
+    caption: attachment.caption ?? void 0
+  };
+  const cacheKey = cache ? {
+    flowMediaId: attachment.id,
+    senderKey: cache.senderKey
+  } : void 0;
+  if (cache && cacheKey) {
+    const knownMediaId = await cache.store.get(cacheKey);
+    if (knownMediaId) {
+      try {
+        return await channel.sendMedia({
+          ...common,
+          mediaId: knownMediaId
+        });
+      } catch {
+        await cache.store.clear(cacheKey);
+      }
+    }
+  }
+  const buffer = await params.objectStorage.getObject(attachment.uploadId);
+  const result = await channel.sendMedia({
+    ...common,
+    buffer
+  });
+  if (cache && cacheKey && result.mediaId) await cache.store.set({
+    ...cacheKey,
+    mediaId: result.mediaId
+  });
+  return result;
+}
+__name(sendAttachment, "sendAttachment");
 function createSendMediaAction(params) {
   return async ({ node, session, channel }) => {
     if (!session.flowKey) return;
@@ -1703,13 +1748,14 @@ function createSendMediaAction(params) {
     const attachments = await params.flowMediaRepository.listActive(location);
     for (const attachment of attachments) {
       try {
-        const buffer = await params.objectStorage.getObject(attachment.uploadId);
-        const { externalMessageId } = await channel.sendMedia({
+        const { externalMessageId } = await sendAttachment({
+          attachment,
+          channel,
           to: session.whatsappNumber,
-          buffer,
-          mimeType: attachment.mimeType,
-          filename: attachment.filename,
-          caption: attachment.caption ?? void 0
+          objectStorage: params.objectStorage,
+          ...params.mediaIdCache ? {
+            cache: params.mediaIdCache
+          } : {}
         });
         await params.logMessage.execute({
           companyId: session.companyId,
@@ -1898,6 +1944,42 @@ var FlowMediaRepository = class {
   }
 };
 
+// src/repositories/FlowMediaIdRepository.ts
+import { eq as eq7, sql as sql5 } from "drizzle-orm";
+var FlowMediaIdRepository = class {
+  static {
+    __name(this, "FlowMediaIdRepository");
+  }
+  db;
+  constructor(db) {
+    this.db = db;
+  }
+  async get(params) {
+    const rows = await this.db.select({
+      ids: flowMedia.metaMediaIds
+    }).from(flowMedia).where(eq7(flowMedia.id, params.flowMediaId)).limit(1);
+    return rows[0]?.ids?.[params.senderKey];
+  }
+  /**
+  * Grava só a chave deste número.
+  *
+  * `jsonb_set` no banco, e não ler-alterar-escrever na aplicação: dois clientes passando pelo nó
+  * ao mesmo tempo com números diferentes leriam o mesmo mapa e o último gravaria por cima,
+  * apagando o id do outro. A escrita atômica não tem essa janela.
+  */
+  async set(params) {
+    await this.db.update(flowMedia).set({
+      metaMediaIds: sql5`jsonb_set(${flowMedia.metaMediaIds}, ARRAY[${params.senderKey}::text], to_jsonb(${params.mediaId}::text), true)`
+    }).where(eq7(flowMedia.id, params.flowMediaId));
+  }
+  /** Remove só a chave deste número — o id do outro número continua válido. */
+  async clear(params) {
+    await this.db.update(flowMedia).set({
+      metaMediaIds: sql5`${flowMedia.metaMediaIds} - ${params.senderKey}::text`
+    }).where(eq7(flowMedia.id, params.flowMediaId));
+  }
+};
+
 // src/channel/WhatsAppChannelAdapter.ts
 import { WhatsAppWindowExpiredError as ProviderWindowExpiredError } from "@adatechnology/meta-graph-core";
 import { WindowExpiredError as WindowExpiredError2 } from "@adatechnology/meta-whatsapp-contracts";
@@ -1933,7 +2015,8 @@ var WhatsAppChannelAdapter = class {
   async sendMedia(params) {
     const result = await this.translateErrors(() => this.messages.sendMedia(params));
     return {
-      externalMessageId: result.waMessageId
+      externalMessageId: result.waMessageId,
+      mediaId: result.mediaId
     };
   }
   async sendTemplate(params) {
@@ -2002,7 +2085,7 @@ var WhatsAppChannelAdapter = class {
 };
 
 // src/channel/ReceiveWebhook.use-case.ts
-import { whatsAppWebhookPayloadSchema } from "@adatechnology/meta-whatsapp-contracts";
+import { whatsAppWebhookPayloadSchema, whatsAppTemplateStatusUpdateSchema, whatsAppPhoneNumberQualityUpdateSchema, WHATSAPP_WEBHOOK_FIELDS } from "@adatechnology/meta-whatsapp-contracts";
 
 // src/channel/webhookSecurity.ts
 import { WEBHOOK_CLAIM_TTL_SECONDS, WEBHOOK_NONCE_TTL_SECONDS, buildWebhookDeliveryKey, isValidWebhookChallenge, isValidWebhookSignature } from "@adatechnology/meta-graph-core";
@@ -2034,7 +2117,7 @@ async function confirmWebhookDelivery(params) {
 __name(confirmWebhookDelivery, "confirmWebhookDelivery");
 
 // src/channel/IngestInboundMedia.use-case.ts
-import { eq as eq7, and as and6 } from "drizzle-orm";
+import { eq as eq8, and as and6 } from "drizzle-orm";
 
 // src/use-cases/TranscribeAudio.use-case.ts
 import { AudioNotIngestedError, MessageNotAudioError, TranscriptionDisabledError } from "@adatechnology/meta-whatsapp-contracts";
@@ -2206,7 +2289,7 @@ var IngestInboundMediaUseCase = class {
     this.transcription = transcription;
   }
   async execute(params) {
-    const [message] = await this.db.select().from(messages).where(and6(eq7(messages.companyId, params.companyId), eq7(messages.id, params.messageId))).limit(1);
+    const [message] = await this.db.select().from(messages).where(and6(eq8(messages.companyId, params.companyId), eq8(messages.id, params.messageId))).limit(1);
     if (!message) throw new Error(`Mensagem ${params.messageId} n\xE3o encontrada para ingest\xE3o de m\xEDdia`);
     const payload = message.payload ?? {};
     if (payload["uploadId"] && payload["sourceMediaId"] === params.sourceMediaId) {
@@ -2237,7 +2320,7 @@ var IngestInboundMediaUseCase = class {
     };
     await this.db.update(messages).set({
       payload: updatedPayload
-    }).where(and6(eq7(messages.companyId, params.companyId), eq7(messages.id, params.messageId)));
+    }).where(and6(eq8(messages.companyId, params.companyId), eq8(messages.id, params.messageId)));
     await this.documentRepository?.link({
       companyId: params.companyId,
       sessionId: message.sessionId,
@@ -2436,6 +2519,13 @@ var ProcessInboundDispatchUseCase = class {
 };
 
 // src/channel/ReceiveWebhook.use-case.ts
+var EMPTY_RESULT = {
+  messagesProcessed: 0,
+  statusesProcessed: 0,
+  ignoredForeignNumber: 0,
+  accountEventsProcessed: 0,
+  unhandledEvents: 0
+};
 function extractContent(message) {
   if (message.text?.body) return message.text.body;
   const interactive = message.interactive;
@@ -2461,6 +2551,14 @@ function extractPayload(message) {
   return Object.keys(payload).length > 0 ? payload : null;
 }
 __name(extractPayload, "extractPayload");
+var ACCOUNT_EVENT_FIELDS = [
+  WHATSAPP_WEBHOOK_FIELDS.TEMPLATE_STATUS_UPDATE,
+  WHATSAPP_WEBHOOK_FIELDS.PHONE_NUMBER_QUALITY_UPDATE
+];
+function isAccountEventField(field) {
+  return field !== void 0 && ACCOUNT_EVENT_FIELDS.includes(field);
+}
+__name(isAccountEventField, "isAccountEventField");
 var ReceiveWebhookUseCase = class {
   static {
     __name(this, "ReceiveWebhookUseCase");
@@ -2491,17 +2589,36 @@ var ReceiveWebhookUseCase = class {
     });
     if (!claimed) return {
       duplicate: true,
-      messagesProcessed: 0,
-      statusesProcessed: 0,
-      ignoredForeignNumber: 0
+      ...EMPTY_RESULT
     };
     const rawText = typeof input.rawBody === "string" ? input.rawBody : input.rawBody.toString("utf8");
-    const payload = whatsAppWebhookPayloadSchema.parse(JSON.parse(rawText));
+    const parsed = whatsAppWebhookPayloadSchema.safeParse(JSON.parse(rawText));
+    if (!parsed.success) {
+      await this.params.hooks?.onUnhandledWebhookEvent?.({
+        field: void 0,
+        reason: "invalid-shape",
+        value: rawText
+      });
+      return {
+        duplicate: false,
+        ...EMPTY_RESULT,
+        unhandledEvents: 1
+      };
+    }
+    const payload = parsed.data;
     let messagesProcessed = 0;
     let statusesProcessed = 0;
     let ignoredForeignNumber = 0;
+    let accountEventsProcessed = 0;
+    let unhandledEvents = 0;
     for (const entry of payload.entry) {
       for (const change of entry.changes) {
+        if (isAccountEventField(change.field)) {
+          const handled = await this.handleAccountEvent(change);
+          if (handled) accountEventsProcessed++;
+          else unhandledEvents++;
+          continue;
+        }
         const targetNumber = change.value.metadata?.phone_number_id;
         if (targetNumber && targetNumber !== this.params.phoneNumberId) {
           ignoredForeignNumber++;
@@ -2515,6 +2632,15 @@ var ReceiveWebhookUseCase = class {
           await this.handleStatus(input.companyId, status);
           statusesProcessed++;
         }
+        const carriedConversationData = (change.value.messages?.length ?? 0) > 0 || (change.value.message_echoes?.length ?? 0) > 0 || (change.value.statuses?.length ?? 0) > 0;
+        if (!carriedConversationData) {
+          unhandledEvents++;
+          await this.params.hooks?.onUnhandledWebhookEvent?.({
+            field: change.field,
+            reason: "unknown-field",
+            value: change.value
+          });
+        }
       }
     }
     await confirmWebhookDelivery({
@@ -2525,9 +2651,39 @@ var ReceiveWebhookUseCase = class {
       duplicate: false,
       messagesProcessed,
       statusesProcessed,
-      ignoredForeignNumber
+      ignoredForeignNumber,
+      accountEventsProcessed,
+      unhandledEvents
     };
   }
+  // Devolve `false` quando o corpo não bate com o schema do field — o chamador conta como não
+  // tratado. O host é avisado nos dois casos, mas com `reason` diferente.
+  async handleAccountEvent(change) {
+    if (change.field === WHATSAPP_WEBHOOK_FIELDS.TEMPLATE_STATUS_UPDATE) {
+      const update = whatsAppTemplateStatusUpdateSchema.safeParse(change.value);
+      if (!update.success) {
+        await this.params.hooks?.onUnhandledWebhookEvent?.({
+          field: change.field,
+          reason: "invalid-shape",
+          value: change.value
+        });
+        return false;
+      }
+      await this.params.hooks?.onTemplateStatusUpdate?.(update.data);
+      return true;
+    }
+    const quality = whatsAppPhoneNumberQualityUpdateSchema.safeParse(change.value);
+    if (!quality.success) {
+      await this.params.hooks?.onUnhandledWebhookEvent?.({
+        field: change.field,
+        reason: "invalid-shape",
+        value: change.value
+      });
+      return false;
+    }
+    await this.params.hooks?.onPhoneNumberQualityUpdate?.(quality.data);
+    return true;
+  }
   async handleMessage(companyId, message) {
     const saved = await this.params.logMessage.execute({
       companyId,
@@ -2672,6 +2828,14 @@ function createMetaWhatsAppModule(params) {
       objectStorage: providers.objectStorage,
       logMessage,
       startState,
+      // Cache ligado por padrão, com o store do próprio módulo: a tabela é daqui e a coluna é
+      // daqui, então exigir que cada host escrevesse o repositório faria todos reescreverem o
+      // mesmo código — e, até escreverem, o mesmo binário continuaria subindo por cliente. Quem
+      // quiser outro lugar (Redis) troca o `store`; quem não fizer nada já sai sem ressubir.
+      mediaIdCache: {
+        store: new FlowMediaIdRepository(db),
+        senderKey: config.phoneNumberId
+      },
       onError: hooks?.onFlowMediaError
     }));
   }
@@ -2888,6 +3052,7 @@ export {
   FlowGraphCache,
   FlowGraphRepository,
   FlowInterpreter,
+  FlowMediaIdRepository,
   FlowMediaRepository,
   GetFlowGraphUseCase,
   GetLiveFlowPositionsUseCase,