@hed-hog/core 0.0.398 → 0.0.400

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

@@ -27,7 +27,7 @@ export function buildMailConfigFromIntegration(
         clientId: String(cfg.client_id ?? ''),
         clientSecret: String(cfg.client_secret ?? ''),
         refreshToken: String(cfg.refresh_token ?? ''),
-        from: String(cfg.from_email ?? ''),
+        from: String(cfg.from_email ?? '').trim(),
       };
     case 'ses':
       return {
@@ -36,7 +36,7 @@ export function buildMailConfigFromIntegration(
         region: String(cfg.region ?? ''),
         accessKeyId: String(cfg.access_key_id ?? ''),
         secretAccessKey: String(cfg.secret_access_key ?? ''),
-        from: String(cfg.from_email ?? ''),
+        from: String(cfg.from_email ?? '').trim(),
       };
     case 'resend':
       // Resend usa a API HTTP própria (não nodemailer). Retornamos um marcador
@@ -48,7 +48,7 @@ export function buildMailConfigFromIntegration(
         apiToken: String(cfg.api_token ?? ''),
         domain: String(cfg.domain ?? ''),
         region: String(cfg.region ?? ''),
-        from: String(cfg.from_email ?? ''),
+        from: String(cfg.from_email ?? '').trim(),
       };
     case 'imap':
       // Sem este caso o operador que apontasse o perfil de envio para uma caixa
@@ -123,8 +123,8 @@ export function buildResendConfigFromIntegration(
 
 export function getFromAddress(config: unknown): string {
   const cfg = (config as Cfg) ?? {};
-  const fromEmail = String(cfg.from_email ?? '');
-  const fromName = String(cfg.from_name ?? '');
+  const fromEmail = String(cfg.from_email ?? '').trim();
+  const fromName = String(cfg.from_name ?? '').trim();
   return fromName ? `${fromName} <${fromEmail}>` : fromEmail;
 }
 

package/src/integration-profile/testers/index.ts

@@ -6,6 +6,7 @@ import { IntegrationTester } from './integration-tester.types';
 import { MESSAGING_TESTERS } from './messaging.testers';
 import { OAUTH_TESTERS } from './oauth.testers';
 import { PAYMENT_TESTERS } from './payment.testers';
+import { SHIPPING_TESTERS } from './shipping.testers';
 import { STORAGE_TESTERS } from './storage.testers';
 
 /**
@@ -23,6 +24,7 @@ export const BUILTIN_INTEGRATION_TESTERS: IntegrationTester[] = [
   ...PAYMENT_TESTERS,
   ...CAPTCHA_TESTERS,
   ...INFRASTRUCTURE_TESTERS,
+  ...SHIPPING_TESTERS,
 ];
 
 export * from './http-probe';

package/src/integration-profile/testers/remaining.testers.spec.ts

@@ -5,6 +5,7 @@ import { EMAIL_TESTERS } from './email.testers';
 import { INFRASTRUCTURE_TESTERS } from './infrastructure.testers';
 import { MESSAGING_TESTERS } from './messaging.testers';
 import { PAYMENT_TESTERS } from './payment.testers';
+import { SHIPPING_TESTERS } from './shipping.testers';
 import { IntegrationTestContext, IntegrationTester } from './integration-tester.types';
 
 /**
@@ -19,6 +20,7 @@ const all = [
   ...AI_TESTERS,
   ...PAYMENT_TESTERS,
   ...INFRASTRUCTURE_TESTERS,
+  ...SHIPPING_TESTERS,
 ];
 
 const bySlug = (slug: string): IntegrationTester =>
@@ -444,3 +446,80 @@ describe('digitalocean tester', () => {
     });
   });
 });
+
+describe('melhor-envio tester', () => {
+  const tester = bySlug('melhor-envio');
+  const account = { firstname: 'Ana', lastname: 'Souza', email: 'ana@acme.com' };
+
+  it('identifica a conta e o ambiente de produção', async () => {
+    fetchMock.mockResolvedValue(jsonResponse(account));
+
+    await expect(tester.test({ access_token: 'tok' }, ctx())).resolves.toEqual({
+      ok: true,
+      info: 'Ana Souza — ana@acme.com (production)',
+    });
+
+    const [url, init] = fetchMock.mock.calls[0] as [string, RequestInit];
+    expect(url).toBe('https://melhorenvio.com.br/api/v2/me');
+    const headers = init.headers as Record<string, string>;
+    expect(headers.Authorization).toBe('Bearer tok');
+    // Sem User-Agent identificável o Melhor Envio recusa a requisição.
+    expect(headers['User-Agent']).toBe('HedHog Commerce');
+  });
+
+  it('usa a base de sandbox e avisa que o preço não é real', async () => {
+    fetchMock.mockResolvedValue(jsonResponse(account));
+
+    const outcome = await tester.test(
+      { access_token: 'tok', sandbox: true, user_agent: 'Loja (contato@acme.com)' },
+      ctx(),
+    );
+
+    expect(outcome.ok).toBe(true);
+    expect(outcome.info).toContain('(sandbox)');
+    expect(outcome.warning).toContain('not real prices');
+
+    const [url, init] = fetchMock.mock.calls[0] as [string, RequestInit];
+    expect(url).toBe('https://sandbox.melhorenvio.com.br/api/v2/me');
+    expect((init.headers as Record<string, string>)['User-Agent']).toBe(
+      'Loja (contato@acme.com)',
+    );
+  });
+
+  it('aceita a string "true" que o formulário do admin grava', async () => {
+    fetchMock.mockResolvedValue(jsonResponse(account));
+
+    await tester.test({ access_token: 'tok', sandbox: 'true' }, ctx());
+
+    const [url] = fetchMock.mock.calls[0] as [string];
+    expect(url).toBe('https://sandbox.melhorenvio.com.br/api/v2/me');
+  });
+
+  it('aponta o switch de sandbox no 401, que é o erro mais comum', async () => {
+    fetchMock.mockResolvedValue(jsonResponse({}, 401));
+
+    const outcome = await tester.test({ access_token: 'tok' }, ctx());
+
+    expect(outcome.ok).toBe(false);
+    expect(outcome.error).toContain('in production');
+    expect(outcome.error).toContain('sandbox switch');
+  });
+
+  it('distingue falta de escopo (403) de token inválido', async () => {
+    fetchMock.mockResolvedValue(jsonResponse({}, 403));
+
+    await expect(tester.test({ access_token: 'tok' }, ctx())).resolves.toEqual({
+      ok: false,
+      error:
+        'The Melhor Envio token has no permission to read the account. Reissue it including the shipping scopes.',
+    });
+  });
+
+  it('exige o token antes de ir à rede', async () => {
+    await expect(tester.test({}, ctx())).resolves.toEqual({
+      ok: false,
+      error: 'Access token is required.',
+    });
+    expect(fetchMock).not.toHaveBeenCalled();
+  });
+});

package/src/integration-profile/testers/shipping.testers.ts

@@ -0,0 +1,94 @@
+import {
+  describeHttpError,
+  fail,
+  pass,
+  probeJson,
+  requireFields,
+  str,
+} from './http-probe';
+import { IntegrationTester } from './integration-tester.types';
+
+/**
+ * Testadores das transportadoras / intermediadores de frete.
+ *
+ * Só leitura da conta: nada aqui gera etiqueta, compra postagem ou mexe no saldo
+ * da carteira — mesmo princípio dos testers de pagamento.
+ */
+
+/**
+ * Sandbox e produção são contas SEPARADAS no Melhor Envio, cada uma com o seu
+ * token. Trocar o switch sem trocar o token devolve 401, então a resolução da
+ * base tem que ser idêntica à do consumidor
+ * (libraries/commerce/src/commerce-shipping/melhor-envio.provider.ts) — senão o
+ * teste valida um ambiente e a loja cota no outro.
+ */
+function resolveBaseUrl(config: Record<string, unknown>): {
+  baseUrl: string;
+  sandbox: boolean;
+} {
+  // Aceita boolean do JSON e a string do formulário do admin.
+  const sandbox = config.sandbox === true || String(config.sandbox ?? '') === 'true';
+  return {
+    sandbox,
+    baseUrl: sandbox
+      ? 'https://sandbox.melhorenvio.com.br'
+      : 'https://melhorenvio.com.br',
+  };
+}
+
+const melhorEnvioTester: IntegrationTester = {
+  providerSlug: 'melhor-envio',
+  test: async (config, ctx) => {
+    const missing = requireFields(config, [['access_token', 'Access token']]);
+    if (missing) return missing;
+
+    const { baseUrl, sandbox } = resolveBaseUrl(config);
+    const environment = sandbox ? 'sandbox' : 'production';
+
+    const result = await probeJson(
+      `${baseUrl}/api/v2/me`,
+      {
+        headers: {
+          Authorization: `Bearer ${str(config, 'access_token')}`,
+          Accept: 'application/json',
+          // Sem User-Agent identificável o Melhor Envio recusa a requisição, e o
+          // teste falharia por etiqueta faltando em vez de credencial errada.
+          'User-Agent': str(config, 'user_agent') || 'HedHog Commerce',
+        },
+      },
+      ctx.signal,
+    );
+
+    if (result.status === 401) {
+      // O erro mais comum não é token digitado errado: é token de sandbox num
+      // perfil de produção (ou o contrário), porque são contas diferentes.
+      return fail(
+        `Melhor Envio rejected the access token in ${environment}. Check the token and the sandbox switch — sandbox and production are separate accounts.`,
+      );
+    }
+    if (result.status === 403) {
+      return fail(
+        'The Melhor Envio token has no permission to read the account. Reissue it including the shipping scopes.',
+      );
+    }
+    if (!result.ok) {
+      return fail(describeHttpError(result, 'Melhor Envio rejected the credentials.'));
+    }
+
+    const name = [result.body?.firstname, result.body?.lastname]
+      .map((part) => String(part ?? '').trim())
+      .filter(Boolean)
+      .join(' ');
+    const email = String(result.body?.email ?? '').trim();
+    const account = [name, email].filter(Boolean).join(' — ') || 'Melhor Envio account';
+
+    return pass(
+      `${account} (${environment})`,
+      // Cotação de sandbox tem preço fictício: passar despercebido significa loja
+      // no ar vendendo frete que não existe.
+      sandbox ? 'This profile points to the sandbox, so quotes are not real prices.' : undefined,
+    );
+  },
+};
+
+export const SHIPPING_TESTERS: IntegrationTester[] = [melhorEnvioTester];

package/src/mail/dto/send.dto.ts

@@ -10,8 +10,13 @@ export class SendTemplatedMailDTO {
   @IsNotEmpty({ message: (args) => getLocaleText('validation.fieldRequired', args.value) })
   slug: string;
 
+  /**
+   * Contexto do Handlebars. Nao e so string: o corpo do e-mail e compilado com
+   * Handlebars de verdade, entao um array aqui alimenta `{{#each}}` no template
+   * (e o resumo do aluno usa isso para a grade de sequencia da semana).
+   */
   @IsObject({ message: (args) => getLocaleText('validation.objectRequired', args.value) })
-  variables: Record<string, string>;
+  variables: Record<string, unknown>;
 
   /**
    * Slug do perfil de integração de e-mail a usar neste envio.

package/src/mail/mail-template.spec.ts

@@ -1,5 +1,10 @@
 import { describe, it, expect } from '@jest/globals';
-import { DEFAULT_MAIL_LAYOUT, renderMailTemplate, resolveMailAssetUrl } from '@hed-hog/api-mail';
+import {
+  DEFAULT_MAIL_LAYOUT,
+  renderMailTemplate,
+  resolveMailAssetUrl,
+  sanitizeAccentColor,
+} from '@hed-hog/api-mail';
 
 // Testes do renderizador de e-mail moram aqui (e nao em packages/api-mail)
 // porque o api-mail nao tem jest configurado; o jest do core resolve o pacote.
@@ -249,6 +254,58 @@ describe('renderMailTemplate', () => {
   });
 });
 
+describe('cor da etapa (accentColor)', () => {
+  // O commerce manda uma cor por etapa da compra; as demais libraries nao
+  // mandam nada e precisam continuar exatamente como estavam.
+  it('pinta a barra de destaque com a cor da etapa', () => {
+    const html = renderMailTemplate({
+      subject: 'Pagamento confirmado',
+      body: '<p>Ola</p>',
+      primaryColor: '#111827',
+      accentColor: '#16a34a',
+    });
+
+    expect(html).toContain('background:#16a34a;');
+    expect(html).toContain('background: #16a34a;');
+  });
+
+  it('cai na cor da marca quando nenhuma etapa e informada', () => {
+    const html = renderMailTemplate({
+      subject: 'Recuperar senha',
+      body: '<p>Ola</p>',
+      primaryColor: '#1465b8',
+    });
+
+    expect(html).toContain('background:#1465b8;');
+    expect(html).not.toContain('{{accentColor}}');
+  });
+
+  // O valor e interpolado dentro do bloco <style> do wrapper: string livre ali
+  // fecharia a regra e reescreveria o layout inteiro.
+  it('ignora cor fora do formato #rrggbb', () => {
+    const html = renderMailTemplate({
+      subject: 'Oi',
+      body: '<p>Ola</p>',
+      primaryColor: '#1465b8',
+      accentColor: 'red;} body { display:none } .x {',
+    });
+
+    expect(html).not.toContain('display:none');
+    expect(html).toContain('background:#1465b8;');
+  });
+
+  it('sanitizeAccentColor aceita so hexadecimal de 6 digitos', () => {
+    expect(sanitizeAccentColor('#16a34a')).toBe('#16a34a');
+    expect(sanitizeAccentColor('  #ABCDEF  ')).toBe('#ABCDEF');
+    expect(sanitizeAccentColor('#abc')).toBeUndefined();
+    expect(sanitizeAccentColor('green')).toBeUndefined();
+    expect(sanitizeAccentColor('#16a34a;')).toBeUndefined();
+    expect(sanitizeAccentColor('')).toBeUndefined();
+    expect(sanitizeAccentColor(undefined)).toBeUndefined();
+    expect(sanitizeAccentColor(null)).toBeUndefined();
+  });
+});
+
 describe('resolveMailAssetUrl', () => {
   it('mantem URLs ja absolutas ou data: intactas', () => {
     expect(resolveMailAssetUrl('https://cdn.example.com/logo.svg', 'http://localhost:3100')).toBe(

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

@@ -82,11 +82,45 @@ describe('MailService', () => {
       expect(call('A\r\nB', {})).toBe('A<br/>B');
     });
 
+    it('preserva as quebras de linha de um documento HTML completo (não injeta <br/> dentro de <style>/<head>)', () => {
+      // Bug real: um HTML completo colado em Templates de e-mail (que
+      // funciona no preview cru de Campanhas) aparecia quebrado aqui porque
+      // toda quebra de linha virava "<br/>" literal mesmo dentro de <style>,
+      // invalidando o CSS antes de chegar em renderMailTemplate.
+      const fullHtml =
+        '<!DOCTYPE html>\n<html>\n<head>\n<style>\n.foo {\n  color: red;\n}\n</style>\n</head>\n<body>{{name}}</body>\n</html>';
+      const result = call(fullHtml, { name: 'Bob' });
+      expect(result).not.toContain('<br/>');
+      expect(result).toContain('.foo {\n  color: red;\n}');
+      expect(result).toContain('Bob');
+    });
+
     it('lança BadRequestException em sintaxe inválida', () => {
       expect(() => call('{{#if foo}}sem fechar', {})).toThrow(
         BadRequestException,
       );
     });
+
+    // Bug real: o assunto e texto puro (vira o header `subject:` do e-mail),
+    // mas o Handlebars padrao escapa `& < > " ' `` `` como se fosse HTML —
+    // uma crase no titulo da tarefa saia como `&#x60;` cru na caixa de
+    // entrada, e escapava DE NOVO no `<h1>` do corpo (renderMailTemplate),
+    // virando `&amp;#x60;`. `escapeHtml: false` e o que os call sites do
+    // assunto passam pra evitar isso.
+    it('com escapeHtml:false, nao escapa nada — usado no assunto (texto puro)', () => {
+      const src = 'Tarefa `{{title}}` & <urgente> "importante"';
+      const result = (makeService().service as any).interpolateTemplate(
+        src,
+        { title: 'status' },
+        { escapeHtml: false },
+      );
+      expect(result).toBe('Tarefa `status` & <urgente> "importante"');
+    });
+
+    it('por padrao (sem a opcao) continua escapando — usado no corpo, que e HTML de verdade', () => {
+      const result = call('Nome: {{name}}', { name: 'A & B <b>' });
+      expect(result).toBe('Nome: A &amp; B &lt;b&gt;');
+    });
   });
 
   describe('isSettingEnabled', () => {
@@ -331,6 +365,54 @@ describe('MailService', () => {
       ).resolves.toEqual({ sent: true, providerMessageId: 'ses-abc' });
     });
 
+    it('assunto com crase, & e aspas chega cru no e-mail — sem &#x60;/&amp; vazando (corpo continua escapando)', async () => {
+      const { service, deps } = makeService();
+      deps.setting.getSettingValues.mockResolvedValue({
+        'configured-mail': 'true',
+      } as any);
+      // `resolveUserLocale` diferente de 'en' evita o fallback que chama
+      // `normalizeLocaleCode(callerLocale)` — sem relação com o bug desta
+      // task, só contorna o pacote @hed-hog/api-locale com dist desatualizado
+      // neste ambiente (falta o export, dist nao republicado).
+      deps.setting.resolveUserLocale.mockResolvedValue('pt');
+      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: [
+          {
+            // A crase literal no template (fora de {{}}) nunca foi escapada
+            // pelo Handlebars — quem escapava era o VALOR interpolado da
+            // variavel. O bug real tinha a crase dentro do dado (nome da
+            // tarefa), entao o teste reproduz isso: a crase mora em `title`,
+            // nao no texto fixo do template.
+            subject: 'Você foi atribuído à tarefa {{title}} & "urgente"',
+            body: 'Título: {{title}}',
+            locale: { code: 'en' },
+          },
+        ],
+        mail_var: [],
+      });
+      deps.mailMainService.send.mockResolvedValue({ result: { MessageId: 'ses-abc' } });
+
+      await service.sendTemplatedMail('en', {
+        email: 'a@b.com',
+        slug: 's',
+        variables: { title: '`status`' },
+      } as any);
+
+      const sentArgs = deps.mailMainService.send.mock.calls[0][0] as { subject: string; body: string };
+      expect(sentArgs.subject).toBe('Você foi atribuído à tarefa `status` & "urgente"');
+      expect(sentArgs.subject).not.toContain('&#x60;');
+      expect(sentArgs.subject).not.toContain('&amp;');
+      // O corpo e HTML de verdade — a mesma crase, vinda do mesmo dado,
+      // continua escapando normalmente ali (nao é dupla checagem à toa: prova
+      // que `escapeHtml:false` ficou restrito ao assunto).
+      expect(sentArgs.body).toContain('&#x60;status&#x60;');
+    });
+
     // 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', () => {
@@ -579,6 +661,36 @@ describe('MailService', () => {
       expect(html).toContain('lang="pt"');
     });
 
+    // Regressao do bug real: assunto com crase saia como `&#x60;` cru no
+    // assunto do e-mail e `&amp;#x60;` (escape duplo) no <h1> do corpo. O
+    // fluxo completo (interpolateTemplate -> renderMailTemplate) precisa
+    // produzir cada caractere especial escapado NO MAXIMO uma vez, e so pelo
+    // renderMailTemplate — sem o <script> escapando pra HTML executavel.
+    it('assunto com crase, &, aspas e <script> nao vaza entidade e nao escapa duas vezes no <h1>', async () => {
+      const { service } = makePreviewService();
+
+      const { html } = await service.preview('pt', {
+        subject: 'Tarefa `{{title}}` & "urgente" <script>alert(1)</script>',
+        body: '<p>Corpo</p>',
+        variables: { title: 'status' },
+      });
+
+      // Crase nunca vira entidade (renderMailTemplate/escapeHtml nem trata
+      // crase como caractere especial) — nem &#x60; nem, pior, &amp;#x60;.
+      expect(html).not.toContain('#x60;');
+      // & e " escapados exatamente uma vez (não &amp;amp; / &amp;quot;).
+      expect(html).toContain('&amp;');
+      expect(html).not.toContain('&amp;amp;');
+      expect(html).not.toContain('&amp;quot;');
+      // <script> chega escapado, nunca como tag executável.
+      expect(html).not.toContain('<script>alert(1)</script>');
+      expect(html).toContain('&lt;script&gt;');
+
+      expect(html).toContain(
+        '<h1>Tarefa `status` &amp; &quot;urgente&quot; &lt;script&gt;alert(1)&lt;/script&gt;</h1>',
+      );
+    });
+
     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

package/src/mail/mail.service.ts

@@ -8,9 +8,11 @@ import {
 import {
   DEFAULT_PRIMARY_COLOR,
   DEFAULT_PRIMARY_FOREGROUND,
+  isFullHtmlDocument,
   MailLayout,
   MailService as MailMainService,
   renderMailTemplate,
+  sanitizeAccentColor,
 } from '@hed-hog/api-mail';
 import { PaginationDTO } from '@hed-hog/api-pagination';
 import { PrismaService } from '@hed-hog/api-prisma';
@@ -508,8 +510,14 @@ export class MailService implements OnModuleInit {
       const brandName = await this.mailMainService.getBrandName(app, templateLocale);
       const { primaryColor, primaryForeground } = await this.getThemeVariables();
       const mergedVariables = { brandName, primaryColor, primaryForeground, ...variables };
-      const parsedSubject = this.interpolateTemplate(subject, mergedVariables);
+      const parsedSubject = this.interpolateTemplate(subject, mergedVariables, { escapeHtml: false });
       const parsedBody = this.interpolateTemplate(body, mergedVariables);
+      // A cor da etapa vem do remetente (o commerce manda uma por slug) e chega
+      // ate o wrapper, que pinta a barra de destaque. `sanitizeAccentColor`
+      // descarta o que nao for `#rrggbb` porque o valor entra num bloco <style>.
+      const accentColor = sanitizeAccentColor(
+        typeof variables?.accentColor === 'string' ? variables.accentColor : undefined,
+      );
 
       const sendResult: any = await this.mailMainService.send({
         to: email,
@@ -517,6 +525,7 @@ export class MailService implements OnModuleInit {
         ...(resolvedReplyTo ? { replyTo: resolvedReplyTo } : {}),
         subject: parsedSubject,
         body: parsedBody,
+        ...(accentColor ? { accentColor } : {}),
         mail_id: mail.id,
         // O layout (header/footer) e escolhido por este locale la no api-mail,
         // entao tem que ser o do template escolhido, nao o cru do request.
@@ -662,12 +671,31 @@ export class MailService implements OnModuleInit {
     return mail;
   }
 
+  /**
+   * `escapeHtml` (default true) controla o escape padrao do Handlebars pra
+   * `&`, `<`, `>`, `"`, `'` e crase. O corpo e HTML de verdade e precisa dele;
+   * o assunto e texto puro (vira o header `subject:` do e-mail e, no corpo,
+   * passa de novo por `renderMailTemplate`/`escapeHtml` do `@hed-hog/api-mail`
+   * pra virar o `<h1>`) — escapar aqui tambem faria uma crase no assunto virar
+   * `&#x60;` cru na caixa de entrada, e depois `&amp;#x60;` no `<h1>` (escape
+   * duplo). Quem chama pro assunto passa `{ escapeHtml: false }`.
+   */
   private interpolateTemplate(
     source: string,
     data: any,
+    { escapeHtml = true }: { escapeHtml?: boolean } = {},
   ): string {
     try {
-      const template = Handlebars.compile(source.replace(/(\r\n|\n|\r)/g, '<br/>'));
+      // Um documento HTML completo (<style>/<head>/<script>) tem quebra de
+      // linha significativa dentro dessas tags — trocar por <br/> às cegas
+      // quebra o CSS/HTML (renderMailTemplate já pula o wrapper pra esse
+      // caso; aqui só espelhamos a mesma detecção pra não mutilar antes
+      // disso). Emails simples (sem <html>) continuam ganhando <br/> pra
+      // preservar quebras de linha digitadas pelo usuário.
+      const normalized = isFullHtmlDocument(source)
+        ? source
+        : source.replace(/(\r\n|\n|\r)/g, '<br/>');
+      const template = Handlebars.compile(normalized, { noEscape: !escapeHtml });
       return template(data);
     } catch (error: any) {
       this.logger.error('Handlebars template compilation error:', error);
@@ -741,7 +769,7 @@ export class MailService implements OnModuleInit {
       ? (await this.brandAsset.resolveAssetUrl(rawLogoUrl)) || undefined
       : undefined;
     const data = { brandName, primaryColor, primaryForeground, ...(variables || {}) };
-    const parsedSubject = subject ? this.interpolateTemplate(subject, data) : '';
+    const parsedSubject = subject ? this.interpolateTemplate(subject, data, { escapeHtml: false }) : '';
     const parsedBody = body ? this.interpolateTemplate(body, data) : '';
 
     let resolvedLayout: MailLayout | null = null;
@@ -765,6 +793,11 @@ export class MailService implements OnModuleInit {
       brandName,
       primaryColor,
       primaryForeground,
+      // Mesma leitura do envio: sem isto a pre-visualizacao do admin mostraria a
+      // barra na cor da marca e o e-mail sairia na cor da etapa.
+      accentColor: sanitizeAccentColor(
+        typeof variables?.accentColor === 'string' ? variables.accentColor : undefined,
+      ),
       logoUrl,
       lang: locale,
     });
@@ -792,13 +825,18 @@ export class MailService implements OnModuleInit {
       const brandName = await this.mailMainService.getBrandName(undefined, locale);
       const { primaryColor, primaryForeground } = await this.getThemeVariables();
       const mergedVariables = { brandName, primaryColor, primaryForeground, ...(variables || {}) };
-      const parsedSubject = this.interpolateTemplate(subject, mergedVariables);
+      const parsedSubject = this.interpolateTemplate(subject, mergedVariables, { escapeHtml: false });
       const parsedBody = this.interpolateTemplate(body, mergedVariables);
 
+      const accentColor = sanitizeAccentColor(
+        typeof variables?.accentColor === 'string' ? variables.accentColor : undefined,
+      );
+
       return this.mailMainService.send({
         to: email,
         subject: parsedSubject,
         body: parsedBody,
+        ...(accentColor ? { accentColor } : {}),
         mail_id: mail.id,
         from,
         locale,

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

@@ -12,6 +12,7 @@ import {
 import { CreateDTO } from './dto/create.dto';
 import { QueryMailSentListDTO } from './dto/query-mail-sent-list.dto';
 import { UpdateDTO } from './dto/update.dto';
+import { MAIL_SENT_SORT } from './mail-sent.sort';
 
 type MailSentUserStatus = 'received' | 'read' | 'error';
 
@@ -186,6 +187,8 @@ export class MailSentService {
           },
         },
       },
+      undefined,
+      { sort: MAIL_SENT_SORT },
     );
 
     const data = (result.data as MailSentWithUsers[]).map((item) => {

package/src/mail-sent/mail-sent.sort.ts

@@ -0,0 +1,19 @@
+import { defineSortable } from '@hed-hog/api-pagination';
+
+/**
+ * Campos ordenáveis de `mail_sent`.
+ *
+ * "Delivery" (o badge exibido na listagem) fica de fora: é um resumo agregado
+ * calculado no service a partir de `mail_sent_user` (to-many), não uma coluna
+ * — o Prisma não tem como ordenar por ele.
+ */
+export const MAIL_SENT_SORT = defineSortable(
+  {
+    subject: true,
+    from: true,
+    to: true,
+    created_at: { initialOrder: 'desc' },
+    id: { initialOrder: 'desc' },
+  },
+  { default: 'created_at', defaultOrder: 'desc' },
+);