@depup/nodemailer 7.0.12-depup.0

package/lib/sendmail-transport/index.js

@@ -0,0 +1,210 @@
+'use strict';
+
+const spawn = require('child_process').spawn;
+const packageData = require('../../package.json');
+const shared = require('../shared');
+
+/**
+ * Generates a Transport object for Sendmail
+ *
+ * Possible options can be the following:
+ *
+ *  * **path** optional path to sendmail binary
+ *  * **newline** either 'windows' or 'unix'
+ *  * **args** an array of arguments for the sendmail binary
+ *
+ * @constructor
+ * @param {Object} optional config parameter for Sendmail
+ */
+class SendmailTransport {
+    constructor(options) {
+        options = options || {};
+
+        // use a reference to spawn for mocking purposes
+        this._spawn = spawn;
+
+        this.options = options || {};
+
+        this.name = 'Sendmail';
+        this.version = packageData.version;
+
+        this.path = 'sendmail';
+        this.args = false;
+        this.winbreak = false;
+
+        this.logger = shared.getLogger(this.options, {
+            component: this.options.component || 'sendmail'
+        });
+
+        if (options) {
+            if (typeof options === 'string') {
+                this.path = options;
+            } else if (typeof options === 'object') {
+                if (options.path) {
+                    this.path = options.path;
+                }
+                if (Array.isArray(options.args)) {
+                    this.args = options.args;
+                }
+                this.winbreak = ['win', 'windows', 'dos', '\r\n'].includes((options.newline || '').toString().toLowerCase());
+            }
+        }
+    }
+
+    /**
+     * <p>Compiles a mailcomposer message and forwards it to handler that sends it.</p>
+     *
+     * @param {Object} emailMessage MailComposer object
+     * @param {Function} callback Callback function to run when the sending is completed
+     */
+    send(mail, done) {
+        // Sendmail strips this header line by itself
+        mail.message.keepBcc = true;
+
+        let envelope = mail.data.envelope || mail.message.getEnvelope();
+        let messageId = mail.message.messageId();
+        let args;
+        let sendmail;
+        let returned;
+
+        const hasInvalidAddresses = []
+            .concat(envelope.from || [])
+            .concat(envelope.to || [])
+            .some(addr => /^-/.test(addr));
+        if (hasInvalidAddresses) {
+            return done(new Error('Can not send mail. Invalid envelope addresses.'));
+        }
+
+        if (this.args) {
+            // force -i to keep single dots
+            args = ['-i'].concat(this.args).concat(envelope.to);
+        } else {
+            args = ['-i'].concat(envelope.from ? ['-f', envelope.from] : []).concat(envelope.to);
+        }
+
+        let callback = err => {
+            if (returned) {
+                // ignore any additional responses, already done
+                return;
+            }
+            returned = true;
+            if (typeof done === 'function') {
+                if (err) {
+                    return done(err);
+                } else {
+                    return done(null, {
+                        envelope: mail.data.envelope || mail.message.getEnvelope(),
+                        messageId,
+                        response: 'Messages queued for delivery'
+                    });
+                }
+            }
+        };
+
+        try {
+            sendmail = this._spawn(this.path, args);
+        } catch (E) {
+            this.logger.error(
+                {
+                    err: E,
+                    tnx: 'spawn',
+                    messageId
+                },
+                'Error occurred while spawning sendmail. %s',
+                E.message
+            );
+            return callback(E);
+        }
+
+        if (sendmail) {
+            sendmail.on('error', err => {
+                this.logger.error(
+                    {
+                        err,
+                        tnx: 'spawn',
+                        messageId
+                    },
+                    'Error occurred when sending message %s. %s',
+                    messageId,
+                    err.message
+                );
+                callback(err);
+            });
+
+            sendmail.once('exit', code => {
+                if (!code) {
+                    return callback();
+                }
+                let err;
+                if (code === 127) {
+                    err = new Error('Sendmail command not found, process exited with code ' + code);
+                } else {
+                    err = new Error('Sendmail exited with code ' + code);
+                }
+
+                this.logger.error(
+                    {
+                        err,
+                        tnx: 'stdin',
+                        messageId
+                    },
+                    'Error sending message %s to sendmail. %s',
+                    messageId,
+                    err.message
+                );
+                callback(err);
+            });
+            sendmail.once('close', callback);
+
+            sendmail.stdin.on('error', err => {
+                this.logger.error(
+                    {
+                        err,
+                        tnx: 'stdin',
+                        messageId
+                    },
+                    'Error occurred when piping message %s to sendmail. %s',
+                    messageId,
+                    err.message
+                );
+                callback(err);
+            });
+
+            let recipients = [].concat(envelope.to || []);
+            if (recipients.length > 3) {
+                recipients.push('...and ' + recipients.splice(2).length + ' more');
+            }
+            this.logger.info(
+                {
+                    tnx: 'send',
+                    messageId
+                },
+                'Sending message %s to <%s>',
+                messageId,
+                recipients.join(', ')
+            );
+
+            let sourceStream = mail.message.createReadStream();
+            sourceStream.once('error', err => {
+                this.logger.error(
+                    {
+                        err,
+                        tnx: 'stdin',
+                        messageId
+                    },
+                    'Error occurred when generating message %s. %s',
+                    messageId,
+                    err.message
+                );
+                sendmail.kill('SIGINT'); // do not deliver the message
+                callback(err);
+            });
+
+            sourceStream.pipe(sendmail.stdin);
+        } else {
+            return callback(new Error('sendmail was not found'));
+        }
+    }
+}
+
+module.exports = SendmailTransport;

package/lib/ses-transport/index.js

@@ -0,0 +1,234 @@
+'use strict';
+
+const EventEmitter = require('events');
+const packageData = require('../../package.json');
+const shared = require('../shared');
+const LeWindows = require('../mime-node/le-windows');
+const MimeNode = require('../mime-node');
+
+/**
+ * Generates a Transport object for AWS SES
+ *
+ * @constructor
+ * @param {Object} optional config parameter
+ */
+class SESTransport extends EventEmitter {
+    constructor(options) {
+        super();
+        options = options || {};
+
+        this.options = options || {};
+        this.ses = this.options.SES;
+
+        this.name = 'SESTransport';
+        this.version = packageData.version;
+
+        this.logger = shared.getLogger(this.options, {
+            component: this.options.component || 'ses-transport'
+        });
+    }
+
+    getRegion(cb) {
+        if (this.ses.sesClient.config && typeof this.ses.sesClient.config.region === 'function') {
+            // promise
+            return this.ses.sesClient.config
+                .region()
+                .then(region => cb(null, region))
+                .catch(err => cb(err));
+        }
+        return cb(null, false);
+    }
+
+    /**
+     * Compiles a mailcomposer message and forwards it to SES
+     *
+     * @param {Object} emailMessage MailComposer object
+     * @param {Function} callback Callback function to run when the sending is completed
+     */
+    send(mail, callback) {
+        let statObject = {
+            ts: Date.now(),
+            pending: true
+        };
+
+        let fromHeader = mail.message._headers.find(header => /^from$/i.test(header.key));
+        if (fromHeader) {
+            let mimeNode = new MimeNode('text/plain');
+            fromHeader = mimeNode._convertAddresses(mimeNode._parseAddresses(fromHeader.value));
+        }
+
+        let envelope = mail.data.envelope || mail.message.getEnvelope();
+        let messageId = mail.message.messageId();
+
+        let recipients = [].concat(envelope.to || []);
+        if (recipients.length > 3) {
+            recipients.push('...and ' + recipients.splice(2).length + ' more');
+        }
+        this.logger.info(
+            {
+                tnx: 'send',
+                messageId
+            },
+            'Sending message %s to <%s>',
+            messageId,
+            recipients.join(', ')
+        );
+
+        let getRawMessage = next => {
+            // do not use Message-ID and Date in DKIM signature
+            if (!mail.data._dkim) {
+                mail.data._dkim = {};
+            }
+            if (mail.data._dkim.skipFields && typeof mail.data._dkim.skipFields === 'string') {
+                mail.data._dkim.skipFields += ':date:message-id';
+            } else {
+                mail.data._dkim.skipFields = 'date:message-id';
+            }
+
+            let sourceStream = mail.message.createReadStream();
+            let stream = sourceStream.pipe(new LeWindows());
+            let chunks = [];
+            let chunklen = 0;
+
+            stream.on('readable', () => {
+                let chunk;
+                while ((chunk = stream.read()) !== null) {
+                    chunks.push(chunk);
+                    chunklen += chunk.length;
+                }
+            });
+
+            sourceStream.once('error', err => stream.emit('error', err));
+
+            stream.once('error', err => {
+                next(err);
+            });
+
+            stream.once('end', () => next(null, Buffer.concat(chunks, chunklen)));
+        };
+
+        setImmediate(() =>
+            getRawMessage((err, raw) => {
+                if (err) {
+                    this.logger.error(
+                        {
+                            err,
+                            tnx: 'send',
+                            messageId
+                        },
+                        'Failed creating message for %s. %s',
+                        messageId,
+                        err.message
+                    );
+                    statObject.pending = false;
+                    return callback(err);
+                }
+
+                let sesMessage = {
+                    Content: {
+                        Raw: {
+                            // required
+                            Data: raw // required
+                        }
+                    },
+                    FromEmailAddress: fromHeader ? fromHeader : envelope.from,
+                    Destination: {
+                        ToAddresses: envelope.to
+                    }
+                };
+
+                Object.keys(mail.data.ses || {}).forEach(key => {
+                    sesMessage[key] = mail.data.ses[key];
+                });
+
+                this.getRegion((err, region) => {
+                    if (err || !region) {
+                        region = 'us-east-1';
+                    }
+
+                    const command = new this.ses.SendEmailCommand(sesMessage);
+                    const sendPromise = this.ses.sesClient.send(command);
+
+                    sendPromise
+                        .then(data => {
+                            if (region === 'us-east-1') {
+                                region = 'email';
+                            }
+
+                            statObject.pending = true;
+                            callback(null, {
+                                envelope: {
+                                    from: envelope.from,
+                                    to: envelope.to
+                                },
+                                messageId: '<' + data.MessageId + (!/@/.test(data.MessageId) ? '@' + region + '.amazonses.com' : '') + '>',
+                                response: data.MessageId,
+                                raw
+                            });
+                        })
+                        .catch(err => {
+                            this.logger.error(
+                                {
+                                    err,
+                                    tnx: 'send'
+                                },
+                                'Send error for %s: %s',
+                                messageId,
+                                err.message
+                            );
+                            statObject.pending = false;
+                            callback(err);
+                        });
+                });
+            })
+        );
+    }
+
+    /**
+     * Verifies SES configuration
+     *
+     * @param {Function} callback Callback function
+     */
+    verify(callback) {
+        let promise;
+        if (!callback) {
+            promise = new Promise((resolve, reject) => {
+                callback = shared.callbackPromise(resolve, reject);
+            });
+        }
+
+        const cb = err => {
+            if (err && !['InvalidParameterValue', 'MessageRejected'].includes(err.code || err.Code || err.name)) {
+                return callback(err);
+            }
+            return callback(null, true);
+        };
+
+        const sesMessage = {
+            Content: {
+                Raw: {
+                    Data: Buffer.from('From: <invalid@invalid>\r\nTo: <invalid@invalid>\r\n Subject: Invalid\r\n\r\nInvalid')
+                }
+            },
+            FromEmailAddress: 'invalid@invalid',
+            Destination: {
+                ToAddresses: ['invalid@invalid']
+            }
+        };
+
+        this.getRegion((err, region) => {
+            if (err || !region) {
+                region = 'us-east-1';
+            }
+
+            const command = new this.ses.SendEmailCommand(sesMessage);
+            const sendPromise = this.ses.sesClient.send(command);
+
+            sendPromise.then(data => cb(null, data)).catch(err => cb(err));
+        });
+
+        return promise;
+    }
+}
+
+module.exports = SESTransport;