@hed-hog/core 0.0.400 → 0.0.402

package/src/whatsapp-sender/whatsapp-sender.service.ts

@@ -32,8 +32,17 @@ export type WhatsappSendInput = {
   phoneNumberId?: string;
   /** Template aprovado pela Meta — sem ele o envio só chega na janela de 24h. */
   template?: { name: string; language?: string; params?: string[] };
+  /**
+   * Providers aceitos para este envio. Vazio aceita qualquer um. Quem manda em
+   * lote para alunos restringe ao oficial: disparo em massa pela Evolution
+   * (WhatsApp Web) derruba e bane o número.
+   */
+  providers?: readonly string[];
 };
 
+/** Só a Cloud API da Meta — para envio em volume a quem não é da equipe. */
+export const WHATSAPP_OFFICIAL_ONLY: readonly string[] = ['whatsapp-official'];
+
 type ResolvedProfile = {
   id: number;
   slug: string;
@@ -46,13 +55,27 @@ type ResolvedProfile = {
  * resultado diferente. Um HTTP 4xx da Graph API (id inexistente, sem
  * permissão, token ruim) não muda em cinco minutos; um 5xx ou falha de rede
  * pode ser uma instabilidade passageira do provedor.
+ *
+ * `isTransient` repete o `retryable` no formato que o `TransientError.is` da
+ * fila reconhece por duck-typing (o core não depende do queue): com ele as
+ * tentativas intermediárias vão ao Sentry como warning, e só a última como erro.
+ *
+ * `reason` marca as falhas que valem para a instância inteira, não para a
+ * mensagem: com a sessão fechada ou a credencial recusada, a próxima mensagem
+ * do mesmo lote tem o mesmo destino, e quem envia em série pode parar ali.
  */
+export type WhatsappSendErrorReason = 'session_closed' | 'unauthorized';
+
 export class WhatsappSendError extends BadRequestException {
+  readonly isTransient: boolean;
+
   constructor(
     message: string,
     public readonly retryable: boolean,
+    public readonly reason?: WhatsappSendErrorReason,
   ) {
     super(message);
+    this.isTransient = retryable;
   }
 }
 
@@ -73,7 +96,7 @@ export class WhatsappSenderService {
   ) {}
 
   async send(input: WhatsappSendInput): Promise<void> {
-    const profile = await this.resolveProfile(input.profileSlug);
+    const profile = await this.resolveProfile(input.profileSlug, input.providers);
 
     switch (profile.providerSlug) {
       case 'evolution-api':
@@ -88,9 +111,12 @@ export class WhatsappSenderService {
   }
 
   /** Diz se há perfil utilizável, para o chamador decidir por um fallback sem tentar o envio. */
-  async isConfigured(profileSlug?: string): Promise<boolean> {
+  async isConfigured(
+    profileSlug?: string,
+    providers?: readonly string[],
+  ): Promise<boolean> {
     try {
-      const profile = await this.resolveProfile(profileSlug);
+      const profile = await this.resolveProfile(profileSlug, providers);
 
       if (profile.providerSlug === 'evolution-api') {
         const { baseUrl, token, instance } = this.readEvolutionConfig(profile);
@@ -150,8 +176,12 @@ export class WhatsappSenderService {
     return normalized;
   }
 
-  private async resolveProfile(profileSlug?: string): Promise<ResolvedProfile> {
+  private async resolveProfile(
+    profileSlug?: string,
+    providers?: readonly string[],
+  ): Promise<ResolvedProfile> {
     const slug = String(profileSlug ?? '').trim();
+    const allowed = providers?.length ? [...providers] : null;
 
     const profile = slug
       ? await this.prisma.integration_profile.findUnique({
@@ -162,7 +192,11 @@ export class WhatsappSenderService {
           },
         })
       : await this.prisma.integration_profile.findFirst({
-          where: { is_active: true, integration_type: { slug: 'whatsapp' } },
+          where: {
+            is_active: true,
+            integration_type: { slug: 'whatsapp' },
+            ...(allowed ? { integration_provider: { slug: { in: allowed } } } : {}),
+          },
           orderBy: { updated_at: 'desc' },
           include: {
             integration_provider: { select: { slug: true } },
@@ -174,7 +208,9 @@ export class WhatsappSenderService {
       throw new NotFoundException(
         slug
           ? `Perfil de integração "${slug}" não encontrado.`
-          : 'Nenhum perfil de integração de WhatsApp ativo encontrado.',
+          : allowed
+            ? `Nenhum perfil de WhatsApp ativo do provider ${allowed.join(' ou ')} encontrado.`
+            : 'Nenhum perfil de integração de WhatsApp ativo encontrado.',
       );
     }
 
@@ -184,10 +220,21 @@ export class WhatsappSenderService {
       );
     }
 
+    const providerSlug = String((profile as any).integration_provider?.slug ?? '');
+
+    // Perfil escolhido à mão que não é do provider exigido: é configuração, não
+    // instabilidade — reenviar daria no mesmo.
+    if (allowed && !allowed.includes(providerSlug)) {
+      throw new WhatsappSendError(
+        `Perfil de integração "${profile.slug}" usa o provider "${providerSlug}", e este envio só aceita ${allowed.join(' ou ')}.`,
+        false,
+      );
+    }
+
     return {
       id: profile.id,
       slug: profile.slug,
-      providerSlug: String((profile as any).integration_provider?.slug ?? ''),
+      providerSlug,
       config: ((profile.config ?? {}) as Record<string, unknown>),
     };
   }
@@ -242,17 +289,62 @@ export class WhatsappSenderService {
       const detail = await response.text().catch(() => '');
 
       if (response.status === 401) {
-        throw new BadRequestException(
+        throw new WhatsappSendError(
           `Credenciais do WhatsApp inválidas (401). Verifique o token do perfil "${profile.slug}".`,
+          false,
+          'unauthorized',
         );
       }
 
-      throw new BadRequestException(
+      // Número sem conta no WhatsApp: a Evolution responde 400 com
+      // `exists: false`. É dado do cadastro, não instabilidade — reenviar não
+      // muda nada, e o chamador precisa saber disso para não insistir.
+      if (isEvolutionNumberMissing(detail)) {
+        throw new WhatsappSendError(
+          `O número ${target} não tem WhatsApp (Evolution: exists=false).`,
+          false,
+        );
+      }
+
+      // Sessão da instância caída (celular deslogado ou Baileys reconectando):
+      // a Evolution responde 500 "Connection Closed". Segue retentável porque a
+      // reconexão costuma ser sozinha; se persistir, quem ler a falha precisa
+      // saber que a ação é reconectar a instância, não mexer no envio.
+      if (isEvolutionSessionClosed(detail)) {
+        throw new WhatsappSendError(
+          `A instância "${instance}" da Evolution está desconectada do WhatsApp (Connection Closed). Reconecte a instância (QR code) do perfil "${profile.slug}".`,
+          true,
+          'session_closed',
+        );
+      }
+
+      // Mesmo critério do provider oficial: 4xx é recusa estrutural, 5xx e
+      // 429 podem passar numa próxima tentativa.
+      throw new WhatsappSendError(
         `Evolution API recusou o envio (HTTP ${response.status}): ${detail.slice(0, 300)}`,
+        response.status >= 500 || response.status === 429,
       );
     }
   }
 
+  /**
+   * Número padrão do perfil, mantido pela library `whatsapp` (sync com o WABA
+   * ou registro na primeira mensagem recebida).
+   *
+   * A tabela não é do core: num projeto sem a library `whatsapp` o delegate não
+   * existe, e o envio segue sem padrão — cai no erro de phone_number_id ausente.
+   */
+  private async resolveDefaultPhoneNumberId(profileId: number): Promise<string> {
+    const delegate = (this.prisma as any).whatsapp_phone_number;
+    if (!delegate?.findFirst) return '';
+
+    const found = await delegate.findFirst({
+      where: { integration_profile_id: profileId, is_default: true, status: 'active' },
+      select: { phone_number_id: true },
+    });
+    return String(found?.phone_number_id ?? '').trim();
+  }
+
   private async sendWithOfficial(
     profile: ResolvedProfile,
     input: WhatsappSendInput,
@@ -278,15 +370,16 @@ export class WhatsappSenderService {
       );
     }
 
-    // O phone_number_id não vive no perfil: um WABA pode ter vários números,
-    // então quem envia precisa dizer por qual deles a mensagem sai.
-    const phoneNumberId = String(
-      input.phoneNumberId ?? profile.config.phone_number_id ?? '',
-    ).trim();
+    // O phone_number_id não vive no perfil: um WABA pode ter vários números.
+    // Quem envia pode dizer por qual deles a mensagem sai; sem isso, vale o
+    // número padrão do perfil.
+    const phoneNumberId =
+      String(input.phoneNumberId ?? profile.config.phone_number_id ?? '').trim() ||
+      (await this.resolveDefaultPhoneNumberId(profile.id));
 
     if (!phoneNumberId) {
       throw new BadRequestException(
-        'O provider whatsapp-official exige o phone_number_id do número remetente.',
+        `Perfil de WhatsApp "${profile.slug}" não tem número padrão: informe o phone_number_id do número remetente ou mande uma mensagem para o número, que ele é registrado.`,
       );
     }
 
@@ -308,7 +401,7 @@ export class WhatsappSenderService {
                 type: 'body',
                 parameters: (input.template.params ?? [input.text]).map((text) => ({
                   type: 'text',
-                  text,
+                  text: toTemplateParam(text),
                 })),
               },
             ],
@@ -359,6 +452,51 @@ export class WhatsappSenderService {
   }
 }
 
+/**
+ * Reconhece o 400 da Evolution para destino inexistente:
+ * `{"response":{"message":[{"exists":false,"number":"55..."}]}}`.
+ */
+function isEvolutionNumberMissing(detail: string): boolean {
+  try {
+    const messages = JSON.parse(detail)?.response?.message;
+    return (
+      Array.isArray(messages) &&
+      messages.some((item) => item && typeof item === 'object' && item.exists === false)
+    );
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Reconhece o 500 da Evolution com a sessão do WhatsApp fechada:
+ * `{"response":{"message":"Connection Closed"}}` (às vezes com a string num array).
+ */
+function isEvolutionSessionClosed(detail: string): boolean {
+  try {
+    const message = JSON.parse(detail)?.response?.message;
+    const texts = Array.isArray(message) ? message : [message];
+    return texts.some(
+      (item) => typeof item === 'string' && /connection closed/i.test(item),
+    );
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * A Meta recusa parâmetro de template com quebra de linha, tab ou mais de
+ * quatro espaços seguidos (erro 132018) — e o texto que os módulos montam para
+ * o WhatsApp vem em parágrafos. Vazio também é recusado.
+ */
+export function toTemplateParam(text: unknown): string {
+  const flat = String(text ?? '')
+    .replace(/\s*[\r\n\t]+\s*/g, ' · ')
+    .replace(/ {2,}/g, ' ')
+    .trim();
+  return flat || '-';
+}
+
 /** Evolution espera base64 puro; um data URL vindo do chamador quebraria o envio. */
 function stripDataUrlPrefix(image: string): string {
   const match = /^data:[^;]+;base64,(.*)$/i.exec(image);