@hed-hog/core 0.0.399 → 0.0.401

package/src/meeting/meeting-provider.registry.ts

@@ -1,4 +1,5 @@
 import { Injectable, Logger } from '@nestjs/common';
+import { MeetingChatMessage } from './meeting.constants';
 
 /**
  * Pedido de criação de uma reunião online para uma entidade de negócio qualquer.
@@ -25,6 +26,12 @@ export interface CreateMeetingInput {
    * participante comum.
    */
   coOrganizerUserIds?: number[];
+  /**
+   * E-mails/UPNs adicionais do Entra ID a coorganizar, além dos resolvidos por
+   * {@link coOrganizerUserIds}. Resolvidos pelo provedor — quem não existir no
+   * diretório é apenas ignorado, nunca falha a criação da reunião.
+   */
+  coOrganizerEmails?: string[];
   /** Convidados do evento de calendário. */
   attendeeEmails?: string[];
   /** Local do evento (aula presencial/híbrida com reunião gerenciada). */
@@ -77,6 +84,40 @@ export interface UpdateMeetingDetailsInput {
   description?: string | null;
 }
 
+/**
+ * Pedido de troca dos coorganizadores extras de uma reunião já existente.
+ *
+ * Separado de `createMeeting` pelo mesmo motivo de `updateAttendees`: corrigir
+ * a reunião de uma aula que já foi criada não pode gerar link novo. Só cobre
+ * os coorganizadores extras (por e-mail) — o coorganizador derivado do
+ * instrutor não é tocado por este caminho.
+ */
+export interface UpdateMeetingCoOrganizersInput {
+  sourceModule: string;
+  sourceEntity: string;
+  sourceEntityId: string;
+  coOrganizerEmails: string[];
+}
+
+/**
+ * Estado da tarefa que traz a gravação do provedor para o storage local.
+ *
+ * Descrito em termos genéricos de propósito: a origem precisa saber se a
+ * importação está andando, travou ou vai retentar, mas não pode depender de
+ * como o provedor a executa. Hoje é um job da fila do módulo Microsoft; num
+ * provedor com webhook não haveria job nenhum, e o contrato continua valendo.
+ */
+export interface MeetingRecordingImport {
+  status: 'pending' | 'running' | 'done' | 'failed';
+  attempts: number;
+  maxAttempts: number;
+  lastError: string | null;
+  startedAt: Date | null;
+  finishedAt: Date | null;
+  /** Quando a próxima tentativa acontece, se houver uma agendada. */
+  nextRetryAt: Date | null;
+}
+
 /**
  * Estado de uma reunião, na forma em que o módulo de origem precisa ver.
  *
@@ -107,6 +148,12 @@ export interface MeetingSummary {
    * acompanha a turma.
    */
   attendeeEmails: string[];
+  /**
+   * Coorganizadores extras (por e-mail) atualmente aplicados na reunião, para
+   * o módulo de origem comparar antes de mandar atualizar — mesmo motivo de
+   * `attendeeEmails`. Não inclui o coorganizador derivado do instrutor.
+   */
+  coOrganizerEmails: string[];
   /** Estado da importação da gravação, quando `autoRecord` está ligado. */
   recordingStatus:
     | 'not_requested'
@@ -116,6 +163,115 @@ export interface MeetingSummary {
     | 'failed';
   recordingFileId: number | null;
   lastError: string | null;
+  /**
+   * Quando o provedor procurou a gravação pela última vez, e quantas vezes já
+   * procurou.
+   *
+   * Existe para a origem distinguir "ainda não deu tempo" de "está procurando e
+   * não acha": os dois são `recordingStatus: 'pending'`, e sem isto a tela do
+   * módulo de origem só pode dizer "aguardando", que é a mesma frase por horas.
+   */
+  recordingCheckedAt: Date | null;
+  recordingAttempts: number;
+  recordingImportedAt: Date | null;
+  /**
+   * Janela em que o provedor procura a gravação, já resolvida em instantes.
+   *
+   * Derivada aqui, e não na origem, porque a carência antes da primeira busca e
+   * a largura da janela são conhecimento do provedor — o LMS não deve saber que
+   * o Teams leva 15 minutos para publicar nem que a busca desiste em 48 h.
+   * `null` quando não há gravação pedida ou o provedor não expõe a janela.
+   */
+  recordingSearchStartsAt: Date | null;
+  recordingSearchExpiresAt: Date | null;
+  /**
+   * Andamento do download da gravação, quando o provedor já o iniciou.
+   *
+   * Vem do provedor e não da origem porque só ele sabe como importa — a
+   * alternativa seria o módulo de origem vasculhar a fila de outro módulo por
+   * `source_entity`, que é exatamente o acoplamento que este contrato evita.
+   */
+  recordingImport: MeetingRecordingImport | null;
+}
+
+/**
+ * Pedido do conteúdo de um anexo do chat de uma reunião.
+ *
+ * A origem repassa os identificadores que recebeu no evento do chat; traduzi-los
+ * em chamadas ao provedor é problema de quem implementa.
+ */
+export interface FetchMeetingChatAttachmentInput {
+  sourceModule: string;
+  sourceEntity: string;
+  sourceEntityId: string;
+  providerMessageId: string;
+  providerAttachmentId: string;
+  /** O que veio no evento; alguns provedores só sabem baixar por ele. */
+  contentUrl?: string | null;
+  /** Acima disso o provedor desiste antes de transferir. */
+  maxBytes?: number;
+}
+
+export interface MeetingChatAttachmentContent {
+  buffer: Buffer;
+  filename: string;
+  mimetype: string;
+  size: number;
+}
+
+/**
+ * Pedido de publicação de uma mensagem no chat da reunião de uma origem.
+ *
+ * O corpo é HTML simples — `<p>`, `<br>`, `<strong>`, `<a href>` — e não texto
+ * puro porque o que motiva este contrato é mandar um link clicável para dentro
+ * da reunião. Provedor que não renderize HTML degrada tirando as tags; o texto
+ * continua legível.
+ */
+export interface PostMeetingChatMessageInput {
+  sourceModule: string;
+  sourceEntity: string;
+  sourceEntityId: string;
+  html: string;
+}
+
+/**
+ * Desfecho da publicação, sem exceção.
+ *
+ * Postar no chat é conveniência, não o caminho crítico: quem chama tem sempre o
+ * plano B de mostrar o texto para alguém colar à mão. Transformar "o tenant
+ * desligou o chat da reunião" em exceção obrigaria toda tela a tratar erro para
+ * uma situação que é normal.
+ */
+export type PostMeetingChatFailure =
+  /** Não há identidade/configuração para escrever. */
+  | 'unavailable'
+  /** A reunião não tem chat (ninguém entrou, ou o tenant o desligou). */
+  | 'no_chat'
+  /** Falta consentimento do escopo de envio na conta que escreve. */
+  | 'missing_scope'
+  /** O provedor recusou por outro motivo. */
+  | 'failed';
+
+/**
+ * Um objeto com campos opcionais, e não uma união discriminada, porque o
+ * monorepo compila com `strictNullChecks: false` — e sem essa flag o
+ * TypeScript não estreita a união pelo `ok`, obrigando todo consumidor a um
+ * cast. Melhor um contrato que funciona do que um mais elegante que ninguém
+ * consegue usar sem contorno.
+ *
+ * `ok: true` traz `providerMessageId`; `ok: false` traz `reason` e `message`.
+ */
+export interface PostMeetingChatMessageResult {
+  ok: boolean;
+  providerMessageId?: string | null;
+  reason?: PostMeetingChatFailure;
+  message?: string;
+}
+
+export interface ListMeetingChatMessagesInput {
+  sourceModule: string;
+  sourceEntity: string;
+  sourceEntityId: string;
 }
 
 /**
@@ -146,8 +302,53 @@ export interface IMeetingProvider {
    * link novo. Tolerante a reunião inexistente (mesmo padrão de updateAttendees).
    */
   updateDetails(input: UpdateMeetingDetailsInput): Promise<void>;
+  /**
+   * Troca os coorganizadores extras de uma reunião já criada, sem gerar link
+   * novo. Tolerante a reunião inexistente (mesmo padrão de updateAttendees).
+   */
+  updateCoOrganizers(input: UpdateMeetingCoOrganizersInput): Promise<void>;
   /** Estado das reuniões das origens informadas, para a UI do módulo de origem. */
   findBySource(ref: MeetingSourceRef): Promise<MeetingSummary[]>;
+  /**
+   * Baixa o conteúdo de um anexo do chat da reunião.
+   *
+   * Opcional de propósito: o chat é o terceiro artefato pós-reunião e nem todo
+   * provedor o expõe. Quem chama testa a existência do método antes — assim um
+   * provedor mais antigo continua válido sem alteração.
+   *
+   * Devolve `null` quando o anexo não pôde ser lido (permissão do arquivo,
+   * item removido, tamanho acima do teto). Não é erro: o arquivo do anexo mora
+   * no drive de quem o enviou, não na caixa que organizou a reunião, então
+   * negativa é desfecho esperado e a origem precisa de um plano B em vez de uma
+   * exceção.
+   */
+  fetchChatAttachment?(
+    input: FetchMeetingChatAttachmentInput,
+  ): Promise<MeetingChatAttachmentContent | null>;
+  /**
+   * Publica uma mensagem no chat da reunião.
+   *
+   * Opcional pelo mesmo motivo de {@link fetchChatAttachment}, e nunca lança:
+   * o desfecho vem no retorno.
+   */
+  postChatMessage?(
+    input: PostMeetingChatMessageInput,
+  ): Promise<PostMeetingChatMessageResult>;
+  /**
+   * As mensagens do chat que o provedor já capturou para esta origem.
+   *
+   * Existe porque o evento `MEETING_CHAT_AVAILABLE_EVENT` tem teto de mensagens
+   * e, quando estoura, entrega as mais RECENTES. Isso serve para achar o
+   * material que o instrutor colou no fim da aula, e não serve para uma turma
+   * de 250 pessoas em que cada uma escreve: as primeiras somem do payload.
+   *
+   * Lê o que o provedor já guardou, sem ida nova ao serviço remoto — é a
+   * alternativa a fazer o módulo de origem ler a tabela do provedor, que é
+   * exatamente o acoplamento que este contrato existe para evitar.
+   */
+  listChatMessages?(
+    input: ListMeetingChatMessagesInput,
+  ): Promise<MeetingChatMessage[]>;
 }
 
 /**

package/src/meeting/meeting.constants.ts

@@ -51,3 +51,77 @@ export interface MeetingAttendanceAvailablePayload {
   providerMeetingId?: string | null;
   records: MeetingAttendanceRecord[];
 }
+
+/**
+ * Evento publicado quando o chat de uma reunião foi capturado.
+ *
+ * Terceiro do mesmo desenho, depois de gravação e presença, e pela mesma razão:
+ * o provedor sabe o que foi escrito no chat, mas não sabe o que é uma aula; o
+ * módulo de origem sabe quem é o instrutor, mas não conhece o Graph.
+ */
+export const MEETING_CHAT_AVAILABLE_EVENT = 'microsoft.meeting.chat.available';
+
+/** Arquivo ou imagem que acompanha uma mensagem do chat. */
+export interface MeetingChatAttachment {
+  providerAttachmentId: string;
+  /**
+   * `attachment` é arquivo compartilhado na conversa; `hosted_content` é imagem
+   * colada no corpo da mensagem. A origem costuma querer só o primeiro — print
+   * de tela raramente é material de aula.
+   */
+  kind: 'attachment' | 'hosted_content';
+  name: string | null;
+  contentType: string | null;
+  /**
+   * Endereço do arquivo no provedor. Não é baixável sem token: serve de rastro
+   * e é o que a origem devolve ao provedor para pedir o conteúdo.
+   */
+  contentUrl: string | null;
+}
+
+/** Uma mensagem do chat, na forma em que a origem precisa ver. */
+export interface MeetingChatMessage {
+  providerMessageId: string;
+  /** Mensagem à qual esta responde, quando houver. */
+  replyToId: string | null;
+  /**
+   * Nulo quando o provedor não identificou quem escreveu (convidado anônimo,
+   * aplicativo, ou evento de sistema). A origem decide o que fazer — e quando a
+   * decisão publica conteúdo para terceiros, o certo é descartar: casar por
+   * nome confundiria homônimos.
+   */
+  senderEmail: string | null;
+  senderDisplayName: string;
+  /** ISO-8601. */
+  sentAt: string;
+  /** `message`, `systemEventMessage`, … — como o provedor classificou. */
+  messageType: string;
+  /**
+   * Texto puro, nunca HTML.
+   *
+   * O payload é persistido como jsonb no outbox, e o HTML do Teams é gordo o
+   * bastante para que uma aula inteira não caiba. Quem precisar do original lê
+   * a tabela do provedor.
+   */
+  text: string;
+  attachments: MeetingChatAttachment[];
+}
+
+export interface MeetingChatAvailablePayload {
+  sourceModule: string;
+  sourceEntity: string;
+  sourceEntityId: string;
+  providerMeetingId?: string | null;
+  providerChatId?: string | null;
+  /** Quantas mensagens o chat tem de verdade, mesmo se `messages` foi cortado. */
+  messageCount: number;
+  firstMessageAt: string | null;
+  lastMessageAt: string | null;
+  /** Mensagens em ordem cronológica, limitadas ao teto do evento. */
+  messages: MeetingChatMessage[];
+  /**
+   * `messages` não traz tudo: o chat passou do teto do evento ou da paginação
+   * do provedor. `messageCount` continua sendo o número real.
+   */
+  truncated: boolean;
+}

package/src/menu/menu.service.spec.ts

@@ -74,3 +74,92 @@ describe('MenuService.ensureValidParent', () => {
     await expect(call('en', 5, 10)).rejects.toThrow(BadRequestException);
   });
 });
+
+describe('MenuService.getMenus', () => {
+  let prisma: any;
+  let service: MenuService;
+
+  const row = (id: number, menuId: number | null, name: string) => ({
+    id,
+    menu_id: menuId,
+    order: id,
+    menu_locale: [{ name }],
+  });
+
+  beforeEach(() => {
+    prisma = {
+      user: { count: jest.fn<any>().mockResolvedValue(1) },
+      menu: { findMany: jest.fn<any>().mockResolvedValue([]) },
+    };
+    service = makeService(prisma);
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('lança BadRequestException quando o usuário não existe', async () => {
+    prisma.user.count.mockResolvedValue(0);
+    await expect(service.getMenus('en', 42)).rejects.toThrow(BadRequestException);
+    expect(prisma.menu.findMany).not.toHaveBeenCalled();
+  });
+
+  it('monta a árvore inteira com uma única consulta', async () => {
+    prisma.menu.findMany.mockResolvedValue([
+      row(1, null, 'LMS'),
+      row(2, 1, 'Cursos'),
+      row(3, 2, 'Estrutura'),
+      row(4, null, 'CRM'),
+    ]);
+
+    const tree = await service.getMenus('en', 42);
+
+    // O ponto da correção: uma query para tudo, não uma por nó.
+    expect(prisma.menu.findMany).toHaveBeenCalledTimes(1);
+    expect(prisma.user.count).toHaveBeenCalledTimes(1);
+
+    expect(tree.map((m: any) => m.id)).toEqual([1, 4]);
+    expect(tree[0].name).toBe('LMS');
+    expect(tree[0].menu.map((m: any) => m.id)).toEqual([2]);
+    expect(tree[0].menu[0].menu.map((m: any) => m.id)).toEqual([3]);
+    expect(tree[1].menu).toEqual([]);
+  });
+
+  it('não promove a raiz um menu cujo pai o usuário não acessa', async () => {
+    // O pai (10) não veio do banco porque o usuário não tem o papel dele; o
+    // filho não pode aparecer solto na raiz por causa disso.
+    prisma.menu.findMany.mockResolvedValue([
+      row(1, null, 'LMS'),
+      row(11, 10, 'Filho de menu inacessível'),
+    ]);
+
+    const tree = await service.getMenus('en', 42);
+
+    expect(tree.map((m: any) => m.id)).toEqual([1]);
+  });
+
+  it('respeita a ordem dos irmãos vinda da consulta', async () => {
+    prisma.menu.findMany.mockResolvedValue([
+      row(7, 1, 'Segundo'),
+      row(1, null, 'Raiz'),
+      row(5, 1, 'Primeiro'),
+    ]);
+
+    const tree = await service.getMenus('en', 42);
+
+    expect(tree[0].menu.map((m: any) => m.id)).toEqual([7, 5]);
+  });
+
+  it('retorna apenas a subárvore quando um menuId é informado', async () => {
+    prisma.menu.findMany.mockResolvedValue([
+      row(1, null, 'LMS'),
+      row(2, 1, 'Cursos'),
+      row(3, 2, 'Estrutura'),
+    ]);
+
+    const tree = await service.getMenus('en', 42, 1);
+
+    expect(tree.map((m: any) => m.id)).toEqual([2]);
+    expect(tree[0].menu.map((m: any) => m.id)).toEqual([3]);
+  });
+});

package/src/menu/menu.service.ts

@@ -258,7 +258,6 @@ export class MenuService {
   }
 
   async getMenus(locale: string, userId: number, menuId = 0) {
-
     const userExists = await this.prismaService.user.count({
       where: {
         id: userId,
@@ -271,13 +270,13 @@ export class MenuService {
       );
     }
 
-    if (menuId === 0) {
-      menuId = null;
-    }
-
-    let menu = (await this.prismaService.menu.findMany({
+    // Uma consulta para a árvore inteira, em vez de uma por nó. A versão
+    // recursiva anterior repetia esta busca — e o `user.count` acima — a cada
+    // nível: com os ~260 itens de menu que as libraries registram, eram
+    // centenas de idas ao banco em série e o `/menu/system` levava ~2s a cada
+    // navegação do admin, mesmo quando a resposta terminava em 304.
+    const rows = (await this.prismaService.menu.findMany({
       where: {
-        menu_id: menuId,
         role_menu: {
           some: {
             role: {
@@ -307,13 +306,32 @@ export class MenuService {
       },
     })) as unknown[] as any[];
 
-    menu = menu.map((m) => itemTranslations('menu_locale', m));
+    const childrenByParent = new Map<number | null, any[]>();
+
+    for (const row of rows) {
+      const item = itemTranslations('menu_locale', row) as any;
+      const parentId = item.menu_id ?? null;
+      const siblings = childrenByParent.get(parentId);
 
-    for (let i = 0; i < menu.length; i++) {
-      menu[i].menu = await this.getMenus(locale, userId, menu[i].id);
+      if (siblings) siblings.push(item);
+      else childrenByParent.set(parentId, [item]);
     }
 
-    return menu;
+    // Descer apenas pelos filhos presentes no resultado preserva a regra
+    // anterior: um menu cujo pai o usuário não acessa continua invisível, em
+    // vez de subir para a raiz. Os irmãos já vêm ordenados por `order` da
+    // consulta, e o agrupamento acima mantém essa ordem.
+    const buildTree = (parentId: number | null): any[] => {
+      const children = childrenByParent.get(parentId) ?? [];
+
+      for (const child of children) {
+        child.menu = buildTree(child.id);
+      }
+
+      return children;
+    };
+
+    return buildTree(menuId === 0 ? null : menuId);
   }
 
   async getSystemMenu(locale: string, userId: number) {

package/src/message-template/dto/update-message-template.dto.ts

@@ -0,0 +1,22 @@
+import { IsBoolean, IsObject, IsOptional } from 'class-validator';
+
+/**
+ * Corpo aceito pela edição de um modelo de mensagem.
+ *
+ * `slug` fica de fora de propósito: quem procura o modelo é o código, e
+ * renomeá-lo pelo painel desligaria o aviso em silêncio. O que se edita aqui é o
+ * texto.
+ *
+ * `name` e `description` também não entram: eles moram no registry, declarados
+ * pela library dona do modelo. Deixar editá-los aqui criaria um rótulo que
+ * diverge do que o código diz — e a tela não teria como saber qual vale.
+ */
+export class UpdateMessageTemplateDTO {
+  @IsOptional()
+  @IsBoolean()
+  is_active?: boolean;
+
+  @IsOptional()
+  @IsObject()
+  locale?: Record<string, { body?: string }>;
+}

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

@@ -0,0 +1,163 @@
+import { BadRequestException, NotFoundException } from '@nestjs/common';
+
+import { MessageTemplateAdminService } from './message-template-admin.service';
+import {
+  clearMessageTemplateRegistry,
+  registerMessageTemplates,
+} from './message-template.registry';
+
+/**
+ * O CRUD da tela, que no SAC não tinha cobertura nenhuma.
+ *
+ * O que estes testes protegem é o desenho: a listagem vem do REGISTRY e o banco
+ * entra por cima. Um modelo recém-declarado por uma library precisa aparecer
+ * antes de existir linha no banco — senão volta a dor dos prompts de IA, em que
+ * prompt sem seed simplesmente não aparece.
+ */
+describe('MessageTemplateAdminService', () => {
+  let prisma: any;
+  let service: MessageTemplateAdminService;
+
+  const SLUG = 'demo.aviso';
+
+  beforeEach(() => {
+    clearMessageTemplateRegistry();
+    registerMessageTemplates([
+      {
+        slug: SLUG,
+        moduleSlug: 'demo',
+        name: { pt: 'Aviso' },
+        description: { pt: 'Sai quando algo acontece.' },
+        fallback: { pt: 'Padrão {{protocol}}', en: 'Default {{protocol}}' },
+        variables: { protocol: { sample: '202609-000045' } },
+      },
+      {
+        slug: 'outro.aviso',
+        moduleSlug: 'outro',
+        name: { pt: 'Outro' },
+        fallback: { pt: 'Outro padrão' },
+        variables: {},
+      },
+    ]);
+
+    prisma = {
+      message_template: {
+        findMany: jest.fn().mockResolvedValue([]),
+        findUnique: jest.fn().mockResolvedValue(null),
+        upsert: jest.fn().mockResolvedValue({ id: 7, slug: SLUG }),
+        delete: jest.fn().mockResolvedValue({}),
+      },
+      message_template_locale: { upsert: jest.fn().mockResolvedValue({}) },
+      locale: { findFirst: jest.fn().mockResolvedValue({ id: 1 }) },
+    };
+
+    service = new MessageTemplateAdminService(prisma);
+  });
+
+  describe('list', () => {
+    it('mostra o modelo antes de existir linha no banco', async () => {
+      const { data } = await service.list();
+
+      expect(data).toHaveLength(2);
+      const item = data.find((d) => d.slug === SLUG)!;
+      expect(item.customized).toBe(false);
+      expect(item.is_active).toBe(true);
+      expect(item.body.pt).toBe('Padrão {{protocol}}');
+    });
+
+    it('o texto editado vence o padrão, por idioma', async () => {
+      prisma.message_template.findMany.mockResolvedValue([
+        {
+          slug: SLUG,
+          is_active: true,
+          message_template_locale: [
+            { body: 'Editado {{protocol}}', locale: { code: 'pt' } },
+          ],
+        },
+      ]);
+
+      const { data } = await service.list();
+      const item = data.find((d) => d.slug === SLUG)!;
+
+      expect(item.customized).toBe(true);
+      expect(item.body.pt).toBe('Editado {{protocol}}');
+      // O inglês não foi editado: segue o padrão do código.
+      expect(item.body.en).toBe('Default {{protocol}}');
+      // E o padrão continua exposto, para a tela poder restaurar.
+      expect(item.fallback.pt).toBe('Padrão {{protocol}}');
+    });
+
+    it('filtra por módulo, para o agrupamento da tela', async () => {
+      const { data } = await service.list('outro');
+      expect(data.map((d) => d.slug)).toEqual(['outro.aviso']);
+    });
+  });
+
+  describe('update', () => {
+    it('cria a linha na primeira edição', async () => {
+      await service.update(SLUG, { locale: { pt: { body: 'Novo {{protocol}}' } } });
+
+      expect(prisma.message_template.upsert).toHaveBeenCalledWith(
+        expect.objectContaining({ where: { slug: SLUG } }),
+      );
+      expect(prisma.message_template_locale.upsert).toHaveBeenCalled();
+    });
+
+    it('recusa corpo com sintaxe quebrada antes de gravar', async () => {
+      // Aceitar deixaria a tela dizendo "salvo" enquanto o aviso sai com o texto
+      // padrão, sem explicação nenhuma.
+      await expect(
+        service.update(SLUG, { locale: { pt: { body: '{{#if x}}sem fechar' } } }),
+      ).rejects.toThrow(BadRequestException);
+
+      expect(prisma.message_template.upsert).not.toHaveBeenCalled();
+    });
+
+    it('não mexe em is_active quando o corpo não o menciona', async () => {
+      await service.update(SLUG, { locale: { pt: { body: 'ok' } } });
+
+      expect(prisma.message_template.upsert).toHaveBeenCalledWith(
+        expect.objectContaining({ update: {} }),
+      );
+    });
+
+    it('recusa slug que nenhuma library registrou', async () => {
+      await expect(service.update('demo.fantasma', {})).rejects.toThrow(
+        NotFoundException,
+      );
+    });
+  });
+
+  describe('restore', () => {
+    it('apaga a linha em vez de copiar o padrão para dentro dela', async () => {
+      // Copiar congelaria o texto na versão de hoje, e a próxima melhoria que
+      // viesse por deploy não chegaria a quem restaurou.
+      await service.restore(SLUG);
+
+      expect(prisma.message_template.delete).toHaveBeenCalledWith({
+        where: { slug: SLUG },
+      });
+    });
+
+    it('restaurar um modelo que nunca foi editado não é erro', async () => {
+      prisma.message_template.delete.mockRejectedValue(new Error('não existe'));
+      await expect(service.restore(SLUG)).resolves.toBeDefined();
+    });
+  });
+
+  describe('preview', () => {
+    it('renderiza com as amostras declaradas pelo registry', () => {
+      expect(service.preview(SLUG, 'Chamado {{protocol}}')).toEqual({
+        text: 'Chamado 202609-000045',
+      });
+    });
+
+    it('recusa sintaxe quebrada', () => {
+      expect(() => service.preview(SLUG, '{{#if x}}')).toThrow(BadRequestException);
+    });
+  });
+
+  it('modules lista os módulos que declararam algum modelo', () => {
+    expect(service.modules()).toEqual({ data: ['demo', 'outro'] });
+  });
+});