@nocobase/plugin-workflow-mailer 2.2.16 → 2.2.18

package/dist/node_modules/nodemailer/lib/ses-transport/index.js

@@ -3,16 +3,25 @@
 const EventEmitter = require('events');
 const packageData = require('../../package.json');
 const shared = require('../shared');
+const errors = require('../errors');
 const LeWindows = require('../mime-node/le-windows');
+const MimeNode = require('../mime-node');
+
+/**
+ * Tags AWS SDK rejections that carry no `code` property (SDK v3 errors only
+ * have a `name`) with the generic SES transport error code, keeping the
+ * original error object intact
+ */
+function tagSesError(err) {
+    if (err && typeof err === 'object' && !err.code) {
+        err.code = errors.ESES;
+    }
+    return err;
+}
 
 /**
  * Generates a Transport object for AWS SES
  *
- * Possible options can be the following:
- *
- *  * **sendingRate** optional Number specifying how many messages per second should be delivered to SES
- *  * **maxConnections** optional Number specifying max number of parallel connections to SES
- *
  * @constructor
  * @param {Object} optional config parameter
  */
@@ -21,7 +30,7 @@ class SESTransport extends EventEmitter {
         super();
         options = options || {};
 
-        this.options = options || {};
+        this.options = options;
         this.ses = this.options.SES;
 
         this.name = 'SESTransport';
@@ -30,119 +39,18 @@ class SESTransport extends EventEmitter {
         this.logger = shared.getLogger(this.options, {
             component: this.options.component || 'ses-transport'
         });
-
-        // parallel sending connections
-        this.maxConnections = Number(this.options.maxConnections) || Infinity;
-        this.connections = 0;
-
-        // max messages per second
-        this.sendingRate = Number(this.options.sendingRate) || Infinity;
-        this.sendingRateTTL = null;
-        this.rateInterval = 1000; // milliseconds
-        this.rateMessages = [];
-
-        this.pending = [];
-
-        this.idling = true;
-
-        setImmediate(() => {
-            if (this.idling) {
-                this.emit('idle');
-            }
-        });
     }
 
-    /**
-     * Schedules a sending of a message
-     *
-     * @param {Object} emailMessage MailComposer object
-     * @param {Function} callback Callback function to run when the sending is completed
-     */
-    send(mail, callback) {
-        if (this.connections >= this.maxConnections) {
-            this.idling = false;
-            return this.pending.push({
-                mail,
-                callback
-            });
+    getRegion(cb) {
+        if (this.ses.sesClient.config && typeof this.ses.sesClient.config.region === 'function') {
+            // Resolve the region provider. Use the two-argument form of then() so that a
+            // synchronous throw from cb is not recaught here and used to invoke cb a second time.
+            return this.ses.sesClient.config.region().then(
+                region => cb(null, region),
+                err => cb(err)
+            );
         }
-
-        if (!this._checkSendingRate()) {
-            this.idling = false;
-            return this.pending.push({
-                mail,
-                callback
-            });
-        }
-
-        this._send(mail, (...args) => {
-            setImmediate(() => callback(...args));
-            this._sent();
-        });
-    }
-
-    _checkRatedQueue() {
-        if (this.connections >= this.maxConnections || !this._checkSendingRate()) {
-            return;
-        }
-
-        if (!this.pending.length) {
-            if (!this.idling) {
-                this.idling = true;
-                this.emit('idle');
-            }
-            return;
-        }
-
-        let next = this.pending.shift();
-        this._send(next.mail, (...args) => {
-            setImmediate(() => next.callback(...args));
-            this._sent();
-        });
-    }
-
-    _checkSendingRate() {
-        clearTimeout(this.sendingRateTTL);
-
-        let now = Date.now();
-        let oldest = false;
-        // delete older messages
-        for (let i = this.rateMessages.length - 1; i >= 0; i--) {
-            if (this.rateMessages[i].ts >= now - this.rateInterval && (!oldest || this.rateMessages[i].ts < oldest)) {
-                oldest = this.rateMessages[i].ts;
-            }
-
-            if (this.rateMessages[i].ts < now - this.rateInterval && !this.rateMessages[i].pending) {
-                this.rateMessages.splice(i, 1);
-            }
-        }
-
-        if (this.rateMessages.length < this.sendingRate) {
-            return true;
-        }
-
-        let delay = Math.max(oldest + 1001, now + 20);
-        this.sendingRateTTL = setTimeout(() => this._checkRatedQueue(), now - delay);
-
-        try {
-            this.sendingRateTTL.unref();
-        } catch (E) {
-            // Ignore. Happens on envs with non-node timer implementation
-        }
-
-        return false;
-    }
-
-    _sent() {
-        this.connections--;
-        this._checkRatedQueue();
-    }
-
-    /**
-     * Returns true if there are free slots in the queue
-     */
-    isIdle() {
-        return this.idling;
+        return cb(null, false);
     }
 
     /**
@@ -151,18 +59,17 @@ class SESTransport extends EventEmitter {
      * @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
-        };
-        this.connections++;
-        this.rateMessages.push(statObject);
+    send(mail, callback) {
+        let fromHeader = mail.message._headers.find(header => /^from$/i.test(header.key));
+        if (fromHeader) {
+            const 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();
+        const envelope = mail.message.getEnvelope();
+        const messageId = mail.message.messageId();
 
-        let recipients = [].concat(envelope.to || []);
+        const recipients = [].concat(envelope.to || []);
         if (recipients.length > 3) {
             recipients.push('...and ' + recipients.splice(2).length + ' more');
         }
@@ -176,7 +83,7 @@ class SESTransport extends EventEmitter {
             recipients.join(', ')
         );
 
-        let getRawMessage = next => {
+        const getRawMessage = next => {
             // do not use Message-ID and Date in DKIM signature
             if (!mail.data._dkim) {
                 mail.data._dkim = {};
@@ -187,9 +94,9 @@ class SESTransport extends EventEmitter {
                 mail.data._dkim.skipFields = 'date:message-id';
             }
 
-            let sourceStream = mail.message.createReadStream();
-            let stream = sourceStream.pipe(new LeWindows());
-            let chunks = [];
+            const sourceStream = mail.message.createReadStream();
+            const stream = sourceStream.pipe(new LeWindows());
+            const chunks = [];
             let chunklen = 0;
 
             stream.on('readable', () => {
@@ -202,9 +109,7 @@ class SESTransport extends EventEmitter {
 
             sourceStream.once('error', err => stream.emit('error', err));
 
-            stream.once('error', err => {
-                next(err);
-            });
+            stream.once('error', err => next(err));
 
             stream.once('end', () => next(null, Buffer.concat(chunks, chunklen)));
         };
@@ -222,49 +127,51 @@ class SESTransport extends EventEmitter {
                         messageId,
                         err.message
                     );
-                    statObject.pending = false;
                     return callback(err);
                 }
 
-                let sesMessage = {
-                    RawMessage: {
-                        // required
-                        Data: raw // required
+                // mail.data.ses is caller supplied message data, so copy its own keys only
+                const sesMessage = shared.copyOwnKeys(
+                    {
+                        Content: {
+                            Raw: {
+                                // required
+                                Data: raw // required
+                            }
+                        },
+                        FromEmailAddress: fromHeader || envelope.from,
+                        Destination: {
+                            ToAddresses: envelope.to
+                        }
                     },
-                    Source: envelope.from,
-                    Destinations: envelope.to
-                };
-
-                Object.keys(mail.data.ses || {}).forEach(key => {
-                    sesMessage[key] = mail.data.ses[key];
-                });
+                    mail.data.ses
+                );
 
-                let ses = (this.ses.aws ? this.ses.ses : this.ses) || {};
-                let aws = this.ses.aws || {};
-
-                let getRegion = cb => {
-                    if (ses.config && typeof ses.config.region === 'function') {
-                        // promise
-                        return ses.config
-                            .region()
-                            .then(region => cb(null, region))
-                            .catch(err => cb(err));
-                    }
-                    return cb(null, (ses.config && ses.config.region) || 'us-east-1');
-                };
-
-                getRegion((err, region) => {
+                this.getRegion((err, region) => {
                     if (err || !region) {
                         region = 'us-east-1';
                     }
 
                     let sendPromise;
-                    if (typeof ses.send === 'function' && aws.SendRawEmailCommand) {
-                        // v3 API
-                        sendPromise = ses.send(new aws.SendRawEmailCommand(sesMessage));
-                    } else {
-                        // v2 API
-                        sendPromise = ses.sendRawEmail(sesMessage).promise();
+                    try {
+                        // command construction or dispatch can throw synchronously on a
+                        // misconfigured SDK; surface it as a single error callback instead
+                        // of letting it escape into getRegion's promise chain
+                        const command = new this.ses.SendEmailCommand(sesMessage);
+                        sendPromise = this.ses.sesClient.send(command);
+                    } catch (err) {
+                        tagSesError(err);
+                        this.logger.error(
+                            {
+                                err,
+                                tnx: 'send'
+                            },
+                            'Send error for %s: %s',
+                            messageId,
+                            err.message
+                        );
+                        setImmediate(() => callback(err));
+                        return;
                     }
 
                     sendPromise
@@ -273,8 +180,7 @@ class SESTransport extends EventEmitter {
                                 region = 'email';
                             }
 
-                            statObject.pending = false;
-                            callback(null, {
+                            const info = {
                                 envelope: {
                                     from: envelope.from,
                                     to: envelope.to
@@ -282,9 +188,14 @@ class SESTransport extends EventEmitter {
                                 messageId: '<' + data.MessageId + (!/@/.test(data.MessageId) ? '@' + region + '.amazonses.com' : '') + '>',
                                 response: data.MessageId,
                                 raw
-                            });
+                            };
+
+                            // invoke the callback outside the promise chain so a throw from it
+                            // is not recaught by .catch() and used to call it a second time
+                            setImmediate(() => callback(null, info));
                         })
                         .catch(err => {
+                            tagSesError(err);
                             this.logger.error(
                                 {
                                     err,
@@ -294,8 +205,7 @@ class SESTransport extends EventEmitter {
                                 messageId,
                                 err.message
                             );
-                            statObject.pending = false;
-                            callback(err);
+                            setImmediate(() => callback(err));
                         });
                 });
             })
@@ -309,38 +219,45 @@ class SESTransport extends EventEmitter {
      */
     verify(callback) {
         let promise;
-        let ses = (this.ses.aws ? this.ses.ses : this.ses) || {};
-        let aws = this.ses.aws || {};
-
-        const sesMessage = {
-            RawMessage: {
-                // required
-                Data: 'From: invalid@invalid\r\nTo: invalid@invalid\r\n Subject: Invalid\r\n\r\nInvalid'
-            },
-            Source: 'invalid@invalid',
-            Destinations: ['invalid@invalid']
-        };
-
         if (!callback) {
             promise = new Promise((resolve, reject) => {
                 callback = shared.callbackPromise(resolve, reject);
             });
         }
+
         const cb = err => {
-            if (err && (err.code || err.Code) !== 'InvalidParameterValue') {
-                return callback(err);
+            if (err && !['InvalidParameterValue', 'MessageRejected'].includes(err.code || err.Code || err.name)) {
+                return callback(tagSesError(err));
             }
             return callback(null, true);
         };
 
-        if (typeof ses.send === 'function' && aws.SendRawEmailCommand) {
-            // v3 API
-            sesMessage.RawMessage.Data = Buffer.from(sesMessage.RawMessage.Data);
-            ses.send(new aws.SendRawEmailCommand(sesMessage), cb);
-        } else {
-            // v2 API
-            ses.sendRawEmail(sesMessage, cb);
-        }
+        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']
+            }
+        };
+
+        // the region value is not used for anything when verifying, but the lookup
+        // exercises the client configuration the same way as send() does
+        this.getRegion(() => {
+            let sendPromise;
+            try {
+                const command = new this.ses.SendEmailCommand(sesMessage);
+                sendPromise = this.ses.sesClient.send(command);
+            } catch (err) {
+                setImmediate(() => cb(err));
+                return;
+            }
+
+            sendPromise.then(() => setImmediate(() => cb(null))).catch(err => setImmediate(() => cb(err)));
+        });
 
         return promise;
     }