@hed-hog/core 0.0.387 → 0.0.390

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

@@ -0,0 +1,313 @@
+import { PrismaService } from '@hed-hog/api-prisma';
+import {
+  BadRequestException,
+  forwardRef,
+  Inject,
+  Injectable,
+  Logger,
+  NotFoundException,
+} from '@nestjs/common';
+import {
+  buildWhatsappOfficialConfigFromIntegration,
+} from '../integration-profile/integration-profile.utils';
+
+export type WhatsappTargetType = 'phone' | 'group';
+
+export type WhatsappMedia = {
+  /** Bare base64 (sem prefixo data:) ou data URL — ambos aceitos. */
+  base64: string;
+  mimetype: string;
+  fileName: string;
+  caption?: string;
+};
+
+export type WhatsappSendInput = {
+  /** Slug do perfil de integração. Vazio => primeiro perfil ativo do tipo whatsapp. */
+  profileSlug?: string;
+  to: string;
+  targetType?: WhatsappTargetType;
+  text: string;
+  media?: WhatsappMedia;
+  /** Exigido pelo provider `whatsapp-official` (id do número no WABA). */
+  phoneNumberId?: string;
+  /** Template aprovado pela Meta — sem ele o envio só chega na janela de 24h. */
+  template?: { name: string; language?: string; params?: string[] };
+};
+
+type ResolvedProfile = {
+  slug: string;
+  providerSlug: string;
+  config: Record<string, unknown>;
+};
+
+/**
+ * Envio de WhatsApp usando um perfil de integração escolhido pelo usuário.
+ *
+ * O provider não é fixado em código: ele vem do próprio perfil, então quem
+ * configura o sistema decide entre Evolution API e a Cloud API oficial da Meta
+ * sem que o chamador precise saber a diferença.
+ */
+@Injectable()
+export class WhatsappSenderService {
+  private readonly logger = new Logger(WhatsappSenderService.name);
+
+  constructor(
+    @Inject(forwardRef(() => PrismaService))
+    private readonly prisma: PrismaService,
+  ) {}
+
+  async send(input: WhatsappSendInput): Promise<void> {
+    const profile = await this.resolveProfile(input.profileSlug);
+
+    switch (profile.providerSlug) {
+      case 'evolution-api':
+        return this.sendWithEvolution(profile, input);
+      case 'whatsapp-official':
+        return this.sendWithOfficial(profile, input);
+      default:
+        throw new BadRequestException(
+          `Perfil de integração "${profile.slug}" usa o provider "${profile.providerSlug}", que não envia WhatsApp. Use um perfil evolution-api ou whatsapp-official.`,
+        );
+    }
+  }
+
+  /** Diz se há perfil utilizável, para o chamador decidir por um fallback sem tentar o envio. */
+  async isConfigured(profileSlug?: string): Promise<boolean> {
+    try {
+      const profile = await this.resolveProfile(profileSlug);
+
+      if (profile.providerSlug === 'evolution-api') {
+        const { baseUrl, token, instance } = this.readEvolutionConfig(profile);
+        return Boolean(baseUrl && token && instance);
+      }
+
+      if (profile.providerSlug === 'whatsapp-official') {
+        const cfg = buildWhatsappOfficialConfigFromIntegration(profile.config);
+        return Boolean(cfg.accessToken);
+      }
+
+      return false;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Normaliza o destino: número vira só dígitos, id de grupo passa intacto
+   * (grupos do WhatsApp têm sufixo `@g.us`, que seria destruído por um strip).
+   */
+  normalizeTarget(target: string, targetType: WhatsappTargetType = 'phone'): string {
+    const raw = String(target ?? '').trim();
+
+    if (!raw) {
+      throw new BadRequestException('Destino de WhatsApp vazio.');
+    }
+
+    if (targetType === 'group') {
+      return raw;
+    }
+
+    const normalized = raw.replace(/\D+/g, '');
+
+    if (!normalized) {
+      throw new BadRequestException(
+        'O número de WhatsApp precisa conter ao menos um dígito.',
+      );
+    }
+
+    return normalized;
+  }
+
+  private async resolveProfile(profileSlug?: string): Promise<ResolvedProfile> {
+    const slug = String(profileSlug ?? '').trim();
+
+    const profile = slug
+      ? await this.prisma.integration_profile.findUnique({
+          where: { slug },
+          include: {
+            integration_provider: { select: { slug: true } },
+            integration_type: { select: { slug: true } },
+          },
+        })
+      : await this.prisma.integration_profile.findFirst({
+          where: { is_active: true, integration_type: { slug: 'whatsapp' } },
+          orderBy: { updated_at: 'desc' },
+          include: {
+            integration_provider: { select: { slug: true } },
+            integration_type: { select: { slug: true } },
+          },
+        });
+
+    if (!profile) {
+      throw new NotFoundException(
+        slug
+          ? `Perfil de integração "${slug}" não encontrado.`
+          : 'Nenhum perfil de integração de WhatsApp ativo encontrado.',
+      );
+    }
+
+    if ((profile as any).integration_type?.slug !== 'whatsapp') {
+      throw new BadRequestException(
+        `Perfil de integração "${profile.slug}" não é do tipo whatsapp.`,
+      );
+    }
+
+    return {
+      slug: profile.slug,
+      providerSlug: String((profile as any).integration_provider?.slug ?? ''),
+      config: ((profile.config ?? {}) as Record<string, unknown>),
+    };
+  }
+
+  private readEvolutionConfig(profile: ResolvedProfile) {
+    const cfg = profile.config;
+
+    return {
+      baseUrl: String(cfg.host ?? cfg.base_url ?? '').trim().replace(/\/+$/, ''),
+      token: String(cfg.token ?? cfg.api_key ?? '').trim(),
+      instance: String(cfg.instance_name ?? cfg.instance ?? '').trim(),
+    };
+  }
+
+  private async sendWithEvolution(
+    profile: ResolvedProfile,
+    input: WhatsappSendInput,
+  ): Promise<void> {
+    const { baseUrl, token, instance } = this.readEvolutionConfig(profile);
+
+    if (!baseUrl || !token || !instance) {
+      throw new BadRequestException(
+        `Perfil de WhatsApp "${profile.slug}" incompleto. Obrigatórios: host, instance_name e token.`,
+      );
+    }
+
+    const target = this.normalizeTarget(input.to, input.targetType);
+    const encodedInstance = encodeURIComponent(instance);
+
+    const url = input.media
+      ? `${baseUrl}/message/sendMedia/${encodedInstance}`
+      : `${baseUrl}/message/sendText/${encodedInstance}`;
+
+    const body = input.media
+      ? {
+          number: target,
+          mediatype: 'image',
+          mimetype: input.media.mimetype,
+          fileName: input.media.fileName,
+          media: stripDataUrlPrefix(input.media.base64),
+          caption: input.media.caption ?? input.text,
+        }
+      : { number: target, text: input.text };
+
+    const response = await fetch(url, {
+      method: 'POST',
+      headers: { apikey: token, 'Content-Type': 'application/json' },
+      body: JSON.stringify(body),
+    });
+
+    if (!response.ok) {
+      const detail = await response.text().catch(() => '');
+
+      if (response.status === 401) {
+        throw new BadRequestException(
+          `Credenciais do WhatsApp inválidas (401). Verifique o token do perfil "${profile.slug}".`,
+        );
+      }
+
+      throw new BadRequestException(
+        `Evolution API recusou o envio (HTTP ${response.status}): ${detail.slice(0, 300)}`,
+      );
+    }
+  }
+
+  private async sendWithOfficial(
+    profile: ResolvedProfile,
+    input: WhatsappSendInput,
+  ): Promise<void> {
+    const cfg = buildWhatsappOfficialConfigFromIntegration(profile.config);
+
+    if (!cfg.accessToken) {
+      throw new BadRequestException(
+        `Perfil de WhatsApp "${profile.slug}" está sem access_token.`,
+      );
+    }
+
+    // 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();
+
+    if (!phoneNumberId) {
+      throw new BadRequestException(
+        'O provider whatsapp-official exige o phone_number_id do número remetente.',
+      );
+    }
+
+    const to = this.normalizeTarget(input.to, 'phone');
+
+    // A Meta só aceita mensagem iniciada pela empresa através de template
+    // aprovado. Sem template, o texto livre só chega se o destinatário tiver
+    // falado com o número nas últimas 24h.
+    const body = input.template?.name
+      ? {
+          messaging_product: 'whatsapp',
+          to,
+          type: 'template',
+          template: {
+            name: input.template.name,
+            language: { code: input.template.language || 'pt_BR' },
+            components: [
+              {
+                type: 'body',
+                parameters: (input.template.params ?? [input.text]).map((text) => ({
+                  type: 'text',
+                  text,
+                })),
+              },
+            ],
+          },
+        }
+      : {
+          messaging_product: 'whatsapp',
+          to,
+          type: 'text',
+          text: { body: input.text.slice(0, 4000) },
+        };
+
+    const url = `https://graph.facebook.com/${cfg.graphApiVersion}/${encodeURIComponent(
+      phoneNumberId,
+    )}/messages`;
+
+    const response = await fetch(url, {
+      method: 'POST',
+      headers: {
+        Authorization: `Bearer ${cfg.accessToken}`,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify(body),
+    });
+
+    if (!response.ok) {
+      const payload = (await response.json().catch(() => ({}))) as {
+        error?: { message?: string };
+      };
+
+      throw new BadRequestException(
+        `WhatsApp recusou o envio (HTTP ${response.status}): ${
+          payload?.error?.message ?? 'sem detalhe'
+        }${
+          input.template?.name
+            ? ''
+            : ' — sem template configurado, a entrega só funciona na janela de 24h'
+        }`,
+      );
+    }
+  }
+}
+
+/** 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);
+  return match ? match[1] : image;
+}