Send mail using setTimeout - node.js

Question

I'd like to send emails each 200ms, but it seems not working with promises :
My function :
SendMail.send = function(from, to, subject, body, name, logo) {
var transporter, html,
contactparam = _.find(options.blocks, { name: 'contactparam' }).params,
smtpUsername = _.find(contactparam, { name: 'smtp_username' }),
smtpPassword = _.find(contactparam, { name: 'smtp_password' }),
smtpHost = _.find(contactparam, { name: 'smtp_host' }),
smtpPort = _.find(contactparam, { name: 'smtp_port' }),
compagny = _.find(contactparam, { name: 'compagny' }),
firstname = _.find(contactparam, { name: 'firstname' }),
facebookUrl = _.find(_.find(options.blocks, { name: 'socialparam' }).params, { name: 'facebook' }).value,
twitterUrl = _.find(_.find(options.blocks, { name: 'socialparam' }).params, { name: 'twitter' }).value,
linkedinUrl = _.find(_.find(options.blocks, { name: 'socialparam' }).params, { name: 'linkedin' }).value,
secondaryColor = _.find(_.find(options.blocks, { name: 'themeparam' }).params, { name: 'secondary_color' }).value,
loadedLogo = logo || _.find(_.find(options.blocks, { name: 'logoparam' }).params, { name: 'logo' }).value,
websiteUrl = _.find(_.find(options.blocks, { name: 'mainparam' }).params, { name: 'url' }).value,
templateFile = fs.readFileSync('./app/views/0-templates/' + options.template + '/mail.ejs', 'utf-8'),
loadedName = name || (compagny && compagny.value) || (firstname && name && firstname.value + ' ' + name.value),
ejsTemplate = ejs.compile(templateFile);
html = ejsTemplate({
logo: loadedLogo || '/images/LOGO.png',
websiteUrl: websiteUrl,
body: body,
title: subject,
facebookUrl: facebookUrl,
twitterUrl: twitterUrl,
linkedinUrl: linkedinUrl,
secondaryColor: secondaryColor || '#1c1c1c'
});
if ((smtpUsername && smtpUsername.value !== '') && (smtpPassword && smtpPassword.value !== '') && (smtpHost && smtpHost.value !== '') && (smtpPort && smtpPort.value !== '')) {
transporter = nodemailer.createTransport({
host: smtpHost.value,
pool: true,
port: parseInt(smtpPort.value, 10),
auth: {
user: smtpUsername.value,
pass: smtpPassword.value
}
});
} else {
transporter = nodemailer.createTransport({
sendmail: true,
newline: 'unix',
path: '/usr/sbin/sendmail'
});
}
return transporter.sendMail({
from: loadedName + ' <' + from + '>',
replyTo: from,
to: to,
subject: subject,
html: html
});
};
SendMail.arraySend = function(array) {
var promises = [];
promises = array.map(function (emailObj, index) {
return new Promise(function () {
setTimeout(function () {
return sendMailHelper.send(emailObj.from, emailObj.to, emailObj.title, emailObj.htmlMessage);
}, 200 * index);
});
});
return promises;
};
Using my function :
Promise.all(sendMailHelper.arraySend(emailsArray)).then( function() {
request.flash('success', 'Emails sent !');
response.redirect('/');
});
emailsArray :
emailsArray.push({
from: from,
to: registration.cfc_user.email,
title: 'Finale : ' + newTournament.name,
htmlMessage: htmlMessage
});
Issue : emails are not sent.

Answer 1

First of all, you need to actually resolve the promises you create. Without resolving (or rejecting) them, Promise.all will wait forever.
Also, .sendMail() returns a Promise when called, so this can be leveraged to make sure the delayed Promise is resolve only after the actual sending is completed:
SendMail.arraySend = function(array) {
var promises = array.map(function (emailObj, index) {
return new Promise(function (resolve, reject) { //<-- add the resolve/reject parameters
setTimeout(function () {
sendMailHelper
.send(emailObj.from, emailObj.to, emailObj.title, emailObj.htmlMessage)
.then(resolve) // <-- resolve the Promise once execution is done
.catch(reject); // <-- reject on failure
}, 200 * index);
});
});
return promises;
};
This will launch all Promises at once, but each will trigger within 200ms of each other. The actual sending might need some time but eventually everything will be done.
Alternatively, you can set it up so after each Promise is done, you wait 200ms and then launch another one. This will mean that you get a single Promise object in the end, not an array but it's guaranteed that messages are sent sequentially. It is easy to do this using Array#reduce
//helper function that converts email objects to be sent into Promises
const delayedSend = (emailObj, delay) => () => {
return new Promise((resolve, reject) => {
setTimeout(
() => sendMailHelper.send(emailObj.from, emailObj.to, emailObj.title, emailObj.htmlMessage)
.then(resolve)
.catch(reject);
},
delay
)
})
}
SendMail.arraySend = function(array) {
var promises = array.reduce(function (sequence, emailObj) {
// ^^^^^^ reduce to convert to a single Promise
return sequence.then(delayedSend(emailObj, 200)); // <-- chain .then() and delay each following execution
}, Promise.resolve());
// ^^^^^^^^^^^^^^^^^ initial value is a simple resolved Promise.
return promises;
};

Answer 2

You can not return from a function called in a timeout. Also, it does not seem like a good idea to call that many Promises.
Best way is to group all your emails within a single Promise, returning an object of emails sent and emails with errors:
SendMail.arraySend = array => {
return new Promise(resolve => {
let sent = [];
let errors = [];
const finalise = () => {
if ((sent.length + errors.length) >= array.length) {
resolve({ sent, errors });
}
};
array.forEach((emailObj, index) => {
setTimeout(function () {
sendMailHelper.send(emailObj.from, emailObj.to, emailObj.title, emailObj.htmlMessage)
.then(() => {
sent.push(emailObj);
finalise();
});
.catch(() => {
errors.push(emailObj);
finalise();
})
}, 200 * index);
});
});
};