tr-email-templates
Version:
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.
382 lines (319 loc) • 55.7 kB
JavaScript
"use strict";
function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
function _defineProperty(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; }
const fs = require('fs');
const path = require('path');
const I18N = require('@ladjs/i18n');
const _ = require('lodash');
const consolidate = require('consolidate');
const debug = require('debug')('email-templates');
const getPaths = require('get-paths');
const htmlToText = require('html-to-text');
const is = require('@sindresorhus/is');
const juice = require('juice');
const nodemailer = require('nodemailer');
const pify = require('pify');
const previewEmail = require('preview-email'); // promise version of `juice.juiceResources`
const juiceResources = (html, options) => {
return new Promise((resolve, reject) => {
juice.juiceResources(html, options, (err, html) => {
if (err) return reject(err);
resolve(html);
});
});
};
const env = (process.env.NODE_ENV || 'development').toLowerCase();
const stat = pify(fs.stat);
const readFile = pify(fs.readFile);
class Email {
constructor(config = {}) {
debug('config passed %O', config);
console.log('config passed', config); // 2.x backwards compatible support
if (config.juiceOptions) {
config.juiceResources = config.juiceOptions;
delete config.juiceOptions;
}
debug('config.juiceResources %O', config.juiceResources);
console.log('config.juiceResources', config.juiceResources);
if (config.disableJuice) {
config.juice = false;
delete config.disableJuice;
}
debug('config.juice %O', config.juice);
console.log('config.juice', config.juice);
if (config.render) {
config.customRender = true;
}
debug('config.customRender %O', config.customRender);
console.log('config.customRender', config.customRender);
this.config = _.merge({
views: {
// directory where email templates reside
root: path.resolve('emails'),
options: {
// default file extension for template
extension: 'pug',
map: {
hbs: 'handlebars',
njk: 'nunjucks'
},
engineSource: consolidate
},
// locals to pass to templates for rendering
locals: {
// turn on caching for non-development environments
cache: !['development', 'test'].includes(env),
// pretty is automatically set to `false` for subject/text
pretty: true
}
},
// <https://nodemailer.com/message/>
message: {},
send: !['development', 'test'].includes(env),
preview: env === 'development',
// <https://github.com/ladjs/i18n>
// set to an object to configure and enable it
i18n: false,
// pass a custom render function if necessary
render: this.render.bind(this),
customRender: false,
// force text-only rendering of template (disregards template folder)
textOnly: false,
// <https://github.com/werk85/node-html-to-text>
htmlToText: {
ignoreImage: true
},
subjectPrefix: false,
// <https://github.com/Automattic/juice>
juice: true,
juiceResources: {
preserveImportant: true,
webResources: {
relativeTo: path.resolve('build'),
images: false
}
},
// pass a transport configuration object or a transport instance
// (e.g. an instance is created via `nodemailer.createTransport`)
// <https://nodemailer.com/transports/>
transport: {},
// last locale field name (also used by @ladjs/i18n)
lastLocaleField: 'last_locale',
getPath(type, template) {
return path.join(template, type);
}
}, config);
debug('merged config %O', this.config);
console.log('merged config', this.config); // override existing method
this.render = this.config.render;
debug('config.transport %O', this.config.transport);
console.log('config.transport', this.config.transport);
if (!_.isFunction(this.config.transport.sendMail)) this.config.transport = nodemailer.createTransport(this.config.transport);
debug('transport created');
console.log('transport created');
debug('transformed config %O', this.config);
console.log('transformed config', this.config);
this.juiceResources = this.juiceResources.bind(this);
this.getTemplatePath = this.getTemplatePath.bind(this);
this.templateExists = this.templateExists.bind(this);
this.checkAndRender = this.checkAndRender.bind(this);
this.render = this.render.bind(this);
this.renderAll = this.renderAll.bind(this);
this.send = this.send.bind(this);
} // shorthand use of `juiceResources` with the config
// (mainly for custom renders like from a database)
juiceResources(html) {
debug('Juicing resources for HTML');
console.log('Juicing resources for HTML');
return juiceResources(html, this.config.juiceResources);
} // a simple helper function that gets the actual file path for the template
async getTemplatePath(template) {
try {
debug('Getting template path for %s', template);
console.log('Getting template path for', template);
const [root, view] = path.isAbsolute(template) ? [path.dirname(template), path.basename(template)] : [this.config.views.root, template];
const paths = await getPaths(root, view, this.config.views.options.extension);
const filePath = path.resolve(root, paths.rel);
debug('Template path resolved to %s', filePath);
console.log('Template path resolved to', filePath);
return {
filePath,
paths
};
} catch (err) {
debug('getTemplatePath error: %O', err);
console.log('getTemplatePath error:', err);
throw err;
}
} // returns true or false if a template exists
// (uses same look-up approach as `render` function)
async templateExists(view) {
try {
debug('Checking if template exists for %s', view);
console.log('Checking if template exists for', view);
const {
filePath
} = await this.getTemplatePath(view);
const stats = await stat(filePath);
if (!stats.isFile()) throw new Error(`${filePath} was not a file`);
debug('Template exists for %s', view);
console.log('Template exists for', view);
return true;
} catch (err) {
debug('templateExists error: %O', err);
console.log('templateExists error:', err);
return false;
}
}
async checkAndRender(type, template, locals) {
try {
debug('Checking and rendering type %s for template %s', type, template);
console.log('Checking and rendering type', type, 'for template', template);
const str = this.config.getPath(type, template, locals);
if (!this.config.customRender) {
const exists = await this.templateExists(str);
if (!exists) return;
}
debug('Rendering template %s with locals %O', str, locals);
console.log('Rendering template', str, 'with locals', locals);
return this.render(str, _objectSpread({}, locals, {}, type === 'html' ? {} : {
pretty: false
}));
} catch (err) {
debug('checkAndRender error: %O', err);
console.log('checkAndRender error:', err);
throw err;
}
} // promise version of consolidate's render
// inspired by koa-views and re-uses the same config
// <https://github.com/queckezz/koa-views>
async render(view, locals = {}) {
try {
debug('Rendering view %s with locals %O', view, locals);
console.log('Rendering view', view, 'with locals', locals);
const {
map,
engineSource
} = this.config.views.options;
const {
filePath,
paths
} = await this.getTemplatePath(view);
if (paths.ext === 'html' && !map) {
const res = await readFile(filePath, 'utf8');
debug('Rendered HTML view %s', view);
console.log('Rendered HTML view', view);
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(this.config.i18n)) {
if (this.config.i18n.lastLocaleField && this.config.lastLocaleField && this.config.i18n.lastLocaleField !== this.config.lastLocaleField) throw new Error(`The 'lastLocaleField' (String) option for @ladjs/i18n and email-templates do not match, i18n value was ${this.config.i18n.lastLocaleField} and email-templates value was ${this.config.lastLocaleField}`);
const i18n = new I18N(_objectSpread({}, this.config.i18n, {
register: locals
})); // support `locals.user.last_locale` (variable based name lastLocaleField)
// (e.g. for <https://lad.js.org>)
if (_.isObject(locals.user) && _.isString(locals.user[this.config.lastLocaleField])) locals.locale = locals.user[this.config.lastLocaleField];
if (_.isString(locals.locale)) i18n.setLocale(locals.locale);
}
const res = await pify(renderFn)(filePath, locals);
debug('Rendered view %s with engine %s', view, engineName);
console.log('Rendered view', view, 'with engine', engineName); // transform the html with juice using remote paths
// google now supports media queries
// https://developers.google.com/gmail/design/reference/supported_css
if (!this.config.juice) return res;
const html = await this.juiceResources(res);
debug('Juiced HTML for view %s', view);
console.log('Juiced HTML for view', view);
return html;
} catch (err) {
debug('render error: %O', err);
console.log('render error:', err);
throw err;
}
} // eslint-disable-next-line complexity
async renderAll(template, locals = {}, nodemailerMessage = {}) {
try {
debug('Rendering all parts of template %s', template);
console.log('Rendering all parts of template', template);
const message = _objectSpread({}, nodemailerMessage);
if (template && (!message.subject || !message.html || !message.text)) {
const [subject, html, text] = await Promise.all(['subject', 'html', 'text'].map(type => this.checkAndRender(type, template, locals)));
if (subject && !message.subject) message.subject = subject;
if (html && !message.html) message.html = html;
if (text && !message.text) message.text = text;
}
if (message.subject && this.config.subjectPrefix) message.subject = this.config.subjectPrefix + message.subject; // trim subject
if (message.subject) message.subject = message.subject.trim();
if (this.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, this.config.htmlToText); // if we only want a text-based version of the email
if (this.config.textOnly) delete message.html; // if no subject, html, or text content exists then we should
// throw an error that says at least one must be found
// otherwise the email would be blank (defeats purpose of email-templates)
if ((!is.string(message.subject) || is.emptyStringOrWhitespace(message.subject)) && (!is.string(message.text) || is.emptyStringOrWhitespace(message.text)) && (!is.string(message.html) || is.emptyStringOrWhitespace(message.html)) && _.isArray(message.attachments) && _.isEmpty(message.attachments)) throw new Error(`No content was passed for subject, html, text, nor attachments message props. Check that the files for the template "${template}" exist.`);
debug('Rendered all parts of template %s', template);
console.log('Rendered all parts of template', template);
return message;
} catch (err) {
debug('renderAll error: %O', err);
console.log('renderAll error:', err);
throw err;
}
}
async send(options = {}) {
try {
debug('Sending email with options %O', options);
console.log('Sending email with options', options);
options = _objectSpread({
template: '',
message: {},
locals: {}
}, options);
let {
template,
message,
locals
} = options;
const attachments = message.attachments || this.config.message.attachments || [];
message = _.defaultsDeep({}, _.omit(message, 'attachments'), _.omit(this.config.message, 'attachments'));
locals = _.defaultsDeep({}, this.config.views.locals, locals);
if (attachments) message.attachments = attachments;
debug('template %s', template);
console.log('template', template);
debug('message %O', message);
console.log('message', message);
debug('locals (keys only): %O', Object.keys(locals));
console.log('locals (keys only):', Object.keys(locals)); // get all available templates
const obj = await this.renderAll(template, locals, message); // assign the object variables over to the message
Object.assign(message, obj);
if (this.config.preview) {
debug('using `preview-email` to preview email');
console.log('using `preview-email` to preview email');
if (_.isObject(this.config.preview)) await previewEmail(message, this.config.preview);else await previewEmail(message);
}
if (!this.config.send) {
debug('send disabled so we are ensuring JSONTransport');
console.log('send disabled so we are ensuring JSONTransport'); // <https://github.com/nodemailer/nodemailer/issues/798>
// if (this.config.transport.name !== 'JSONTransport')
this.config.transport = nodemailer.createTransport({
jsonTransport: true
});
}
const res = await this.config.transport.sendMail(message);
debug('message sent');
console.log('message sent');
res.originalMessage = message;
return res;
} catch (err) {
debug('send error: %O', err);
console.log('send error:', err);
throw err;
}
}
}
module.exports = Email;
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/index.js"],"names":["fs","require","path","I18N","_","consolidate","debug","getPaths","htmlToText","is","juice","nodemailer","pify","previewEmail","juiceResources","html","options","Promise","resolve","reject","err","env","process","NODE_ENV","toLowerCase","stat","readFile","Email","constructor","config","console","log","juiceOptions","disableJuice","render","customRender","merge","views","root","extension","map","hbs","njk","engineSource","locals","cache","includes","pretty","message","send","preview","i18n","bind","textOnly","ignoreImage","subjectPrefix","preserveImportant","webResources","relativeTo","images","transport","lastLocaleField","getPath","type","template","join","isFunction","sendMail","createTransport","getTemplatePath","templateExists","checkAndRender","renderAll","view","isAbsolute","dirname","basename","paths","filePath","rel","stats","isFile","Error","str","exists","ext","res","engineName","renderFn","isObject","register","user","isString","locale","setLocale","nodemailerMessage","subject","text","all","trim","fromString","string","emptyStringOrWhitespace","isArray","attachments","isEmpty","defaultsDeep","omit","Object","keys","obj","assign","jsonTransport","originalMessage","module","exports"],"mappings":"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","sourcesContent":["const fs = require('fs');\nconst path = require('path');\n\nconst I18N = require('@ladjs/i18n');\nconst _ = require('lodash');\nconst consolidate = require('consolidate');\nconst debug = require('debug')('email-templates');\nconst getPaths = require('get-paths');\nconst htmlToText = require('html-to-text');\nconst is = require('@sindresorhus/is');\nconst juice = require('juice');\nconst nodemailer = require('nodemailer');\nconst pify = require('pify');\nconst previewEmail = require('preview-email');\n\n// promise version of `juice.juiceResources`\nconst juiceResources = (html, options) => {\n  return new Promise((resolve, reject) => {\n    juice.juiceResources(html, options, (err, html) => {\n      if (err) return reject(err);\n      resolve(html);\n    });\n  });\n};\n\nconst env = (process.env.NODE_ENV || 'development').toLowerCase();\nconst stat = pify(fs.stat);\nconst readFile = pify(fs.readFile);\n\nclass Email {\n  constructor(config = {}) {\n    debug('config passed %O', config);\n    console.log('config passed', config);\n\n    // 2.x backwards compatible support\n    if (config.juiceOptions) {\n      config.juiceResources = config.juiceOptions;\n      delete config.juiceOptions;\n    }\n\n    debug('config.juiceResources %O', config.juiceResources);\n    console.log('config.juiceResources', config.juiceResources);\n\n    if (config.disableJuice) {\n      config.juice = false;\n      delete config.disableJuice;\n    }\n\n    debug('config.juice %O', config.juice);\n    console.log('config.juice', config.juice);\n\n    if (config.render) {\n      config.customRender = true;\n    }\n\n    debug('config.customRender %O', config.customRender);\n    console.log('config.customRender', config.customRender);\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            // turn on caching for non-development environments\n            cache: !['development', 'test'].includes(env),\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        // last locale field name (also used by @ladjs/i18n)\n        lastLocaleField: 'last_locale',\n        getPath(type, template) {\n          return path.join(template, type);\n        }\n      },\n      config\n    );\n\n    debug('merged config %O', this.config);\n    console.log('merged config', this.config);\n\n    // override existing method\n    this.render = this.config.render;\n\n    debug('config.transport %O', this.config.transport);\n    console.log('config.transport', this.config.transport);\n\n    if (!_.isFunction(this.config.transport.sendMail))\n      this.config.transport = nodemailer.createTransport(this.config.transport);\n\n    debug('transport created');\n    console.log('transport created');\n\n    debug('transformed config %O', this.config);\n    console.log('transformed config', this.config);\n\n    this.juiceResources = this.juiceResources.bind(this);\n    this.getTemplatePath = this.getTemplatePath.bind(this);\n    this.templateExists = this.templateExists.bind(this);\n    this.checkAndRender = this.checkAndRender.bind(this);\n    this.render = this.render.bind(this);\n    this.renderAll = this.renderAll.bind(this);\n    this.send = this.send.bind(this);\n  }\n\n  // shorthand use of `juiceResources` with the config\n  // (mainly for custom renders like from a database)\n  juiceResources(html) {\n    debug('Juicing resources for HTML');\n    console.log('Juicing resources for 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(template) {\n    try {\n      debug('Getting template path for %s', template);\n      console.log('Getting template path for', template);\n      const [root, view] = path.isAbsolute(template)\n        ? [path.dirname(template), path.basename(template)]\n        : [this.config.views.root, template];\n      const paths = await getPaths(\n        root,\n        view,\n        this.config.views.options.extension\n      );\n      const filePath = path.resolve(root, paths.rel);\n      debug('Template path resolved to %s', filePath);\n      console.log('Template path resolved to', filePath);\n      return { filePath, paths };\n    } catch (err) {\n      debug('getTemplatePath error: %O', err);\n      console.log('getTemplatePath error:', err);\n      throw err;\n    }\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      debug('Checking if template exists for %s', view);\n      console.log('Checking if template exists for', view);\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      debug('Template exists for %s', view);\n      console.log('Template exists for', view);\n      return true;\n    } catch (err) {\n      debug('templateExists error: %O', err);\n      console.log('templateExists error:', err);\n      return false;\n    }\n  }\n\n  async checkAndRender(type, template, locals) {\n    try {\n      debug('Checking and rendering type %s for template %s', type, template);\n      console.log(\n        'Checking and rendering type',\n        type,\n        'for template',\n        template\n      );\n      const str = this.config.getPath(type, template, locals);\n      if (!this.config.customRender) {\n        const exists = await this.templateExists(str);\n        if (!exists) return;\n      }\n\n      debug('Rendering template %s with locals %O', str, locals);\n      console.log('Rendering template', str, 'with locals', locals);\n      return this.render(str, {\n        ...locals,\n        ...(type === 'html' ? {} : { pretty: false })\n      });\n    } catch (err) {\n      debug('checkAndRender error: %O', err);\n      console.log('checkAndRender error:', err);\n      throw err;\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    try {\n      debug('Rendering view %s with locals %O', view, locals);\n      console.log('Rendering view', view, 'with locals', 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        debug('Rendered HTML view %s', view);\n        console.log('Rendered HTML view', view);\n        return res;\n      }\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        if (\n          this.config.i18n.lastLocaleField &&\n          this.config.lastLocaleField &&\n          this.config.i18n.lastLocaleField !== this.config.lastLocaleField\n        )\n          throw new Error(\n            `The 'lastLocaleField' (String) option for @ladjs/i18n and email-templates do not match, i18n value was ${this.config.i18n.lastLocaleField} and email-templates value was ${this.config.lastLocaleField}`\n          );\n\n        const i18n = new I18N({ ...this.config.i18n, register: locals });\n\n        // support `locals.user.last_locale` (variable based name lastLocaleField)\n        // (e.g. for <https://lad.js.org>)\n        if (\n          _.isObject(locals.user) &&\n          _.isString(locals.user[this.config.lastLocaleField])\n        )\n          locals.locale = locals.user[this.config.lastLocaleField];\n\n        if (_.isString(locals.locale)) i18n.setLocale(locals.locale);\n      }\n\n      const res = await pify(renderFn)(filePath, locals);\n      debug('Rendered view %s with engine %s', view, engineName);\n      console.log('Rendered view', view, 'with engine', engineName);\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      debug('Juiced HTML for view %s', view);\n      console.log('Juiced HTML for view', view);\n      return html;\n    } catch (err) {\n      debug('render error: %O', err);\n      console.log('render error:', err);\n      throw err;\n    }\n  }\n\n  // eslint-disable-next-line complexity\n  async renderAll(template, locals = {}, nodemailerMessage = {}) {\n    try {\n      debug('Rendering all parts of template %s', template);\n      console.log('Rendering all parts of template', template);\n      const message = { ...nodemailerMessage };\n\n      if (template && (!message.subject || !message.html || !message.text)) {\n        const [subject, html, text] = await Promise.all(\n          ['subject', 'html', 'text'].map((type) =>\n            this.checkAndRender(type, template, locals)\n          )\n        );\n\n        if (subject &