@hed-hog/core 0.0.399 → 0.0.400

package/src/message-template/message-template.service.spec.ts

@@ -0,0 +1,149 @@
+import {
+  clearMessageTemplateRegistry,
+  registerMessageTemplates,
+} from './message-template.registry';
+import { MessageTemplateService } from './message-template.service';
+
+/**
+ * O que estes testes protegem: o aviso nunca depender do texto editado dar certo.
+ *
+ * Portados do SAC, onde a regra era "todo caminho ruim devolve null e o chamador
+ * usa o texto embutido". Aqui a regra ficou mais forte: todo caminho ruim cai no
+ * `fallback` do registry, e o chamador não precisa mais manter texto nenhum.
+ */
+describe('MessageTemplateService', () => {
+  let prisma: any;
+  let service: MessageTemplateService;
+
+  const SLUG = 'demo.aviso';
+  const PADRAO = 'Padrão: {{protocol}}';
+
+  const linha = (body: string, overrides: Record<string, unknown> = {}) => ({
+    is_active: true,
+    message_template_locale: [{ body, locale: { code: 'pt' } }],
+    ...overrides,
+  });
+
+  beforeEach(() => {
+    clearMessageTemplateRegistry();
+    registerMessageTemplates([
+      {
+        slug: SLUG,
+        moduleSlug: 'demo',
+        name: { pt: 'Aviso' },
+        fallback: { pt: PADRAO, en: 'Default: {{protocol}}' },
+        variables: { protocol: { sample: '202609-000045' } },
+      },
+    ]);
+
+    prisma = { message_template: { findUnique: jest.fn().mockResolvedValue(null) } };
+    service = new MessageTemplateService(prisma);
+  });
+
+  it('renderiza o texto editado quando existe', async () => {
+    prisma.message_template.findUnique.mockResolvedValue(
+      linha('Chamado {{protocol}} de {{requester_name}}'),
+    );
+
+    await expect(
+      service.render(SLUG, {
+        protocol: '202609-000045',
+        requester_name: 'João Rangel',
+      }),
+    ).resolves.toBe('Chamado 202609-000045 de João Rangel');
+  });
+
+  it('não escapa o texto, que vai puro para o WhatsApp', async () => {
+    // Com escape de HTML um apóstrofo viraria `&#x27;` na tela do celular.
+    prisma.message_template.findUnique.mockResolvedValue(linha('{{nome}}'));
+
+    await expect(service.render(SLUG, { nome: "Joao D'Avila" })).resolves.toBe(
+      "Joao D'Avila",
+    );
+  });
+
+  it('esconde a seção quando o campo vem vazio', async () => {
+    prisma.message_template.findUnique.mockResolvedValue(
+      linha('A\n{{#if contact}}\nContato: {{contact}}\n{{/if}}\nB'),
+    );
+
+    await expect(service.render(SLUG, { contact: '' })).resolves.toBe('A\nB');
+  });
+
+  describe('cai no texto padrão quando o editado não serve', () => {
+    const esperado = 'Padrão: 202609-000045';
+    const variaveis = { protocol: '202609-000045' };
+
+    it('não há linha no banco — o caso comum, antes de alguém editar', async () => {
+      prisma.message_template.findUnique.mockResolvedValue(null);
+      await expect(service.render(SLUG, variaveis)).resolves.toBe(esperado);
+    });
+
+    it('a linha está desligada', async () => {
+      prisma.message_template.findUnique.mockResolvedValue(
+        linha('Editado', { is_active: false }),
+      );
+      await expect(service.render(SLUG, variaveis)).resolves.toBe(esperado);
+    });
+
+    it('o corpo editado está em branco', async () => {
+      prisma.message_template.findUnique.mockResolvedValue(linha('   '));
+      await expect(service.render(SLUG, variaveis)).resolves.toBe(esperado);
+    });
+
+    it('o corpo editado tem sintaxe quebrada', async () => {
+      prisma.message_template.findUnique.mockResolvedValue(
+        linha('{{#if contact}}sem fechar'),
+      );
+      await expect(service.render(SLUG, variaveis)).resolves.toBe(esperado);
+    });
+
+    it('o corpo editado renderiza vazio', async () => {
+      // Template só com blocos que não casaram. Mandar mensagem em branco para o
+      // grupo é pior que mandar o texto padrão.
+      prisma.message_template.findUnique.mockResolvedValue(
+        linha('{{#if nada}}oi{{/if}}'),
+      );
+      await expect(service.render(SLUG, variaveis)).resolves.toBe(esperado);
+    });
+
+    it('o banco está fora do ar', async () => {
+      prisma.message_template.findUnique.mockRejectedValue(new Error('sem conexão'));
+      await expect(service.render(SLUG, variaveis)).resolves.toBe(esperado);
+    });
+  });
+
+  it('sem tradução no idioma pedido, usa a primeira que existir', async () => {
+    // Um texto escrito só em português continua valendo para quem abriu o painel
+    // em inglês; o contrário seria a equipe receber o padrão por causa do idioma
+    // da sessão.
+    prisma.message_template.findUnique.mockResolvedValue(
+      linha('Só em português'),
+    );
+
+    await expect(service.render(SLUG, {}, 'en')).resolves.toBe('Só em português');
+  });
+
+  it('sem texto padrão no idioma pedido, usa o português', async () => {
+    clearMessageTemplateRegistry();
+    registerMessageTemplates([
+      {
+        slug: SLUG,
+        moduleSlug: 'demo',
+        name: { pt: 'Aviso' },
+        fallback: { pt: PADRAO },
+        variables: {},
+      },
+    ]);
+
+    await expect(service.render(SLUG, { protocol: 'X' }, 'en')).resolves.toBe(
+      'Padrão: X',
+    );
+  });
+
+  it('devolve null só quando o slug não está registrado', async () => {
+    // Nulo aqui é erro de programação — slug digitado errado, library não
+    // carregada —, não configuração. Por isso é o único caso.
+    await expect(service.render('demo.inexistente', {})).resolves.toBeNull();
+  });
+});

package/src/message-template/message-template.service.ts

@@ -0,0 +1,149 @@
+import { PrismaService } from '@hed-hog/api-prisma';
+import { Inject, Injectable, Logger, forwardRef } from '@nestjs/common';
+import * as Handlebars from 'handlebars';
+
+import {
+  MessageTemplateDefinition,
+  getMessageTemplateDefinition,
+} from './message-template.registry';
+
+/**
+ * Idioma em que a plataforma escreve para a própria equipe.
+ *
+ * O aviso interno não é mensagem ao cliente: quem lê é quem trabalha aqui, e o
+ * fato gerador pode ter chegado em qualquer idioma. Por isso o corpo sai no
+ * idioma do painel, e não no de quem comprou ou abriu o chamado.
+ */
+export const DEFAULT_MESSAGE_LOCALE = 'pt';
+
+/**
+ * Renderiza o texto das mensagens que saem por canal que não é e-mail.
+ *
+ * O corpo é texto puro com o markdown do WhatsApp, e não HTML: não dá para
+ * reusar o `MailService`, cujo render troca quebra de linha por `<br/>` — o que
+ * no WhatsApp apareceria literal na tela.
+ *
+ * **Nunca devolve nulo para um slug registrado.** Linha ausente, `is_active`
+ * desligado, corpo em branco, sintaxe quebrada ou banco fora do ar caem no texto
+ * canônico do registry. Isso é o que permite ao chamador parar de manter um
+ * construtor de texto em código só como rede: a rede é o `fallback`.
+ */
+@Injectable()
+export class MessageTemplateService {
+  private readonly logger = new Logger(MessageTemplateService.name);
+
+  constructor(
+    @Inject(forwardRef(() => PrismaService))
+    private readonly prisma: PrismaService,
+  ) {}
+
+  /**
+   * O texto pronto, ou `null` quando o slug não está registrado.
+   *
+   * Nulo aqui é erro de programação (slug digitado errado, library não
+   * carregada), não configuração — daí ser o único caso.
+   */
+  async render(
+    slug: string,
+    variables: Record<string, unknown>,
+    locale = DEFAULT_MESSAGE_LOCALE,
+  ): Promise<string | null> {
+    const definition = getMessageTemplateDefinition(slug);
+
+    if (!definition) {
+      this.logger.error(
+        `Modelo de mensagem "${slug}" não está registrado; nada a renderizar.`,
+      );
+      return null;
+    }
+
+    const edited = await this.readEditedBody(slug, locale);
+
+    if (edited) {
+      const rendered = MessageTemplateService.compile(edited, variables);
+      if (rendered) return rendered;
+
+      // Texto editado que não compila ou renderiza vazio não pode calar o aviso.
+      this.logger.warn(
+        `O texto editado do modelo "${slug}" não pôde ser usado; caindo no padrão.`,
+      );
+    }
+
+    return MessageTemplateService.renderFallback(definition, variables, locale);
+  }
+
+  /**
+   * Renderiza o texto canônico do registry.
+   *
+   * Estático e público porque o teste que varre o registry inteiro o usa para
+   * afirmar que todo modelo registrado compila com as suas amostras — é ele que
+   * substitui a manutenção do texto em dois lugares.
+   */
+  static renderFallback(
+    definition: MessageTemplateDefinition,
+    variables: Record<string, unknown>,
+    locale = DEFAULT_MESSAGE_LOCALE,
+  ): string | null {
+    const body =
+      definition.fallback[locale] ?? definition.fallback[DEFAULT_MESSAGE_LOCALE];
+
+    return body ? MessageTemplateService.compile(body, variables) : null;
+  }
+
+  /**
+   * Compila e renderiza, ou `null` em qualquer desfecho ruim.
+   *
+   * `noEscape` de propósito: escapar encheria o WhatsApp de `&#x27;`. Template
+   * preenchido só com blocos que não casaram renderiza vazio, e mandar mensagem
+   * em branco para o grupo é pior que mandar o texto padrão.
+   */
+  private static compile(
+    body: string,
+    variables: Record<string, unknown>,
+  ): string | null {
+    try {
+      const rendered = Handlebars.compile(body, { noEscape: true })(variables).trim();
+      return rendered || null;
+    } catch {
+      return null;
+    }
+  }
+
+  /**
+   * O corpo editado no painel, ou `null` quando não há nada utilizável.
+   *
+   * Sem linha no idioma pedido, usa a primeira que existir: um texto escrito só
+   * em português continua valendo para quem abriu o painel em inglês — o
+   * contrário seria a equipe receber o padrão por causa do idioma da sessão.
+   */
+  private async readEditedBody(
+    slug: string,
+    locale: string,
+  ): Promise<string | null> {
+    try {
+      const template = await (this.prisma as any).message_template.findUnique({
+        where: { slug },
+        select: {
+          is_active: true,
+          message_template_locale: {
+            select: { body: true, locale: { select: { code: true } } },
+          },
+        },
+      });
+
+      if (!template?.is_active) return null;
+
+      const rows = template.message_template_locale ?? [];
+      const match = rows.find((row: any) => row.locale?.code === locale) ?? rows[0];
+
+      return String(match?.body ?? '').trim() || null;
+    } catch (error) {
+      this.logger.warn(
+        `Não foi possível ler o modelo "${slug}": ${
+          (error as Error)?.message ?? 'erro desconhecido'
+        }`,
+      );
+      return null;
+    }
+  }
+}

package/src/notification/notification.constants.ts

@@ -0,0 +1,10 @@
+/**
+ * Nome do evento de notificação no WebSocket (`/realtime`).
+ *
+ * Segue a convenção `dominio:evento` dos outros produtores (`presence:update`,
+ * `lms:waiting-room:tick`). O payload é o mesmo `NotificationStreamEvent` que o
+ * SSE já entrega — os dois transportes convivem por tempo indeterminado (o
+ * class-app publicado nas lojas só fala SSE), e transporte que carrega dado
+ * diferente faz o comportamento do cliente depender de qual dos dois está vivo.
+ */
+export const NOTIFICATION_REALTIME_EVENT = 'notification:event';

package/src/notification/notification.module.ts

@@ -1,6 +1,7 @@
 import { PaginationModule } from '@hed-hog/api-pagination';
 import { PrismaModule } from '@hed-hog/api-prisma';
 import { forwardRef, Module } from '@nestjs/common';
+import { RealtimeModule } from '../realtime/realtime.module';
 import { NotificationController } from './notification.controller';
 import { NotificationService } from './notification.service';
 
@@ -8,6 +9,8 @@ import { NotificationService } from './notification.service';
   imports: [
     forwardRef(() => PrismaModule),
     forwardRef(() => PaginationModule),
+    // O funil de eventos empurra a notificação pelo WebSocket além do SSE.
+    forwardRef(() => RealtimeModule),
   ],
   controllers: [NotificationController],
   providers: [NotificationService],

package/src/notification/notification.service.spec.ts

@@ -4,6 +4,7 @@ import {
   ForbiddenException,
   NotFoundException,
 } from '@nestjs/common';
+import { NOTIFICATION_REALTIME_EVENT } from './notification.constants';
 import { NotificationService } from './notification.service';
 
 const makeDeps = () => {
@@ -22,7 +23,8 @@ const makeDeps = () => {
   };
   const pagination = { paginate: jest.fn().mockResolvedValue({ data: [] }) };
   const eventEmitter = { emitAsync: jest.fn().mockResolvedValue([]) };
-  return { prisma, pagination, eventEmitter };
+  const realtime = { emitToUser: jest.fn() };
+  return { prisma, pagination, eventEmitter, realtime };
 };
 
 const makeService = (deps = makeDeps()) => ({
@@ -30,6 +32,7 @@ const makeService = (deps = makeDeps()) => ({
     deps.prisma as any,
     deps.pagination as any,
     deps.eventEmitter as any,
+    deps.realtime as any,
   ),
   deps,
 });
@@ -240,6 +243,77 @@ describe('NotificationService', () => {
       });
       expect(received).toHaveLength(1);
     });
+
+    // Os dois transportes convivem: o SSE (EventEmitter + pg_notify) ainda
+    // serve o class-app publicado, e o socket serve os apps web. Este teste
+    // trava a coexistência — derrubar um dos três é o jeito mais fácil de
+    // quebrar notificação em produção sem nenhum erro aparecer.
+    it('entrega nos três canais: local, socket e pg_notify', async () => {
+      const { service, deps } = makeService();
+      const received: any[] = [];
+      (service as any).notificationEvents.on('notification:7', (e: any) =>
+        received.push(e),
+      );
+      const event = { type: 'notification.created', notificationId: 3 };
+
+      await (service as any).broadcastNotificationEvent(7, event);
+
+      expect(received).toEqual([event]);
+      expect(deps.realtime.emitToUser).toHaveBeenCalledWith(
+        7,
+        NOTIFICATION_REALTIME_EVENT,
+        event,
+      );
+      expect(deps.prisma.$executeRaw).toHaveBeenCalled();
+    });
+
+    it('emit do socket falhando não impede o pg_notify', async () => {
+      const { service, deps } = makeService();
+      deps.realtime.emitToUser.mockImplementation(() => {
+        throw new Error('socket down');
+      });
+
+      await expect(
+        (service as any).broadcastNotificationEvent(7, {
+          type: 'notification.updated',
+        }),
+      ).resolves.toBeUndefined();
+      expect(deps.prisma.$executeRaw).toHaveBeenCalled();
+    });
+  });
+
+  describe('notifyRewardGranted', () => {
+    it('emite sinal sem payload para o usuário', async () => {
+      const { service } = makeService();
+      const received: any[] = [];
+      (service as any).notificationEvents.on('notification:9', (e: any) =>
+        received.push(e),
+      );
+
+      await service.notifyRewardGranted(9);
+
+      // Só o tipo: a recompensa mora em `lms_student_reward`, e quem ouve refaz
+      // o GET da própria fila. Mandar o conteúdo aqui abriria caminho para
+      // comemorar duas vezes entre a web e o app.
+      expect(received).toEqual([{ type: 'reward.granted' }]);
+    });
+
+    it('atravessa o cluster pelo pg_notify', async () => {
+      const { service, deps } = makeService();
+
+      await service.notifyRewardGranted(9);
+
+      // O desbloqueio acontece no worker de fila, um processo separado de quem
+      // segura a conexão SSE — sem esta publicação o aviso morria no pod errado.
+      expect(deps.prisma.$executeRaw).toHaveBeenCalled();
+    });
+
+    it('não derruba o chamador quando o broadcast falha', async () => {
+      const { service, deps } = makeService();
+      deps.prisma.$executeRaw.mockRejectedValue(new Error('down'));
+
+      await expect(service.notifyRewardGranted(9)).resolves.toBeUndefined();
+    });
   });
 
   describe('handleClusterNotification', () => {

package/src/notification/notification.service.ts

@@ -16,8 +16,10 @@ import type { Request, Response } from 'express';
 import { randomUUID } from 'node:crypto';
 import { EventEmitter } from 'node:events';
 import { Client, type Notification as PgNotification } from 'pg';
+import { RealtimeService } from '../realtime/realtime.service';
 import { CreateNotificationDto } from './dto/create-notification.dto';
 import { UpdateProgressDto } from './dto/update-progress.dto';
+import { NOTIFICATION_REALTIME_EVENT } from './notification.constants';
 import {
     NOTIFICATION_STALE_PROGRESS_CHECK,
     NotificationStaleProgressCheckEvent,
@@ -26,7 +28,11 @@ import {
 type NotificationStreamEventType =
   | 'ready'
   | 'notification.created'
-  | 'notification.updated';
+  | 'notification.updated'
+  // Sinal de "acorda e busca", sem relação com a lista de notificações: quem
+  // ouve refaz o GET da própria fila. Anda por aqui porque este é o único
+  // stream que os apps do aluno já mantêm aberto e que alcança todos os pods.
+  | 'reward.granted';
 
 type NotificationStreamEvent = {
   type: NotificationStreamEventType;
@@ -53,6 +59,8 @@ export class NotificationService implements OnModuleInit, OnModuleDestroy {
     @Inject(forwardRef(() => PaginationService))
     private readonly pagination: PaginationService,
     private readonly eventEmitter: EventEmitter2,
+    @Inject(forwardRef(() => RealtimeService))
+    private readonly realtime: RealtimeService,
   ) {
     this.notificationEvents.setMaxListeners(0);
   }
@@ -122,6 +130,19 @@ export class NotificationService implements OnModuleInit, OnModuleDestroy {
     await this.broadcastNotificationEvent(userId, { type: 'notification.updated' });
   }
 
+  /**
+   * Avisa que o usuário ganhou uma recompensa de gamificação, para o cliente
+   * buscar a fila dele.
+   *
+   * Sem payload de propósito: a recompensa mora em `lms_student_reward` com o
+   * `seen_at` como fonte da verdade — mandar o conteúdo aqui abriria caminho
+   * para comemorar duas vezes entre a web e o app, e engordaria o `pg_notify`,
+   * cujo teto de 8000 bytes falha calado (ver `broadcastNotificationEvent`).
+   */
+  async notifyRewardGranted(userId: number) {
+    await this.broadcastNotificationEvent(userId, { type: 'reward.granted' });
+  }
+
   async unreadCount(userId: number) {
     const count = await this.prisma.notification.count({
       where: { user_id: userId, status: 'unread' },
@@ -330,6 +351,23 @@ export class NotificationService implements OnModuleInit, OnModuleDestroy {
   ) {
     this.emitLocalNotificationEvent(userId, event);
 
+    // WebSocket, antes do `pg_notify` abaixo: o emit é síncrono e o
+    // `$executeRaw` é aguardado, então empurrar primeiro tira o socket da
+    // latência do Postgres. Vai por `emitToUser` — a sala `user:{id}` só é
+    // entrada com o `sub` do JWT verificado, e o `subscribe` do gateway monta
+    // salas com o prefixo literal `channel:`, então ela não é assinável de
+    // fora. É o que torna seguro mandar a notificação inteira aqui; por
+    // `emitToChannel` o título e o corpo vazariam para qualquer conta.
+    //
+    // O try/catch existe porque este é o primeiro call-site de `emitToUser` em
+    // produção: um throw derrubaria `create`, `markRead` e o resto do funil, e
+    // a entrega pelo SSE (acima) já aconteceu.
+    try {
+      this.realtime.emitToUser(userId, NOTIFICATION_REALTIME_EVENT, event);
+    } catch (error) {
+      this.logger.warn('Failed to push notification over realtime', error as any);
+    }
+
     const payload: ClusterNotificationPayload = {
       ...event,
       userId,

package/src/oauth/oauth.controller.ts

@@ -290,7 +290,6 @@ export class OAuthController {
       state,
       type: 'login',
       redirectUri,
-      includeRefreshTokenInBody: Boolean(redirectUri),
       requestOrigin: origin,
       requestReferer: referer,
     });

package/src/oauth/oauth.errors.ts

@@ -11,6 +11,13 @@ export class OAuthProviderException extends Error {
     public readonly status?: number,
     public readonly providerError?: string,
     public readonly providerErrorCode?: string,
+    /**
+     * Erro original do provider (tipicamente um AxiosError). Declarado como
+     * propriedade em vez de `super(message, { cause })` porque a library compila
+     * com `lib: es2021`, onde `ErrorOptions` ainda não existe — o que importa é a
+     * propriedade em runtime, que é o que o `linkedErrors` do Sentry encadeia.
+     */
+    public readonly cause?: unknown,
   ) {
     super(message);
     this.name = 'OAuthProviderException';

package/src/oauth/oauth.module.ts

@@ -23,7 +23,12 @@ import { MicrosoftProvider } from './providers/microsoft.provider';
 
 @Module({
   imports: [
-    forwardRef(() => HttpModule),
+    // O default do axios é `timeout: 0` — espera indefinidamente. Como a troca do
+    // código roda dentro da transação de 60s do OAuthCallbackCoordinatorService,
+    // uma conexão pendurada com o provider prendia uma conexão do pool até a
+    // transação estourar. 10s é folgado para um endpoint de token e falha como
+    // ECONNABORTED, que o mapProviderError classifica.
+    HttpModule.register({ timeout: 10_000, maxRedirects: 5 }),
     forwardRef(() => PrismaModule),
     forwardRef(() => MailSendModule),
     forwardRef(() => ConfigModule),

package/src/oauth/oauth.service.spec.ts

@@ -224,15 +224,13 @@ describe('OAuthService', () => {
       service = makeService().service;
     });
 
-    it('inclui refresh quando solicitado', () => {
-      expect((service as any).formatAuthResponse('a', 'r', true)).toEqual({
-        accessToken: 'a',
-        refreshToken: 'r',
-      });
-    });
-    it('omite refresh por padrão', () => {
+    // O corpo carrega o par em TODO fluxo, web inclusive: o Class fala com a API
+    // por rewrite same-origin e nunca chega a ter o cookie `rt`, então omitir o
+    // refresh token aqui deixava o aluno sem nada para renovar.
+    it('inclui o refresh token', () => {
       expect((service as any).formatAuthResponse('a', 'r')).toEqual({
         accessToken: 'a',
+        refreshToken: 'r',
       });
     });
   });
@@ -288,6 +286,59 @@ describe('OAuthService', () => {
     it('mapeia erro genérico para ServiceUnavailable', () => {
       expect(map(new Error('boom'))).toBeInstanceOf(ServiceUnavailableException);
     });
+
+    // O frontend precisa reconhecer "código já usado" sem depender do idioma da
+    // mensagem — o match por substring só funcionava em inglês.
+    it.each([
+      ['callback_consumed', 'callback_consumed'],
+      ['invalid_callback', 'invalid_callback'],
+    ])('expõe oauthReason=%s no corpo do 400', (reason, expected) => {
+      const error = map(
+        new OAuthProviderException('google', reason as any, 'msg'),
+      ) as BadRequestException;
+
+      expect((error.getResponse() as any).oauthReason).toBe(expected);
+    });
+
+    it('expõe oauthReason=already_processed no callback repetido', () => {
+      const error = map(new OAuthCallbackAlreadyProcessedError()) as BadRequestException;
+
+      expect((error.getResponse() as any).oauthReason).toBe('already_processed');
+    });
+
+    it('mantém o envelope do 400 (statusCode/message/error)', () => {
+      const error = map(
+        new OAuthProviderException('google', 'invalid_callback', 'msg'),
+      ) as BadRequestException;
+      const body = error.getResponse() as any;
+
+      expect(body.statusCode).toBe(400);
+      expect(body.error).toBe('Bad Request');
+      expect(typeof body.message).toBe('string');
+    });
+
+    // Sem a causa encadeada o evento no Sentry chega sem status, sem corpo do
+    // provider e com o stack enraizado no próprio mapCallbackError.
+    it('preserva o erro original como cause nos dois ramos de 503', () => {
+      const generic = new Error('boom');
+      expect(map(generic).cause).toBe(generic);
+
+      const upstream = new OAuthProviderException('google', 'upstream_failure', 'msg', 500);
+      expect(map(upstream).cause).toBe(upstream);
+    });
+
+    // O Nest só aplica a description default quando o segundo argumento é ausente
+    // ou string, então passar `{ cause }` sozinho zeraria o campo `error`.
+    it.each([
+      ['genérico', new Error('boom')],
+      ['upstream', new OAuthProviderException('google', 'upstream_failure', 'msg', 500)],
+    ])('mantém o envelope do 503 no ramo %s', (_label, input) => {
+      const body = (map(input) as ServiceUnavailableException).getResponse() as any;
+
+      expect(body.statusCode).toBe(503);
+      expect(body.error).toBe('Service Unavailable');
+      expect(typeof body.message).toBe('string');
+    });
   });
 
   describe('consumeMobileState', () => {