@hed-hog/core 0.0.400 → 0.0.402

package/src/setting/favicon.controller.ts

@@ -0,0 +1,135 @@
+import { Public } from '@hed-hog/api';
+import { Controller, Get, Logger, NotFoundException, Res } from '@nestjs/common';
+import { Response } from 'express';
+import { BrandAssetService } from './brand-asset.service';
+import { SettingService } from './setting.service';
+
+/** Timeout do fetch da imagem configurada. */
+const FETCH_TIMEOUT_MS = 5_000;
+
+/** Quanto tempo o binario baixado fica em memoria antes de buscar de novo. */
+const CACHE_TTL_MS = 10 * 60_000;
+
+type CachedIcon = {
+  url: string;
+  body: Buffer;
+  contentType: string;
+  expiresAt: number;
+};
+
+/**
+ * `GET /favicon.ico` no host da API, com o icone do Branding (`icon-url`).
+ *
+ * Quem procura o favicon no dominio da API sao os clientes que so conhecem esse
+ * endereco - o conector MCP no claude.ai, por exemplo, mostra o icone do dominio
+ * do servidor ao lado do nome. Sem esta rota a resposta era o 404 JSON do Nest e
+ * o conector caia na letra inicial.
+ *
+ * O arquivo e servido daqui (e nao por redirect) porque nem todo coletor de
+ * favicon segue redirecionamento. O Content-Type e o da origem, entao um SVG
+ * configurado no Branding chega como SVG.
+ */
+@Controller()
+export class FaviconController {
+  private readonly logger = new Logger(FaviconController.name);
+  private cache: CachedIcon | null = null;
+
+  constructor(
+    private readonly setting: SettingService,
+    private readonly brandAsset: BrandAssetService,
+  ) {}
+
+  @Public()
+  @Get('favicon.ico')
+  async favicon(@Res() res: Response) {
+    const icon = await this.loadIcon();
+
+    if (!icon) {
+      throw new NotFoundException();
+    }
+
+    res.setHeader('Content-Type', icon.contentType);
+    res.setHeader('Cache-Control', 'public, max-age=3600');
+    res.send(icon.body);
+  }
+
+  private async loadIcon(): Promise<CachedIcon | null> {
+    const settings = await this.setting.getSettingValues([
+      'icon-url',
+      'image-url',
+    ]);
+    const value =
+      String(settings['icon-url'] ?? '').trim() ||
+      String(settings['image-url'] ?? '').trim();
+    const url = await this.brandAsset.resolveAssetUrl(value);
+
+    if (!url) {
+      return null;
+    }
+
+    if (
+      this.cache &&
+      this.cache.url === url &&
+      this.cache.expiresAt > Date.now()
+    ) {
+      return this.cache;
+    }
+
+    const icon = await this.download(url);
+
+    if (icon) {
+      this.cache = icon;
+      return icon;
+    }
+
+    // Origem fora do ar: melhor o icone anterior do que nenhum.
+    return this.cache?.url === url ? this.cache : null;
+  }
+
+  private async download(url: string): Promise<CachedIcon | null> {
+    const dataUri = /^data:([^;,]+)(;base64)?,([\s\S]*)$/i.exec(url);
+
+    if (dataUri) {
+      const [, contentType, base64, payload] = dataUri;
+      return {
+        url,
+        contentType,
+        body: base64
+          ? Buffer.from(payload, 'base64')
+          : Buffer.from(decodeURIComponent(payload)),
+        expiresAt: Date.now() + CACHE_TTL_MS,
+      };
+    }
+
+    try {
+      const controller = new AbortController();
+      const timeout = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+      const response = await globalThis
+        .fetch(url, { signal: controller.signal })
+        .finally(() => clearTimeout(timeout));
+
+      const contentType = response.headers.get('content-type') ?? '';
+
+      if (!response.ok || !contentType.startsWith('image/')) {
+        this.logger.warn(
+          `Favicon source ${url} answered ${response.status} ${contentType || '(no content-type)'}`,
+        );
+        return null;
+      }
+
+      return {
+        url,
+        contentType,
+        body: Buffer.from(await response.arrayBuffer()),
+        expiresAt: Date.now() + CACHE_TTL_MS,
+      };
+    } catch (error) {
+      this.logger.warn(
+        `Could not fetch favicon source ${url}: ${
+          error instanceof Error ? error.message : String(error)
+        }`,
+      );
+      return null;
+    }
+  }
+}

package/src/setting/setting.module.ts

@@ -5,6 +5,7 @@ import { Global, Module, forwardRef } from '@nestjs/common';
 import { AuthModule } from '../auth/auth.module';
 import { MailModule } from '../mail/mail.module';
 import { BrandAssetService } from './brand-asset.service';
+import { FaviconController } from './favicon.controller';
 import { SettingsController } from './setting.controller';
 import { SettingService } from './setting.service';
 
@@ -17,7 +18,7 @@ import { SettingService } from './setting.service';
     forwardRef(() => LocaleModule),
     forwardRef(() => MailModule),
   ],
-  controllers: [SettingsController],
+  controllers: [SettingsController, FaviconController],
   providers: [SettingService, BrandAssetService],
   exports: [SettingService, BrandAssetService],
 })

package/src/setting/setting.service.ts

@@ -555,6 +555,9 @@ export class SettingService implements OnModuleInit, OnModuleDestroy {
       'lms-video-frame-capture-interval-seconds',
       'lms-error-modal-enabled',
       'url',
+      // Base dos callbacks OAuth do backend (canais do social): o perfil de
+      // integração mostra a URL exata que o backend envia ao provider.
+      'api-url',
       'app-urls',
       // Hcode Store: liga/desliga a venda no frontend (o backend também
       // recusa o checkout — isto é só para a UI mostrar "Em breve" cedo).

package/src/task/task.service.spec.ts

@@ -1,5 +1,11 @@
 import { describe, it, expect, beforeEach, afterEach, jest } from '@jest/globals';
-import { TasksService } from './task.service';
+
+const runMonitoredCron = jest.fn((_prisma: any, _options: any, work: () => any) => work());
+
+jest.mock('../observability/monitored-cron', () => ({ runMonitoredCron }));
+
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const { TasksService } = require('./task.service');
 
 const makeDeps = () => {
   const prismaService = { $executeRaw: jest.fn().mockResolvedValue(0) };
@@ -23,6 +29,25 @@ describe('TasksService', () => {
       expect(deps.prismaService.$executeRaw).toHaveBeenCalledTimes(8);
       expect(deps.settingService.getSettingValues).toHaveBeenCalled();
     });
+
+    it('elege um unico pod por tick via runMonitoredCron', async () => {
+      // Sem eleicao, todos os pods drenavam o access_log ao mesmo tempo e
+      // esgotavam o pool (Sentry 7692792694).
+      const { service, deps } = makeService();
+      await service.clear();
+      expect(runMonitoredCron).toHaveBeenCalledWith(
+        deps.prismaService,
+        expect.objectContaining({ slug: 'core-daily-cleanup', maxRuntimeMinutes: 15 }),
+        expect.any(Function),
+      );
+    });
+
+    it('nao limpa nada quando outro pod ganhou o tick', async () => {
+      runMonitoredCron.mockImplementationOnce(async () => undefined);
+      const { service, deps } = makeService();
+      await service.clear();
+      expect(deps.prismaService.$executeRaw).not.toHaveBeenCalled();
+    });
   });
 
   describe('clearExpiredMfaChallenges (default de batch limit)', () => {
@@ -46,6 +71,57 @@ describe('TasksService', () => {
   });
 
   describe('clearOldAccessLogs', () => {
+    let setTimeoutSpy: ReturnType<typeof jest.spyOn>;
+
+    beforeEach(() => {
+      // A pausa entre lotes nao interessa aqui: resolve na hora.
+      setTimeoutSpy = jest.spyOn(global, 'setTimeout').mockImplementation(((fn: () => void) => {
+        fn();
+        return 0;
+      }) as any);
+    });
+
+    afterEach(() => setTimeoutSpy.mockRestore());
+
+    it('pausa entre lotes cheios, mas nao depois do ultimo', async () => {
+      const { service, deps } = makeService();
+      deps.settingService.getSettingValues.mockResolvedValue({
+        'cleanup-batch-limit': 100,
+      });
+      deps.prismaService.$executeRaw
+        .mockResolvedValueOnce(100)
+        .mockResolvedValueOnce(100)
+        .mockResolvedValueOnce(42);
+
+      await (service as any).clearOldAccessLogs();
+
+      expect(setTimeoutSpy).toHaveBeenCalledTimes(2);
+    });
+
+    it('para sem falhar quando o pool esgota no meio da drenagem', async () => {
+      const { service, deps } = makeService();
+      deps.settingService.getSettingValues.mockResolvedValue({
+        'cleanup-batch-limit': 100,
+      });
+      deps.prismaService.$executeRaw
+        .mockResolvedValueOnce(100)
+        .mockRejectedValueOnce(
+          Object.assign(new Error('Timed out fetching a new connection from the connection pool'), {
+            code: 'P2024',
+          }),
+        );
+
+      await expect((service as any).clearOldAccessLogs()).resolves.toBeUndefined();
+      expect(deps.prismaService.$executeRaw).toHaveBeenCalledTimes(2);
+    });
+
+    it('propaga erro que nao e de pool', async () => {
+      const { service, deps } = makeService();
+      deps.prismaService.$executeRaw.mockRejectedValueOnce(new Error('syntax error'));
+
+      await expect((service as any).clearOldAccessLogs()).rejects.toThrow('syntax error');
+    });
+
     it('repete lotes ate drenar o acumulo', async () => {
       // O bug: um unico lote por execucao diaria contra uma ingestao uma ordem
       // de grandeza maior deixava a retencao inalcancavel.

package/src/task/task.service.ts

@@ -1,8 +1,15 @@
-import { Prisma, PrismaService } from '@hed-hog/api-prisma';
+import {
+  classifyDatabaseInfraError,
+  Prisma,
+  PrismaService,
+} from '@hed-hog/api-prisma';
 import { Injectable, Logger } from '@nestjs/common';
 import { Cron, CronExpression } from '@nestjs/schedule';
+import { runMonitoredCron } from '../observability/monitored-cron';
 import { SettingService } from '../setting/setting.service';
 
+const CLEANUP_CRON_SCHEDULE = CronExpression.EVERY_DAY_AT_MIDNIGHT;
+
 /**
  * Teto de tempo da limpeza do `access_log`. Existe para o caso da entrada
  * superar a saída de novo: o laço para e devolve o resto para a execução
@@ -10,6 +17,14 @@ import { SettingService } from '../setting/setting.service';
  */
 const ACCESS_LOG_CLEANUP_BUDGET_MS = 10 * 60 * 1000;
 
+/**
+ * Pausa entre dois lotes cheios do `access_log`. Sem ela o laço emenda um DELETE
+ * de 20 mil linhas no outro e o Postgres (1 CPU) não sobra para o tráfego: as
+ * requests do pod ficam lentas, seguram as 5 conexões do pool e o próprio lote
+ * seguinte morre em "Timed out fetching a new connection" (Sentry 7692792694).
+ */
+const ACCESS_LOG_BATCH_PAUSE_MS = 500;
+
 @Injectable()
 export class TasksService {
   private readonly logger = new Logger(TasksService.name);
@@ -24,9 +39,21 @@ export class TasksService {
    *
    * As tarefas são executadas sequencialmente para evitar contenção excessiva no banco.
    * Cada tarefa possui logging detalhado para monitoramento e troubleshooting.
+   *
+   * O @Cron dispara no mesmo segundo em todos os pods (API e workers); sem a
+   * eleição do `runMonitoredCron` cada um drenava o `access_log` em paralelo,
+   * disputando as mesmas linhas e saturando o banco.
    */
-  @Cron(CronExpression.EVERY_DAY_AT_MIDNIGHT)
+  @Cron(CLEANUP_CRON_SCHEDULE)
   async clear() {
+    await runMonitoredCron(
+      this.prismaService,
+      { slug: 'core-daily-cleanup', schedule: CLEANUP_CRON_SCHEDULE, maxRuntimeMinutes: 15 },
+      () => this.runCleanup(),
+    );
+  }
+
+  private async runCleanup(): Promise<void> {
     this.logger.verbose('++++++++++++++++++++++++++++++++++');
     this.logger.verbose('Running scheduled cleanup tasks');
     this.logger.verbose('++++++++++++++++++++++++++++++++++');
@@ -307,18 +334,18 @@ export class TasksService {
     let deleted = 0;
     let batches = 0;
     for (;;) {
-      const removed = await this.prismaService.$executeRaw`
-        WITH del AS (
-          SELECT id
-          FROM access_log
-          WHERE created_at < (now() - ${Prisma.sql`INTERVAL '${Prisma.raw(String(retentionDays))} days'`})
-          ORDER BY id
-          LIMIT ${batchLimit}
-        )
-        DELETE FROM access_log al
-        USING del
-        WHERE al.id = del.id
-      `;
+      let removed: number;
+      try {
+        removed = await this.deleteAccessLogBatch(retentionDays, batchLimit);
+      } catch (error) {
+        // Limpeza é best-effort: com o pool saturado o resto fica para a próxima
+        // execução, como no estouro do orçamento de tempo.
+        if (classifyDatabaseInfraError(error) !== 'pool') throw error;
+        this.logger.warn(
+          `Access log cleanup stopped on a saturated connection pool after ${deleted} rows; the remainder goes on the next run.`,
+        );
+        break;
+      }
 
       deleted += removed;
       batches += 1;
@@ -331,6 +358,8 @@ export class TasksService {
         );
         break;
       }
+
+      await new Promise((resolve) => setTimeout(resolve, ACCESS_LOG_BATCH_PAUSE_MS));
     }
 
     this.logger.verbose(
@@ -338,6 +367,21 @@ export class TasksService {
     );
   }
 
+  private deleteAccessLogBatch(retentionDays: number, batchLimit: number): Promise<number> {
+    return this.prismaService.$executeRaw`
+      WITH del AS (
+        SELECT id
+        FROM access_log
+        WHERE created_at < (now() - ${Prisma.sql`INTERVAL '${Prisma.raw(String(retentionDays))} days'`})
+        ORDER BY id
+        LIMIT ${batchLimit}
+      )
+      DELETE FROM access_log al
+      USING del
+      WHERE al.id = del.id
+    `;
+  }
+
   private async clearOldNotifications(): Promise<void> {
     const settings = await this.settingService.getSettingValues([
       'cleanup-batch-limit',

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

@@ -1,6 +1,8 @@
 import {
   WhatsappSendError,
   WhatsappSenderService,
+  WHATSAPP_OFFICIAL_ONLY,
+  toTemplateParam,
 } from './whatsapp-sender.service';
 
 describe('WhatsappSenderService', () => {
@@ -109,4 +111,265 @@ describe('WhatsappSenderService', () => {
       expect(JSON.parse(init.body).number).toBe('120363430651137530@g.us');
     });
   });
+
+  // O worker so insiste quando a recusa pode mudar; numero sem WhatsApp e dado
+  // de cadastro e reprocessaria o job tres vezes a toa.
+  describe('recusa da Evolution', () => {
+    let fetchSpy: jest.SpyInstance;
+
+    const buildEvolution = () => {
+      const built = buildService('evolution-api');
+      built.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' },
+      });
+      return built.service;
+    };
+
+    const respond = (status: number, body: unknown) =>
+      fetchSpy.mockResolvedValue({
+        ok: false,
+        status,
+        text: async () => JSON.stringify(body),
+      } as any);
+
+    const sendAndCatch = () =>
+      buildEvolution()
+        .send({ profileSlug: 'hcode', to: '5515991103304', text: 'Oi' })
+        .catch((thrown) => thrown);
+
+    beforeEach(() => {
+      fetchSpy = jest.spyOn(global, 'fetch' as any);
+    });
+
+    afterEach(() => fetchSpy.mockRestore());
+
+    it('numero sem WhatsApp e recusa permanente com mensagem legivel', async () => {
+      respond(400, {
+        status: 400,
+        error: 'Bad Request',
+        response: {
+          message: [{ jid: '5515991103304@s.whatsapp.net', exists: false, number: '5515991103304' }],
+        },
+      });
+
+      const error = await sendAndCatch();
+
+      expect(error).toBeInstanceOf(WhatsappSendError);
+      expect(error.retryable).toBe(false);
+      expect(error.message).toMatch(/5515991103304 não tem WhatsApp/);
+    });
+
+    it('outro 4xx tambem e permanente', async () => {
+      respond(400, { response: { message: ['text is required'] } });
+
+      const error = await sendAndCatch();
+
+      expect(error.retryable).toBe(false);
+      expect(error.isTransient).toBe(false);
+      expect(error.message).toMatch(/HTTP 400/);
+    });
+
+    it('5xx e 429 podem ser tentados de novo', async () => {
+      respond(502, {});
+      const serverError = await sendAndCatch();
+      expect(serverError.retryable).toBe(true);
+      expect(serverError.isTransient).toBe(true);
+
+      respond(429, {});
+      expect((await sendAndCatch()).retryable).toBe(true);
+    });
+
+    it('sessao fechada na Evolution pede para reconectar a instancia', async () => {
+      respond(500, {
+        status: 500,
+        error: 'Internal Server Error',
+        response: { message: 'Connection Closed' },
+      });
+
+      const error = await sendAndCatch();
+
+      expect(error).toBeInstanceOf(WhatsappSendError);
+      expect(error.retryable).toBe(true);
+      expect(error.isTransient).toBe(true);
+      expect(error.message).toMatch(/desconectada/);
+      expect(error.message).toMatch(/Reconecte a instância/);
+    });
+  });
+
+  // Sem phone_number_id no envio nem no perfil, vale o número padrão que a
+  // library whatsapp registra — senão cada comunicação pede o id à mão.
+  describe('número padrão do perfil no provider oficial', () => {
+    let fetchSpy: jest.SpyInstance;
+
+    const build = (phoneNumber: any, withDelegate = true) => {
+      const prisma: any = {
+        integration_profile: {
+          findUnique: jest.fn().mockResolvedValue({
+            id: 15,
+            slug: 'whatsapp-api-hcode',
+            config: { access_token: 'token' },
+            integration_provider: { slug: 'whatsapp-official' },
+            integration_type: { slug: 'whatsapp' },
+          }),
+          findFirst: jest.fn(),
+        },
+      };
+      if (withDelegate) {
+        prisma.whatsapp_phone_number = {
+          findFirst: jest.fn().mockResolvedValue(phoneNumber),
+        };
+      }
+      return { prisma, service: new WhatsappSenderService(prisma) };
+    };
+
+    beforeEach(() => {
+      fetchSpy = jest
+        .spyOn(global, 'fetch' as any)
+        .mockResolvedValue({ ok: true, json: async () => ({}) } as any);
+    });
+
+    afterEach(() => fetchSpy.mockRestore());
+
+    it('envia pelo número padrão quando o chamador não informa', async () => {
+      const { prisma, service } = build({ phone_number_id: '1188434797689179' });
+
+      await service.send({ profileSlug: 'whatsapp-api-hcode', to: '5511999999999', text: 'oi' });
+
+      expect(prisma.whatsapp_phone_number.findFirst).toHaveBeenCalledWith(
+        expect.objectContaining({
+          where: { integration_profile_id: 15, is_default: true, status: 'active' },
+        }),
+      );
+      expect(String(fetchSpy.mock.calls[0][0])).toContain('/1188434797689179/messages');
+    });
+
+    it('o id informado pelo chamador vence o padrão', async () => {
+      const { prisma, service } = build({ phone_number_id: '1188434797689179' });
+
+      await service.send({
+        profileSlug: 'whatsapp-api-hcode',
+        to: '5511999999999',
+        text: 'oi',
+        phoneNumberId: '555',
+      });
+
+      expect(prisma.whatsapp_phone_number.findFirst).not.toHaveBeenCalled();
+      expect(String(fetchSpy.mock.calls[0][0])).toContain('/555/messages');
+    });
+
+    it('sem padrão nem tabela, recusa sem chamar a Graph API', async () => {
+      const { service } = build(null, false);
+
+      await expect(
+        service.send({ profileSlug: 'whatsapp-api-hcode', to: '5511999999999', text: 'oi' }),
+      ).rejects.toThrow('não tem número padrão');
+      expect(fetchSpy).not.toHaveBeenCalled();
+    });
+
+    it('achata as quebras de linha dos parâmetros do template', async () => {
+      const { service } = build({ phone_number_id: '1188434797689179' });
+
+      await service.send({
+        profileSlug: 'whatsapp-api-hcode',
+        to: '5511999999999',
+        text: 'oi',
+        template: { name: 'lms_resumo', params: ['Maria', 'linha 1\n\nlinha 2'] },
+      });
+
+      const body = JSON.parse(fetchSpy.mock.calls[0][1].body);
+      expect(body.template.components[0].parameters).toEqual([
+        { type: 'text', text: 'Maria' },
+        { type: 'text', text: 'linha 1 · linha 2' },
+      ]);
+    });
+  });
+
+  describe('toTemplateParam', () => {
+    it('troca quebra de linha e tab por separador e colapsa espaços', () => {
+      expect(toTemplateParam('a\n\nb\tc     d')).toBe('a · b · c d');
+    });
+
+    it('não deixa parâmetro vazio, que a Meta recusa', () => {
+      expect(toTemplateParam('  ')).toBe('-');
+      expect(toTemplateParam(undefined)).toBe('-');
+    });
+  });
+
+  // Envio em lote para aluno não pode sair pela Evolution (WhatsApp Web): um
+  // disparo desses desconectou e bloqueou o número por 24h.
+  describe('restrição de provider', () => {
+    let fetchSpy: jest.SpyInstance;
+
+    beforeEach(() => {
+      fetchSpy = jest
+        .spyOn(global, 'fetch' as any)
+        .mockResolvedValue({ ok: true, json: async () => ({}) } as any);
+    });
+
+    afterEach(() => fetchSpy.mockRestore());
+
+    it('recusa um perfil Evolution escolhido à mão, sem nova tentativa', async () => {
+      const { service } = buildService('evolution-api');
+
+      const error = await service
+        .send({
+          profileSlug: 'hcode',
+          to: '5511999999999',
+          text: 'oi',
+          providers: WHATSAPP_OFFICIAL_ONLY,
+        })
+        .catch((e) => e);
+
+      expect(error).toBeInstanceOf(WhatsappSendError);
+      expect(error.retryable).toBe(false);
+      expect(fetchSpy).not.toHaveBeenCalled();
+    });
+
+    it('sem perfil escolhido, o fallback só procura perfis do provider exigido', async () => {
+      const { prisma, service } = buildService('whatsapp-official');
+      prisma.integration_profile.findFirst.mockResolvedValue({
+        id: 15,
+        slug: 'whatsapp-api-hcode',
+        config: { access_token: 'token', phone_number_id: '1188434797689179' },
+        integration_provider: { slug: 'whatsapp-official' },
+        integration_type: { slug: 'whatsapp' },
+      });
+
+      await service.send({ to: '5511999999999', text: 'oi', providers: WHATSAPP_OFFICIAL_ONLY });
+
+      expect(prisma.integration_profile.findFirst).toHaveBeenCalledWith(
+        expect.objectContaining({
+          where: expect.objectContaining({
+            integration_provider: { slug: { in: ['whatsapp-official'] } },
+          }),
+        }),
+      );
+      expect(String(fetchSpy.mock.calls[0][0])).toContain('/1188434797689179/messages');
+    });
+
+    it('isConfigured é falso para perfil de outro provider', async () => {
+      const { service } = buildService('evolution-api');
+
+      await expect(service.isConfigured('hcode', WHATSAPP_OFFICIAL_ONLY)).resolves.toBe(false);
+    });
+
+    it('sem restrição, a Evolution continua aceita', async () => {
+      const { service } = buildService('evolution-api');
+
+      await expect(service.isConfigured('hcode')).resolves.toBe(false);
+      // `false` aqui é só por falta de baseUrl/token no config de teste — o
+      // perfil foi resolvido, não recusado.
+      await expect(
+        service.describeProfile('hcode'),
+      ).resolves.toMatchObject({ providerSlug: 'evolution-api' });
+    });
+  });
 });