@adatechnology/meta-whatsapp-module 0.2.0-rc.0 → 0.2.0-rc.10

package/dist/index.js

@@ -85,9 +85,14 @@ var messages = metaWhatsAppSchema.table("messages", {
     length: 12
   }).notNull(),
   agentUserId: uuid("agent_user_id"),
-  type: varchar("type", {
-    length: 16
-  }).notNull().default("text"),
+  // 32, não 16: os tipos da própria Meta são curtos ('text', 'interactive'), mas o host rotula
+  type: (
+    // a saída com o subtipo que enviou ('interactive_buttons' já tem 19). Apertar aqui só
+    // transfere para o consumidor a escolha entre truncar o rótulo e estourar o insert.
+    varchar("type", {
+      length: 32
+    }).notNull().default("text")
+  ),
   content: text("content"),
   // T5.4 — nunca base64 aqui; mídia vive no ObjectStorageInterface do host, referenciada por
   // uploadId dentro deste jsonb.
@@ -101,6 +106,12 @@ var messages = metaWhatsAppSchema.table("messages", {
   readAt: timestamp("read_at", {
     withTimezone: true
   }),
+  // Moderação de conteúdo. `null` significa NÃO AVALIADO (moderação desligada, ou mensagem
+  // anterior ao recurso) — diferente de `false`, que é avaliado e limpo. Colunas em vez de chave
+  // dentro de `payload` porque "listar o que foi sinalizado" é consulta de operação, e índice
+  // parcial sobre boolean resolve isso sem cavar jsonb.
+  moderationFlagged: boolean("moderation_flagged"),
+  moderationTerms: jsonb("moderation_terms").$type(),
   createdAt: timestamp("created_at", {
     withTimezone: true
   }).notNull().defaultNow()
@@ -112,7 +123,10 @@ var messages = metaWhatsAppSchema.table("messages", {
   // paralelo, então as duas passariam pela checagem e inseririam duplicado. Parcial porque
   // mensagens outbound ainda sem waMessageId (envio em curso) são legitimamente NULL, e NULLs
   // não podem competir entre si por unicidade.
-  uniqueIndex("idx_messages_company_wa_message_id").on(table.companyId, table.waMessageId).where(sql`${table.waMessageId} is not null`)
+  uniqueIndex("idx_messages_company_wa_message_id").on(table.companyId, table.waMessageId).where(sql`${table.waMessageId} is not null`),
+  // Parcial: só as sinalizadas entram, então o índice fica do tamanho do problema e não do
+  // tamanho do transcript.
+  index("idx_messages_moderation_flagged").on(table.companyId, table.createdAt).where(sql`${table.moderationFlagged}`)
 ]);
 var flowGraphs = metaWhatsAppSchema.table("flow_graphs", {
   id: uuid("id").primaryKey().defaultRandom(),
@@ -165,6 +179,31 @@ var settings = metaWhatsAppSchema.table("settings", {
 
 // src/repositories/SessionRepository.ts
 var DEFAULT_LIMIT = 20;
+var conversationSummaryProjection = {
+  lastContent: sql2`(
+    select m.content from ${messages} m
+    where m.company_id = ${sessions}.company_id and m.session_id = ${sessions}.id
+    order by m.created_at desc limit 1
+  )`,
+  lastDirection: sql2`(
+    select m.direction from ${messages} m
+    where m.company_id = ${sessions}.company_id and m.session_id = ${sessions}.id
+    order by m.created_at desc limit 1
+  )`,
+  // Entradas do cliente depois da última leitura do atendente. Sessão nunca lida conta
+  // tudo — é o comportamento esperado de uma conversa que ninguém abriu ainda.
+  unread: sql2`(
+    select count(*)::int from ${messages} m
+    where m.company_id = ${sessions}.company_id
+      and m.session_id = ${sessions}.id
+      and m.direction = 'inbound'
+      and (${sessions}.last_agent_read_at is null or m.created_at > ${sessions}.last_agent_read_at)
+  )`
+};
+function sessionContextPatch(patch) {
+  return sql2`${sessions.context} || ${JSON.stringify(patch)}::jsonb`;
+}
+__name(sessionContextPatch, "sessionContextPatch");
 var SessionRepository = class {
   static {
     __name(this, "SessionRepository");
@@ -195,6 +234,9 @@ var SessionRepository = class {
     }).returning();
     return created;
   }
+  // O `context` jsonb é o ponto de extensão oficial para estado de sessão por produto: o módulo
+  // não conhece a forma, o consumidor a declara em TSessionContext. Este setter SUBSTITUI o
+  // objeto inteiro — para acumular respostas ao longo da conversa use patchContext.
   async setState(companyId, whatsappNumber, state, context) {
     await this.db.update(sessions).set({
       currentState: state,
@@ -205,6 +247,25 @@ var SessionRepository = class {
       updatedAt: sql2`now()`
     }).where(and(eq(sessions.companyId, companyId), eq(sessions.whatsappNumber, whatsappNumber)));
   }
+  // Mescla parcial do context, feita no banco (`||`) e não por read-modify-write no host: duas
+  // mensagens do mesmo cliente processadas em paralelo sobrescreveriam uma à outra, e o campo
+  // acumula justamente as respostas coletadas ao longo da conversa. Chave presente no patch
+  // vence a existente; as demais permanecem.
+  async patchContext(companyId, whatsappNumber, patch) {
+    await this.db.update(sessions).set({
+      context: sessionContextPatch(patch),
+      lastActivity: sql2`now()`,
+      updatedAt: sql2`now()`
+    }).where(and(eq(sessions.companyId, companyId), eq(sessions.whatsappNumber, whatsappNumber)));
+  }
+  // Leitura tipada do estado de sessão do produto. Devolve undefined quando a sessão não existe —
+  // distinto de existir com context vazio, que devolve o objeto vazio.
+  async readContext(companyId, whatsappNumber) {
+    const [row] = await this.db.select({
+      context: sessions.context
+    }).from(sessions).where(and(eq(sessions.companyId, companyId), eq(sessions.whatsappNumber, whatsappNumber))).limit(1);
+    return row?.context;
+  }
   // Posição no grafo de fluxo — chamado pelo host a cada transição do FlowInterpreter.
   // Passar null em ambos desliga o rastreio (ex.: conversa saiu do motor de fluxo).
   async setFlowPosition(companyId, whatsappNumber, flowKey, currentNodeId) {
@@ -280,17 +341,28 @@ var SessionRepository = class {
       currentState: sessions.currentState,
       lastActivity: sessions.lastActivity,
       lastInboundAt: sessions.lastInboundAt,
-      humanRequestedAt: sessions.humanRequestedAt
+      humanRequestedAt: sessions.humanRequestedAt,
+      // Prévia e contagem saem de subquery correlacionada em vez de N+1 na volta: uma inbox
+      // lista dezenas de conversas por página, e uma query por linha é o gargalo clássico
+      // dessa tela. Ambos os campos são dados do próprio módulo — deixá-los para o host
+      // obrigaria todo consumidor a reescrever o mesmo join contra tabelas que não são dele.
+      ...conversationSummaryProjection
     }).from(sessions).where(and(...conditions)).orderBy(desc(sessions.lastActivity)).limit(limit).offset(offset);
     return rows.map((row) => ({
       id: row.id,
       whatsappNumber: row.whatsappNumber,
+      ...row.lastContent !== null ? {
+        lastContent: row.lastContent
+      } : {},
+      ...row.lastDirection !== null ? {
+        lastDirection: row.lastDirection
+      } : {},
       lastAt: row.lastActivity.toISOString(),
       lastInboundAt: row.lastInboundAt?.toISOString() ?? null,
       mode: row.mode,
       assignedUserId: row.assignedUserId,
       waitingHuman: row.humanRequestedAt !== null,
-      unread: 0,
+      unread: Number(row.unread),
       currentState: row.currentState
     }));
   }
@@ -334,7 +406,9 @@ var MessageRepository = class {
       content: params.content ?? null,
       payload: params.payload ?? null,
       waMessageId: params.waMessageId ?? null,
-      status: params.status ?? null
+      status: params.status ?? null,
+      moderationFlagged: params.moderationFlagged ?? null,
+      moderationTerms: params.moderationTerms ?? null
     };
     const [created] = await this.db.insert(messages).values(values).onConflictDoNothing().returning();
     return created;
@@ -550,16 +624,19 @@ var LogMessageUseCase = class {
   sessionRepository;
   messageRepository;
   realtime;
-  constructor(sessionRepository, messageRepository, realtime) {
+  moderator;
+  constructor(sessionRepository, messageRepository, realtime, moderator) {
     this.sessionRepository = sessionRepository;
     this.messageRepository = messageRepository;
     this.realtime = realtime;
+    this.moderator = moderator;
   }
   async execute(params) {
     const session = await this.sessionRepository.getOrCreate(params.companyId, params.whatsappNumber, params.startState);
     const saved = await this.messageRepository.insertMessage({
       ...params,
-      sessionId: session.id
+      sessionId: session.id,
+      ...this.moderationOf(params)
     });
     if (!saved) return void 0;
     if (params.direction === "inbound") {
@@ -572,6 +649,20 @@ var LogMessageUseCase = class {
     this.realtime?.emit("global", "data-changed", {});
     return saved;
   }
+  // Só o que o cliente escreveu: marcar o que o próprio atendente ou o bot enviou não sinaliza
+  // abuso, apenas sujaria o transcript com etiqueta na resposta de quem atende.
+  moderationOf(params) {
+    if (!this.moderator || params.direction !== "inbound") return {};
+    const text2 = params.content?.trim();
+    if (!text2) return {};
+    const verdict = this.moderator.inspect(text2);
+    return {
+      moderationFlagged: verdict.isOffensive,
+      moderationTerms: verdict.isOffensive ? [
+        ...verdict.matchedTerms
+      ] : null
+    };
+  }
 };
 
 // src/use-cases/SendMessage.use-case.ts
@@ -1113,6 +1204,8 @@ function toSessionContract(row) {
     companyId: row.companyId,
     whatsappNumber: row.whatsappNumber,
     currentState: row.currentState,
+    flowKey: row.flowKey,
+    currentNodeId: row.currentNodeId,
     context: row.context,
     mode: row.mode,
     assignedUserId: row.assignedUserId,
@@ -1323,7 +1416,7 @@ function createMetaWhatsAppModule(params) {
   const messageRepository = new MessageRepository(db);
   const settingsRepository = new SettingsRepository(db);
   const flowGraphRepository = new FlowGraphRepository(db);
-  const logMessage = new LogMessageUseCase(sessionRepository, messageRepository, providers.realtime);
+  const logMessage = new LogMessageUseCase(sessionRepository, messageRepository, providers.realtime, providers.moderator);
   const sendMessage = new SendMessageUseCase(channel, sessionRepository, logMessage, providers.objectStorage);
   const receiveWebhook = new ReceiveWebhookUseCase({
     appSecret: config.appSecret,
@@ -1379,11 +1472,15 @@ __name(createMetaWhatsAppModule, "createMetaWhatsAppModule");
 
 // src/runMigrations.ts
 import { join } from "path";
-import { migrate } from "drizzle-orm/bun-sql/migrator";
-async function runMetaWhatsAppMigrations(db) {
-  await migrate(db, {
-    migrationsFolder: join(__dirname, "migrations"),
-    migrationsTable: "meta_whatsapp_migrations"
+var META_WHATSAPP_MIGRATIONS_TABLE = "meta_whatsapp_migrations";
+function metaWhatsAppMigrationsFolder() {
+  return join(__dirname, "migrations");
+}
+__name(metaWhatsAppMigrationsFolder, "metaWhatsAppMigrationsFolder");
+async function runMetaWhatsAppMigrations(params) {
+  await params.migrate(params.db, {
+    migrationsFolder: metaWhatsAppMigrationsFolder(),
+    migrationsTable: META_WHATSAPP_MIGRATIONS_TABLE
   });
 }
 __name(runMetaWhatsAppMigrations, "runMetaWhatsAppMigrations");
@@ -1477,6 +1574,7 @@ export {
   ListFlowGraphsUseCase,
   ListMessagesUseCase,
   LogMessageUseCase,
+  META_WHATSAPP_MIGRATIONS_TABLE,
   MessageRepository,
   OptimisticLockError,
   ReceiveWebhookUseCase,
@@ -1495,6 +1593,7 @@ export {
   flowGraphs,
   issueSseTicket,
   messages,
+  metaWhatsAppMigrationsFolder,
   metaWhatsAppSchema,
   redeemSseTicket,
   runMetaWhatsAppMigrations,