@hed-hog/core 0.0.386 → 0.0.390

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';
 
@@ -28,7 +29,8 @@ const makeDeps = () => {
   const localeService = {};
   const setting = { getSettingValues: jest.fn(), setValue: jest.fn() };
   const integrationApi = { subscribe: jest.fn() };
-  return { prismaService, mailMainService, localeService, setting, integrationApi };
+  const incident = { record: jest.fn(), persist: jest.fn() };
+  return { prismaService, mailMainService, localeService, setting, integrationApi, incident };
 };
 
 const makeService = (deps = makeDeps()) => ({
@@ -38,6 +40,7 @@ const makeService = (deps = makeDeps()) => ({
     deps.localeService as any,
     deps.setting as any,
     deps.integrationApi as any,
+    deps.incident as any,
   ),
   deps,
 });
@@ -254,4 +257,116 @@ describe('MailService', () => {
       expect(deps.mailMainService.send).not.toHaveBeenCalled();
     });
   });
+
+  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('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>');
+    });
+  });
 });

package/src/mail/mail.service.ts

@@ -1,6 +1,10 @@
 import { DeleteDTO } from '@hed-hog/api';
 import { getLocaleText, LocaleService } from '@hed-hog/api-locale';
-import { MailService as MailMainService } from '@hed-hog/api-mail';
+import {
+  MailLayout,
+  MailService as MailMainService,
+  renderMailTemplate,
+} from '@hed-hog/api-mail';
 import { PaginationDTO } from '@hed-hog/api-pagination';
 import { PrismaService } from '@hed-hog/api-prisma';
 import {
@@ -21,9 +25,11 @@ import { IntegrationDeveloperApiService } from '../integration/services/integrat
 import { SettingService } from '../setting/setting.service';
 import { CreateDTO } from './dto/create.dto';
 import { ImportDTO } from './dto/import.dto';
+import { PreviewDTO } from './dto/preview.dto';
 import { SendTemplatedMailDTO } from './dto/send.dto';
 import { TestMailDTO } from './dto/test-mail.dto';
 import { UpdateDTO } from './dto/update.dto';
+import { IncidentService } from '../incident/incident.service';
 
 @Injectable()
 export class MailService implements OnModuleInit {
@@ -43,6 +49,8 @@ export class MailService implements OnModuleInit {
     private readonly setting: SettingService,
     @Inject(forwardRef(() => IntegrationDeveloperApiService))
     private readonly integrationApi: IntegrationDeveloperApiService,
+    @Inject(forwardRef(() => IncidentService))
+    private readonly incident: IncidentService,
   ) { }
 
   onModuleInit(): void {
@@ -389,22 +397,33 @@ export class MailService implements OnModuleInit {
 
   async sendTemplatedMail(
     locale: string,
-    { email, slug, variables }: SendTemplatedMailDTO,
+    { email, slug, variables, profileSlug, app }: SendTemplatedMailDTO,
   ) {
     const settings = await this.setting.getSettingValues(['configured-mail']);
 
     if (!this.isSettingEnabled(settings['configured-mail'])) {
       this.logger.warn('Mail service is not configured. Aborting sending email.');
+      // Aborto silencioso: sem isto, todo e-mail transacional do sistema para
+      // de sair e ninguem fica sabendo ate um usuario reclamar.
+      this.incident.record({
+        source: 'core.mail',
+        code: 'mail_not_configured',
+        severity: 'critical',
+        message: 'Envio de e-mail abortado: a configuracao de e-mail nao esta ativa.',
+        context: { slug },
+      });
       return;
     }
 
     try {
-      const { from } = await this.reloadConfig();
+      const { from } = await this.reloadConfig(profileSlug);
       const localeRecord = await this.getLocaleRecord(locale);
       const mail = await this.getMailTemplate(slug, localeRecord.id);
       const { subject, body } = mail.mail_locale[0];
-      const parsedSubject = this.interpolateTemplate(subject, variables);
-      const parsedBody = this.interpolateTemplate(body, variables);
+      const brandName = await this.mailMainService.getBrandName(app, locale);
+      const mergedVariables = { brandName, ...variables };
+      const parsedSubject = this.interpolateTemplate(subject, mergedVariables);
+      const parsedBody = this.interpolateTemplate(body, mergedVariables);
 
       await this.mailMainService.send({
         to: email,
@@ -412,11 +431,21 @@ export class MailService implements OnModuleInit {
         subject: parsedSubject,
         body: parsedBody,
         mail_id: mail.id,
+        locale,
+        app,
       });
 
     } catch (error) {
       this.logger.error('Error sending templated mail:', error);
-      await this.setting.setValue('configured-mail', 'false');
+      // Agrupado por slug: um template quebrado vira um incidente com contador,
+      // nao uma linha por destinatario.
+      this.incident.record({
+        source: 'core.mail',
+        code: 'mail_send_failed',
+        message: error instanceof Error ? error.message : String(error),
+        key: slug,
+        context: { slug, locale },
+      });
     }
   }
 
@@ -468,6 +497,84 @@ export class MailService implements OnModuleInit {
     }
   }
 
+  /**
+   * Le o layout padrao direto do banco, sem passar pelo cache do api-mail.
+   *
+   * O preview tem que refletir o que acabou de ser salvo, entao aqui o cache de
+   * 60s atrapalharia em vez de ajudar.
+   */
+  private async resolveDefaultLayout(
+    locale: string,
+  ): Promise<MailLayout | null> {
+    const layoutRow = await this.prismaService.mail_layout.findFirst({
+      where: { is_default: true },
+      include: {
+        mail_layout_locale: {
+          include: { locale: { select: { code: true } } },
+        },
+      },
+    });
+
+    if (!layoutRow) {
+      return null;
+    }
+
+    const translations = layoutRow.mail_layout_locale || [];
+    const translation =
+      translations.find((t: any) => t.locale?.code === locale) ||
+      translations.find((t: any) => t.locale?.code === 'en') ||
+      translations[0];
+
+    return {
+      wrapper: layoutRow.wrapper,
+      header: translation?.header ?? '',
+      footer: translation?.footer ?? '',
+    };
+  }
+
+  /**
+   * Renderiza exatamente o HTML que sairia no envio.
+   *
+   * Usa o mesmo `interpolateTemplate` de `sendTemplatedMail` (inclusive a troca
+   * de quebras de linha por `<br/>`) e o mesmo `renderMailTemplate`. Qualquer
+   * atalho aqui recriaria a divergencia entre o que o admin ve e o que o
+   * destinatario recebe.
+   */
+  async preview(
+    locale: string,
+    { subject, body, variables, use_layout, layout }: PreviewDTO,
+  ): Promise<{ html: string }> {
+    const settings = await this.setting.getSettingValues(['system-name']);
+    const brandName = settings['system-name'] as string;
+    const data = { brandName, ...(variables || {}) };
+    const parsedSubject = subject ? this.interpolateTemplate(subject, data) : '';
+    const parsedBody = body ? this.interpolateTemplate(body, data) : '';
+
+    let resolvedLayout: MailLayout | null = null;
+
+    if (use_layout !== false) {
+      resolvedLayout = layout
+        ? {
+            wrapper: layout.wrapper ?? '',
+            header: layout.header ?? '',
+            footer: layout.footer ?? '',
+          }
+        : await this.resolveDefaultLayout(locale);
+    }
+
+    const html = renderMailTemplate({
+      subject: parsedSubject,
+      body: parsedBody,
+      // use_layout === false vira um layout sem wrapper, o que faz o render
+      // devolver o corpo cru.
+      layout: use_layout === false ? { wrapper: '' } : resolvedLayout,
+      brandName,
+      lang: locale,
+    });
+
+    return { html };
+  }
+
   async sendTestMail(locale: string, {
     slug,
     email,
@@ -486,12 +593,10 @@ export class MailService implements OnModuleInit {
     const { from } = await this.reloadConfig();
 
     try {
-      const parsedSubject = variables
-        ? this.interpolateTemplate(subject, variables)
-        : subject;
-      const parsedBody = variables
-        ? this.interpolateTemplate(body, variables)
-        : body;
+      const brandName = await this.mailMainService.getBrandName(undefined, locale);
+      const mergedVariables = { brandName, ...(variables || {}) };
+      const parsedSubject = this.interpolateTemplate(subject, mergedVariables);
+      const parsedBody = this.interpolateTemplate(body, mergedVariables);
 
       return this.mailMainService.send({
         to: email,
@@ -499,6 +604,7 @@ export class MailService implements OnModuleInit {
         body: parsedBody,
         mail_id: mail.id,
         from,
+        locale,
       });
     } catch (error) {
       this.logger.error('Error sending test mail:', error);

package/src/mail-layout/dto/update.dto.ts

@@ -0,0 +1,19 @@
+import { IsObject, IsOptional, IsString } from 'class-validator';
+
+export class UpdateDTO {
+  @IsString()
+  @IsOptional()
+  wrapper?: string;
+
+  /**
+   * Traducoes indexadas pelo CODIGO do locale (`{ pt: { name, header, footer } }`).
+   *
+   * Codigo e nao id de proposito: o `useApp().locales` do admin so expoe
+   * `{ code, name }`, entao qualquer payload baseado em id acabaria adivinhando o
+   * id a partir do indice do array. `LocaleService.updateModelWithLocale` resolve
+   * o codigo via `getByCode`.
+   */
+  @IsObject()
+  @IsOptional()
+  locale?: Record<string, { name?: string; header?: string; footer?: string }>;
+}

package/src/mail-layout/mail-layout.controller.ts

@@ -0,0 +1,47 @@
+import { Role } from '@hed-hog/api';
+import { Locale } from '@hed-hog/api-locale';
+import { Pagination } from '@hed-hog/api-pagination';
+import {
+  Body,
+  Controller,
+  Get,
+  Inject,
+  Param,
+  ParseIntPipe,
+  Patch,
+  forwardRef,
+} from '@nestjs/common';
+import { UpdateDTO } from './dto/update.dto';
+import { MailLayoutService } from './mail-layout.service';
+
+/**
+ * Controller proprio (e nao `@Get('layout')` dentro de MailController) porque o
+ * MailController ja declara `@Get(':id')` com ParseIntPipe: uma rota
+ * `/mail/layout` seria capturada por ele e responderia 400.
+ */
+@Role()
+@Controller('mail-layout')
+export class MailLayoutController {
+  constructor(
+    @Inject(forwardRef(() => MailLayoutService))
+    private readonly mailLayoutService: MailLayoutService,
+  ) {}
+
+  @Get()
+  async list(@Locale() locale, @Pagination() paginationParams) {
+    return this.mailLayoutService.list(locale, paginationParams);
+  }
+
+  @Get(':id')
+  async get(@Param('id', ParseIntPipe) id: number) {
+    return this.mailLayoutService.get(id);
+  }
+
+  @Patch(':id')
+  async update(
+    @Param('id', ParseIntPipe) id: number,
+    @Body() data: UpdateDTO,
+  ) {
+    return this.mailLayoutService.update(id, data);
+  }
+}

package/src/mail-layout/mail-layout.module.ts

@@ -0,0 +1,22 @@
+import { LocaleModule } from '@hed-hog/api-locale';
+import { PaginationModule } from '@hed-hog/api-pagination';
+import { PrismaModule } from '@hed-hog/api-prisma';
+import { forwardRef, Module } from '@nestjs/common';
+import { MailModule } from '../mail/mail.module';
+import { MailLayoutController } from './mail-layout.controller';
+import { MailLayoutService } from './mail-layout.service';
+
+@Module({
+  imports: [
+    // MailModule registra o MailModule global do api-mail, de onde vem o
+    // MailService usado para invalidar o cache do layout.
+    forwardRef(() => MailModule),
+    forwardRef(() => PrismaModule),
+    forwardRef(() => PaginationModule),
+    forwardRef(() => LocaleModule),
+  ],
+  controllers: [MailLayoutController],
+  providers: [MailLayoutService],
+  exports: [MailLayoutService],
+})
+export class MailLayoutModule {}

package/src/mail-layout/mail-layout.service.ts

@@ -0,0 +1,94 @@
+import { LocaleService } from '@hed-hog/api-locale';
+import { MailService as MailMainService } from '@hed-hog/api-mail';
+import { PaginationDTO } from '@hed-hog/api-pagination';
+import { PrismaService } from '@hed-hog/api-prisma';
+import {
+  BadRequestException,
+  forwardRef,
+  Inject,
+  Injectable,
+  NotFoundException,
+} from '@nestjs/common';
+import { UpdateDTO } from './dto/update.dto';
+
+/**
+ * Layout base aplicado a todo e-mail transacional do sistema.
+ *
+ * Modelo de registro unico na pratica (um `is_default`), mas a tabela ja tem
+ * `slug` + `is_default` para permitir varios layouts depois sem migration
+ * destrutiva.
+ */
+@Injectable()
+export class MailLayoutService {
+  private readonly modelName = 'mail_layout';
+  private readonly foreignKeyName = 'mail_layout_id';
+
+  constructor(
+    @Inject(forwardRef(() => PrismaService))
+    private readonly prismaService: PrismaService,
+    @Inject(forwardRef(() => LocaleService))
+    private readonly localeService: LocaleService,
+    @Inject(forwardRef(() => MailMainService))
+    private readonly mailMainService: MailMainService,
+  ) {}
+
+  async list(locale: string, paginationParams: PaginationDTO): Promise<any> {
+    return this.localeService.listModelWithLocale(
+      locale,
+      this.modelName,
+      paginationParams,
+    );
+  }
+
+  async get(id: number): Promise<any> {
+    const layout = await this.localeService.getModelWithLocale(
+      this.modelName,
+      id,
+    );
+
+    if (!layout) {
+      throw new NotFoundException(`Mail layout with id ${id} not found.`);
+    }
+
+    return layout;
+  }
+
+  /** Retorna o layout marcado como padrao, que e o que a tela do admin edita. */
+  async getDefault(): Promise<any> {
+    const row = await this.prismaService.mail_layout.findFirst({
+      where: { is_default: true },
+      select: { id: true },
+    });
+
+    if (!row) {
+      throw new NotFoundException('No default mail layout configured.');
+    }
+
+    return this.get(row.id);
+  }
+
+  async update(id: number, data: UpdateDTO): Promise<any> {
+    if (data.wrapper !== undefined && !this.hasContentToken(data.wrapper)) {
+      // Um wrapper sem slot de conteudo enviaria e-mails vazios para todo mundo,
+      // e a falha so apareceria na caixa do destinatario.
+      throw new BadRequestException(
+        'The wrapper must contain a {{{content}}} token.',
+      );
+    }
+
+    const updated = await this.localeService.updateModelWithLocale(
+      this.modelName,
+      this.foreignKeyName,
+      id,
+      data,
+    );
+
+    this.mailMainService.invalidateLayoutCache();
+
+    return updated;
+  }
+
+  private hasContentToken(wrapper: string): boolean {
+    return wrapper.includes('{{{content}}}') || wrapper.includes('{{content}}');
+  }
+}