@hed-hog/core 0.0.398 → 0.0.400

package/src/utils/date-range.ts

@@ -0,0 +1,246 @@
+/**
+ * Tradução única de `?from=yyyy-MM-dd&to=yyyy-MM-dd` para limites comparáveis
+ * no banco.
+ *
+ * A janela é **meio-aberta** — `[from 00:00, to+1d 00:00)` — e nunca inclusiva.
+ * `lte new Date('2026-08-31')` compara contra o *instante* `T00:00:00Z` e
+ * derruba o dia 31 inteiro; `lte 23:59:59.999` perde o último milissegundo e
+ * mente sobre o modelo de dados. A forma meio-aberta é a única que vale igual
+ * para coluna `@db.Date` e para coluna `@db.Timestamptz(6)`, sem flag nenhum.
+ *
+ * Diferenças de propósito para o `resolveRangeWindow` do operations
+ * (`libraries/operations/src/services/shared/operations-activity-window.helper.ts`),
+ * que serve relatório e não listagem:
+ *
+ * - sem `from` e sem `to` devolve `null` (= sem recorte), e não o dia de hoje:
+ *   listagem sem filtro tem de devolver tudo;
+ * - **não limita o fim em agora**: reunião de amanhã, contrato que vence em
+ *   2027 e assinatura com período à frente são justamente o que essas telas
+ *   procuram;
+ * - aceita janela aberta de um lado só.
+ *
+ * Os dois hão de convergir, mas depois: aquele alimenta o e-mail do relatório
+ * diário e depende do clamp.
+ */
+
+export interface DateRangeBounds {
+  gte?: Date;
+  lt?: Date;
+}
+
+export interface DateRange {
+  /** Início inclusivo, no fuso pedido. Ausente quando só veio `to`. */
+  gte?: Date;
+  /** Fim EXCLUSIVO (`to` + 1 dia), no fuso pedido. Ausente quando só veio `from`. */
+  lt?: Date;
+  /**
+   * As mesmas bordas em UTC puro — o que uma coluna `@db.Date` entende.
+   *
+   * O Prisma manda o parâmetro como `DATE` e o trunca pela leitura **UTC** do
+   * `Date`. Uma borda deslocada para fuso a leste derruba um dia inteiro sem
+   * erro nenhum: meia-noite de 01/09 em `Asia/Tokyo` é `2026-08-31T15:00Z`,
+   * que trunca para `2026-08-31`. Coluna de data pura não tem fuso, então
+   * converter fuso nela é sempre errado.
+   */
+  dateOnly: DateRangeBounds;
+  /** `yyyy-MM-dd` normalizado, já desinvertido. */
+  fromIso?: string;
+  /** `to + 1 dia`, para o `< $n::date` do SQL cru. */
+  toExclusiveIso?: string;
+}
+
+export interface DateRangeOptions {
+  /**
+   * Fuso IANA das bordas civis; o padrão é UTC, que é o fuso dos pods da API.
+   * Só afeta coluna com hora — veja `dateOnly`.
+   */
+  timezone?: string;
+}
+
+/** Tolera ISO completo: só o prefixo `yyyy-MM-dd` interessa. */
+const ISO_DATE_PREFIX = /^(\d{4})-(\d{2})-(\d{2})/;
+
+function normalizeTimezone(timezone?: string): string {
+  const candidate = String(timezone ?? '').trim();
+  if (!candidate) return 'UTC';
+
+  try {
+    new Intl.DateTimeFormat('en-US', { timeZone: candidate });
+    return candidate;
+  } catch {
+    // Fuso inventado não pode derrubar uma listagem: cai no fuso dos pods.
+    return 'UTC';
+  }
+}
+
+function toIsoDate(value?: string | null): string | null {
+  const match = ISO_DATE_PREFIX.exec(String(value ?? '').trim());
+  if (!match) return null;
+
+  const [, yearText, monthText, dayText] = match;
+  const year = Number(yearText);
+  const month = Number(monthText);
+  const day = Number(dayText);
+
+  // `2026-02-31` casa com o regex e o `Date.UTC` o aceita virando 03/03.
+  // Só a volta denuncia.
+  const probe = new Date(Date.UTC(year, month - 1, day));
+  if (
+    probe.getUTCFullYear() !== year ||
+    probe.getUTCMonth() !== month - 1 ||
+    probe.getUTCDate() !== day
+  ) {
+    return null;
+  }
+
+  return `${yearText}-${monthText}-${dayText}`;
+}
+
+/**
+ * Soma dias de **calendário**. Somar 86400000 ms a um instante zonado erra o
+ * dia em toda virada de horário de verão.
+ */
+export function addIsoDays(isoDate: string, days: number): string {
+  const [year, month, day] = isoDate.split('-').map(Number);
+
+  return new Date(Date.UTC(year, month - 1, day + days))
+    .toISOString()
+    .slice(0, 10);
+}
+
+function utcMidnight(isoDate: string): Date {
+  return new Date(`${isoDate}T00:00:00.000Z`);
+}
+
+/**
+ * Deslocamento do fuso, em ms, no instante informado. Formatar a data no fuso
+ * e reinterpretar as partes como UTC devolve o offset vigente — inclusive em
+ * fuso com horário de verão.
+ */
+function timezoneOffsetMs(at: Date, timezone: string): number {
+  const parts = new Intl.DateTimeFormat('en-US', {
+    timeZone: timezone,
+    hour12: false,
+    year: 'numeric',
+    month: '2-digit',
+    day: '2-digit',
+    hour: '2-digit',
+    minute: '2-digit',
+    second: '2-digit',
+  }).formatToParts(at);
+
+  const part = (type: string) =>
+    Number(parts.find((item) => item.type === type)?.value ?? 0);
+
+  const asUtc = Date.UTC(
+    part('year'),
+    part('month') - 1,
+    part('day'),
+    // Algumas engines devolvem "24" para a meia-noite em hour12:false.
+    part('hour') % 24,
+    part('minute'),
+    part('second'),
+  );
+
+  return asUtc - at.getTime();
+}
+
+/** Meia-noite civil de `isoDate` naquele fuso, como instante UTC. */
+function zonedMidnight(isoDate: string, timezone: string): Date {
+  if (timezone === 'UTC') return utcMidnight(isoDate);
+
+  const naive = Date.parse(`${isoDate}T00:00:00.000Z`);
+
+  // Duas passadas: a primeira usa o offset do palpite, a segunda o do instante
+  // já corrigido — é o que resolve a virada de horário de verão.
+  let utc = naive;
+  for (let pass = 0; pass < 2; pass += 1) {
+    utc = naive - timezoneOffsetMs(new Date(utc), timezone);
+  }
+
+  return new Date(utc);
+}
+
+/**
+ * Resolve o par `from`/`to` da query.
+ *
+ * Devolve `null` quando nenhuma das pontas é data utilizável — o que cobre de
+ * uma vez "o cliente não filtrou", "o cliente limpou o campo e mandou
+ * `?from=`" e "o cliente mandou `31/08/2026`". Filtro ilegível vira "sem
+ * filtro", não 500: o `ValidationPipe` barra o que dá para barrar na borda, e
+ * aqui dentro a listagem não pode cair.
+ *
+ * Intervalo invertido é desinvertido: arrastar o calendário de trás para
+ * frente não deve devolver lista vazia.
+ */
+export function resolveDateRange(
+  from?: string | null,
+  to?: string | null,
+  options: DateRangeOptions = {},
+): DateRange | null {
+  const timezone = normalizeTimezone(options.timezone);
+
+  let fromIso = toIsoDate(from);
+  let toIso = toIsoDate(to);
+
+  if (!fromIso && !toIso) return null;
+
+  if (fromIso && toIso && toIso < fromIso) {
+    [fromIso, toIso] = [toIso, fromIso];
+  }
+
+  const toExclusiveIso = toIso ? addIsoDays(toIso, 1) : undefined;
+
+  return {
+    gte: fromIso ? zonedMidnight(fromIso, timezone) : undefined,
+    lt: toExclusiveIso ? zonedMidnight(toExclusiveIso, timezone) : undefined,
+    dateOnly: {
+      gte: fromIso ? utcMidnight(fromIso) : undefined,
+      lt: toExclusiveIso ? utcMidnight(toExclusiveIso) : undefined,
+    },
+    fromIso: fromIso ?? undefined,
+    toExclusiveIso,
+  };
+}
+
+export interface DateRangeWhereOptions extends DateRangeOptions {
+  /**
+   * `true` para coluna `@db.Date`. Usa as bordas UTC puras, que são as únicas
+   * que o `DATE` do Postgres trunca para o dia certo.
+   */
+  dateOnly?: boolean;
+}
+
+/**
+ * Fragmento pronto para espalhar dentro de um `where` do Prisma:
+ *
+ * ```ts
+ * const where = {
+ *   deleted_at: null,
+ *   ...dateRangeWhere('created_at', filters?.from, filters?.to),
+ * };
+ * ```
+ *
+ * Devolve `{}` quando não há recorte, então espalhar é sempre seguro e não
+ * existe o caminho "montei um `created_at: {}` vazio". As chaves ausentes são
+ * omitidas de verdade, não postas como `undefined`.
+ */
+export function dateRangeWhere(
+  field: string,
+  from?: string | null,
+  to?: string | null,
+  options: DateRangeWhereOptions = {},
+): Record<string, DateRangeBounds> {
+  const range = resolveDateRange(from, to, options);
+  if (!range) return {};
+
+  const source = options.dateOnly
+    ? range.dateOnly
+    : { gte: range.gte, lt: range.lt };
+
+  const bounds: DateRangeBounds = {};
+  if (source.gte) bounds.gte = source.gte;
+  if (source.lt) bounds.lt = source.lt;
+
+  return Object.keys(bounds).length > 0 ? { [field]: bounds } : {};
+}

package/src/webhook-integration/webhook-utils.spec.ts

@@ -0,0 +1,67 @@
+import { describe, it, expect } from '@jest/globals';
+import { renderTemplate } from './webhook-utils';
+
+describe('renderTemplate', () => {
+  it('interpola valores simples e aninhados', () => {
+    expect(renderTemplate('olá {{name}}', { name: 'João' })).toBe('olá João');
+    expect(
+      renderTemplate('{{alerts.0.labels.severity}}', {
+        alerts: [{ labels: { severity: 'warning' } }],
+      }),
+    ).toBe('warning');
+  });
+
+  it('percorre listas com each', () => {
+    const out = renderTemplate('{{#each alerts}}[{{name}}]{{/each}}', {
+      alerts: [{ name: 'a' }, { name: 'b' }],
+    });
+    expect(out).toBe('[a][b]');
+  });
+
+  // O motivo dos helpers: o payload do Alertmanager traz status "firing" ou
+  // "resolved" e a mensagem tem de ser diferente em cada caso.
+  it('escolhe o ramo pelo status com o helper eq', () => {
+    const tpl = '{{#if (eq status "firing")}}ALERTA{{else}}NORMALIZOU{{/if}}';
+    expect(renderTemplate(tpl, { status: 'firing' })).toBe('ALERTA');
+    expect(renderTemplate(tpl, { status: 'resolved' })).toBe('NORMALIZOU');
+  });
+
+  it('compara número e string como equivalentes', () => {
+    // O payload vem de JSON externo: quem escreve o template não deve precisar
+    // saber se o produtor mandou 200 ou "200".
+    expect(renderTemplate('{{#if (eq code 200)}}ok{{/if}}', { code: '200' })).toBe('ok');
+    expect(renderTemplate('{{#if (eq code "200")}}ok{{/if}}', { code: 200 })).toBe('ok');
+  });
+
+  it('oferece ne, gt e lt', () => {
+    expect(renderTemplate('{{#if (ne a "x")}}dif{{/if}}', { a: 'y' })).toBe('dif');
+    expect(renderTemplate('{{#if (gt n 5)}}maior{{/if}}', { n: 6 })).toBe('maior');
+    expect(renderTemplate('{{#if (lt n 5)}}menor{{/if}}', { n: 4 })).toBe('menor');
+  });
+
+  it('normaliza caixa com upper e lower', () => {
+    expect(renderTemplate('{{upper s}}', { s: 'firing' })).toBe('FIRING');
+    expect(renderTemplate('{{lower s}}', { s: 'FIRING' })).toBe('firing');
+    // Ausente não pode virar "undefined" no meio da mensagem.
+    expect(renderTemplate('{{upper ausente}}', {})).toBe('');
+  });
+
+  it('mantém acentos e símbolos quando usa triple stash', () => {
+    // O destino é WhatsApp, não HTML: escapar viraria ' na tela do usuário.
+    const ctx = { texto: "capacidade 78% — 'atenção'" };
+    expect(renderTemplate('{{{texto}}}', ctx)).toBe("capacidade 78% — 'atenção'");
+  });
+
+  it('atravessa objetos e listas preservando os tipos que não são string', () => {
+    const out = renderTemplate(
+      { titulo: '{{name}}', ativo: true, tentativas: 3, tags: ['{{name}}'] },
+      { name: 'x' },
+    );
+    expect(out).toEqual({ titulo: 'x', ativo: true, tentativas: 3, tags: ['x'] });
+  });
+
+  it('devolve null e undefined sem tentar compilar', () => {
+    expect(renderTemplate(null, {})).toBeNull();
+    expect(renderTemplate(undefined, {})).toBeUndefined();
+  });
+});

package/src/webhook-integration/webhook-utils.ts

@@ -13,6 +13,32 @@ export function hashToken(token: string) {
   return createHash('sha256').update(token).digest('hex');
 }
 
+/**
+ * Handlebars puro não compara valores: `{{#if}}` só testa se algo é vazio. Sem
+ * isto um template não consegue reagir ao conteúdo do payload — o caso que
+ * motivou os helpers foi o webhook do Alertmanager, onde `status` chega como
+ * "firing" ou "resolved" e a mensagem precisa ser diferente em cada caso (mandar
+ * o texto de alerta quando o problema acabou é pior do que não mandar nada).
+ *
+ * Registrados uma vez, no import do módulo: `Handlebars.registerHelper` é global
+ * e chamá-lo a cada render só repetiria trabalho.
+ */
+const HELPERS: Record<string, (...args: any[]) => any> = {
+  // `{{#if (eq status "firing")}}`. A comparação é frouxa de propósito: o payload
+  // vem de JSON externo, onde 200 e "200" são a mesma coisa para quem escreve o
+  // template.
+  eq: (a: unknown, b: unknown) => String(a) === String(b),
+  ne: (a: unknown, b: unknown) => String(a) !== String(b),
+  gt: (a: unknown, b: unknown) => Number(a) > Number(b),
+  lt: (a: unknown, b: unknown) => Number(a) < Number(b),
+  upper: (value: unknown) => String(value ?? '').toUpperCase(),
+  lower: (value: unknown) => String(value ?? '').toLowerCase(),
+};
+
+for (const [name, fn] of Object.entries(HELPERS)) {
+  Handlebars.registerHelper(name, fn);
+}
+
 export function renderTemplate(source: unknown, context: Record<string, any>) {
   if (source === undefined || source === null) {
     return source;

package/src/whatsapp-sender/whatsapp-recipients.spec.ts

@@ -0,0 +1,89 @@
+import { parseWhatsappRecipients, toWhatsappGroupJid } from './whatsapp-recipients';
+
+/**
+ * O que este parser decide é para ONDE um aviso interno vai. Errar aqui não dá
+ * erro: entrega em outro número, ou some em silêncio — os dois modos de falha
+ * que o canal existe para evitar.
+ */
+describe('toWhatsappGroupJid', () => {
+  it('aceita a forma atual, só dígitos com sufixo', () => {
+    expect(toWhatsappGroupJid('120363430651137530@g.us')).toBe(
+      '120363430651137530@g.us',
+    );
+  });
+
+  it('aceita a forma antiga, derivada de quem criou o grupo', () => {
+    expect(toWhatsappGroupJid('5511992662104-1564082267@g.us')).toBe(
+      '5511992662104-1564082267@g.us',
+    );
+  });
+
+  it('completa o sufixo de um id colado sem ele', () => {
+    expect(toWhatsappGroupJid('120363430651137530')).toBe(
+      '120363430651137530@g.us',
+    );
+  });
+
+  it('não confunde telefone com grupo', () => {
+    expect(toWhatsappGroupJid('5511999998888')).toBeNull();
+  });
+
+  it('descarta a colagem de dois telefones grudados', () => {
+    expect(toWhatsappGroupJid('5511999998888551199999777')).toBeNull();
+  });
+});
+
+describe('parseWhatsappRecipients', () => {
+  it('devolve lista vazia para configuração ausente', () => {
+    expect(parseWhatsappRecipients(null)).toEqual([]);
+    expect(parseWhatsappRecipients('')).toEqual([]);
+  });
+
+  it('completa o DDI 55 de um número nacional com máscara', () => {
+    expect(parseWhatsappRecipients('(11) 99999-8888')).toEqual([
+      { to: '5511999998888', targetType: 'phone' },
+    ]);
+  });
+
+  it('não acrescenta DDI a quem já veio com um', () => {
+    expect(parseWhatsappRecipients('5511999998888')).toEqual([
+      { to: '5511999998888', targetType: 'phone' },
+    ]);
+  });
+
+  it('separa por vírgula, ponto-e-vírgula e quebra de linha, nunca por espaço', () => {
+    // Espaço faz parte da máscara: quebrar ali produziria `+55`, `(11)` e
+    // `3333-4444`, todos descartados, e a lista sumiria em silêncio.
+    expect(
+      parseWhatsappRecipients(
+        '+55 (11) 3333-4444, 5511999998888;\n120363430651137530@g.us',
+      ),
+    ).toEqual([
+      { to: '551133334444', targetType: 'phone' },
+      { to: '5511999998888', targetType: 'phone' },
+      { to: '120363430651137530@g.us', targetType: 'group' },
+    ]);
+  });
+
+  it('conta uma vez só o mesmo destino escrito de duas formas', () => {
+    expect(
+      parseWhatsappRecipients('(11) 99999-8888, 5511999998888'),
+    ).toHaveLength(1);
+  });
+
+  it('descarta o que não é telefone nem grupo', () => {
+    // Menos de 10 dígitos não tem DDD, e acima de 20 nem grupo é: a faixa entre
+    // 16 e 20 pertence ao id de grupo colado sem o sufixo `@g.us`.
+    expect(
+      parseWhatsappRecipients('123, abc, 123456789012345678901'),
+    ).toEqual([]);
+  });
+
+  it('16 a 20 dígitos é id de grupo, não telefone longo demais', () => {
+    // O descarte silencioso por "longo demais" é justamente o modo de falha que
+    // este canal combate: quem cola o id do painel da Evolution não recebe erro.
+    expect(parseWhatsappRecipients('1203634306511375')).toEqual([
+      { to: '1203634306511375@g.us', targetType: 'group' },
+    ]);
+  });
+});

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

@@ -0,0 +1,83 @@
+import { WhatsappTargetType } from './whatsapp-sender.service';
+
+/**
+ * Destino de um aviso interno por WhatsApp: celular ou grupo.
+ *
+ * Mora no core, e nao na library que avisa, porque ja sao duas a ler a mesma
+ * lista digitada a mao — o SAC, para o grupo do atendimento, e o commerce, para
+ * os grupos de venda. Reconhecedor de JID de grupo duplicado e como as duas
+ * divergem: uma passa a aceitar o id sem sufixo e a outra nao, e o destino some
+ * em silencio no modulo que ficou para tras.
+ */
+export type WhatsappRecipient = {
+  to: string;
+  targetType: WhatsappTargetType;
+};
+
+/**
+ * Id de grupo do WhatsApp (`...@g.us`), ou null quando o item nao e grupo.
+ *
+ * Grupo tem duas formas: a atual, so digitos (`120363...@g.us`), e a antiga,
+ * derivada de quem criou o grupo (`5511999998888-1564082267@g.us`). As duas
+ * saem do painel da Evolution ja com o sufixo.
+ *
+ * Sem sufixo tambem vale: um id colado do painel tem 18 digitos, e acima do teto
+ * do E.164 (15) nao existe telefone — a alternativa seria o descarte silencioso
+ * por "longo demais", que e o modo de falha que este canal combate. O corte em
+ * 20 digitos deixa de fora a colagem de dois telefones grudados, que nao e
+ * destino nenhum.
+ */
+export function toWhatsappGroupJid(value: string): string | null {
+  const match = /^(\d{5,}(?:-\d{5,})?)@g\.us$/i.exec(value);
+  if (match) return `${match[1]}@g.us`;
+
+  return /^\d{16,20}$/.test(value) ? `${value}@g.us` : null;
+}
+
+/**
+ * Destinos de WhatsApp de uma lista digitada a mao: celulares e grupos.
+ *
+ * Nao da para reusar um `split` de e-mail: `WhatsappSenderService.normalizeTarget`
+ * apenas remove os nao-digitos e **nao acrescenta DDI**. Um `(11) 99999-8888`
+ * digitado no admin viraria `11999998888`, um numero que o provedor aceita e
+ * entrega em outro lugar — falha silenciosa, que e exatamente o que este canal
+ * existe para evitar. Por isso o DDI 55 e completado aqui quando o que sobrou
+ * tem cara de numero nacional (DDD + 8 ou 9 digitos).
+ *
+ * A separacao e so por virgula, ponto-e-virgula e quebra de linha — nao por
+ * espaco. Espaco faz parte da mascara de um telefone (`+55 (11) 3333-4444`), e
+ * quebrar ali produziria os fragmentos `+55`, `(11)` e `3333-4444`, todos
+ * descartados: a lista inteira sumiria em silencio.
+ *
+ * Menos de 10 digitos nao e telefone com DDD, e mais de 15 nao e telefone nenhum
+ * (o teto do E.164) — normalmente sao dois numeros que alguem separou so com
+ * espaco. Descartar e melhor que enviar para um numero inventado.
+ */
+export function parseWhatsappRecipients(
+  raw: string | null | undefined,
+): WhatsappRecipient[] {
+  if (!raw) return [];
+
+  // Map, e nao Set: o mesmo destino escrito de duas formas continua contando uma
+  // vez so, e o tipo precisa vir junto do valor.
+  const seen = new Map<string, WhatsappRecipient>();
+
+  for (const item of raw.split(/[,;\n]+/)) {
+    const value = item.trim();
+    if (!value) continue;
+
+    const group = toWhatsappGroupJid(value);
+
+    if (group) {
+      seen.set(group, { to: group, targetType: 'group' });
+      continue;
+    }
+
+    const digits = value.replace(/\D+/g, '');
+    if (digits.length < 10 || digits.length > 15) continue;
+    const phone = digits.length <= 11 ? `55${digits}` : digits;
+    seen.set(phone, { to: phone, targetType: 'phone' });
+  }
+
+  return [...seen.values()];
+}

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

@@ -0,0 +1,112 @@
+import {
+  WhatsappSendError,
+  WhatsappSenderService,
+} from './whatsapp-sender.service';
+
+describe('WhatsappSenderService', () => {
+  const buildService = (providerSlug: string) => {
+    const prisma = {
+      integration_profile: {
+        findUnique: jest.fn().mockResolvedValue({
+          id: 7,
+          slug: 'whatsapp-api-hcode',
+          config: { access_token: 'token', phone_number_id: '109371452' },
+          integration_provider: { slug: providerSlug },
+          integration_type: { slug: 'whatsapp' },
+        }),
+        findFirst: jest.fn(),
+      },
+    };
+
+    return { prisma, service: new WhatsappSenderService(prisma as any) };
+  };
+
+  describe('normalizeTarget', () => {
+    it('preserva o sufixo do grupo, que um strip de digitos destruiria', () => {
+      const { service } = buildService('evolution-api');
+
+      expect(
+        service.normalizeTarget('120363430651137530@g.us', 'group'),
+      ).toBe('120363430651137530@g.us');
+    });
+
+    it('reduz o telefone a digitos', () => {
+      const { service } = buildService('evolution-api');
+
+      expect(service.normalizeTarget('+55 (11) 3333-4444')).toBe(
+        '551133334444',
+      );
+    });
+  });
+
+  // A Cloud API nao tem endpoint de grupo. Sem a guarda, o destino seria
+  // reduzido a digitos e a Graph API receberia o id do grupo como telefone.
+  describe('grupo no provider oficial', () => {
+    let fetchSpy: jest.SpyInstance;
+
+    beforeEach(() => {
+      fetchSpy = jest
+        .spyOn(global, 'fetch' as any)
+        .mockResolvedValue({ ok: true, json: async () => ({}) } as any);
+    });
+
+    afterEach(() => fetchSpy.mockRestore());
+
+    it('recusa o envio sem chamar a Graph API', async () => {
+      const { service } = buildService('whatsapp-official');
+
+      await expect(
+        service.send({
+          profileSlug: 'whatsapp-api-hcode',
+          to: '120363430651137530@g.us',
+          targetType: 'group',
+          text: 'Novo chamado',
+        }),
+      ).rejects.toThrow(/não envia mensagem para grupo/);
+
+      expect(fetchSpy).not.toHaveBeenCalled();
+    });
+
+    it('marca a recusa como permanente, para o job nao insistir', async () => {
+      const { service } = buildService('whatsapp-official');
+
+      const error = await service
+        .send({
+          profileSlug: 'whatsapp-api-hcode',
+          to: '120363430651137530@g.us',
+          targetType: 'group',
+          text: 'Novo chamado',
+        })
+        .catch((thrown) => thrown);
+
+      expect(error).toBeInstanceOf(WhatsappSendError);
+      expect((error as WhatsappSendError).retryable).toBe(false);
+    });
+
+    it('a Evolution continua entregando no grupo', async () => {
+      const { prisma, service } = buildService('evolution-api');
+      prisma.integration_profile.findUnique.mockResolvedValue({
+        id: 2,
+        slug: 'hcode',
+        config: {
+          host: 'https://evolution.hcode.com.br',
+          token: 'apikey',
+          instance_name: 'hcode',
+        },
+        integration_provider: { slug: 'evolution-api' },
+        integration_type: { slug: 'whatsapp' },
+      });
+
+      await service.send({
+        profileSlug: 'hcode',
+        to: '120363430651137530@g.us',
+        targetType: 'group',
+        text: 'Novo chamado',
+      });
+
+      const [url, init] = fetchSpy.mock.calls[0];
+      expect(url).toBe('https://evolution.hcode.com.br/message/sendText/hcode');
+      expect(JSON.parse(init.body).number).toBe('120363430651137530@g.us');
+    });
+  });
+});