@hed-hog/core 0.0.387 → 0.0.393

package/src/incident/incident.service.ts

@@ -0,0 +1,209 @@
+import { PageOrderDirection, PaginationService } from '@hed-hog/api-pagination';
+import { PrismaService } from '@hed-hog/api-prisma';
+import { forwardRef, Inject, Injectable, Logger } from '@nestjs/common';
+import { createHash } from 'crypto';
+import { IncidentNotifierService } from './incident-notifier.service';
+
+export type IncidentSeverity = 'warning' | 'error' | 'critical';
+
+export interface RecordIncidentInput {
+  /** `<modulo>.<area>`, ex.: `core.mail`, `legacy.reconcile`. */
+  source: string;
+  /** Identificador estável da falha, ex.: `mail_send_failed`. */
+  code: string;
+  message: string;
+  severity?: IncidentSeverity;
+  /**
+   * Torna o incidente distinto dentro de `(source, code)`. Use algo estável e
+   * de baixa cardinalidade — o slug do template, o id do provider. **Nunca** um
+   * id de usuário ou timestamp: viraria uma linha por ocorrência, que é
+   * exatamente o que esta tabela existe para evitar.
+   */
+  key?: string;
+  context?: Record<string, unknown>;
+}
+
+export interface IncidentListParams {
+  page?: number;
+  pageSize?: number;
+  search?: string;
+  sortField?: string;
+  sortOrder?: PageOrderDirection;
+  fields?: string;
+  source?: string;
+  severity?: IncidentSeverity;
+  status?: 'open' | 'resolved' | 'all';
+}
+
+const MAX_MESSAGE_LENGTH = 2000;
+
+/**
+ * Registro central das falhas que hoje somem em `.catch(() => null)` e
+ * `logger.error`.
+ *
+ * Não substitui a fila: job que falha já tem `queue_job_event` com timeline. O
+ * alvo aqui são os caminhos fire-and-forget, onde ninguém fica sabendo.
+ */
+@Injectable()
+export class IncidentService {
+  private readonly logger = new Logger(IncidentService.name);
+
+  constructor(
+    @Inject(forwardRef(() => PrismaService))
+    private readonly prisma: PrismaService,
+    @Inject(forwardRef(() => PaginationService))
+    private readonly pagination: PaginationService,
+    @Inject(forwardRef(() => IncidentNotifierService))
+    private readonly notifier: IncidentNotifierService,
+  ) {}
+
+  /**
+   * Nunca lança e nunca bloqueia quem chamou — o remédio não pode virar a
+   * doença. Registrar um incidente jamais pode derrubar o fluxo que já estava
+   * degradado.
+   */
+  record(input: RecordIncidentInput): void {
+    void this.persist(input).catch((error) => {
+      const message = error instanceof Error ? error.message : String(error);
+      this.logger.warn(`Falha ao registrar incidente ${input.source}/${input.code}: ${message}`);
+    });
+  }
+
+  /** Versão aguardável, para quem precisa garantir a gravação (testes, jobs). */
+  async persist(input: RecordIncidentInput): Promise<void> {
+    const source = String(input.source ?? '').trim().slice(0, 120);
+    const code = String(input.code ?? '').trim().slice(0, 120);
+
+    if (!source || !code) return;
+
+    const fingerprint = createHash('sha256')
+      .update(`${source}|${code}|${input.key ?? ''}`)
+      .digest('hex');
+
+    const now = new Date();
+    const message = String(input.message ?? '').slice(0, MAX_MESSAGE_LENGTH);
+
+    // Lido antes do upsert só para saber se é novo ou reabertura — é o que
+    // decide se vale um aviso. Repetição pura não avisa.
+    const existing = await (this.prisma as any).system_incident.findUnique({
+      where: { fingerprint },
+      select: { id: true, resolved_at: true, notified_at: true },
+    });
+
+    const incident = await (this.prisma as any).system_incident.upsert({
+      where: { fingerprint },
+      // Repetição vira contador, não linha nova. `resolved_at: null` reabre um
+      // incidente que alguém já tinha dado como resolvido e voltou a acontecer.
+      update: {
+        occurrences: { increment: 1 },
+        last_seen_at: now,
+        message,
+        context: (input.context ?? undefined) as any,
+        severity: input.severity ?? 'error',
+        resolved_at: null,
+        resolved_by: null,
+        updated_at: now,
+      },
+      create: {
+        source,
+        code,
+        severity: input.severity ?? 'error',
+        message,
+        context: (input.context ?? undefined) as any,
+        fingerprint,
+        occurrences: 1,
+        first_seen_at: now,
+        last_seen_at: now,
+      },
+      select: { id: true, occurrences: true },
+    });
+
+    const reason = !existing ? 'created' : existing.resolved_at ? 'reopened' : null;
+
+    if (!reason) return;
+
+    await this.notifier.notify({
+      id: incident.id,
+      source,
+      code,
+      severity: input.severity ?? 'error',
+      message,
+      occurrences: incident.occurrences,
+      context: input.context ?? null,
+      notifiedAt: existing?.notified_at ?? null,
+      reason,
+    });
+  }
+
+  async list(params: IncidentListParams) {
+    const where: Record<string, unknown> = {};
+
+    if (params.source) where.source = params.source;
+    if (params.severity) where.severity = params.severity;
+
+    // Aberto é o default: a tela existe para mostrar o que precisa de ação.
+    if (params.status !== 'all') {
+      where.resolved_at = params.status === 'resolved' ? { not: null } : null;
+    }
+
+    if (params.search) {
+      where.OR = [
+        { message: { contains: params.search, mode: 'insensitive' } },
+        { code: { contains: params.search, mode: 'insensitive' } },
+        { source: { contains: params.search, mode: 'insensitive' } },
+      ];
+    }
+
+    return this.pagination.paginate(
+      (this.prisma as any).system_incident,
+      { ...params, fields: params.fields ?? '' },
+      { where, orderBy: { last_seen_at: 'desc' } },
+    );
+  }
+
+  /** Contadores da barra de KPI e das abas de filtro. */
+  async summary() {
+    const [open, resolved, bySeverity, bySource] = await Promise.all([
+      (this.prisma as any).system_incident.count({ where: { resolved_at: null } }),
+      (this.prisma as any).system_incident.count({ where: { resolved_at: { not: null } } }),
+      (this.prisma as any).system_incident.groupBy({
+        by: ['severity'],
+        where: { resolved_at: null },
+        _count: { _all: true },
+        _sum: { occurrences: true },
+      }),
+      (this.prisma as any).system_incident.groupBy({
+        by: ['source'],
+        where: { resolved_at: null },
+        _count: { _all: true },
+        orderBy: { _count: { source: 'desc' } },
+        take: 20,
+      }),
+    ]);
+
+    return {
+      open,
+      resolved,
+      bySeverity: bySeverity.map((row: any) => ({
+        severity: row.severity,
+        incidents: row._count._all,
+        occurrences: Number(row._sum?.occurrences ?? 0),
+      })),
+      bySource: bySource.map((row: any) => ({ source: row.source, incidents: row._count._all })),
+    };
+  }
+
+  async resolve(id: number, userId?: number) {
+    return (this.prisma as any).system_incident.update({
+      where: { id },
+      data: { resolved_at: new Date(), resolved_by: userId ?? null, updated_at: new Date() },
+    });
+  }
+
+  async reopen(id: number) {
+    return (this.prisma as any).system_incident.update({
+      where: { id },
+      data: { resolved_at: null, resolved_by: null, updated_at: new Date() },
+    });
+  }
+}

package/src/index.ts

@@ -5,6 +5,10 @@ export * from './core.module';
 export * from './auth/auth.service';
 export * from './auth/guards/auth.guard';
 
+// Captcha Module (shared by every public form: campaign signup, sac tickets, ...)
+export * from './captcha/captcha.module';
+export * from './captcha/captcha.service';
+
 // Menu Module
 export * from './menu/menu.service';
 
@@ -19,6 +23,13 @@ export * from './screen/screen.service';
 export * from './user/constants/user.constants';
 export * from './user/user.service';
 
+export * from './incident/incident.module';
+export * from './incident/incident.service';
+export * from './leaked-password/leaked-password.module';
+export * from './leaked-password/leaked-password.service';
+
+export * from './mail-layout/mail-layout.module';
+export * from './mail-layout/mail-layout.service';
 export * from './mail/mail.module';
 export * from './mail/mail.service';
 
@@ -27,26 +38,54 @@ export * from './integration-profile/integration-profile.service';
 export * from './integration-profile/integration-profile.utils';
 export * from './integration-profile/integration-profile.secrets';
 export * from './integration-profile/integration-credential-crypto.service';
+export * from './integration-profile/testers/integration-tester.types';
+export * from './integration-profile/testers/integration-tester.registry';
+
+export * from './whatsapp-sender/whatsapp-sender.module';
+export * from './whatsapp-sender/whatsapp-sender.service';
 
 export * from './file/file.module';
 export * from './file/file.service';
 
 export * from './pdf/pdf.module';
 export * from './pdf/pdf.service';
+export * from './setting/brand-asset.service';
 export * from './setting/setting.module';
 export * from './setting/setting.service';
 
 export * from './ai/ai.module';
 export * from './ai/ai.service';
 
+export * from './ai-instruction/ai-instruction.module';
+export * from './ai-instruction/ai-instruction.service';
+export * from './ai-instruction/ai-prompt-builder.service';
+export * from './ai-instruction/ai-prompt-registry';
+export * from './ai-instruction/ai-prompt-resolver.service';
+export * from './ai-instruction/ai-prompt-template.util';
+export * from './ai-instruction/types/ai-instruction.types';
+
 export * from './app-command/app-command.module';
 export * from './app-command/app-command.registry';
+export * from './mail-delivery/mail-delivery.constants';
+export * from './mail-delivery/mail-delivery-provision.service';
+export * from './mail-delivery/mail-delivery.module';
+export * from './mail-delivery/mail-delivery.service';
+export * from './mail-delivery/ses-event.parser';
+export * from './mail-delivery/ses-webhook.service';
+export * from './mail-delivery/sns-message.util';
 export * from './webhook-integration/event-webhook.service';
 export * from './webhook-integration/integration-event-catalog.service';
 export * from './webhook-integration/webhook-integration.module';
 export * from './webhook-integration/webhook-integration.service';
 export * from './webhook-integration/webhook-protocol.registry';
 
+// Meeting Module (porta genérica de reuniões online)
+export * from './mailbox/mailbox.module';
+export * from './mailbox/mailbox-fetcher.registry';
+export * from './meeting/meeting.constants';
+export * from './meeting/meeting.module';
+export * from './meeting/meeting-provider.registry';
+
 // Integration Module
 export * from './integration/integration.module';
 export * from './integration/services/domain-event.publisher';
@@ -74,8 +113,15 @@ export * from './mcp/mcp-registry.service';
 export * from './mcp/mcp.module';
 export * from './mcp/types/mcp-context.type';
 
+// OAuth Module
+export * from './oauth/oauth.module';
+export * from './oauth/oauth-token-broker.service';
+
 // Utilities
 export * from './utils/locale-context';
+export * from './utils/geo-ip';
+export * from './utils/user-agent';
+export * from './utils/security-event-vars';
 
 
 // Notification Module
@@ -83,3 +129,15 @@ export * from './notification/dto/create-notification.dto';
 export * from './notification/notification.module';
 export * from './notification/notification.service';
 
+// Realtime Module (generic WebSocket layer)
+export * from './realtime/realtime.module';
+export * from './realtime/realtime.service';
+export * from './realtime/realtime.gateway';
+
+// Presence Module
+export * from './presence/presence.module';
+export * from './presence/presence.service';
+
+// Observability
+export * from './observability/monitored-cron';
+

package/src/integration/services/outbox-polling.coordinator.spec.ts

@@ -0,0 +1,90 @@
+import { describe, it, expect, beforeEach, afterEach, jest } from '@jest/globals';
+import { OutboxPollingCoordinator } from './outbox-polling.coordinator';
+
+const makeSettings = (over: Partial<Record<string, any>> = {}) => ({
+  outboxEnabled: true,
+  outboxProcessorEnabled: true,
+  pollingIntervalMs: 1000,
+  idlePollingIntervalMs: 2000,
+  batchSize: 10,
+  startupDrainBatchSize: 50,
+  maxAttempts: 3,
+  processingLeaseMs: 30000,
+  retryBaseDelayMs: 1000,
+  deadLetterEnabled: true,
+  ...over,
+});
+
+const makeDeps = () => {
+  const processor = { processBatch: jest.fn<any>() };
+  const notifier = { subscribe: jest.fn(), unsubscribe: jest.fn() };
+  const integrationSettingsService = { getRuntimeSettings: jest.fn<any>() };
+  return { processor, notifier, integrationSettingsService };
+};
+
+describe('OutboxPollingCoordinator', () => {
+  beforeEach(() => {
+    jest.useFakeTimers();
+  });
+
+  afterEach(async () => {
+    jest.clearAllMocks();
+    jest.useRealTimers();
+  });
+
+  it('não deixa uma falha de uma iteração derrubar o loop (sem unhandled rejection)', async () => {
+    const deps = makeDeps();
+    deps.integrationSettingsService.getRuntimeSettings.mockResolvedValue(makeSettings());
+    deps.processor.processBatch
+      .mockRejectedValueOnce(
+        new Error('Transaction API error: Unable to start a transaction in the given time.'),
+      )
+      .mockResolvedValue(0);
+
+    const coordinator = new OutboxPollingCoordinator(
+      deps.processor as any,
+      deps.notifier as any,
+      deps.integrationSettingsService as any,
+    );
+
+    await coordinator.startProcessingLoop();
+
+    // 1st iteration throws -> caught, backs off ERROR_BACKOFF_MS (5000ms) instead of crashing
+    await jest.advanceTimersByTimeAsync(5000);
+
+    expect(deps.processor.processBatch).toHaveBeenCalledTimes(2);
+    // The loop must still be running — a caught iteration error must not stop/crash it
+    expect(coordinator.isRunning()).toBe(true);
+
+    // Ask it to stop (flips shouldStopLoop synchronously), then let the in-flight idle delay
+    // from the 2nd (successful) iteration resolve so the loop can observe the flag and exit
+    // cleanly, without running a 3rd iteration.
+    const stopPromise = coordinator.stopProcessingLoop();
+    await jest.advanceTimersByTimeAsync(2000);
+    await stopPromise;
+
+    expect(coordinator.isRunning()).toBe(false);
+    expect(deps.processor.processBatch).toHaveBeenCalledTimes(2);
+  });
+
+  it('não fica preso em "running" para sempre se o loop rejeitar de forma inesperada', async () => {
+    const deps = makeDeps();
+    // Simulate a failure before the inner try/catch can even run (e.g. notifier.subscribe throwing)
+    deps.notifier.subscribe.mockImplementation(() => {
+      throw new Error('boom');
+    });
+
+    const coordinator = new OutboxPollingCoordinator(
+      deps.processor as any,
+      deps.notifier as any,
+      deps.integrationSettingsService as any,
+    );
+
+    await coordinator.startProcessingLoop();
+    // Let the rejected promise's .catch() handler run
+    await Promise.resolve();
+    await Promise.resolve();
+
+    expect(coordinator.isRunning()).toBe(false);
+  });
+});

package/src/integration/services/outbox-polling.coordinator.ts

@@ -11,6 +11,8 @@ import { OutboxProcessor } from './outbox.processor';
 @Injectable()
 export class OutboxPollingCoordinator {
   private readonly logger = new Logger(OutboxPollingCoordinator.name);
+  /** Fallback backoff used when a loop iteration throws before settings can be trusted */
+  private static readonly ERROR_BACKOFF_MS = 5000;
   private processingLoopRunning = false;
   private processingLoopPromise: Promise<void> | null = null;
   private immediateWakeupTriggered = false;
@@ -38,7 +40,14 @@ export class OutboxPollingCoordinator {
     this.shouldStopLoop = false;
     this.logger.log('Starting outbox hybrid processing loop');
 
-    this.processingLoopPromise = this.runProcessingLoop();
+    // Defense-in-depth: runProcessingLoop() catches errors internally and should never reject,
+    // but if it somehow does, don't let it become an unhandled rejection (which kills the pod —
+    // see Sentry.onUnhandledRejectionIntegration({ mode: 'strict' }) in apps/api/src/instrument.ts)
+    // and don't leave the flag stuck as "running" with no way to recover.
+    this.processingLoopPromise = this.runProcessingLoop().catch((error) => {
+      this.logger.error('[outbox:loop] processing loop crashed unexpectedly', error);
+      this.processingLoopRunning = false;
+    });
   }
 
   /**
@@ -94,47 +103,60 @@ export class OutboxPollingCoordinator {
 
     try {
       while (!this.shouldStopLoop) {
-        const settings = await this.integrationSettingsService.getRuntimeSettings();
-        const isEnabled = settings.outboxEnabled;
-        const processorEnabled = settings.outboxProcessorEnabled;
-
-        if (!isEnabled || !processorEnabled) {
-          this.logger.debug(
-            `[outbox:loop] processor disabled (outboxEnabled=${isEnabled} processorEnabled=${processorEnabled}), sleeping ${settings.idlePollingIntervalMs}ms`,
-          );
-          await this.delay(settings.idlePollingIntervalMs);
-          continue;
-        }
-
-        // Check if we should process immediately (woken by notification)
-        const shouldProcessImmediately = this.immediateWakeupTriggered;
-        this.immediateWakeupTriggered = false;
-
-        // Process batch
-        const processedCount = await this.processor.processBatch();
-
-        // Determine next polling interval
-        let nextDelayMs: number;
-
-        if (shouldProcessImmediately && processedCount > 0) {
-          // We processed items from immediate wakeup - use active polling interval
-          nextDelayMs = settings.pollingIntervalMs;
-          this.logger.debug(
-            `Processed ${processedCount} events from immediate wakeup, next poll in ${nextDelayMs}ms`,
+        try {
+          const settings = await this.integrationSettingsService.getRuntimeSettings();
+          const isEnabled = settings.outboxEnabled;
+          const processorEnabled = settings.outboxProcessorEnabled;
+
+          if (!isEnabled || !processorEnabled) {
+            this.logger.debug(
+              `[outbox:loop] processor disabled (outboxEnabled=${isEnabled} processorEnabled=${processorEnabled}), sleeping ${settings.idlePollingIntervalMs}ms`,
+            );
+            await this.delay(settings.idlePollingIntervalMs);
+            continue;
+          }
+
+          // Check if we should process immediately (woken by notification)
+          const shouldProcessImmediately = this.immediateWakeupTriggered;
+          this.immediateWakeupTriggered = false;
+
+          // Process batch
+          const processedCount = await this.processor.processBatch();
+
+          // Determine next polling interval
+          let nextDelayMs: number;
+
+          if (shouldProcessImmediately && processedCount > 0) {
+            // We processed items from immediate wakeup - use active polling interval
+            nextDelayMs = settings.pollingIntervalMs;
+            this.logger.debug(
+              `Processed ${processedCount} events from immediate wakeup, next poll in ${nextDelayMs}ms`,
+            );
+          } else if (processedCount > 0) {
+            // Processed items from periodic polling - use active interval
+            nextDelayMs = settings.pollingIntervalMs;
+            this.logger.debug(
+              `Processed ${processedCount} events, next poll in ${nextDelayMs}ms`,
+            );
+          } else {
+            // No items processed - use idle interval
+            nextDelayMs = settings.idlePollingIntervalMs;
+          }
+
+          // Wait for next poll, but be ready for immediate wakeup
+          await this.delay(nextDelayMs);
+        } catch (error) {
+          // A single iteration failing (e.g. a transient DB/transaction error) must never escape
+          // the loop — that would reject processingLoopPromise as an unhandled rejection and, per
+          // Sentry's strict unhandled-rejection mode, take down the whole pod. Log, back off, and
+          // keep polling instead. Don't trust `settings` here — the error may have come from
+          // fetching it — so use a fixed fallback delay.
+          this.logger.error(
+            '[outbox:loop] iteration failed, backing off before retrying',
+            error,
           );
-        } else if (processedCount > 0) {
-          // Processed items from periodic polling - use active interval
-          nextDelayMs = settings.pollingIntervalMs;
-          this.logger.debug(
-            `Processed ${processedCount} events, next poll in ${nextDelayMs}ms`,
-          );
-        } else {
-          // No items processed - use idle interval
-          nextDelayMs = settings.idlePollingIntervalMs;
+          await this.delay(OutboxPollingCoordinator.ERROR_BACKOFF_MS);
         }
-
-        // Wait for next poll, but be ready for immediate wakeup
-        await this.delay(nextDelayMs);
       }
     } finally {
       // Cleanup: unsubscribe from notifications

package/src/integration/services/outbox.service.spec.ts

@@ -156,6 +156,10 @@ describe('OutboxService', () => {
 
       expect(result).toEqual([]);
       expect(tx.$executeRaw).not.toHaveBeenCalled();
+      expect(deps.prisma.$transaction).toHaveBeenCalledWith(
+        expect.any(Function),
+        { maxWait: 5000, timeout: 5000 },
+      );
     });
 
     it('bloqueia linhas encontradas e marca como PROCESSING', async () => {
@@ -173,6 +177,10 @@ describe('OutboxService', () => {
       expect(result).toHaveLength(2);
       expect(result[0].status).toBe(OutboxEventStatus.PROCESSING);
       expect(result[1].status).toBe(OutboxEventStatus.PROCESSING);
+      expect(deps.prisma.$transaction).toHaveBeenCalledWith(
+        expect.any(Function),
+        { maxWait: 5000, timeout: 5000 },
+      );
     });
   });
 

package/src/integration/services/outbox.service.ts

@@ -114,8 +114,9 @@ export class OutboxService {
     const leaseThreshold = new Date(now.getTime() - leaseMs);
     const leaseUntil = new Date(now.getTime() + leaseMs);
 
-    return this.prisma.$transaction(async (tx) => {
-      const rows = await tx.$queryRaw<OutboxEventRecord[]>`
+    return this.prisma.$transaction(
+      async (tx) => {
+        const rows = await tx.$queryRaw<OutboxEventRecord[]>`
         SELECT * FROM outbox_event
         WHERE status = 'pending'::"outbox_event_status_e5d55ba10d_enum"
            OR (status = 'processing'::"outbox_event_status_e5d55ba10d_enum"
@@ -125,10 +126,10 @@ export class OutboxService {
         FOR UPDATE SKIP LOCKED
       `;
 
-      if (rows.length === 0) return [];
+        if (rows.length === 0) return [];
 
-      const ids = rows.map((r) => r.id);
-      await tx.$executeRaw`
+        const ids = rows.map((r) => r.id);
+        await tx.$executeRaw`
         UPDATE outbox_event
         SET status = 'processing'::"outbox_event_status_e5d55ba10d_enum",
             available_at = ${leaseUntil},
@@ -136,14 +137,19 @@ export class OutboxService {
         WHERE id = ANY(${ids}::int[])
       `;
 
-      return rows.map((r) =>
-        this.toDomainEvent({
-          ...r,
-          status: OutboxEventStatus.PROCESSING,
-          available_at: leaseUntil,
-        }),
-      );
-    });
+        return rows.map((r) =>
+          this.toDomainEvent({
+            ...r,
+            status: OutboxEventStatus.PROCESSING,
+            available_at: leaseUntil,
+          }),
+        );
+      },
+      // Default maxWait (2s) is too tight when the pool is briefly under contention from other
+      // long-lived transactions elsewhere in the app; give this short, index-backed query a bit
+      // more slack to acquire a connection before giving up.
+      { maxWait: 5000, timeout: 5000 },
+    );
   }
 
   /**

package/src/integration-profile/dto/test.dto.ts

@@ -0,0 +1,19 @@
+import { Type } from 'class-transformer';
+import { IsInt, IsOptional, Min } from 'class-validator';
+import { CreateDTO } from './create.dto';
+
+export class TestDTO extends CreateDTO {
+  /**
+   * Perfil ao qual estas credenciais pertencem, quando o teste parte da edição.
+   *
+   * Sem ele o perfil armazenado só pode ser encontrado pelo `slug` — e o slug é
+   * editável: quem renomeia o perfil e testa antes de salvar não casa com nenhuma
+   * linha, então os segredos mascarados não são herdados e o teste roda com
+   * "********" no lugar da senha. Opcional para não quebrar quem já chama a rota.
+   */
+  @IsOptional()
+  @IsInt()
+  @Min(1)
+  @Type(() => Number)
+  profile_id?: number;
+}

package/src/integration-profile/integration-profile.controller.ts

@@ -14,14 +14,17 @@ import {
   Query,
   Res,
   UploadedFile,
+  UseGuards,
   UseInterceptors,
   forwardRef,
 } from '@nestjs/common';
 import { FileInterceptor } from '@nestjs/platform-express';
+import { Throttle, ThrottlerGuard } from '@nestjs/throttler';
 import { Response } from 'express';
 import { CreateDTO } from './dto/create.dto';
 import { ExportDTO } from './dto/export.dto';
 import { ImportConfirmDTO } from './dto/import-confirm.dto';
+import { TestDTO } from './dto/test.dto';
 import { UpdateDTO } from './dto/update.dto';
 import { IntegrationProfileService } from './integration-profile.service';
 
@@ -99,8 +102,14 @@ export class IntegrationProfileController {
     return this.integrationProfileService.create(data);
   }
 
+  /**
+   * Dispara chamadas HTTP de saída para o endereço do provider, então tem taxa
+   * limitada — o ThrottlerGuard não é global neste projeto.
+   */
+  @UseGuards(ThrottlerGuard)
+  @Throttle({ default: { limit: 10, ttl: 60_000 } })
   @Post('test')
-  async test(@Body() data: CreateDTO) {
+  async test(@Body() data: TestDTO) {
     return this.integrationProfileService.test(data);
   }