@hed-hog/core 0.0.390 → 0.0.393

package/src/integration/services/outbox-polling.coordinator.spec.ts

@@ -0,0 +1,90 @@
+import { describe, it, expect, beforeEach, afterEach, jest } from '@jest/globals';
+import { OutboxPollingCoordinator } from './outbox-polling.coordinator';
+
+const makeSettings = (over: Partial<Record<string, any>> = {}) => ({
+  outboxEnabled: true,
+  outboxProcessorEnabled: true,
+  pollingIntervalMs: 1000,
+  idlePollingIntervalMs: 2000,
+  batchSize: 10,
+  startupDrainBatchSize: 50,
+  maxAttempts: 3,
+  processingLeaseMs: 30000,
+  retryBaseDelayMs: 1000,
+  deadLetterEnabled: true,
+  ...over,
+});
+
+const makeDeps = () => {
+  const processor = { processBatch: jest.fn<any>() };
+  const notifier = { subscribe: jest.fn(), unsubscribe: jest.fn() };
+  const integrationSettingsService = { getRuntimeSettings: jest.fn<any>() };
+  return { processor, notifier, integrationSettingsService };
+};
+
+describe('OutboxPollingCoordinator', () => {
+  beforeEach(() => {
+    jest.useFakeTimers();
+  });
+
+  afterEach(async () => {
+    jest.clearAllMocks();
+    jest.useRealTimers();
+  });
+
+  it('não deixa uma falha de uma iteração derrubar o loop (sem unhandled rejection)', async () => {
+    const deps = makeDeps();
+    deps.integrationSettingsService.getRuntimeSettings.mockResolvedValue(makeSettings());
+    deps.processor.processBatch
+      .mockRejectedValueOnce(
+        new Error('Transaction API error: Unable to start a transaction in the given time.'),
+      )
+      .mockResolvedValue(0);
+
+    const coordinator = new OutboxPollingCoordinator(
+      deps.processor as any,
+      deps.notifier as any,
+      deps.integrationSettingsService as any,
+    );
+
+    await coordinator.startProcessingLoop();
+
+    // 1st iteration throws -> caught, backs off ERROR_BACKOFF_MS (5000ms) instead of crashing
+    await jest.advanceTimersByTimeAsync(5000);
+
+    expect(deps.processor.processBatch).toHaveBeenCalledTimes(2);
+    // The loop must still be running — a caught iteration error must not stop/crash it
+    expect(coordinator.isRunning()).toBe(true);
+
+    // Ask it to stop (flips shouldStopLoop synchronously), then let the in-flight idle delay
+    // from the 2nd (successful) iteration resolve so the loop can observe the flag and exit
+    // cleanly, without running a 3rd iteration.
+    const stopPromise = coordinator.stopProcessingLoop();
+    await jest.advanceTimersByTimeAsync(2000);
+    await stopPromise;
+
+    expect(coordinator.isRunning()).toBe(false);
+    expect(deps.processor.processBatch).toHaveBeenCalledTimes(2);
+  });
+
+  it('não fica preso em "running" para sempre se o loop rejeitar de forma inesperada', async () => {
+    const deps = makeDeps();
+    // Simulate a failure before the inner try/catch can even run (e.g. notifier.subscribe throwing)
+    deps.notifier.subscribe.mockImplementation(() => {
+      throw new Error('boom');
+    });
+
+    const coordinator = new OutboxPollingCoordinator(
+      deps.processor as any,
+      deps.notifier as any,
+      deps.integrationSettingsService as any,
+    );
+
+    await coordinator.startProcessingLoop();
+    // Let the rejected promise's .catch() handler run
+    await Promise.resolve();
+    await Promise.resolve();
+
+    expect(coordinator.isRunning()).toBe(false);
+  });
+});

package/src/integration/services/outbox-polling.coordinator.ts

@@ -11,6 +11,8 @@ import { OutboxProcessor } from './outbox.processor';
 @Injectable()
 export class OutboxPollingCoordinator {
   private readonly logger = new Logger(OutboxPollingCoordinator.name);
+  /** Fallback backoff used when a loop iteration throws before settings can be trusted */
+  private static readonly ERROR_BACKOFF_MS = 5000;
   private processingLoopRunning = false;
   private processingLoopPromise: Promise<void> | null = null;
   private immediateWakeupTriggered = false;
@@ -38,7 +40,14 @@ export class OutboxPollingCoordinator {
     this.shouldStopLoop = false;
     this.logger.log('Starting outbox hybrid processing loop');
 
-    this.processingLoopPromise = this.runProcessingLoop();
+    // Defense-in-depth: runProcessingLoop() catches errors internally and should never reject,
+    // but if it somehow does, don't let it become an unhandled rejection (which kills the pod —
+    // see Sentry.onUnhandledRejectionIntegration({ mode: 'strict' }) in apps/api/src/instrument.ts)
+    // and don't leave the flag stuck as "running" with no way to recover.
+    this.processingLoopPromise = this.runProcessingLoop().catch((error) => {
+      this.logger.error('[outbox:loop] processing loop crashed unexpectedly', error);
+      this.processingLoopRunning = false;
+    });
   }
 
   /**
@@ -94,47 +103,60 @@ export class OutboxPollingCoordinator {
 
     try {
       while (!this.shouldStopLoop) {
-        const settings = await this.integrationSettingsService.getRuntimeSettings();
-        const isEnabled = settings.outboxEnabled;
-        const processorEnabled = settings.outboxProcessorEnabled;
-
-        if (!isEnabled || !processorEnabled) {
-          this.logger.debug(
-            `[outbox:loop] processor disabled (outboxEnabled=${isEnabled} processorEnabled=${processorEnabled}), sleeping ${settings.idlePollingIntervalMs}ms`,
-          );
-          await this.delay(settings.idlePollingIntervalMs);
-          continue;
-        }
-
-        // Check if we should process immediately (woken by notification)
-        const shouldProcessImmediately = this.immediateWakeupTriggered;
-        this.immediateWakeupTriggered = false;
-
-        // Process batch
-        const processedCount = await this.processor.processBatch();
-
-        // Determine next polling interval
-        let nextDelayMs: number;
-
-        if (shouldProcessImmediately && processedCount > 0) {
-          // We processed items from immediate wakeup - use active polling interval
-          nextDelayMs = settings.pollingIntervalMs;
-          this.logger.debug(
-            `Processed ${processedCount} events from immediate wakeup, next poll in ${nextDelayMs}ms`,
+        try {
+          const settings = await this.integrationSettingsService.getRuntimeSettings();
+          const isEnabled = settings.outboxEnabled;
+          const processorEnabled = settings.outboxProcessorEnabled;
+
+          if (!isEnabled || !processorEnabled) {
+            this.logger.debug(
+              `[outbox:loop] processor disabled (outboxEnabled=${isEnabled} processorEnabled=${processorEnabled}), sleeping ${settings.idlePollingIntervalMs}ms`,
+            );
+            await this.delay(settings.idlePollingIntervalMs);
+            continue;
+          }
+
+          // Check if we should process immediately (woken by notification)
+          const shouldProcessImmediately = this.immediateWakeupTriggered;
+          this.immediateWakeupTriggered = false;
+
+          // Process batch
+          const processedCount = await this.processor.processBatch();
+
+          // Determine next polling interval
+          let nextDelayMs: number;
+
+          if (shouldProcessImmediately && processedCount > 0) {
+            // We processed items from immediate wakeup - use active polling interval
+            nextDelayMs = settings.pollingIntervalMs;
+            this.logger.debug(
+              `Processed ${processedCount} events from immediate wakeup, next poll in ${nextDelayMs}ms`,
+            );
+          } else if (processedCount > 0) {
+            // Processed items from periodic polling - use active interval
+            nextDelayMs = settings.pollingIntervalMs;
+            this.logger.debug(
+              `Processed ${processedCount} events, next poll in ${nextDelayMs}ms`,
+            );
+          } else {
+            // No items processed - use idle interval
+            nextDelayMs = settings.idlePollingIntervalMs;
+          }
+
+          // Wait for next poll, but be ready for immediate wakeup
+          await this.delay(nextDelayMs);
+        } catch (error) {
+          // A single iteration failing (e.g. a transient DB/transaction error) must never escape
+          // the loop — that would reject processingLoopPromise as an unhandled rejection and, per
+          // Sentry's strict unhandled-rejection mode, take down the whole pod. Log, back off, and
+          // keep polling instead. Don't trust `settings` here — the error may have come from
+          // fetching it — so use a fixed fallback delay.
+          this.logger.error(
+            '[outbox:loop] iteration failed, backing off before retrying',
+            error,
           );
-        } else if (processedCount > 0) {
-          // Processed items from periodic polling - use active interval
-          nextDelayMs = settings.pollingIntervalMs;
-          this.logger.debug(
-            `Processed ${processedCount} events, next poll in ${nextDelayMs}ms`,
-          );
-        } else {
-          // No items processed - use idle interval
-          nextDelayMs = settings.idlePollingIntervalMs;
+          await this.delay(OutboxPollingCoordinator.ERROR_BACKOFF_MS);
         }
-
-        // Wait for next poll, but be ready for immediate wakeup
-        await this.delay(nextDelayMs);
       }
     } finally {
       // Cleanup: unsubscribe from notifications

package/src/integration/services/outbox.service.spec.ts

@@ -156,6 +156,10 @@ describe('OutboxService', () => {
 
       expect(result).toEqual([]);
       expect(tx.$executeRaw).not.toHaveBeenCalled();
+      expect(deps.prisma.$transaction).toHaveBeenCalledWith(
+        expect.any(Function),
+        { maxWait: 5000, timeout: 5000 },
+      );
     });
 
     it('bloqueia linhas encontradas e marca como PROCESSING', async () => {
@@ -173,6 +177,10 @@ describe('OutboxService', () => {
       expect(result).toHaveLength(2);
       expect(result[0].status).toBe(OutboxEventStatus.PROCESSING);
       expect(result[1].status).toBe(OutboxEventStatus.PROCESSING);
+      expect(deps.prisma.$transaction).toHaveBeenCalledWith(
+        expect.any(Function),
+        { maxWait: 5000, timeout: 5000 },
+      );
     });
   });
 

package/src/integration/services/outbox.service.ts

@@ -114,8 +114,9 @@ export class OutboxService {
     const leaseThreshold = new Date(now.getTime() - leaseMs);
     const leaseUntil = new Date(now.getTime() + leaseMs);
 
-    return this.prisma.$transaction(async (tx) => {
-      const rows = await tx.$queryRaw<OutboxEventRecord[]>`
+    return this.prisma.$transaction(
+      async (tx) => {
+        const rows = await tx.$queryRaw<OutboxEventRecord[]>`
         SELECT * FROM outbox_event
         WHERE status = 'pending'::"outbox_event_status_e5d55ba10d_enum"
            OR (status = 'processing'::"outbox_event_status_e5d55ba10d_enum"
@@ -125,10 +126,10 @@ export class OutboxService {
         FOR UPDATE SKIP LOCKED
       `;
 
-      if (rows.length === 0) return [];
+        if (rows.length === 0) return [];
 
-      const ids = rows.map((r) => r.id);
-      await tx.$executeRaw`
+        const ids = rows.map((r) => r.id);
+        await tx.$executeRaw`
         UPDATE outbox_event
         SET status = 'processing'::"outbox_event_status_e5d55ba10d_enum",
             available_at = ${leaseUntil},
@@ -136,14 +137,19 @@ export class OutboxService {
         WHERE id = ANY(${ids}::int[])
       `;
 
-      return rows.map((r) =>
-        this.toDomainEvent({
-          ...r,
-          status: OutboxEventStatus.PROCESSING,
-          available_at: leaseUntil,
-        }),
-      );
-    });
+        return rows.map((r) =>
+          this.toDomainEvent({
+            ...r,
+            status: OutboxEventStatus.PROCESSING,
+            available_at: leaseUntil,
+          }),
+        );
+      },
+      // Default maxWait (2s) is too tight when the pool is briefly under contention from other
+      // long-lived transactions elsewhere in the app; give this short, index-backed query a bit
+      // more slack to acquire a connection before giving up.
+      { maxWait: 5000, timeout: 5000 },
+    );
   }
 
   /**

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

@@ -20,6 +20,9 @@ export const INTEGRATION_SECRET_KEYS: Record<string, string[]> = {
   gmail: ['client_secret', 'refresh_token'],
   ses: ['secret_access_key'],
   resend: ['api_token', 'webhook_secret'],
+  // IMAP e um perfil de RECEBIMENTO: a senha (ou senha de app, no Google
+  // Workspace e no M365) da acesso de leitura a caixa inteira.
+  imap: ['password'],
   // Mensageria
   'evolution-api': ['token'],
   // app_secret assina o HMAC do webhook (X-Hub-Signature-256) e verify_token é

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

@@ -50,11 +50,49 @@ export function buildMailConfigFromIntegration(
         region: String(cfg.region ?? ''),
         from: String(cfg.from_email ?? ''),
       };
+    case 'imap':
+      // Sem este caso o operador que apontasse o perfil de envio para uma caixa
+      // IMAP receberia "Unsupported mail provider: imap" e ficaria procurando um
+      // provedor que na verdade existe — so nao serve para enviar.
+      throw new BadRequestException(
+        'IMAP profiles are inbound-only and cannot be used to send mail. ' +
+          'Choose an SMTP, Gmail, SES or Resend profile instead.',
+      );
     default:
       throw new BadRequestException(`Unsupported mail provider: ${providerSlug}`);
   }
 }
 
+export type ImapIntegrationConfig = {
+  host: string;
+  port: number;
+  secure: boolean;
+  username: string;
+  password: string;
+};
+
+/**
+ * Mapeia o config de um perfil `imap` para as credenciais de leitura da caixa.
+ *
+ * `secure: true` e IMAPS direto na 993 (o normal); `false` e conexao limpa na
+ * 143 com STARTTLS. O padrao 993/true cobre Gmail, Microsoft 365, Zoho e cPanel.
+ */
+export function buildImapConfigFromIntegration(
+  config: unknown,
+): ImapIntegrationConfig {
+  const cfg = (config as Cfg) ?? {};
+  const port = Number(cfg.port ?? 993);
+
+  return {
+    host: String(cfg.host ?? '').trim(),
+    port: Number.isFinite(port) && port > 0 ? port : 993,
+    // Só quem explicitamente marcou 143/STARTTLS sai do TLS direto.
+    secure: cfg.secure === undefined ? true : Boolean(cfg.secure),
+    username: String(cfg.username ?? '').trim(),
+    password: String(cfg.password ?? ''),
+  };
+}
+
 export type ResendIntegrationConfig = {
   apiToken: string;
   domain: string;

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

@@ -1,4 +1,8 @@
-import { verifySesCredentials, verifySmtpConnection } from '@hed-hog/api-mail';
+import {
+  verifyImapConnection,
+  verifySesCredentials,
+  verifySmtpConnection,
+} from '@hed-hog/api-mail';
 import {
   describeHttpError,
   fail,
@@ -153,9 +157,38 @@ const resendTester: IntegrationTester = {
   },
 };
 
+/**
+ * IMAP é o único provider de e-mail que não envia — ele lê uma caixa. Por isso
+ * é o único que não exige `from_email`.
+ */
+const imapTester: IntegrationTester = {
+  providerSlug: 'imap',
+  test: async (config) => {
+    const missing = requireFields(config, [
+      ['host', 'IMAP host'],
+      ['username', 'Username'],
+      ['password', 'Password'],
+    ]);
+    if (missing) return missing;
+
+    const result = await verifyImapConnection({
+      host: str(config, 'host'),
+      port: Number(config.port ?? 993),
+      secure: config.secure === undefined ? true : Boolean(config.secure),
+      username: str(config, 'username'),
+      password: String(config.password ?? ''),
+      folder: str(config, 'folder') || 'INBOX',
+      timeoutMs: 10_000,
+    });
+
+    return result.ok ? pass(result.info) : fail(result.error!);
+  },
+};
+
 export const EMAIL_TESTERS: IntegrationTester[] = [
   smtpTester,
   sesTester,
   gmailTester,
   resendTester,
+  imapTester,
 ];

package/src/language/en.json

@@ -171,6 +171,17 @@
       "not_found": "Mail template with id {id} not found."
     }
   },
+  "oauth": {
+    "callback": {
+      "codeRequired": "Authorization code is required to complete OAuth authentication.",
+      "invalidState": "OAuth callback state is invalid or expired. Start the sign-in flow again.",
+      "invalidType": "Unsupported OAuth callback type.",
+      "invalid": "OAuth callback is invalid or expired. Start the sign-in flow again.",
+      "alreadyProcessed": "This OAuth callback was already processed. Start the sign-in flow again.",
+      "inProgress": "This OAuth callback is already being processed. Wait a moment and try again.",
+      "unavailable": "Unable to complete OAuth authentication right now. Please try again."
+    }
+  },
   "mail_sent_not_found": "Mail sent record not found.",
   "validationSslugMustBeString": "Slug must be a string.",
   "sessionRevoked": "Session has been revoked or expired.",

package/src/language/pt.json

@@ -171,6 +171,17 @@
       "not_found": "Modelo de e-mail com id {id} não encontrado."
     }
   },
+  "oauth": {
+    "callback": {
+      "codeRequired": "O código de autorização é obrigatório para concluir a autenticação.",
+      "invalidState": "O retorno da autenticação é inválido ou expirou. Inicie o login novamente.",
+      "invalidType": "Tipo de retorno de autenticação não suportado.",
+      "invalid": "O retorno da autenticação é inválido ou expirou. Inicie o login novamente.",
+      "alreadyProcessed": "Este retorno de autenticação já foi processado. Inicie o login novamente.",
+      "inProgress": "Este retorno de autenticação já está sendo processado. Aguarde um instante e tente novamente.",
+      "unavailable": "Não foi possível concluir a autenticação agora. Tente novamente."
+    }
+  },
   "mail_sent_not_found": "Registro de e-mail enviado não encontrado.",
   "validationSslugMustBeString": "O slug deve ser uma string.",
   "sessionRevoked": "Sessão foi revogada ou expirou.",

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

@@ -1,5 +1,5 @@
 import { getLocaleText } from '@hed-hog/api-locale';
-import { IsNotEmpty, IsObject, IsOptional, IsString } from 'class-validator';
+import { IsNotEmpty, IsNumber, IsObject, IsOptional, IsString } from 'class-validator';
 
 export class SendTemplatedMailDTO {
   @IsString({ message: (args) => getLocaleText('validation.stringRequired', args.value) })
@@ -21,8 +21,52 @@ export class SendTemplatedMailDTO {
   @IsString({ message: (args) => getLocaleText('validation.stringRequired', args.value) })
   profileSlug?: string;
 
-  /** Chave do app de origem (ex.: "class"), usada para resolver o nome de marca via a setting `app-names`. */
+  /**
+   * Endereco para onde a resposta do destinatario deve voltar.
+   *
+   * Sem isto a resposta cai no `from` do perfil, que nao carrega nenhuma
+   * identificacao do assunto tratado. E o que permite ao SAC endereçar cada
+   * chamado (`<protocolo>@dominio-de-resposta`) e reconhecer a resposta na
+   * entrada.
+   */
+  @IsOptional()
+  @IsString({ message: (args) => getLocaleText('validation.stringRequired', args.value) })
+  replyTo?: string;
+
+  /**
+   * Chave do app de origem (ex.: "class"). Nao afeta mais a marca —
+   * `{{brandName}}` vem sempre de `system-name`.
+   */
   @IsOptional()
   @IsString({ message: (args) => getLocaleText('validation.stringRequired', args.value) })
   app?: string;
+
+  /**
+   * Destinatario, quando o chamador ja o conhece.
+   *
+   * Serve so para pular a busca do usuario pelo e-mail na hora de descobrir o
+   * idioma de preferencia; omitir nao muda o resultado.
+   */
+  @IsOptional()
+  @IsNumber({}, { message: (args) => getLocaleText('validation.numberRequired', args.value) })
+  userId?: number;
 }
+
+/**
+ * Resultado de `MailService.sendTemplatedMail`.
+ *
+ * `sent: false` cobre tanto o aborto por configuração ausente quanto qualquer
+ * falha do provedor: os dois são tratados internamente e não lançam, então o
+ * retorno é a única forma de o chamador saber que nada saiu.
+ *
+ * Deliberadamente um objeto único em vez de união discriminada: as libraries
+ * compilam com `strictNullChecks: false`, e nessa configuração o `if (r.sent)`
+ * não estreita a união no ponto de uso.
+ */
+export type SendTemplatedMailResult = {
+  sent: boolean;
+  /** Id devolvido pelo provedor quando `sent` é `true`. */
+  providerMessageId?: string | null;
+  reason?: 'mail-not-configured' | 'send-failed' | 'template-locale-missing';
+  error?: string;
+};

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

@@ -1,5 +1,5 @@
 import { describe, it, expect } from '@jest/globals';
-import { DEFAULT_MAIL_LAYOUT, renderMailTemplate } from '@hed-hog/api-mail';
+import { DEFAULT_MAIL_LAYOUT, renderMailTemplate, resolveMailAssetUrl } 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.
@@ -192,6 +192,83 @@ describe('renderMailTemplate', () => {
     expect(DEFAULT_MAIL_LAYOUT.wrapper).toContain('{{{content}}}');
     expect(DEFAULT_MAIL_LAYOUT.wrapper).toContain('{{{header}}}');
     expect(DEFAULT_MAIL_LAYOUT.wrapper).toContain('{{{footer}}}');
-    expect(DEFAULT_MAIL_LAYOUT.header).toContain('{{brandName}}');
+    expect(DEFAULT_MAIL_LAYOUT.header).toContain('{{{brandMark}}}');
+  });
+
+  it('usa o selo de texto com a cor de marca quando nao ha logo', () => {
+    const html = renderMailTemplate({
+      subject: 'Bem-vindo',
+      body: '<p>Ola</p>',
+      brandName: 'Acme',
+      primaryColor: '#ff760c',
+      primaryForeground: '#ffffff',
+    });
+
+    expect(html).toContain('class="brand"');
+    expect(html).toContain('background:#ff760c');
+    expect(html).toContain('color:#ffffff');
+    expect(html).toContain('>Acme<');
+    // A cor tambem tempera o acento do painel e os links do corpo.
+    expect(html).toContain('background:#ff760c;"></div>');
+  });
+
+  it('usa a imagem do logo quando configurado, no lugar do selo de texto', () => {
+    const html = renderMailTemplate({
+      subject: 'Bem-vindo',
+      body: '<p>Ola</p>',
+      brandName: 'Acme',
+      logoUrl: 'https://cdn.example.com/logo.svg',
+    });
+
+    expect(html).toContain('<img src="https://cdn.example.com/logo.svg"');
+    expect(html).toContain('alt="Acme"');
+    expect(html).not.toContain('class="brand"');
+  });
+
+  it('ignora o logo quando a URL nao e publica, caindo no selo de texto', () => {
+    // Regressao do bug: com API_URL ausente, `image-url` = `/logo.svg` virava
+    // `http://localhost:3100/logo.svg` e o destinatario recebia um <img>
+    // quebrado, mostrando so o alt.
+    const html = renderMailTemplate({
+      subject: 'Bem-vindo',
+      body: '<p>Ola</p>',
+      brandName: 'Acme',
+      logoUrl: 'http://localhost:3100/logo.svg',
+    });
+
+    expect(html).not.toContain('<img');
+    expect(html).toContain('class="brand"');
+    expect(html).toContain('>Acme<');
+  });
+
+  it('cai para as cores padrao quando nenhuma e informada', () => {
+    const html = renderMailTemplate({ subject: 'x', body: 'corpo' });
+
+    expect(html).toContain('#111827');
+    expect(html).toContain('#ffffff');
+  });
+});
+
+describe('resolveMailAssetUrl', () => {
+  it('mantem URLs ja absolutas ou data: intactas', () => {
+    expect(resolveMailAssetUrl('https://cdn.example.com/logo.svg', 'http://localhost:3100')).toBe(
+      'https://cdn.example.com/logo.svg',
+    );
+    expect(resolveMailAssetUrl('data:image/png;base64,abc', 'http://localhost:3100')).toBe(
+      'data:image/png;base64,abc',
+    );
+  });
+
+  it('resolve caminhos relativos contra a base informada', () => {
+    expect(resolveMailAssetUrl('/logo.svg', 'http://localhost:3100')).toBe(
+      'http://localhost:3100/logo.svg',
+    );
+    expect(resolveMailAssetUrl('/logo.svg', 'http://localhost:3100/')).toBe(
+      'http://localhost:3100/logo.svg',
+    );
+  });
+
+  it('devolve string vazia quando a URL esta vazia', () => {
+    expect(resolveMailAssetUrl('', 'http://localhost:3100')).toBe('');
   });
 });

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],