@hed-hog/core 0.0.387 → 0.0.393

package/src/mail/mail.controller.ts

@@ -1,6 +1,5 @@
 import { DeleteDTO, Role } from '@hed-hog/api';
 import { Locale } from '@hed-hog/api-locale';
-import { renderMailTemplate } from '@hed-hog/api-mail';
 import { Pagination } from '@hed-hog/api-pagination';
 import {
     Body,
@@ -20,6 +19,7 @@ import {
 import { Response } from 'express';
 import { CreateDTO } from './dto/create.dto';
 import { ImportDTO } from './dto/import.dto';
+import { PreviewDTO } from './dto/preview.dto';
 import { TestMailDTO } from './dto/test-mail.dto';
 import { UpdateDTO } from './dto/update.dto';
 import { MailService } from './mail.service';
@@ -57,7 +57,9 @@ export class MailController {
   ) {
     const locale = queryLocale || decoratorLocale;
     const mail = await this.mailService.get(locale, id);
-    const html = renderMailTemplate({
+    // Passa pelo preview para que o arquivo baixado use o mesmo layout base do
+    // envio real, e nao uma segunda renderizacao que diverge com o tempo.
+    const { html } = await this.mailService.preview(locale, {
       subject: mail.subject,
       body: mail.body,
     });
@@ -66,6 +68,11 @@ export class MailController {
     res.send(html);
   }
 
+  @Post('preview')
+  async preview(@Locale() decoratorLocale: string, @Body() data: PreviewDTO, @Query('locale') queryLocale?: string) {
+    return this.mailService.preview(queryLocale || decoratorLocale, data);
+  }
+
   @Post()
   async create(@Body() data: CreateDTO) {
     return this.mailService.create(data);

package/src/mail/mail.module.ts

@@ -3,6 +3,7 @@ import { MailModule as MailMainModule, MailModuleOptions } from '@hed-hog/api-ma
 import { PaginationModule } from '@hed-hog/api-pagination';
 import { PrismaModule, PrismaService } from '@hed-hog/api-prisma';
 import { forwardRef, Module } from '@nestjs/common';
+import { ConfigModule } from '@nestjs/config';
 import { MailSentModule } from '../mail-sent/mail-sent.module';
 import { SettingModule } from '../setting/setting.module';
 import { MailController } from './mail.controller';
@@ -95,6 +96,7 @@ import { MailService } from './mail.service';
     forwardRef(() => PaginationModule),
     forwardRef(() => LocaleModule),
     forwardRef(() => SettingModule),
+    ConfigModule,
   ],
   controllers: [MailController],
   providers: [MailService],

package/src/mail/mail.service.spec.ts

@@ -6,6 +6,7 @@ import {
   afterEach,
   jest,
 } from '@jest/globals';
+import { renderMailTemplate } from '@hed-hog/api-mail';
 import { BadRequestException } from '@nestjs/common';
 import { MailService } from './mail.service';
 
@@ -22,13 +23,32 @@ const makeDeps = () => {
       createMany: jest.fn(),
       findMany: jest.fn(),
     },
-    locale: { findMany: jest.fn() },
+    locale: { findMany: jest.fn(), findUnique: jest.fn() },
+    user_identifier: { findFirst: jest.fn(async () => null) },
+  };
+  const mailMainService = {
+    send: jest.fn(),
+    setConfig: jest.fn(),
+    getBrandName: jest.fn(async () => 'HedHog'),
+    invalidateLayoutCache: jest.fn(),
   };
-  const mailMainService = { send: jest.fn(), setConfig: jest.fn() };
   const localeService = {};
-  const setting = { getSettingValues: jest.fn(), setValue: jest.fn() };
+  const setting = {
+    getSettingValues: jest.fn(),
+    setValue: jest.fn(),
+    getUserSettingValue: jest.fn(async () => null),
+    getSettingListValues: jest.fn(async () => ['en', 'pt']),
+    // A cadeia de precedencia em si é testada em setting.service.spec.ts.
+    resolveUserLocale: jest.fn(async () => 'en'),
+  };
   const integrationApi = { subscribe: jest.fn() };
-  return { prismaService, mailMainService, localeService, setting, integrationApi };
+  const incident = { record: jest.fn(), persist: jest.fn() };
+  const brandAsset = {
+    resolveAssetUrl: jest.fn(async (value: string) =>
+      value?.startsWith('/') ? `https://hub.hcode.com.br${value}` : value,
+    ),
+  };
+  return { prismaService, mailMainService, localeService, setting, integrationApi, incident, brandAsset };
 };
 
 const makeService = (deps = makeDeps()) => ({
@@ -38,6 +58,8 @@ const makeService = (deps = makeDeps()) => ({
     deps.localeService as any,
     deps.setting as any,
     deps.integrationApi as any,
+    deps.incident as any,
+    deps.brandAsset as any,
   ),
   deps,
 });
@@ -239,7 +261,10 @@ describe('MailService', () => {
   });
 
   describe('sendTemplatedMail', () => {
-    it('aborta silenciosamente quando mail não configurado', async () => {
+    // Continua sem lançar (há call sites sem await que quebrariam), mas o
+    // retorno agora diz que nada saiu: era isso que faltava para a fila do SAC
+    // distinguir enviado de engolido.
+    it('não lança quando mail não configurado, e devolve sent=false', async () => {
       const { service, deps } = makeService();
       deps.setting.getSettingValues.mockResolvedValue({
         'configured-mail': 'false',
@@ -250,8 +275,399 @@ describe('MailService', () => {
           slug: 's',
           variables: {},
         } as any),
-      ).resolves.toBeUndefined();
+      ).resolves.toEqual({ sent: false, reason: 'mail-not-configured' });
       expect(deps.mailMainService.send).not.toHaveBeenCalled();
     });
+
+    it('devolve sent=false quando o provedor falha, sem propagar a exceção', async () => {
+      const { service, deps } = makeService();
+      deps.setting.getSettingValues.mockResolvedValue({
+        'configured-mail': 'true',
+      });
+      jest
+        .spyOn(service, 'reloadConfig')
+        .mockRejectedValue(new Error('SES unreachable'));
+
+      await expect(
+        service.sendTemplatedMail('en', {
+          email: 'a@b.com',
+          slug: 's',
+          variables: {},
+        } as any),
+      ).resolves.toEqual({
+        sent: false,
+        reason: 'send-failed',
+        error: 'SES unreachable',
+      });
+      expect(deps.mailMainService.send).not.toHaveBeenCalled();
+    });
+
+    it('devolve o id do provedor quando o envio funciona', async () => {
+      const { service, deps } = makeService();
+      deps.setting.getSettingValues.mockResolvedValue({
+        'configured-mail': 'true',
+      } as any);
+      jest
+        .spyOn(service, 'reloadConfig')
+        .mockResolvedValue({ success: true, provider: 'ses', from: 'a@b.com', config: {} });
+      deps.prismaService.locale.findUnique.mockResolvedValue({ id: 1, code: 'en' });
+      deps.prismaService.mail.findUnique.mockResolvedValue({
+        id: 7,
+        mail_locale: [
+          { subject: 'Oi {{name}}', body: 'Corpo', locale: { code: 'en' } },
+        ],
+        mail_var: [],
+      });
+      deps.mailMainService.send.mockResolvedValue({
+        result: { MessageId: 'ses-abc' },
+      });
+
+      await expect(
+        service.sendTemplatedMail('en', {
+          email: 'a@b.com',
+          slug: 's',
+          variables: { name: 'João' },
+        } as any),
+      ).resolves.toEqual({ sent: true, providerMessageId: 'ses-abc' });
+    });
+
+    // O bug que originou esta mudanca: o e-mail saia no idioma do header (ou no
+    // `en` de quem nao manda header), ignorando a preferencia do destinatario.
+    describe('idioma do destinatario', () => {
+      const arrange = (deps: any) => {
+        deps.setting.getSettingValues.mockResolvedValue({
+          'configured-mail': 'true',
+          language: 'en',
+        } as any);
+        deps.prismaService.mail.findUnique.mockResolvedValue({
+          id: 7,
+          mail_locale: [
+            { subject: 'Hello', body: 'Body', locale: { code: 'en' } },
+            { subject: 'Olá', body: 'Corpo', locale: { code: 'pt' } },
+          ],
+          mail_var: [],
+        });
+        deps.mailMainService.send.mockResolvedValue({ result: { MessageId: 'x' } });
+      };
+
+      const send = (service: any, locale: string) =>
+        service.sendTemplatedMail(locale, {
+          email: 'a@b.com',
+          slug: 's',
+          variables: {},
+        } as any);
+
+      it('resolve o idioma pelo destinatario, nao pelo locale do chamador', async () => {
+        const { service, deps } = makeService();
+        arrange(deps);
+        jest.spyOn(service, 'reloadConfig').mockResolvedValue({
+          success: true, provider: 'ses', from: 'a@b.com', config: {},
+        });
+        deps.prismaService.user_identifier.findFirst.mockResolvedValue({ user_id: 42 });
+        deps.setting.resolveUserLocale.mockResolvedValue('pt');
+
+        await send(service, 'en');
+
+        expect(deps.setting.resolveUserLocale).toHaveBeenCalledWith(42);
+        expect(deps.mailMainService.send).toHaveBeenCalledWith(
+          expect.objectContaining({ subject: 'Olá', body: 'Corpo', locale: 'pt' }),
+        );
+      });
+
+      // Envio de fila/cron nao tem requisicao, entao a cadeia do SettingService
+      // nao tem contexto de onde tirar idioma: sobra o que o chamador informou.
+      it('usa o locale do chamador quando nao ha nada melhor', async () => {
+        const { service, deps } = makeService();
+        arrange(deps);
+        jest.spyOn(service, 'reloadConfig').mockResolvedValue({
+          success: true, provider: 'ses', from: 'a@b.com', config: {},
+        });
+        deps.prismaService.user_identifier.findFirst.mockResolvedValue(null);
+        deps.setting.resolveUserLocale.mockResolvedValue('en');
+
+        await send(service, 'pt');
+
+        expect(deps.mailMainService.send).toHaveBeenCalledWith(
+          expect.objectContaining({ subject: 'Olá', locale: 'pt' }),
+        );
+      });
+
+      // Regressao do commerce: 8 call sites passavam 'pt-BR', a tabela `locale`
+      // so tem code de 2 letras e o envio morria silenciosamente.
+      it('aceita tag regional do chamador e envia', async () => {
+        const { service, deps } = makeService();
+        arrange(deps);
+        jest.spyOn(service, 'reloadConfig').mockResolvedValue({
+          success: true, provider: 'ses', from: 'a@b.com', config: {},
+        });
+        deps.prismaService.user_identifier.findFirst.mockResolvedValue(null);
+        deps.setting.getSettingValues.mockResolvedValue({
+          'configured-mail': 'true',
+        } as any);
+
+        await expect(send(service, 'pt-BR')).resolves.toEqual({
+          sent: true,
+          providerMessageId: 'x',
+        });
+        expect(deps.mailMainService.send).toHaveBeenCalledWith(
+          expect.objectContaining({ locale: 'pt' }),
+        );
+      });
+
+      it('usa a traducao disponivel quando o idioma pedido nao existe', async () => {
+        const { service, deps } = makeService();
+        arrange(deps);
+        jest.spyOn(service, 'reloadConfig').mockResolvedValue({
+          success: true, provider: 'ses', from: 'a@b.com', config: {},
+        });
+        deps.prismaService.user_identifier.findFirst.mockResolvedValue({ user_id: 42 });
+        deps.setting.resolveUserLocale.mockResolvedValue('es');
+
+        await send(service, 'es');
+
+        expect(deps.mailMainService.send).toHaveBeenCalledWith(
+          expect.objectContaining({ subject: 'Olá', locale: 'pt' }),
+        );
+      });
+
+      // Antes virava TypeError engolido pelo catch e reportado como falha do
+      // provedor - o e-mail sumia sem ninguem saber por que.
+      it('reporta incidente proprio quando o template nao tem traducao alguma', async () => {
+        const { service, deps } = makeService();
+        arrange(deps);
+        jest.spyOn(service, 'reloadConfig').mockResolvedValue({
+          success: true, provider: 'ses', from: 'a@b.com', config: {},
+        });
+        deps.prismaService.user_identifier.findFirst.mockResolvedValue(null);
+        deps.prismaService.mail.findUnique.mockResolvedValue({
+          id: 7,
+          mail_locale: [],
+          mail_var: [],
+        });
+
+        await expect(send(service, 'pt')).resolves.toEqual({
+          sent: false,
+          reason: 'template-locale-missing',
+        });
+        expect(deps.mailMainService.send).not.toHaveBeenCalled();
+        expect(deps.incident.record).toHaveBeenCalledWith(
+          expect.objectContaining({ code: 'mail_template_no_locale' }),
+        );
+      });
+
+      // Convite, formulario do site: destinatario que ainda nao tem conta.
+      it('nao quebra quando o destinatario nao e usuario', async () => {
+        const { service, deps } = makeService();
+        arrange(deps);
+        jest.spyOn(service, 'reloadConfig').mockResolvedValue({
+          success: true, provider: 'ses', from: 'a@b.com', config: {},
+        });
+        deps.prismaService.user_identifier.findFirst.mockResolvedValue(null);
+
+        await expect(send(service, 'pt')).resolves.toEqual({
+          sent: true,
+          providerMessageId: 'x',
+        });
+        // Sem usuario encontrado, a cadeia e consultada sem id — nao explode.
+        expect(deps.setting.resolveUserLocale).toHaveBeenCalledWith(null);
+      });
+    });
+
+    // Sem isto os transacionais saem sem Reply-To e a resposta de quem trata o
+    // e-mail como conversa cai na caixa do remetente.
+    it('usa o reply-to do perfil de integração quando o chamador não informa', async () => {
+      const { service, deps } = makeService();
+      deps.setting.getSettingValues.mockResolvedValue({
+        'configured-mail': 'true',
+      } as any);
+      jest.spyOn(service, 'reloadConfig').mockResolvedValue({
+        success: true,
+        provider: 'ses',
+        from: 'a@b.com',
+        replyTo: 'Suporte <suporte@b.com>',
+        config: {},
+      });
+      deps.prismaService.locale.findUnique.mockResolvedValue({ id: 1, code: 'en' });
+      deps.prismaService.mail.findUnique.mockResolvedValue({
+        id: 7,
+        mail_locale: [{ subject: 'Oi', body: 'Corpo', locale: { code: 'en' } }],
+        mail_var: [],
+      });
+      deps.mailMainService.send.mockResolvedValue({ result: {} });
+
+      await service.sendTemplatedMail('en', {
+        email: 'a@b.com',
+        slug: 's',
+        variables: {},
+      } as any);
+
+      expect(deps.mailMainService.send).toHaveBeenCalledWith(
+        expect.objectContaining({ replyTo: 'Suporte <suporte@b.com>' }),
+      );
+    });
+
+    it('o reply-to explícito do chamador tem precedência sobre o do perfil', async () => {
+      const { service, deps } = makeService();
+      deps.setting.getSettingValues.mockResolvedValue({
+        'configured-mail': 'true',
+      } as any);
+      jest.spyOn(service, 'reloadConfig').mockResolvedValue({
+        success: true,
+        provider: 'ses',
+        from: 'a@b.com',
+        replyTo: 'suporte@b.com',
+        config: {},
+      });
+      deps.prismaService.locale.findUnique.mockResolvedValue({ id: 1, code: 'en' });
+      deps.prismaService.mail.findUnique.mockResolvedValue({
+        id: 7,
+        mail_locale: [{ subject: 'Oi', body: 'Corpo', locale: { code: 'en' } }],
+        mail_var: [],
+      });
+      deps.mailMainService.send.mockResolvedValue({ result: {} });
+
+      await service.sendTemplatedMail('en', {
+        email: 'a@b.com',
+        slug: 's',
+        variables: {},
+        replyTo: ' atendimento@b.com ',
+      } as any);
+
+      expect(deps.mailMainService.send).toHaveBeenCalledWith(
+        expect.objectContaining({ replyTo: 'atendimento@b.com' }),
+      );
+    });
+  });
+
+  describe('preview', () => {
+    const LAYOUT_ROW = {
+      id: 1,
+      wrapper:
+        '<html lang="{{lang}}"><body>{{{header}}}<main>{{{content}}}</main>{{{footer}}}</body></html>',
+      mail_layout_locale: [
+        {
+          header: '<h1>{{subject}}</h1>',
+          footer: 'Enviado por {{brandName}}',
+          locale: { code: 'pt' },
+        },
+      ],
+    };
+
+    const makePreviewService = () => {
+      const { service, deps } = makeService();
+      (deps.prismaService as any).mail_layout = {
+        findFirst: jest.fn<any>().mockResolvedValue(LAYOUT_ROW),
+      };
+      deps.setting.getSettingValues.mockResolvedValue({
+        'system-name': 'Acme',
+      } as any);
+      return { service, deps };
+    };
+
+    it('interpola variáveis e aplica o layout padrão do banco', async () => {
+      const { service } = makePreviewService();
+
+      const { html } = await service.preview('pt', {
+        subject: 'Olá {{name}}',
+        body: '<p>Bem-vindo, {{name}}</p>',
+        variables: { name: 'Bob' },
+      });
+
+      expect(html).toContain('<h1>Olá Bob</h1>');
+      expect(html).toContain('<p>Bem-vindo, Bob</p>');
+      expect(html).toContain('Enviado por Acme');
+      expect(html).toContain('lang="pt"');
+    });
+
+    it('produz exatamente o mesmo corpo que o envio real', async () => {
+      // Esta é a asserção que justifica o endpoint: o preview do admin não pode
+      // divergir do e-mail que sai. Os dois caminhos passam pelo mesmo
+      // interpolateTemplate (inclusive a troca de \n por <br/>) e pelo mesmo
+      // renderMailTemplate.
+      const { service } = makePreviewService();
+
+      const subject = 'Olá {{name}}';
+      const body = 'Linha 1\nLinha 2 {{name}}';
+      const variables = { name: 'Bob' };
+
+      const { html: previewHtml } = await service.preview('pt', {
+        subject,
+        body,
+        variables,
+      });
+
+      const interpolate = (src: string) =>
+        (service as any).interpolateTemplate(src, variables);
+      const layout = await (service as any).resolveDefaultLayout('pt');
+      const sentHtml = renderMailTemplate({
+        subject: interpolate(subject),
+        body: interpolate(body),
+        layout,
+        brandName: 'Acme',
+        lang: 'pt',
+      });
+
+      expect(previewHtml).toBe(sentHtml);
+      expect(previewHtml).toContain('Linha 1<br/>Linha 2 Bob');
+    });
+
+    it('usa o layout inline enviado pelo editor, sem consultar o banco', async () => {
+      const { service, deps } = makePreviewService();
+
+      const { html } = await service.preview('pt', {
+        body: 'corpo',
+        layout: {
+          wrapper: '<html>[{{{header}}}]{{{content}}}</html>',
+          header: 'CABECALHO',
+          footer: '',
+        },
+      });
+
+      expect(html).toBe('<html>[CABECALHO]corpo</html>');
+      expect(
+        (deps.prismaService as any).mail_layout.findFirst,
+      ).not.toHaveBeenCalled();
+    });
+
+    it('devolve o corpo cru quando use_layout=false', async () => {
+      const { service } = makePreviewService();
+
+      const { html } = await service.preview('pt', {
+        body: '<p>cru</p>',
+        use_layout: false,
+      });
+
+      expect(html).toBe('<p>cru</p>');
+    });
+
+    it('resolve o logo pelo BrandAssetService, não pela env API_URL', async () => {
+      const { service, deps } = makePreviewService();
+      deps.setting.getSettingValues.mockResolvedValue({
+        'system-name': 'Acme',
+        'image-url': '/logo.svg',
+      } as any);
+
+      const { html } = await service.preview('pt', {
+        body: '<p>corpo</p>',
+        layout: {
+          wrapper: '<html>{{{header}}}{{{content}}}</html>',
+          header: '{{{brandMark}}}',
+          footer: '',
+        },
+      });
+
+      expect(deps.brandAsset.resolveAssetUrl).toHaveBeenCalledWith('/logo.svg');
+      expect(html).toContain('<img src="https://hub.hcode.com.br/logo.svg"');
+    });
+
+    it('cai no layout embutido quando não há layout no banco', async () => {
+      const { service, deps } = makePreviewService();
+      (deps.prismaService as any).mail_layout.findFirst.mockResolvedValue(null);
+
+      const { html } = await service.preview('pt', { body: '<p>corpo</p>' });
+
+      expect(html).toContain('<!DOCTYPE html>');
+      expect(html).toContain('<p>corpo</p>');
+    });
   });
 });