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

package/cjs/providers/sendgrid-provider.spec.js

@@ -1,346 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-const _common = require("@nestjs/common");
-const _sendgridprovider = require("./sendgrid-provider");
-// @sendgrid/mail is not an installed dependency in this workspace, so the real dynamic
-// import() inside `initialize()` fails — exercised directly, no mocking needed.
-// For "happy path" behavior we bypass initialize() and inject a fake sgMail client,
-// matching the private `sgMail`/`apiKey` fields the provider mutates internally.
-function injectSgMail(provider, sgMail, apiKey = 'SG.fake-key') {
-    provider.sgMail = sgMail;
-    provider.apiKey = apiKey;
-}
-describe('SendGridProvider', ()=>{
-    let provider;
-    beforeEach(()=>{
-        provider = new _sendgridprovider.SendGridProvider();
-    });
-    describe('initialize', ()=>{
-        it('throws InternalServerErrorException with SDK_NOT_INSTALLED when @sendgrid/mail is unavailable', async ()=>{
-            await expect(provider.initialize({
-                apiKey: 'SG.key'
-            })).rejects.toThrow(_common.InternalServerErrorException);
-        });
-        it('surfaces the sdk name in the exception messageVariables', async ()=>{
-            try {
-                await provider.initialize({
-                    apiKey: 'SG.key'
-                });
-                fail('expected initialize to throw');
-            } catch (error) {
-                expect(error.getResponse()).toEqual(expect.objectContaining({
-                    messageKey: 'system.sdk.not.installed',
-                    messageVariables: {
-                        sdk: 'sendgrid'
-                    }
-                }));
-            }
-        });
-    });
-    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: 'SendGrid provider not initialized'
-            });
-        });
-        it('sends via sgMail.send and extracts the message id from response headers', async ()=>{
-            const send = jest.fn().mockResolvedValue([
-                {
-                    headers: {
-                        'x-message-id': 'sg-msg-1'
-                    }
-                }
-            ]);
-            injectSgMail(provider, {
-                send
-            });
-            const result = await provider.sendEmail({
-                to: [
-                    'a@example.com',
-                    'b@example.com'
-                ],
-                subject: 'Hello',
-                html: '<p>hi</p>',
-                from: 'sender@example.com',
-                fromName: 'Sender Name',
-                cc: 'c@example.com',
-                bcc: [
-                    'd@example.com'
-                ],
-                replyTo: 'reply@example.com'
-            });
-            expect(result).toEqual({
-                success: true,
-                messageId: 'sg-msg-1'
-            });
-            expect(send).toHaveBeenCalledWith(expect.objectContaining({
-                to: [
-                    'a@example.com',
-                    'b@example.com'
-                ],
-                from: {
-                    email: 'sender@example.com',
-                    name: 'Sender Name'
-                },
-                subject: 'Hello',
-                html: '<p>hi</p>',
-                cc: [
-                    'c@example.com'
-                ],
-                bcc: [
-                    'd@example.com'
-                ],
-                replyTo: 'reply@example.com'
-            }));
-        });
-        it('falls back to the capitalized X-Message-Id header when lowercase is absent', async ()=>{
-            const send = jest.fn().mockResolvedValue([
-                {
-                    headers: {
-                        'X-Message-Id': 'sg-msg-2'
-                    }
-                }
-            ]);
-            injectSgMail(provider, {
-                send
-            });
-            const result = await provider.sendEmail({
-                to: 'a@example.com',
-                subject: 'Hi',
-                from: 'x@example.com'
-            });
-            expect(result).toEqual({
-                success: true,
-                messageId: 'sg-msg-2'
-            });
-        });
-        it('base64-encodes buffer attachment content for the SendGrid payload', async ()=>{
-            const send = jest.fn().mockResolvedValue([
-                {
-                    headers: {}
-                }
-            ]);
-            injectSgMail(provider, {
-                send
-            });
-            await provider.sendEmail({
-                to: 'a@example.com',
-                subject: 'Hi',
-                from: 'x@example.com',
-                attachments: [
-                    {
-                        filename: 'doc.txt',
-                        content: Buffer.from('hello'),
-                        contentType: 'text/plain'
-                    }
-                ]
-            });
-            const [msg] = send.mock.calls[0];
-            expect(msg.attachments[0]).toEqual({
-                filename: 'doc.txt',
-                content: Buffer.from('hello').toString('base64'),
-                type: 'text/plain',
-                disposition: 'attachment'
-            });
-        });
-        it('returns the SendGrid API error message on failure', async ()=>{
-            injectSgMail(provider, {
-                send: jest.fn().mockRejectedValue({
-                    response: {
-                        body: {
-                            errors: [
-                                {
-                                    message: 'Invalid recipient'
-                                }
-                            ]
-                        }
-                    }
-                })
-            });
-            const result = await provider.sendEmail({
-                to: 'a@example.com',
-                subject: 'Hi'
-            });
-            expect(result).toEqual({
-                success: false,
-                error: 'Invalid recipient'
-            });
-        });
-        it('falls back to the generic error message when no SendGrid error body is present', async ()=>{
-            injectSgMail(provider, {
-                send: jest.fn().mockRejectedValue(new Error('network down'))
-            });
-            const result = await provider.sendEmail({
-                to: 'a@example.com',
-                subject: 'Hi'
-            });
-            expect(result).toEqual({
-                success: false,
-                error: 'network down'
-            });
-        });
-        it('falls back to "Unknown error" when no message is available at all', async ()=>{
-            injectSgMail(provider, {
-                send: jest.fn().mockRejectedValue({})
-            });
-            const result = await provider.sendEmail({
-                to: 'a@example.com',
-                subject: 'Hi'
-            });
-            expect(result).toEqual({
-                success: false,
-                error: 'Unknown error'
-            });
-        });
-    });
-    describe('sendBulkEmails', ()=>{
-        it('returns a not-initialized failure per message when not initialized', async ()=>{
-            const results = await provider.sendBulkEmails([
-                {
-                    to: 'a@example.com',
-                    subject: 'A'
-                },
-                {
-                    to: 'b@example.com',
-                    subject: 'B'
-                }
-            ]);
-            expect(results).toEqual([
-                {
-                    success: false,
-                    error: 'SendGrid provider not initialized'
-                },
-                {
-                    success: false,
-                    error: 'SendGrid provider not initialized'
-                }
-            ]);
-        });
-        it('sends all messages in a single sgMail.send call and reports success for all', async ()=>{
-            const send = jest.fn().mockResolvedValue(undefined);
-            injectSgMail(provider, {
-                send
-            });
-            const results = await provider.sendBulkEmails([
-                {
-                    to: 'a@example.com',
-                    subject: 'A',
-                    from: 'x@example.com'
-                },
-                {
-                    to: 'b@example.com',
-                    subject: 'B',
-                    from: 'x@example.com'
-                }
-            ]);
-            expect(send).toHaveBeenCalledTimes(1);
-            expect(send).toHaveBeenCalledWith([
-                expect.objectContaining({
-                    to: [
-                        'a@example.com'
-                    ],
-                    subject: 'A'
-                }),
-                expect.objectContaining({
-                    to: [
-                        'b@example.com'
-                    ],
-                    subject: 'B'
-                })
-            ]);
-            expect(results).toEqual([
-                {
-                    success: true
-                },
-                {
-                    success: true
-                }
-            ]);
-        });
-        it('excludes cc/bcc/replyTo/attachments from bulk messages (includeExtras=false)', async ()=>{
-            const send = jest.fn().mockResolvedValue(undefined);
-            injectSgMail(provider, {
-                send
-            });
-            await provider.sendBulkEmails([
-                {
-                    to: 'a@example.com',
-                    subject: 'A',
-                    from: 'x@example.com',
-                    cc: 'c@example.com',
-                    replyTo: 'r@example.com'
-                }
-            ]);
-            const [messages] = send.mock.calls[0];
-            expect(messages[0]).not.toHaveProperty('cc');
-            expect(messages[0]).not.toHaveProperty('replyTo');
-        });
-        it('reports the same failure for every message when the bulk send call rejects', async ()=>{
-            injectSgMail(provider, {
-                send: jest.fn().mockRejectedValue(new Error('rate limited'))
-            });
-            const results = await provider.sendBulkEmails([
-                {
-                    to: 'a@example.com',
-                    subject: 'A',
-                    from: 'x@example.com'
-                },
-                {
-                    to: 'b@example.com',
-                    subject: 'B',
-                    from: 'x@example.com'
-                }
-            ]);
-            expect(results).toEqual([
-                {
-                    success: false,
-                    error: 'rate limited'
-                },
-                {
-                    success: false,
-                    error: 'rate limited'
-                }
-            ]);
-        });
-    });
-    describe('healthCheck', ()=>{
-        it('returns false when not initialized', async ()=>{
-            await expect(provider.healthCheck()).resolves.toBe(false);
-        });
-        it('returns true when sgMail is set and the api key has the SG. prefix', async ()=>{
-            injectSgMail(provider, {
-                send: jest.fn()
-            }, 'SG.validkey');
-            await expect(provider.healthCheck()).resolves.toBe(true);
-        });
-        it('returns false when the api key does not have the SG. prefix', async ()=>{
-            injectSgMail(provider, {
-                send: jest.fn()
-            }, 'invalid-key');
-            await expect(provider.healthCheck()).resolves.toBe(false);
-        });
-    });
-    describe('close', ()=>{
-        it('clears the sgMail client reference', async ()=>{
-            injectSgMail(provider, {
-                send: jest.fn()
-            });
-            await provider.close();
-            const result = await provider.sendEmail({
-                to: 'a@example.com',
-                subject: 'Hi'
-            });
-            expect(result).toEqual({
-                success: false,
-                error: 'SendGrid provider not initialized'
-            });
-        });
-    });
-});

package/cjs/providers/smtp-provider.js

@@ -1,164 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "SmtpProvider", {
-    enumerable: true,
-    get: function() {
-        return SmtpProvider;
-    }
-});
-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;
-}
-function _getRequireWildcardCache(nodeInterop) {
-    if (typeof WeakMap !== "function") return null;
-    var cacheBabelInterop = new WeakMap();
-    var cacheNodeInterop = new WeakMap();
-    return (_getRequireWildcardCache = function(nodeInterop) {
-        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
-    })(nodeInterop);
-}
-function _interop_require_wildcard(obj, nodeInterop) {
-    if (!nodeInterop && obj && obj.__esModule) {
-        return obj;
-    }
-    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
-        return {
-            default: obj
-        };
-    }
-    var cache = _getRequireWildcardCache(nodeInterop);
-    if (cache && cache.has(obj)) {
-        return cache.get(obj);
-    }
-    var newObj = {
-        __proto__: null
-    };
-    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
-    for(var key in obj){
-        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
-            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
-            if (desc && (desc.get || desc.set)) {
-                Object.defineProperty(newObj, key, desc);
-            } else {
-                newObj[key] = obj[key];
-            }
-        }
-    }
-    newObj.default = obj;
-    if (cache) {
-        cache.set(obj, newObj);
-    }
-    return newObj;
-}
-const VERIFY_TIMEOUT_MS = 10_000;
-const SEND_TIMEOUT_MS = 30_000;
-let SmtpProvider = class SmtpProvider {
-    async initialize(config) {
-        const nodemailer = await Promise.resolve().then(()=>/*#__PURE__*/ _interop_require_wildcard(require("nodemailer")));
-        this.transporter = nodemailer.createTransport({
-            host: config.host,
-            port: config.port,
-            secure: config.secure ?? config.port === 465,
-            auth: config.auth,
-            connectionTimeout: VERIFY_TIMEOUT_MS,
-            greetingTimeout: VERIFY_TIMEOUT_MS,
-            socketTimeout: SEND_TIMEOUT_MS,
-            tls: {
-                rejectUnauthorized: config.tls?.rejectUnauthorized ?? true,
-                minVersion: config.tls?.minVersion ?? 'TLSv1.2'
-            }
-        });
-        await this.withTimeout(this.transporter.verify(), VERIFY_TIMEOUT_MS, 'SMTP verification timeout');
-    }
-    async sendEmail(options) {
-        if (!this.transporter) return {
-            success: false,
-            error: 'SMTP provider not initialized'
-        };
-        try {
-            const mailOptions = {
-                from: this.formatFrom(options.from, options.fromName),
-                to: this.joinAddresses(options.to),
-                cc: options.cc ? this.joinAddresses(options.cc) : undefined,
-                bcc: options.bcc ? this.joinAddresses(options.bcc) : undefined,
-                subject: options.subject,
-                text: options.text,
-                html: options.html,
-                replyTo: options.replyTo,
-                attachments: options.attachments?.map((a)=>({
-                        filename: a.filename,
-                        content: a.content,
-                        contentType: a.contentType,
-                        encoding: a.encoding
-                    }))
-            };
-            const info = await this.withTimeout(this.transporter.sendMail(mailOptions), SEND_TIMEOUT_MS, 'SMTP send timeout');
-            return {
-                success: true,
-                messageId: info.messageId
-            };
-        } 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.transporter) return false;
-        try {
-            await this.transporter.verify();
-            return true;
-        } catch  {
-            return false;
-        }
-    }
-    async close() {
-        if (this.transporter) {
-            this.transporter.close();
-            this.transporter = null;
-        }
-    }
-    // ─── Private Helpers ────────────────────────────────────────────────────────
-    formatFrom(from, fromName) {
-        return fromName ? `"${fromName}" <${from}>` : from;
-    }
-    joinAddresses(addresses) {
-        return Array.isArray(addresses) ? addresses.join(', ') : addresses;
-    }
-    async withTimeout(promise, ms, message) {
-        let timer;
-        const timeout = new Promise((_, reject)=>{
-            timer = setTimeout(()=>reject(new Error(message)), ms);
-        });
-        try {
-            return await Promise.race([
-                promise,
-                timeout
-            ]);
-        } finally{
-            clearTimeout(timer);
-        }
-    }
-    extractError(error) {
-        return error instanceof Error ? error.message : 'Unknown error';
-    }
-    constructor(){
-        _define_property(this, "transporter", null);
-    }
-};