@flusys/nestjs-email 7.1.0 → 8.0.0-beta.1

package/fesm/providers/mailgun-provider.js

@@ -1,109 +0,0 @@
-function _define_property(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
-import { SYSTEM_MESSAGES } from '@flusys/nestjs-shared/constants';
-import { InternalServerErrorException } from '@nestjs/common';
-const MAILGUN_API_URL = 'https://api.mailgun.net';
-const MAILGUN_EU_API_URL = 'https://api.eu.mailgun.net';
-export class MailgunProvider {
-    async initialize(config) {
-        this.domain = config.domain;
-        try {
-            // Dynamic import for optional dependency
-            const Mailgun = (await new Function('return import("mailgun.js")')()).default;
-            const FormData = (await new Function('return import("form-data")')()).default;
-            const mailgun = new Mailgun(FormData);
-            const url = config.region === 'eu' ? MAILGUN_EU_API_URL : MAILGUN_API_URL;
-            this.client = mailgun.client({
-                username: 'api',
-                key: config.apiKey,
-                url
-            });
-        } catch  {
-            throw new InternalServerErrorException({
-                message: 'Mailgun initialization failed. Install: npm install mailgun.js form-data',
-                messageKey: SYSTEM_MESSAGES.SDK_NOT_INSTALLED,
-                messageVariables: {
-                    sdk: 'mailgun'
-                }
-            });
-        }
-    }
-    async sendEmail(options) {
-        if (!this.client || !this.domain) {
-            return {
-                success: false,
-                error: 'Mailgun provider not initialized'
-            };
-        }
-        try {
-            const messageData = this.buildMessageData(options);
-            const result = await this.client.messages.create(this.domain, messageData);
-            return {
-                success: true,
-                messageId: result.id
-            };
-        } catch (error) {
-            return {
-                success: false,
-                error: this.extractError(error)
-            };
-        }
-    }
-    async sendBulkEmails(options) {
-        return Promise.all(options.map((opt)=>this.sendEmail(opt)));
-    }
-    async healthCheck() {
-        if (!this.client || !this.domain) return false;
-        try {
-            await this.client.domains.get(this.domain);
-            return true;
-        } catch  {
-            return false;
-        }
-    }
-    async close() {
-        this.client = null;
-    }
-    // ─── Private Helpers ────────────────────────────────────────────────────────
-    buildMessageData(options) {
-        const data = {
-            from: options.fromName ? `${options.fromName} <${options.from}>` : options.from,
-            to: this.joinAddresses(options.to),
-            subject: options.subject
-        };
-        if (options.html) data.html = options.html;
-        if (options.text) data.text = options.text;
-        if (options.cc) data.cc = this.joinAddresses(options.cc);
-        if (options.bcc) data.bcc = this.joinAddresses(options.bcc);
-        if (options.replyTo) data['h:Reply-To'] = options.replyTo;
-        if (options.attachments?.length) {
-            data.attachment = options.attachments.map((a)=>({
-                    filename: a.filename,
-                    data: typeof a.content === 'string' ? Buffer.from(a.content, 'base64') : a.content,
-                    contentType: a.contentType
-                }));
-        }
-        return data;
-    }
-    joinAddresses(addresses) {
-        return Array.isArray(addresses) ? addresses.join(', ') : addresses;
-    }
-    extractError(error) {
-        return error instanceof Error ? error.message : 'Unknown error';
-    }
-    constructor(){
-        _define_property(this, "client", null);
-        _define_property(this, "domain", null);
-    }
-}

package/fesm/providers/mailgun-provider.spec.js

@@ -1,240 +0,0 @@
-import { InternalServerErrorException } from '@nestjs/common';
-import { MailgunProvider } from './mailgun-provider';
-// mailgun.js is not an installed dependency in this workspace, so the real dynamic
-// import() inside `initialize()` fails — that's exercised directly (no mocking needed).
-// For "happy path" behavior we bypass initialize() and inject a fake client, matching
-// the private `client`/`domain` fields the provider mutates internally.
-function injectClient(provider, client, domain = 'example.com') {
-    provider.client = client;
-    provider.domain = domain;
-}
-describe('MailgunProvider', ()=>{
-    let provider;
-    beforeEach(()=>{
-        provider = new MailgunProvider();
-    });
-    describe('initialize', ()=>{
-        it('throws InternalServerErrorException with SDK_NOT_INSTALLED when mailgun.js is unavailable', async ()=>{
-            await expect(provider.initialize({
-                apiKey: 'key',
-                domain: 'example.com'
-            })).rejects.toThrow(InternalServerErrorException);
-        });
-        it('surfaces the sdk name in the exception messageVariables', async ()=>{
-            try {
-                await provider.initialize({
-                    apiKey: 'key',
-                    domain: 'example.com'
-                });
-                fail('expected initialize to throw');
-            } catch (error) {
-                expect(error.getResponse()).toEqual(expect.objectContaining({
-                    messageKey: 'system.sdk.not.installed',
-                    messageVariables: {
-                        sdk: 'mailgun'
-                    }
-                }));
-            }
-        });
-    });
-    describe('sendEmail', ()=>{
-        it('returns a failure result when the provider was never initialized', async ()=>{
-            const result = await provider.sendEmail({
-                to: 'a@example.com',
-                subject: 'Hi'
-            });
-            expect(result).toEqual({
-                success: false,
-                error: 'Mailgun provider not initialized'
-            });
-        });
-        it('sends via the mailgun client and returns the message id on success', async ()=>{
-            const create = jest.fn().mockResolvedValue({
-                id: '<msg-1@mailgun>'
-            });
-            injectClient(provider, {
-                messages: {
-                    create
-                }
-            });
-            const result = await provider.sendEmail({
-                to: 'a@example.com',
-                cc: [
-                    'b@example.com',
-                    'c@example.com'
-                ],
-                bcc: 'd@example.com',
-                subject: 'Hello',
-                html: '<p>hi</p>',
-                text: 'hi',
-                from: 'sender@example.com',
-                fromName: 'Sender Name',
-                replyTo: 'reply@example.com'
-            });
-            expect(result).toEqual({
-                success: true,
-                messageId: '<msg-1@mailgun>'
-            });
-            expect(create).toHaveBeenCalledWith('example.com', expect.objectContaining({
-                from: 'Sender Name <sender@example.com>',
-                to: 'a@example.com',
-                subject: 'Hello',
-                html: '<p>hi</p>',
-                text: 'hi',
-                cc: 'b@example.com, c@example.com',
-                bcc: 'd@example.com',
-                'h:Reply-To': 'reply@example.com'
-            }));
-        });
-        it('omits optional fields (cc/bcc/replyTo/html/text) when not provided', async ()=>{
-            const create = jest.fn().mockResolvedValue({
-                id: 'id-1'
-            });
-            injectClient(provider, {
-                messages: {
-                    create
-                }
-            });
-            await provider.sendEmail({
-                to: 'a@example.com',
-                subject: 'Hi',
-                from: 'x@example.com'
-            });
-            const [, messageData] = create.mock.calls[0];
-            expect(messageData).not.toHaveProperty('cc');
-            expect(messageData).not.toHaveProperty('bcc');
-            expect(messageData).not.toHaveProperty('h:Reply-To');
-            expect(messageData).not.toHaveProperty('html');
-            expect(messageData).not.toHaveProperty('text');
-        });
-        it('base64-decodes attachment content before sending', async ()=>{
-            const create = jest.fn().mockResolvedValue({
-                id: 'id-1'
-            });
-            injectClient(provider, {
-                messages: {
-                    create
-                }
-            });
-            await provider.sendEmail({
-                to: 'a@example.com',
-                subject: 'Hi',
-                attachments: [
-                    {
-                        filename: 'doc.txt',
-                        content: Buffer.from('hello').toString('base64'),
-                        contentType: 'text/plain'
-                    }
-                ]
-            });
-            const [, messageData] = create.mock.calls[0];
-            const attachment = messageData.attachment[0];
-            expect(attachment.filename).toBe('doc.txt');
-            expect(attachment.contentType).toBe('text/plain');
-            expect(Buffer.isBuffer(attachment.data)).toBe(true);
-            expect(attachment.data.toString('utf8')).toBe('hello');
-        });
-        it('returns the error message when the mailgun client rejects with an Error', async ()=>{
-            injectClient(provider, {
-                messages: {
-                    create: jest.fn().mockRejectedValue(new Error('domain not found'))
-                }
-            });
-            const result = await provider.sendEmail({
-                to: 'a@example.com',
-                subject: 'Hi'
-            });
-            expect(result).toEqual({
-                success: false,
-                error: 'domain not found'
-            });
-        });
-        it('returns "Unknown error" when the mailgun client rejects with a non-Error', async ()=>{
-            injectClient(provider, {
-                messages: {
-                    create: jest.fn().mockRejectedValue('some string failure')
-                }
-            });
-            const result = await provider.sendEmail({
-                to: 'a@example.com',
-                subject: 'Hi'
-            });
-            expect(result).toEqual({
-                success: false,
-                error: 'Unknown error'
-            });
-        });
-    });
-    describe('sendBulkEmails', ()=>{
-        it('sends each message individually and aggregates the results', async ()=>{
-            const create = jest.fn().mockResolvedValueOnce({
-                id: 'id-1'
-            }).mockRejectedValueOnce(new Error('failed-2'));
-            injectClient(provider, {
-                messages: {
-                    create
-                }
-            });
-            const results = await provider.sendBulkEmails([
-                {
-                    to: 'a@example.com',
-                    subject: 'A'
-                },
-                {
-                    to: 'b@example.com',
-                    subject: 'B'
-                }
-            ]);
-            expect(results).toEqual([
-                {
-                    success: true,
-                    messageId: 'id-1'
-                },
-                {
-                    success: false,
-                    error: 'failed-2'
-                }
-            ]);
-            expect(create).toHaveBeenCalledTimes(2);
-        });
-    });
-    describe('healthCheck', ()=>{
-        it('returns false when not initialized', async ()=>{
-            await expect(provider.healthCheck()).resolves.toBe(false);
-        });
-        it('returns true when the mailgun domain lookup succeeds', async ()=>{
-            injectClient(provider, {
-                domains: {
-                    get: jest.fn().mockResolvedValue({})
-                }
-            });
-            await expect(provider.healthCheck()).resolves.toBe(true);
-        });
-        it('returns false when the mailgun domain lookup fails', async ()=>{
-            injectClient(provider, {
-                domains: {
-                    get: jest.fn().mockRejectedValue(new Error('nope'))
-                }
-            });
-            await expect(provider.healthCheck()).resolves.toBe(false);
-        });
-    });
-    describe('close', ()=>{
-        it('clears the client reference', async ()=>{
-            injectClient(provider, {
-                messages: {
-                    create: jest.fn()
-                }
-            });
-            await provider.close();
-            const result = await provider.sendEmail({
-                to: 'a@example.com',
-                subject: 'Hi'
-            });
-            expect(result).toEqual({
-                success: false,
-                error: 'Mailgun provider not initialized'
-            });
-        });
-    });
-});

package/fesm/providers/sendgrid-provider.js

@@ -1,119 +0,0 @@
-function _define_property(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
-import { SYSTEM_MESSAGES } from '@flusys/nestjs-shared/constants';
-import { InternalServerErrorException } from '@nestjs/common';
-export class SendGridProvider {
-    async initialize(config) {
-        this.apiKey = config.apiKey;
-        try {
-            // Dynamic import to avoid bundling issues
-            const sgMailModule = await new Function('return import("@sendgrid/mail")')();
-            this.sgMail = sgMailModule.default || sgMailModule;
-            this.sgMail.setApiKey(config.apiKey);
-        } catch  {
-            throw new InternalServerErrorException({
-                message: 'SendGrid initialization failed. Install: npm install @sendgrid/mail',
-                messageKey: SYSTEM_MESSAGES.SDK_NOT_INSTALLED,
-                messageVariables: {
-                    sdk: 'sendgrid'
-                }
-            });
-        }
-    }
-    async sendEmail(options) {
-        if (!this.sgMail) return {
-            success: false,
-            error: 'SendGrid provider not initialized'
-        };
-        try {
-            const msg = this.buildMessage(options, true);
-            const [response] = await this.sgMail.send(msg);
-            const messageId = response.headers['x-message-id'] || response.headers['X-Message-Id'];
-            return {
-                success: true,
-                messageId
-            };
-        } catch (error) {
-            return {
-                success: false,
-                error: this.extractError(error)
-            };
-        }
-    }
-    async sendBulkEmails(options) {
-        if (!this.sgMail) return options.map(()=>({
-                success: false,
-                error: 'SendGrid provider not initialized'
-            }));
-        try {
-            const messages = options.map((opt)=>this.buildMessage(opt, false));
-            await this.sgMail.send(messages);
-            return options.map(()=>({
-                    success: true
-                }));
-        } catch (error) {
-            const errorMessage = this.extractError(error);
-            return options.map(()=>({
-                    success: false,
-                    error: errorMessage
-                }));
-        }
-    }
-    async healthCheck() {
-        return !!(this.sgMail && this.apiKey?.startsWith('SG.'));
-    }
-    async close() {
-        this.sgMail = null;
-    }
-    // ─── Private Helpers ────────────────────────────────────────────────────────
-    buildMessage(options, includeExtras) {
-        const msg = {
-            to: this.toArray(options.to),
-            from: options.fromName ? {
-                email: options.from,
-                name: options.fromName
-            } : options.from,
-            subject: options.subject
-        };
-        if (options.html) msg.html = options.html;
-        if (options.text) msg.text = options.text;
-        if (includeExtras) {
-            if (options.cc) msg.cc = this.toArray(options.cc);
-            if (options.bcc) msg.bcc = this.toArray(options.bcc);
-            if (options.replyTo) msg.replyTo = options.replyTo;
-            if (options.attachments?.length) {
-                msg.attachments = options.attachments.map((a)=>({
-                        filename: a.filename,
-                        content: typeof a.content === 'string' ? a.content : a.content.toString('base64'),
-                        type: a.contentType,
-                        disposition: 'attachment'
-                    }));
-            }
-        }
-        return msg;
-    }
-    toArray(value) {
-        return Array.isArray(value) ? value : [
-            value
-        ];
-    }
-    extractError(error) {
-        const sgError = error;
-        return sgError.response?.body?.errors?.[0]?.message || sgError.message || 'Unknown error';
-    }
-    constructor(){
-        _define_property(this, "sgMail", null);
-        _define_property(this, "apiKey", null);
-    }
-}