fix(mailer): normalize provider response to nodemailer format

Resend returns { id } while Nodemailer returns { accepted, rejected }.
Normalize in sendMail() so controllers checking mail?.accepted.length
work correctly with any provider. Also add attachment support to both
providers and mailer index.

Closes #3373

Author: PierreBrisorgueil

lib/helpers/mailer/index.js

@@ -44,6 +44,9 @@ const isConfigured = () => !!(config.mailer && config.mailer.from && !String(con
  * @param {string} mail.subject - Email subject
  * @param {string} mail.template - Template name (without .html)
  * @param {Object} mail.params - Template parameters
+ * @param {Array} [mail.attachments] - Optional attachments array
+ * @param {string} mail.attachments[].filename - Attachment filename
+ * @param {string} mail.attachments[].content - Attachment content (string or Buffer)
  * @returns {Promise<Object|null>} The send result or null if not configured
  */
 const sendMail = async (mail) => {
@@ -54,12 +57,15 @@ const sendMail = async (mail) => {
   const template = handlebars.compile(file);
   const html = template(mail.params);
   try {
-    return await getProvider().send({
+    const result = await getProvider().send({
       from: config.mailer.from,
       to: mail.to,
       subject: mail.subject,
       html,
+      attachments: mail.attachments,
     });
+    if (!Array.isArray(result?.accepted)) return { ...result, accepted: [mail.to], rejected: [] };
+    return result;
   } catch (err) {
     console.error(`Mail send error: ${err.message}`);
     return null;

lib/helpers/mailer/provider.nodemailer.js

@@ -5,7 +5,9 @@ export default class NodemailerProvider {
     this.transport = nodemailer.createTransport(options);
   }
 
-  async send({ from, to, subject, html }) {
-    return this.transport.sendMail({ from, to, subject, html });
+  async send({ from, to, subject, html, attachments }) {
+    const payload = { from, to, subject, html };
+    if (attachments?.length) payload.attachments = attachments;
+    return this.transport.sendMail(payload);
   }
 }

lib/helpers/mailer/provider.resend.js

@@ -19,10 +19,20 @@ export default class ResendProvider {
    * @param {string} mail.to - Recipient address
    * @param {string} mail.subject - Email subject
    * @param {string} mail.html - HTML body
+   * @param {Array} [mail.attachments] - Optional attachments array
+   * @param {string} mail.attachments[].filename - Attachment filename
+   * @param {string} mail.attachments[].content - Attachment content (string or Buffer)
    * @returns {Promise<Object>} Resend API response data
    */
-  async send({ from, to, subject, html }) {
-    const { data, error } = await this.client.emails.send({ from, to, subject, html });
+  async send({ from, to, subject, html, attachments }) {
+    const payload = { from, to, subject, html };
+    if (attachments?.length) {
+      payload.attachments = attachments.map((a) => ({
+        filename: a.filename,
+        content: Buffer.from(a.content).toString('base64'),
+      }));
+    }
+    const { data, error } = await this.client.emails.send(payload);
     if (error) throw new Error(error.message || 'Resend API error');
     return data;
   }

lib/helpers/mailer/tests/mailer.unit.tests.js

@@ -20,7 +20,7 @@ jest.unstable_mockModule('../../files.js', () => ({
   },
 }));
 
-const mockSend = jest.fn().mockResolvedValue({ id: 'email_123' });
+const mockSend = jest.fn().mockResolvedValue({ id: 'email_123', accepted: ['user@example.com'], rejected: [] });
 jest.unstable_mockModule('../provider.resend.js', () => ({
   default: jest.fn().mockImplementation(() => ({ send: mockSend })),
 }));
@@ -40,7 +40,7 @@ describe('mailer index with resend provider unit tests:', () => {
     expect(mailer.isConfigured()).toBe(true);
   });
 
-  test('should send mail using the resend provider', async () => {
+  test('should send mail using the resend provider and normalize response', async () => {
     mockSend.mockResolvedValue({ id: 'email_456' });
 
     const result = await mailer.sendMail({
@@ -58,10 +58,42 @@ describe('mailer index with resend provider unit tests:', () => {
         html: '<p>Alice</p>',
       }),
     );
-    expect(result).toEqual({ id: 'email_456' });
+    expect(result).toEqual({ id: 'email_456', accepted: ['user@example.com'], rejected: [] });
   });
 
-  test('should return null on send error', async () => {
+  test('should pass through response unchanged when accepted is already an array', async () => {
+    mockSend.mockResolvedValue({ id: 'email_789', accepted: ['user@example.com'], rejected: [] });
+
+    const result = await mailer.sendMail({
+      to: 'user@example.com',
+      subject: 'Welcome',
+      template: 'welcome',
+      params: { name: 'Charlie' },
+    });
+
+    expect(result).toEqual({ id: 'email_789', accepted: ['user@example.com'], rejected: [] });
+  });
+
+  test('should forward attachments to the provider', async () => {
+    mockSend.mockResolvedValue({ id: 'email_attach', accepted: ['user@example.com'], rejected: [] });
+
+    const attachments = [{ filename: 'report.csv', content: 'a,b\n1,2' }];
+    await mailer.sendMail({
+      to: 'user@example.com',
+      subject: 'Report',
+      template: 'welcome',
+      params: { name: 'Carol' },
+      attachments,
+    });
+
+    expect(mockSend).toHaveBeenCalledWith(
+      expect.objectContaining({
+        attachments,
+      }),
+    );
+  });
+
+    test('should return null on send error', async () => {
     mockSend.mockRejectedValue(new Error('API failure'));
 
     const result = await mailer.sendMail({

lib/helpers/mailer/tests/provider.resend.unit.tests.js

@@ -57,6 +57,33 @@ describe('ResendProvider unit tests:', () => {
     expect(result).toEqual(mockData);
   });
 
+  test('should send an email with attachments', async () => {
+    const mockData = { id: 'email_456' };
+    sendMock.mockResolvedValue({ data: mockData, error: null });
+
+    const result = await provider.send({
+      from: 'sender@example.com',
+      to: 'recipient@example.com',
+      subject: 'Test with attachment',
+      html: '<p>See attached</p>',
+      attachments: [{ filename: 'data.csv', content: 'col1,col2\nval1,val2' }],
+    });
+
+    expect(sendMock).toHaveBeenCalledWith({
+      from: 'sender@example.com',
+      to: 'recipient@example.com',
+      subject: 'Test with attachment',
+      html: '<p>See attached</p>',
+      attachments: [
+        {
+          filename: 'data.csv',
+          content: Buffer.from('col1,col2\nval1,val2').toString('base64'),
+        },
+      ],
+    });
+    expect(result).toEqual(mockData);
+  });
+
   test('should throw on Resend API error', async () => {
     sendMock.mockResolvedValue({ data: null, error: { message: 'Invalid API key' } });