@adatechnology/meta-whatsapp-module 0.2.0-rc.13 → 0.2.0-rc.15

package/dist/index.js

@@ -10,6 +10,7 @@ var __dirname = /* @__PURE__ */ getDirname();
 
 // src/createMetaWhatsAppModule.ts
 import { WhatsAppMessageProvider } from "@adatechnology/meta-whatsapp-provider";
+import { FLOW_ACTION_KIND } from "@adatechnology/meta-whatsapp-contracts";
 
 // src/repositories/SessionRepository.ts
 import { and, desc, eq, sql as sql2 } from "drizzle-orm";
@@ -197,6 +198,46 @@ var flowGraphs = metaWhatsAppSchema.table("flow_graphs", {
 }, (table) => [
   uniqueIndex("idx_flow_graphs_company_key").on(table.companyId, table.key)
 ]);
+var flowMedia = metaWhatsAppSchema.table("flow_media", {
+  id: uuid("id").primaryKey().defaultRandom(),
+  companyId: uuid("company_id").notNull(),
+  flowKey: varchar("flow_key", {
+    length: 64
+  }).notNull(),
+  nodeId: varchar("node_id", {
+    length: 64
+  }).notNull(),
+  uploadId: varchar("upload_id", {
+    length: 256
+  }).notNull(),
+  filename: varchar("filename", {
+    length: 512
+  }).notNull(),
+  mimeType: varchar("mime_type", {
+    length: 128
+  }).notNull(),
+  sizeBytes: integer("size_bytes").notNull(),
+  // Legenda da mídia no WhatsApp. Por arquivo, não por nó: um nó que manda tabela de preços e
+  // um folder precisa de textos diferentes para cada um.
+  caption: text("caption"),
+  // Ordem de envio dentro do nó — o cliente recebe as mensagens em sequência, e "tabela antes
+  // do folder" é decisão de quem edita, não do banco.
+  sortOrder: integer("sort_order").notNull().default(0),
+  // 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),
+  createdAt: timestamp("created_at", {
+    withTimezone: true
+  }).notNull().defaultNow(),
+  updatedAt: timestamp("updated_at", {
+    withTimezone: true
+  }).notNull().defaultNow()
+}, (table) => [
+  index("idx_flow_media_node").on(table.companyId, table.flowKey, table.nodeId, table.sortOrder),
+  // O mesmo arquivo anexado duas vezes ao MESMO nó é erro de clique no editor, e o cliente
+  // receberia o documento repetido.
+  uniqueIndex("idx_flow_media_node_upload").on(table.companyId, table.flowKey, table.nodeId, table.uploadId)
+]);
 var settings = metaWhatsAppSchema.table("settings", {
   companyId: uuid("company_id").primaryKey(),
   templateName: varchar("template_name", {
@@ -521,12 +562,21 @@ var FlowGraphRepository = class {
     __name(this, "FlowGraphRepository");
   }
   db;
-  constructor(db) {
+  cache;
+  // Cache opcional: sem ele o repositório se comporta exatamente como antes, lendo sempre do
+  // banco. É o host que decide se quer cachear e com qual provedor (ver CacheInterface).
+  constructor(db, cache) {
     this.db = db;
+    this.cache = cache;
   }
   async get(companyId, key) {
+    const cached = await this.cache?.read(companyId, key);
+    if (cached) return cached;
     const [row] = await this.db.select().from(flowGraphs).where(and3(eq3(flowGraphs.companyId, companyId), eq3(flowGraphs.key, key))).limit(1);
-    return row ? toContractGraph(row) : void 0;
+    if (!row) return void 0;
+    const graph = toContractGraph(row);
+    await this.cache?.write(companyId, graph);
+    return graph;
   }
   async list(companyId) {
     const rows = await this.db.select().from(flowGraphs).where(eq3(flowGraphs.companyId, companyId));
@@ -556,7 +606,9 @@ var FlowGraphRepository = class {
       showInMenu: graph.showInMenu ?? false,
       menuOptionLabel: graph.menuOptionLabel
     }).returning();
-    return toContractGraph(created);
+    const createdGraph = toContractGraph(created);
+    await this.cache?.invalidate(companyId, createdGraph.key);
+    return createdGraph;
   }
   // Lock otimista: a escrita só aplica se `expectedVersion` ainda bater com o que está salvo —
   // senão, alguém mais salvou entretanto e o editor precisa recarregar (ver comentário no schema).
@@ -570,10 +622,12 @@ var FlowGraphRepository = class {
       updatedAt: /* @__PURE__ */ new Date()
     }).where(and3(eq3(flowGraphs.companyId, companyId), eq3(flowGraphs.key, graph.key), eq3(flowGraphs.version, expectedVersion))).returning();
     if (rows.length === 0) throw new OptimisticLockError(graph.key);
+    await this.cache?.invalidate(companyId, graph.key);
     return toContractGraph(rows[0]);
   }
   async delete(companyId, key) {
     await this.db.delete(flowGraphs).where(and3(eq3(flowGraphs.companyId, companyId), eq3(flowGraphs.key, key)));
+    await this.cache?.invalidate(companyId, key);
   }
   // T4.2 — GetLiveFlowPositions: agrega sessões ativas por (flowKey, currentNodeId), lendo as
   // colunas dedicadas gravadas por SessionRepository.setFlowPosition. Agrega no banco (GROUP BY,
@@ -593,6 +647,48 @@ var FlowGraphRepository = class {
   }
 };
 
+// src/repositories/FlowGraphCache.ts
+var KEY_PREFIX = "meta-whatsapp:flow-graph";
+var DEFAULT_FLOW_GRAPH_CACHE_TTL_SECONDS = 300;
+var FlowGraphCache = class {
+  static {
+    __name(this, "FlowGraphCache");
+  }
+  provider;
+  ttlSeconds;
+  constructor(provider, ttlSeconds = DEFAULT_FLOW_GRAPH_CACHE_TTL_SECONDS) {
+    this.provider = provider;
+    this.ttlSeconds = ttlSeconds;
+  }
+  // companyId na chave, e não só a flowKey: a chave do fluxo é escolhida por quem edita e se
+  // repete entre empresas — 'consorcio' existe em todas — então uma chave sem tenant serviria o
+  // grafo de uma empresa para a conversa de outra.
+  keyFor(companyId, flowKey) {
+    return `${KEY_PREFIX}:${companyId}:${flowKey}`;
+  }
+  async read(companyId, flowKey) {
+    try {
+      const cached = await this.provider.get(this.keyFor(companyId, flowKey));
+      if (!cached) return void 0;
+      return JSON.parse(cached);
+    } catch {
+      return void 0;
+    }
+  }
+  async write(companyId, graph) {
+    try {
+      await this.provider.set(this.keyFor(companyId, graph.key), JSON.stringify(graph), this.ttlSeconds);
+    } catch {
+    }
+  }
+  async invalidate(companyId, flowKey) {
+    try {
+      await this.provider.delete(this.keyFor(companyId, flowKey));
+    } catch {
+    }
+  }
+};
+
 // src/repositories/SettingsRepository.ts
 import { eq as eq4 } from "drizzle-orm";
 function toContractSettings(row) {
@@ -1489,6 +1585,151 @@ var FlowInterpreter = class {
   }
 };
 
+// src/flows/createSendMediaAction.ts
+function mediaTypeFor2(mimeType) {
+  if (mimeType.startsWith("image/")) return "image";
+  if (mimeType.startsWith("audio/")) return "audio";
+  if (mimeType.startsWith("video/")) return "video";
+  return "document";
+}
+__name(mediaTypeFor2, "mediaTypeFor");
+function createSendMediaAction(params) {
+  return async ({ node, session, channel }) => {
+    if (!session.flowKey) return;
+    const location = {
+      companyId: session.companyId,
+      flowKey: session.flowKey,
+      nodeId: node.id
+    };
+    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({
+          to: session.whatsappNumber,
+          buffer,
+          mimeType: attachment.mimeType,
+          filename: attachment.filename,
+          caption: attachment.caption ?? void 0
+        });
+        await params.logMessage.execute({
+          companyId: session.companyId,
+          whatsappNumber: session.whatsappNumber,
+          direction: "outbound",
+          sender: "bot",
+          agentUserId: null,
+          type: mediaTypeFor2(attachment.mimeType),
+          content: attachment.caption ?? attachment.filename,
+          payload: {
+            filename: attachment.filename,
+            mimeType: attachment.mimeType,
+            uploadId: attachment.uploadId,
+            flowMediaId: attachment.id
+          },
+          waMessageId: externalMessageId,
+          status: "sent",
+          startState: params.startState
+        });
+      } catch (error) {
+        params.onError?.(error, {
+          flowKey: location.flowKey,
+          nodeId: node.id,
+          uploadId: attachment.uploadId
+        });
+      }
+    }
+  };
+}
+__name(createSendMediaAction, "createSendMediaAction");
+
+// src/repositories/FlowMediaRepository.ts
+import { and as and5, asc as asc2, eq as eq6, sql as sql4 } from "drizzle-orm";
+var FlowMediaRepository = class {
+  static {
+    __name(this, "FlowMediaRepository");
+  }
+  db;
+  constructor(db) {
+    this.db = db;
+  }
+  locationFilter(location) {
+    return and5(eq6(flowMedia.companyId, location.companyId), eq6(flowMedia.flowKey, location.flowKey), eq6(flowMedia.nodeId, location.nodeId));
+  }
+  // O que o nó realmente envia, na ordem de envio. `active` filtrado aqui e não no chamador:
+  // é a razão de a coluna existir, e um chamador que esquecesse do filtro mandaria ao cliente
+  // justamente o material que alguém desligou.
+  async listActive(location) {
+    return this.db.select().from(flowMedia).where(and5(this.locationFilter(location), eq6(flowMedia.active, true))).orderBy(asc2(flowMedia.sortOrder), asc2(flowMedia.createdAt));
+  }
+  // Inclui os desligados — é a visão do editor, onde desligar precisa continuar visível para
+  // poder ser religado.
+  async listAll(location) {
+    return this.db.select().from(flowMedia).where(this.locationFilter(location)).orderBy(asc2(flowMedia.sortOrder), asc2(flowMedia.createdAt));
+  }
+  /**
+  * Anexa um arquivo já existente no storage ao nó.
+  *
+  * `onConflictDoUpdate` em vez de deixar estourar: reanexar o mesmo arquivo é clique repetido no
+  * editor, e o esperado ali é atualizar a legenda/ordem — não um erro de índice único na cara de
+  * quem está montando o fluxo.
+  */
+  async attach(params) {
+    const [row] = await this.db.insert(flowMedia).values({
+      companyId: params.companyId,
+      flowKey: params.flowKey,
+      nodeId: params.nodeId,
+      uploadId: params.uploadId,
+      filename: params.filename,
+      mimeType: params.mimeType,
+      sizeBytes: params.sizeBytes,
+      caption: params.caption ?? null,
+      sortOrder: params.sortOrder ?? 0
+    }).onConflictDoUpdate({
+      target: [
+        flowMedia.companyId,
+        flowMedia.flowKey,
+        flowMedia.nodeId,
+        flowMedia.uploadId
+      ],
+      set: {
+        caption: params.caption ?? null,
+        sortOrder: params.sortOrder ?? 0,
+        active: true,
+        updatedAt: sql4`now()`
+      }
+    }).returning();
+    return row;
+  }
+  async update(params) {
+    const [row] = await this.db.update(flowMedia).set({
+      ...params.caption !== void 0 ? {
+        caption: params.caption
+      } : {},
+      ...params.sortOrder !== void 0 ? {
+        sortOrder: params.sortOrder
+      } : {},
+      ...params.active !== void 0 ? {
+        active: params.active
+      } : {},
+      updatedAt: sql4`now()`
+    }).where(and5(eq6(flowMedia.companyId, params.companyId), eq6(flowMedia.id, params.id))).returning();
+    return row;
+  }
+  /**
+  * Desanexa do nó. Não toca no storage de propósito: o mesmo `uploadId` pode estar anexado a
+  * outro nó ou a outro fluxo, e apagar o binário aqui quebraria os demais. Quem apaga objeto é o
+  * host, que é dono da biblioteca de arquivos.
+  */
+  async detach(params) {
+    await this.db.delete(flowMedia).where(and5(eq6(flowMedia.companyId, params.companyId), eq6(flowMedia.id, params.id)));
+  }
+  // Chamado ao salvar o grafo: nós apagados no editor deixam linhas que nada mais alcança.
+  async detachRemovedNodes(params) {
+    const condition = params.existingNodeIds.length === 0 ? void 0 : sql4`${flowMedia.nodeId} NOT IN ${params.existingNodeIds}`;
+    await this.db.delete(flowMedia).where(and5(eq6(flowMedia.companyId, params.companyId), eq6(flowMedia.flowKey, params.flowKey), condition));
+  }
+};
+
 // src/channel/WhatsAppChannelAdapter.ts
 import { WhatsAppWindowExpiredError as ProviderWindowExpiredError } from "@adatechnology/meta-graph-core";
 import { WindowExpiredError as WindowExpiredError2 } from "@adatechnology/meta-whatsapp-contracts";
@@ -1585,7 +1826,7 @@ async function claimWebhookDelivery(params) {
 __name(claimWebhookDelivery, "claimWebhookDelivery");
 
 // src/channel/IngestInboundMedia.use-case.ts
-import { eq as eq6, and as and5 } from "drizzle-orm";
+import { eq as eq7, and as and6 } from "drizzle-orm";
 var IngestInboundMediaUseCase = class {
   static {
     __name(this, "IngestInboundMediaUseCase");
@@ -1601,7 +1842,7 @@ var IngestInboundMediaUseCase = class {
     this.documentRepository = documentRepository;
   }
   async execute(params) {
-    const [message] = await this.db.select().from(messages).where(and5(eq6(messages.companyId, params.companyId), eq6(messages.id, params.messageId))).limit(1);
+    const [message] = await this.db.select().from(messages).where(and6(eq7(messages.companyId, params.companyId), eq7(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) {
@@ -1622,13 +1863,17 @@ var IngestInboundMediaUseCase = class {
       uploadId,
       sourceMediaId: params.sourceMediaId,
       mimeType: mimeType || params.mimeType,
+      // O tamanho já está na mão (é o buffer que acabou de ser copiado) e a bolha de documento o
+      // exibe ao lado do tipo. Sem gravar aqui, a UI mostraria "PDF" sem o "· 180 KB", e buscá-lo
+      // depois custaria uma consulta à tabela de documentos por mensagem renderizada.
+      sizeBytes: buffer.length,
       ...params.filename ? {
         filename: params.filename
       } : {}
     };
     await this.db.update(messages).set({
       payload: updatedPayload
-    }).where(and5(eq6(messages.companyId, params.companyId), eq6(messages.id, params.messageId)));
+    }).where(and6(eq7(messages.companyId, params.companyId), eq7(messages.id, params.messageId)));
     await this.documentRepository?.link({
       companyId: params.companyId,
       sessionId: message.sessionId,
@@ -1828,8 +2073,11 @@ function createMetaWhatsAppModule(params) {
   const sessionRepository = new SessionRepository(db);
   const messageRepository = new MessageRepository(db);
   const settingsRepository = new SettingsRepository(db);
-  const flowGraphRepository = new FlowGraphRepository(db);
+  const flowGraphCacheFeature = params.features?.flowGraphCache ?? false;
+  const flowGraphCache = flowGraphCacheFeature && providers.cache ? new FlowGraphCache(providers.cache, typeof flowGraphCacheFeature === "object" ? flowGraphCacheFeature.ttlSeconds ?? DEFAULT_FLOW_GRAPH_CACHE_TTL_SECONDS : DEFAULT_FLOW_GRAPH_CACHE_TTL_SECONDS) : void 0;
+  const flowGraphRepository = new FlowGraphRepository(db, flowGraphCache);
   const documentRepository = new DocumentRepository(db);
+  const flowMediaRepository = new FlowMediaRepository(db);
   const logMessage = new LogMessageUseCase(sessionRepository, messageRepository, providers.realtime, providers.moderator);
   const sendMessage = new SendMessageUseCase(channel, sessionRepository, logMessage, providers.objectStorage, documentRepository);
   const receiveWebhook = new ReceiveWebhookUseCase({
@@ -1843,6 +2091,15 @@ function createMetaWhatsAppModule(params) {
     realtime: providers.realtime
   });
   const flowInterpreter = flowEngineEnabled ? new FlowInterpreter() : void 0;
+  if (flowInterpreter && providers.objectStorage?.getObject) {
+    flowInterpreter.registerFlowAction(FLOW_ACTION_KIND.SEND_MEDIA, createSendMediaAction({
+      flowMediaRepository,
+      objectStorage: providers.objectStorage,
+      logMessage,
+      startState,
+      onError: hooks?.onFlowMediaError
+    }));
+  }
   const ingestInboundMedia = providers.objectStorage ? new IngestInboundMediaUseCase(db, channel, providers.objectStorage, documentRepository) : void 0;
   const listDocuments = new ListConversationDocumentsUseCase(sessionRepository, documentRepository);
   return {
@@ -1886,7 +2143,11 @@ function createMetaWhatsAppModule(params) {
       save: new SaveFlowGraphUseCase(flowGraphRepository),
       delete: new DeleteFlowGraphUseCase(flowGraphRepository),
       livePositions: new GetLiveFlowPositionsUseCase(flowGraphRepository),
-      repository: flowGraphRepository
+      repository: flowGraphRepository,
+      // Biblioteca de mídia dos nós `send_media` — o host liga nas rotas do editor
+      // (anexar/reordenar/desligar). Existe mesmo sem storage injetado: gerenciar anexos é
+      // consultar a tabela, e só o ENVIO precisa dos bytes.
+      mediaRepository: flowMediaRepository
     } : void 0,
     catalog: providers.catalog
   };
@@ -1985,12 +2246,15 @@ async function redeemSseTicket(store, ticket) {
 __name(redeemSseTicket, "redeemSseTicket");
 export {
   CreateFlowGraphUseCase,
+  DEFAULT_FLOW_GRAPH_CACHE_TTL_SECONDS,
   DeleteConversationUseCase,
   DeleteFlowGraphUseCase,
   DocumentRepository,
   ExportConversationUseCase,
+  FlowGraphCache,
   FlowGraphRepository,
   FlowInterpreter,
+  FlowMediaRepository,
   GetFlowGraphUseCase,
   GetLiveFlowPositionsUseCase,
   IngestInboundMediaUseCase,
@@ -2017,9 +2281,11 @@ export {
   WhatsAppChannelAdapter,
   claimWebhookDelivery,
   createMetaWhatsAppModule,
+  createSendMediaAction,
   documents,
   extractMediaDescriptor,
   flowGraphs,
+  flowMedia,
   issueSseTicket,
   messages,
   metaWhatsAppMigrationsFolder,