Huge News!Announcing our $40M Series B led by Abstract Ventures.Learn More →
Socket
Sign inDemoInstall
Socket
Sign inDemoInstall

email-templates

Package Overview
Dependencies
Maintainers
1
Versions
137
Alerts
File Explorer

Advanced tools

License
Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

email-templates - npm Package Compare versions

Comparing version 4.0.3 to 4.0.4

279

lib/index.js

@@ -114,17 +114,7 @@ 'use strict';

return new Promise((() => {
var _ref = _asyncToGenerator(function* (resolve, reject) {
try {
const paths = yield getPaths(_this.config.views.root, view, _this.config.views.options.extension);
const filePath = path.resolve(_this.config.views.root, paths.rel);
resolve({ filePath, paths });
} catch (err) {
reject(err);
}
});
return function (_x, _x2) {
return _ref.apply(this, arguments);
};
})());
return _asyncToGenerator(function* () {
const paths = yield getPaths(_this.config.views.root, view, _this.config.views.options.extension);
const filePath = path.resolve(_this.config.views.root, paths.rel);
return { filePath, paths };
})();
}

@@ -137,22 +127,16 @@

return new Promise((() => {
var _ref2 = _asyncToGenerator(function* (resolve) {
try {
var _ref3 = yield _this2.getTemplatePath(view);
return _asyncToGenerator(function* () {
try {
var _ref = yield _this2.getTemplatePath(view);
const filePath = _ref3.filePath;
const filePath = _ref.filePath;
const stats = yield stat(filePath);
if (!stats.isFile()) throw new Error(`${filePath} was not a file`);
resolve(true);
} catch (err) {
debug('templateExists', err);
resolve(false);
}
});
return function (_x3) {
return _ref2.apply(this, arguments);
};
})());
const stats = yield stat(filePath);
if (!stats.isFile()) throw new Error(`${filePath} was not a file`);
return true;
} catch (err) {
debug('templateExists', err);
return false;
}
})();
}

@@ -166,53 +150,40 @@

return new Promise((() => {
var _ref4 = _asyncToGenerator(function* (resolve, reject) {
try {
var _config$views$options = _this3.config.views.options;
const map = _config$views$options.map,
engineSource = _config$views$options.engineSource;
return _asyncToGenerator(function* () {
var _config$views$options = _this3.config.views.options;
const map = _config$views$options.map,
engineSource = _config$views$options.engineSource;
var _ref5 = yield _this3.getTemplatePath(view);
var _ref2 = yield _this3.getTemplatePath(view);
const filePath = _ref5.filePath,
paths = _ref5.paths;
const filePath = _ref2.filePath,
paths = _ref2.paths;
if (paths.ext === 'html' && !map) {
const res = yield readFile(filePath, 'utf8');
resolve(res);
} else {
const engineName = map && map[paths.ext] ? map[paths.ext] : paths.ext;
const renderFn = engineSource[engineName];
if (!engineName || !renderFn) return reject(new Error(`Engine not found for the ".${paths.ext}" file extension`));
if (paths.ext === 'html' && !map) {
const res = yield readFile(filePath, 'utf8');
return res;
}
const engineName = map && map[paths.ext] ? map[paths.ext] : paths.ext;
const renderFn = engineSource[engineName];
if (!engineName || !renderFn) throw new Error(`Engine not found for the ".${paths.ext}" file extension`);
if (_.isObject(_this3.config.i18n)) {
const i18n = new I18N(Object.assign({}, _this3.config.i18n, {
register: locals
}));
if (_.isObject(_this3.config.i18n)) {
const i18n = new I18N(Object.assign({}, _this3.config.i18n, {
register: locals
}));
// support `locals.user.last_locale`
// (e.g. for <https://lad.js.org>)
if (_.isObject(locals.user) && _.isString(locals.user.last_locale)) locals.locale = locals.user.last_locale;
// support `locals.user.last_locale`
// (e.g. for <https://lad.js.org>)
if (_.isObject(locals.user) && _.isString(locals.user.last_locale)) locals.locale = locals.user.last_locale;
if (_.isString(locals.locale)) i18n.setLocale(locals.locale);
}
if (_.isString(locals.locale)) i18n.setLocale(locals.locale);
}
// TODO: convert this to a promise based version
renderFn(filePath, locals, function (err, res) {
if (err) return reject(err);
// transform the html with juice using remote paths
// google now supports media queries
// https://developers.google.com/gmail/design/reference/supported_css
if (!_this3.config.juice) return resolve(res);
_this3.juiceResources(res).then(resolve).catch(reject);
});
}
} catch (err) {
reject(err);
}
});
return function (_x4, _x5) {
return _ref4.apply(this, arguments);
};
})());
const res = yield Promise.promisify(renderFn)(filePath, locals);
// transform the html with juice using remote paths
// google now supports media queries
// https://developers.google.com/gmail/design/reference/supported_css
if (!_this3.config.juice) return res;
const html = yield _this3.juiceResources(res);
return html;
})();
}

@@ -223,51 +194,41 @@

return new Promise((() => {
var _ref6 = _asyncToGenerator(function* (resolve, reject) {
try {
let subjectTemplateExists = _this4.config.customRender;
let htmlTemplateExists = _this4.config.customRender;
let textTemplateExists = _this4.config.customRender;
return _asyncToGenerator(function* () {
let subjectTemplateExists = _this4.config.customRender;
let htmlTemplateExists = _this4.config.customRender;
let textTemplateExists = _this4.config.customRender;
const promises = [_this4.templateExists(`${template}/subject`), _this4.templateExists(`${template}/html`), _this4.templateExists(`${template}/text`)];
const promises = [_this4.templateExists(`${template}/subject`), _this4.templateExists(`${template}/html`), _this4.templateExists(`${template}/text`)];
if (template && !_this4.config.customRender) {
;
if (template && !_this4.config.customRender) {
;
var _ref7 = yield Promise.all(promises);
var _ref3 = yield Promise.all(promises);
var _ref8 = _slicedToArray(_ref7, 3);
var _ref4 = _slicedToArray(_ref3, 3);
subjectTemplateExists = _ref8[0];
htmlTemplateExists = _ref8[1];
textTemplateExists = _ref8[2];
}if (!message.subject && subjectTemplateExists) {
message.subject = yield _this4.render(`${template}/subject`, Object.assign({}, locals, { pretty: false }));
message.subject = message.subject.trim();
}
subjectTemplateExists = _ref4[0];
htmlTemplateExists = _ref4[1];
textTemplateExists = _ref4[2];
}if (!message.subject && subjectTemplateExists) {
message.subject = yield _this4.render(`${template}/subject`, Object.assign({}, locals, { pretty: false }));
message.subject = message.subject.trim();
}
if (message.subject && _this4.config.subjectPrefix) message.subject = _this4.config.subjectPrefix + message.subject;
if (message.subject && _this4.config.subjectPrefix) message.subject = _this4.config.subjectPrefix + message.subject;
if (!message.html && htmlTemplateExists) message.html = yield _this4.render(`${template}/html`, locals);
if (!message.html && htmlTemplateExists) message.html = yield _this4.render(`${template}/html`, locals);
if (!message.text && textTemplateExists) message.text = yield _this4.render(`${template}/text`, Object.assign({}, locals, { pretty: false }));
if (!message.text && textTemplateExists) message.text = yield _this4.render(`${template}/text`, Object.assign({}, locals, { pretty: false }));
if (_this4.config.htmlToText && message.html && !message.text)
// we'd use nodemailer-html-to-text plugin
// but we really don't need to support cid
// <https://github.com/andris9/nodemailer-html-to-text>
message.text = htmlToText.fromString(message.html, _this4.config.htmlToText);
if (_this4.config.htmlToText && message.html && !message.text)
// we'd use nodemailer-html-to-text plugin
// but we really don't need to support cid
// <https://github.com/andris9/nodemailer-html-to-text>
message.text = htmlToText.fromString(message.html, _this4.config.htmlToText);
// if we only want a text-based version of the email
if (_this4.config.textOnly) delete message.html;
// if we only want a text-based version of the email
if (_this4.config.textOnly) delete message.html;
resolve(message);
} catch (err) {
reject(err);
}
});
return function (_x6, _x7) {
return _ref6.apply(this, arguments);
};
})());
return message;
})();
}

@@ -278,61 +239,51 @@

options = Object.assign({
template: '',
message: {},
locals: {}
}, options);
return _asyncToGenerator(function* () {
options = Object.assign({
template: '',
message: {},
locals: {}
}, options);
var _options = options;
let template = _options.template,
message = _options.message,
locals = _options.locals;
var _options = options;
let template = _options.template,
message = _options.message,
locals = _options.locals;
const attachments = message.attachments || this.config.message.attachments || [];
const attachments = message.attachments || _this5.config.message.attachments || [];
message = _.defaultsDeep({}, _.omit(this.config.message, 'attachments'), _.omit(message, 'attachments'));
locals = _.defaultsDeep({}, this.config.views.locals, locals);
message = _.defaultsDeep({}, _.omit(_this5.config.message, 'attachments'), _.omit(message, 'attachments'));
locals = _.defaultsDeep({}, _this5.config.views.locals, locals);
if (attachments) message.attachments = attachments;
if (attachments) message.attachments = attachments;
debug('template %s', template);
debug('message %O', message);
debug('locals (keys only): %O', Object.keys(locals));
debug('template %s', template);
debug('message %O', message);
debug('locals (keys only): %O', Object.keys(locals));
return new Promise((() => {
var _ref9 = _asyncToGenerator(function* (resolve, reject) {
try {
// get all available templates
const obj = yield _this5.renderAll(template, locals, message);
// get all available templates
const obj = yield _this5.renderAll(template, locals, message);
// assign the object variables over to the message
Object.assign(message, obj);
// assign the object variables over to the message
Object.assign(message, obj);
if (_this5.config.preview) {
debug('using `preview-email` to preview email');
yield previewEmail(message);
}
if (_this5.config.preview) {
debug('using `preview-email` to preview email');
yield previewEmail(message);
}
if (!_this5.config.send) {
debug('send disabled so we are ensuring JSONTransport');
// <https://github.com/nodemailer/nodemailer/issues/798>
// if (this.config.transport.name !== 'JSONTransport')
_this5.config.transport = nodemailer.createTransport({
jsonTransport: true
});
}
if (!_this5.config.send) {
debug('send disabled so we are ensuring JSONTransport');
// <https://github.com/nodemailer/nodemailer/issues/798>
// if (this.config.transport.name !== 'JSONTransport')
_this5.config.transport = nodemailer.createTransport({
jsonTransport: true
});
}
const res = yield _this5.config.transport.sendMail(message);
debug('message sent');
res.originalMessage = message;
resolve(res);
} catch (err) {
reject(err);
}
});
return function (_x8, _x9) {
return _ref9.apply(this, arguments);
};
})());
const res = yield _this5.config.transport.sendMail(message);
debug('message sent');
res.originalMessage = message;
return res;
})();
}

@@ -342,2 +293,2 @@ }

module.exports = Email;
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/index.js"],"names":["fs","require","path","debug","htmlToText","I18N","autoBind","nodemailer","consolidate","previewEmail","_","Promise","getPaths","juiceResources","env","process","NODE_ENV","stat","promisify","readFile","Email","constructor","config","juiceOptions","disableJuice","juice","render","customRender","merge","views","root","resolve","options","extension","map","hbs","njk","engineSource","locals","pretty","message","send","includes","preview","i18n","bind","textOnly","ignoreImage","subjectPrefix","preserveImportant","webResources","relativeTo","images","transport","isFunction","sendMail","createTransport","html","getTemplatePath","view","reject","paths","filePath","rel","err","templateExists","stats","isFile","Error","ext","res","engineName","renderFn","isObject","Object","assign","register","user","isString","last_locale","locale","setLocale","then","catch","renderAll","template","subjectTemplateExists","htmlTemplateExists","textTemplateExists","promises","all","subject","trim","text","fromString","attachments","defaultsDeep","omit","keys","obj","jsonTransport","originalMessage","module","exports"],"mappings":"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","file":"index.js","sourcesContent":["const fs = require('fs');\nconst path = require('path');\nconst debug = require('debug')('email-templates');\nconst htmlToText = require('html-to-text');\nconst I18N = require('@ladjs/i18n');\nconst autoBind = require('auto-bind');\nconst nodemailer = require('nodemailer');\nconst consolidate = require('consolidate');\nconst previewEmail = require('preview-email');\nconst _ = require('lodash');\nconst Promise = require('bluebird');\n\nconst getPaths = require('get-paths');\nconst juiceResources = require('juice-resources-promise');\n\nconst env = process.env.NODE_ENV || 'development';\nconst stat = Promise.promisify(fs.stat);\nconst readFile = Promise.promisify(fs.readFile);\n\nclass Email {\n  constructor(config = {}) {\n    debug('config passed %O', config);\n\n    // 2.x backwards compatible support\n    if (config.juiceOptions) {\n      config.juiceResources = config.juiceOptions;\n      delete config.juiceOptions;\n    }\n    if (config.disableJuice) {\n      config.juice = false;\n      delete config.disableJuice;\n    }\n    if (config.render) {\n      config.customRender = true;\n    }\n\n    this.config = _.merge(\n      {\n        views: {\n          // directory where email templates reside\n          root: path.resolve('emails'),\n          options: {\n            // default file extension for template\n            extension: 'pug',\n            map: {\n              hbs: 'handlebars',\n              njk: 'nunjucks'\n            },\n            engineSource: consolidate\n          },\n          // locals to pass to templates for rendering\n          locals: {\n            // pretty is automatically set to `false` for subject/text\n            pretty: true\n          }\n        },\n        // <https://nodemailer.com/message/>\n        message: {},\n        send: !['development', 'test'].includes(env),\n        preview: env === 'development',\n        // <https://github.com/ladjs/i18n>\n        // set to an object to configure and enable it\n        i18n: false,\n        // pass a custom render function if necessary\n        render: this.render.bind(this),\n        customRender: false,\n        // force text-only rendering of template (disregards template folder)\n        textOnly: false,\n        // <https://github.com/werk85/node-html-to-text>\n        htmlToText: {\n          ignoreImage: true\n        },\n        subjectPrefix: false,\n        // <https://github.com/Automattic/juice>\n        juice: true,\n        juiceResources: {\n          preserveImportant: true,\n          webResources: {\n            relativeTo: path.resolve('build'),\n            images: false\n          }\n        },\n        // pass a transport configuration object or a transport instance\n        // (e.g. an instance is created via `nodemailer.createTransport`)\n        // <https://nodemailer.com/transports/>\n        transport: {}\n      },\n      config\n    );\n\n    // override existing method\n    this.render = this.config.render;\n\n    if (!_.isFunction(this.config.transport.sendMail))\n      this.config.transport = nodemailer.createTransport(this.config.transport);\n\n    debug('transformed config %O', this.config);\n\n    autoBind(this);\n  }\n\n  // shorthand use of `juiceResources` with the config\n  // (mainly for custom renders like from a database)\n  juiceResources(html) {\n    return juiceResources(html, this.config.juiceResources);\n  }\n\n  // a simple helper function that gets the actual file path for the template\n  getTemplatePath(view) {\n    return new Promise(async (resolve, reject) => {\n      try {\n        const paths = await getPaths(\n          this.config.views.root,\n          view,\n          this.config.views.options.extension\n        );\n        const filePath = path.resolve(this.config.views.root, paths.rel);\n        resolve({ filePath, paths });\n      } catch (err) {\n        reject(err);\n      }\n    });\n  }\n\n  // returns true or false if a template exists\n  // (uses same look-up approach as `render` function)\n  templateExists(view) {\n    return new Promise(async resolve => {\n      try {\n        const { filePath } = await this.getTemplatePath(view);\n        const stats = await stat(filePath);\n        if (!stats.isFile()) throw new Error(`${filePath} was not a file`);\n        resolve(true);\n      } catch (err) {\n        debug('templateExists', err);\n        resolve(false);\n      }\n    });\n  }\n\n  // promise version of consolidate's render\n  // inspired by koa-views and re-uses the same config\n  // <https://github.com/queckezz/koa-views>\n  render(view, locals = {}) {\n    return new Promise(async (resolve, reject) => {\n      try {\n        const { map, engineSource } = this.config.views.options;\n        const { filePath, paths } = await this.getTemplatePath(view);\n        if (paths.ext === 'html' && !map) {\n          const res = await readFile(filePath, 'utf8');\n          resolve(res);\n        } else {\n          const engineName = map && map[paths.ext] ? map[paths.ext] : paths.ext;\n          const renderFn = engineSource[engineName];\n          if (!engineName || !renderFn)\n            return reject(\n              new Error(\n                `Engine not found for the \".${paths.ext}\" file extension`\n              )\n            );\n\n          if (_.isObject(this.config.i18n)) {\n            const i18n = new I18N(\n              Object.assign({}, this.config.i18n, {\n                register: locals\n              })\n            );\n\n            // support `locals.user.last_locale`\n            // (e.g. for <https://lad.js.org>)\n            if (_.isObject(locals.user) && _.isString(locals.user.last_locale))\n              locals.locale = locals.user.last_locale;\n\n            if (_.isString(locals.locale)) i18n.setLocale(locals.locale);\n          }\n\n          // TODO: convert this to a promise based version\n          renderFn(filePath, locals, (err, res) => {\n            if (err) return reject(err);\n            // transform the html with juice using remote paths\n            // google now supports media queries\n            // https://developers.google.com/gmail/design/reference/supported_css\n            if (!this.config.juice) return resolve(res);\n            this.juiceResources(res)\n              .then(resolve)\n              .catch(reject);\n          });\n        }\n      } catch (err) {\n        reject(err);\n      }\n    });\n  }\n\n  renderAll(template, locals = {}, message = {}) {\n    return new Promise(async (resolve, reject) => {\n      try {\n        let subjectTemplateExists = this.config.customRender;\n        let htmlTemplateExists = this.config.customRender;\n        let textTemplateExists = this.config.customRender;\n\n        const promises = [\n          this.templateExists(`${template}/subject`),\n          this.templateExists(`${template}/html`),\n          this.templateExists(`${template}/text`)\n        ];\n\n        if (template && !this.config.customRender)\n          [\n            subjectTemplateExists,\n            htmlTemplateExists,\n            textTemplateExists\n          ] = await Promise.all(promises);\n\n        if (!message.subject && subjectTemplateExists) {\n          message.subject = await this.render(\n            `${template}/subject`,\n            Object.assign({}, locals, { pretty: false })\n          );\n          message.subject = message.subject.trim();\n        }\n\n        if (message.subject && this.config.subjectPrefix)\n          message.subject = this.config.subjectPrefix + message.subject;\n\n        if (!message.html && htmlTemplateExists)\n          message.html = await this.render(`${template}/html`, locals);\n\n        if (!message.text && textTemplateExists)\n          message.text = await this.render(\n            `${template}/text`,\n            Object.assign({}, locals, { pretty: false })\n          );\n\n        if (this.config.htmlToText && message.html && !message.text)\n          // we'd use nodemailer-html-to-text plugin\n          // but we really don't need to support cid\n          // <https://github.com/andris9/nodemailer-html-to-text>\n          message.text = htmlToText.fromString(\n            message.html,\n            this.config.htmlToText\n          );\n\n        // if we only want a text-based version of the email\n        if (this.config.textOnly) delete message.html;\n\n        resolve(message);\n      } catch (err) {\n        reject(err);\n      }\n    });\n  }\n\n  send(options = {}) {\n    options = Object.assign(\n      {\n        template: '',\n        message: {},\n        locals: {}\n      },\n      options\n    );\n\n    let { template, message, locals } = options;\n\n    const attachments =\n      message.attachments || this.config.message.attachments || [];\n\n    message = _.defaultsDeep(\n      {},\n      _.omit(this.config.message, 'attachments'),\n      _.omit(message, 'attachments')\n    );\n    locals = _.defaultsDeep({}, this.config.views.locals, locals);\n\n    if (attachments) message.attachments = attachments;\n\n    debug('template %s', template);\n    debug('message %O', message);\n    debug('locals (keys only): %O', Object.keys(locals));\n\n    return new Promise(async (resolve, reject) => {\n      try {\n        // get all available templates\n        const obj = await this.renderAll(template, locals, message);\n\n        // assign the object variables over to the message\n        Object.assign(message, obj);\n\n        if (this.config.preview) {\n          debug('using `preview-email` to preview email');\n          await previewEmail(message);\n        }\n\n        if (!this.config.send) {\n          debug('send disabled so we are ensuring JSONTransport');\n          // <https://github.com/nodemailer/nodemailer/issues/798>\n          // if (this.config.transport.name !== 'JSONTransport')\n          this.config.transport = nodemailer.createTransport({\n            jsonTransport: true\n          });\n        }\n\n        const res = await this.config.transport.sendMail(message);\n        debug('message sent');\n        res.originalMessage = message;\n        resolve(res);\n      } catch (err) {\n        reject(err);\n      }\n    });\n  }\n}\n\nmodule.exports = Email;\n"]}
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/index.js"],"names":["fs","require","path","debug","htmlToText","I18N","autoBind","nodemailer","consolidate","previewEmail","_","Promise","getPaths","juiceResources","env","process","NODE_ENV","stat","promisify","readFile","Email","constructor","config","juiceOptions","disableJuice","juice","render","customRender","merge","views","root","resolve","options","extension","map","hbs","njk","engineSource","locals","pretty","message","send","includes","preview","i18n","bind","textOnly","ignoreImage","subjectPrefix","preserveImportant","webResources","relativeTo","images","transport","isFunction","sendMail","createTransport","html","getTemplatePath","view","paths","filePath","rel","templateExists","stats","isFile","Error","err","ext","res","engineName","renderFn","isObject","Object","assign","register","user","isString","last_locale","locale","setLocale","renderAll","template","subjectTemplateExists","htmlTemplateExists","textTemplateExists","promises","all","subject","trim","text","fromString","attachments","defaultsDeep","omit","keys","obj","jsonTransport","originalMessage","module","exports"],"mappings":"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","file":"index.js","sourcesContent":["const fs = require('fs');\nconst path = require('path');\nconst debug = require('debug')('email-templates');\nconst htmlToText = require('html-to-text');\nconst I18N = require('@ladjs/i18n');\nconst autoBind = require('auto-bind');\nconst nodemailer = require('nodemailer');\nconst consolidate = require('consolidate');\nconst previewEmail = require('preview-email');\nconst _ = require('lodash');\nconst Promise = require('bluebird');\n\nconst getPaths = require('get-paths');\nconst juiceResources = require('juice-resources-promise');\n\nconst env = process.env.NODE_ENV || 'development';\nconst stat = Promise.promisify(fs.stat);\nconst readFile = Promise.promisify(fs.readFile);\n\nclass Email {\n  constructor(config = {}) {\n    debug('config passed %O', config);\n\n    // 2.x backwards compatible support\n    if (config.juiceOptions) {\n      config.juiceResources = config.juiceOptions;\n      delete config.juiceOptions;\n    }\n    if (config.disableJuice) {\n      config.juice = false;\n      delete config.disableJuice;\n    }\n    if (config.render) {\n      config.customRender = true;\n    }\n\n    this.config = _.merge(\n      {\n        views: {\n          // directory where email templates reside\n          root: path.resolve('emails'),\n          options: {\n            // default file extension for template\n            extension: 'pug',\n            map: {\n              hbs: 'handlebars',\n              njk: 'nunjucks'\n            },\n            engineSource: consolidate\n          },\n          // locals to pass to templates for rendering\n          locals: {\n            // pretty is automatically set to `false` for subject/text\n            pretty: true\n          }\n        },\n        // <https://nodemailer.com/message/>\n        message: {},\n        send: !['development', 'test'].includes(env),\n        preview: env === 'development',\n        // <https://github.com/ladjs/i18n>\n        // set to an object to configure and enable it\n        i18n: false,\n        // pass a custom render function if necessary\n        render: this.render.bind(this),\n        customRender: false,\n        // force text-only rendering of template (disregards template folder)\n        textOnly: false,\n        // <https://github.com/werk85/node-html-to-text>\n        htmlToText: {\n          ignoreImage: true\n        },\n        subjectPrefix: false,\n        // <https://github.com/Automattic/juice>\n        juice: true,\n        juiceResources: {\n          preserveImportant: true,\n          webResources: {\n            relativeTo: path.resolve('build'),\n            images: false\n          }\n        },\n        // pass a transport configuration object or a transport instance\n        // (e.g. an instance is created via `nodemailer.createTransport`)\n        // <https://nodemailer.com/transports/>\n        transport: {}\n      },\n      config\n    );\n\n    // override existing method\n    this.render = this.config.render;\n\n    if (!_.isFunction(this.config.transport.sendMail))\n      this.config.transport = nodemailer.createTransport(this.config.transport);\n\n    debug('transformed config %O', this.config);\n\n    autoBind(this);\n  }\n\n  // shorthand use of `juiceResources` with the config\n  // (mainly for custom renders like from a database)\n  juiceResources(html) {\n    return juiceResources(html, this.config.juiceResources);\n  }\n\n  // a simple helper function that gets the actual file path for the template\n  async getTemplatePath(view) {\n    const paths = await getPaths(\n      this.config.views.root,\n      view,\n      this.config.views.options.extension\n    );\n    const filePath = path.resolve(this.config.views.root, paths.rel);\n    return { filePath, paths };\n  }\n\n  // returns true or false if a template exists\n  // (uses same look-up approach as `render` function)\n  async templateExists(view) {\n    try {\n      const { filePath } = await this.getTemplatePath(view);\n      const stats = await stat(filePath);\n      if (!stats.isFile()) throw new Error(`${filePath} was not a file`);\n      return true;\n    } catch (err) {\n      debug('templateExists', err);\n      return false;\n    }\n  }\n\n  // promise version of consolidate's render\n  // inspired by koa-views and re-uses the same config\n  // <https://github.com/queckezz/koa-views>\n  async render(view, locals = {}) {\n    const { map, engineSource } = this.config.views.options;\n    const { filePath, paths } = await this.getTemplatePath(view);\n    if (paths.ext === 'html' && !map) {\n      const res = await readFile(filePath, 'utf8');\n      return res;\n    }\n    const engineName = map && map[paths.ext] ? map[paths.ext] : paths.ext;\n    const renderFn = engineSource[engineName];\n    if (!engineName || !renderFn)\n      throw new Error(\n        `Engine not found for the \".${paths.ext}\" file extension`\n      );\n\n    if (_.isObject(this.config.i18n)) {\n      const i18n = new I18N(\n        Object.assign({}, this.config.i18n, {\n          register: locals\n        })\n      );\n\n      // support `locals.user.last_locale`\n      // (e.g. for <https://lad.js.org>)\n      if (_.isObject(locals.user) && _.isString(locals.user.last_locale))\n        locals.locale = locals.user.last_locale;\n\n      if (_.isString(locals.locale)) i18n.setLocale(locals.locale);\n    }\n\n    const res = await Promise.promisify(renderFn)(filePath, locals);\n    // transform the html with juice using remote paths\n    // google now supports media queries\n    // https://developers.google.com/gmail/design/reference/supported_css\n    if (!this.config.juice) return res;\n    const html = await this.juiceResources(res);\n    return html;\n  }\n\n  async renderAll(template, locals = {}, message = {}) {\n    let subjectTemplateExists = this.config.customRender;\n    let htmlTemplateExists = this.config.customRender;\n    let textTemplateExists = this.config.customRender;\n\n    const promises = [\n      this.templateExists(`${template}/subject`),\n      this.templateExists(`${template}/html`),\n      this.templateExists(`${template}/text`)\n    ];\n\n    if (template && !this.config.customRender)\n      [\n        subjectTemplateExists,\n        htmlTemplateExists,\n        textTemplateExists\n      ] = await Promise.all(promises);\n\n    if (!message.subject && subjectTemplateExists) {\n      message.subject = await this.render(\n        `${template}/subject`,\n        Object.assign({}, locals, { pretty: false })\n      );\n      message.subject = message.subject.trim();\n    }\n\n    if (message.subject && this.config.subjectPrefix)\n      message.subject = this.config.subjectPrefix + message.subject;\n\n    if (!message.html && htmlTemplateExists)\n      message.html = await this.render(`${template}/html`, locals);\n\n    if (!message.text && textTemplateExists)\n      message.text = await this.render(\n        `${template}/text`,\n        Object.assign({}, locals, { pretty: false })\n      );\n\n    if (this.config.htmlToText && message.html && !message.text)\n      // we'd use nodemailer-html-to-text plugin\n      // but we really don't need to support cid\n      // <https://github.com/andris9/nodemailer-html-to-text>\n      message.text = htmlToText.fromString(\n        message.html,\n        this.config.htmlToText\n      );\n\n    // if we only want a text-based version of the email\n    if (this.config.textOnly) delete message.html;\n\n    return message;\n  }\n\n  async send(options = {}) {\n    options = Object.assign(\n      {\n        template: '',\n        message: {},\n        locals: {}\n      },\n      options\n    );\n\n    let { template, message, locals } = options;\n\n    const attachments =\n      message.attachments || this.config.message.attachments || [];\n\n    message = _.defaultsDeep(\n      {},\n      _.omit(this.config.message, 'attachments'),\n      _.omit(message, 'attachments')\n    );\n    locals = _.defaultsDeep({}, this.config.views.locals, locals);\n\n    if (attachments) message.attachments = attachments;\n\n    debug('template %s', template);\n    debug('message %O', message);\n    debug('locals (keys only): %O', Object.keys(locals));\n\n    // get all available templates\n    const obj = await this.renderAll(template, locals, message);\n\n    // assign the object variables over to the message\n    Object.assign(message, obj);\n\n    if (this.config.preview) {\n      debug('using `preview-email` to preview email');\n      await previewEmail(message);\n    }\n\n    if (!this.config.send) {\n      debug('send disabled so we are ensuring JSONTransport');\n      // <https://github.com/nodemailer/nodemailer/issues/798>\n      // if (this.config.transport.name !== 'JSONTransport')\n      this.config.transport = nodemailer.createTransport({\n        jsonTransport: true\n      });\n    }\n\n    const res = await this.config.transport.sendMail(message);\n    debug('message sent');\n    res.originalMessage = message;\n    return res;\n  }\n}\n\nmodule.exports = Email;\n"]}

18

package.json
{
"name": "email-templates",
"description": "Create, preview, and send custom email templates for Node.js. Highly configurable and supports automatic inline CSS, stylesheets, embedded images and fonts, and much more! Made for sending beautiful emails with Lad.",
"version": "4.0.3",
"version": "4.0.4",
"author": "Nick Baugh <niftylettuce@gmail.com> (http://niftylettuce.com)",

@@ -19,3 +19,3 @@ "bugs": {

"debug": "^3.1.0",
"get-paths": "^0.0.2",
"get-paths": "^0.0.4",
"html-to-text": "^4.0.0",

@@ -25,4 +25,4 @@ "juice": "^4.3.2",

"lodash": "^4.17.10",
"nodemailer": "^4.6.7",
"preview-email": "^0.0.7"
"nodemailer": "^4.6.8",
"preview-email": "^0.0.8"
},

@@ -36,13 +36,13 @@ "devDependencies": {

"cross-env": "^5.2.0",
"eslint": "^5.2.0",
"eslint-config-prettier": "^2.9.0",
"eslint": "^5.4.0",
"eslint-config-prettier": "^3.0.1",
"eslint-plugin-prettier": "^2.6.2",
"husky": "^0.14.3",
"lint-staged": "^7.2.0",
"lint-staged": "^7.2.2",
"nyc": "^12.0.2",
"prettier": "^1.14.0",
"prettier": "^1.14.2",
"pug": "^2.0.3",
"remark-cli": "^5.0.0",
"remark-preset-github": "^0.0.8",
"xo": "^0.21.1"
"xo": "^0.22.0"
},

@@ -49,0 +49,0 @@ "engines": {

6

README.md

@@ -10,4 +10,6 @@ # [**Email Templates**](https://github.com/niftylettuce/email-templates)

> Create, [preview][preview-email], and send custom email templates for [Node.js][node]. Highly configurable and supports automatic inline CSS, stylesheets, embedded images and fonts, and much more! Made for sending beautiful emails with [Lad][].
>
> :heart: Love this project? Support <a href="https://github.com/niftylettuce" target="_blank">@niftylettuce's</a> [FOSS](https://en.wikipedia.org/wiki/Free_and_open-source_software) on <a href="https://patreon.com/niftylettuce" target="_blank">Patreon</a> or <a href="https://paypal.me/niftylettuce">PayPal</a> :unicorn:
Create, [preview][preview-email], and send custom email templates for [Node.js][node]. Highly configurable and supports automatic inline CSS, stylesheets, embedded images and fonts, and much more! Made for sending beautiful emails with [Lad][].
> **Still on v2.x?**: v3.x is released (you'll need Node v6.4.0+); see [breaking changes below](#v3-breaking-changes). [2.x branch][2-x-branch] docs available if necessary.

@@ -14,0 +16,0 @@

SocketSocket SOC 2 Logo

Product

  • Package Alerts
  • Integrations
  • Docs
  • Pricing
  • FAQ
  • Roadmap
  • Changelog

About

Packages

npm

Go

Maven

PyPI

Rubygems

Stay in touch

Get open source security insights delivered straight into your inbox.

  • Terms
  • Privacy
  • Security

Made with ⚡️ by Socket Inc