email-templates/lib/index.js

"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 util = require('util');

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 juice = require('juice');

const nodemailer = require('nodemailer');

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 = util.promisify(fs.stat);
const readFile = util.promisify(fs.readFile);

class Email {
  constructor(config = {}) {
    debug('config passed %O', config); // 2.x backwards compatible support

    if (config.juiceOptions) {
      config.juiceResources = config.juiceOptions;
      delete config.juiceOptions;
    }

    if (config.disableJuice) {
      config.juice = false;
      delete config.disableJuice;
    }

    if (config.render) {
      config.customRender = true;
    }

    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,
      // Override juice global settings <https://github.com/Automattic/juice#juicecodeblockss>
      juiceSettings: {
        tableElements: ['TABLE']
      },
      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); // override existing method

    this.render = this.config.render;
    if (!_.isFunction(this.config.transport.sendMail)) this.config.transport = nodemailer.createTransport(this.config.transport); // Override juice global settings https://github.com/Automattic/juice#juicecodeblocks

    if (_.isObject(this.config.juiceSettings)) {
      for (const [key, value] of Object.entries(this.config.juiceSettings)) {
        juice[key] = value;
      }
    }

    debug('transformed config %O', 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, juiceRenderResources = {}) {
    const juiceR = _.merge(this.config.juiceResources, juiceRenderResources);

    return juiceResources(html, juiceR);
  } // a simple helper function that gets the actual file path for the template


  async getTemplatePath(template) {
    let juiceRenderResources = {};

    if (_.isObject(template)) {
      juiceRenderResources = template.juiceResources;
      template = template.path;
    }

    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);
    return {
      filePath,
      paths,
      juiceRenderResources
    };
  } // returns true or false if a template exists
  // (uses same look-up approach as `render` function)


  async templateExists(view) {
    try {
      const {
        filePath
      } = await this.getTemplatePath(view);
      const stats = await stat(filePath);
      if (!stats.isFile()) throw new Error(`${filePath} was not a file`);
      return true;
    } catch (err) {
      debug('templateExists', err);
      return false;
    }
  }

  async checkAndRender(type, template, locals) {
    let juiceRenderResources = {};

    if (_.isObject(template)) {
      juiceRenderResources = template.juiceResources;
      template = template.path;
    }

    const string = this.config.getPath(type, template, locals);

    if (!this.config.customRender) {
      const exists = await this.templateExists(string);
      if (!exists) return;
    }

    return this.render(string, _objectSpread(_objectSpread({}, locals), type === 'html' ? {} : {
      pretty: false
    }), juiceRenderResources);
  } // 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 = {}) {
    const {
      map,
      engineSource
    } = this.config.views.options;
    const {
      filePath,
      paths,
      juiceRenderResources
    } = await this.getTemplatePath(view);

    if (paths.ext === 'html' && !map) {
      const res = await 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(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(_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 util.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 (!this.config.juice) return res;
    const html = await this.juiceResources(res, juiceRenderResources);
    return html;
  } // eslint-disable-next-line complexity


  async renderAll(template, locals = {}, nodemailerMessage = {}) {
    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 ((!_.isString(message.subject) || _.isEmpty(_.trim(message.subject))) && (!_.isString(message.text) || _.isEmpty(_.trim(message.text))) && (!_.isString(message.html) || _.isEmpty(_.trim(message.html))) && _.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.`);
    return message;
  }

  async send(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);
    debug('message %O', message);
    debug('locals (keys only): %O', Object.keys(locals)); // get all available templates

    const object = await this.renderAll(template, locals, message); // assign the object variables over to the message

    Object.assign(message, object);

    if (this.config.preview) {
      debug('using `preview-email` to preview email');
      await (_.isObject(this.config.preview) ? previewEmail(message, this.config.preview) : previewEmail(message));
    }

    if (!this.config.send) {
      debug('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');
    res.originalMessage = message;
    return res;
  }

}

module.exports = Email;
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/index.js"],"names":["fs","require","path","util","I18N","_","consolidate","debug","getPaths","htmlToText","juice","nodemailer","previewEmail","juiceResources","html","options","Promise","resolve","reject","err","env","process","NODE_ENV","toLowerCase","stat","promisify","readFile","Email","constructor","config","juiceOptions","disableJuice","render","customRender","merge","views","root","extension","map","hbs","njk","engineSource","locals","cache","includes","pretty","message","send","preview","i18n","bind","textOnly","ignoreImage","subjectPrefix","juiceSettings","tableElements","preserveImportant","webResources","relativeTo","images","transport","lastLocaleField","getPath","type","template","join","isFunction","sendMail","createTransport","isObject","key","value","Object","entries","getTemplatePath","templateExists","checkAndRender","renderAll","juiceRenderResources","juiceR","view","isAbsolute","dirname","basename","paths","filePath","rel","stats","isFile","Error","string","exists","ext","res","engineName","renderFn","register","user","isString","locale","setLocale","nodemailerMessage","subject","text","all","trim","fromString","isEmpty","attachments","defaultsDeep","omit","keys","object","assign","jsonTransport","originalMessage","module","exports"],"mappings":"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","sourcesContent":["const fs = require('fs');\nconst path = require('path');\nconst util = require('util');\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 juice = require('juice');\nconst nodemailer = require('nodemailer');\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 = util.promisify(fs.stat);\nconst readFile = util.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\n    if (config.disableJuice) {\n      config.juice = false;\n      delete config.disableJuice;\n    }\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            // 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        // Override juice global settings <https://github.com/Automattic/juice#juicecodeblockss>\n        juiceSettings: {\n          tableElements: ['TABLE']\n        },\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    // 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    // Override juice global settings https://github.com/Automattic/juice#juicecodeblocks\n    if (_.isObject(this.config.juiceSettings)) {\n      for (const [key, value] of Object.entries(this.config.juiceSettings)) {\n        juice[key] = value;\n      }\n    }\n\n    debug('transformed config %O', 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, juiceRenderResources = {}) {\n    const juiceR = _.merge(this.config.juiceResources, juiceRenderResources);\n    return juiceResources(html, juiceR);\n  }\n\n  // a simple helper function that gets the actual file path for the template\n  async getTemplatePath(template) {\n    let juiceRenderResources = {};\n\n    if (_.isObject(template)) {\n      juiceRenderResources = template.juiceResources;\n      template = template.path;\n    }\n\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    return { filePath, paths, juiceRenderResources };\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  async checkAndRender(type, template, locals) {\n    let juiceRenderResources = {};\n\n    if (_.isObject(template)) {\n      juiceRenderResources = template.juiceResources;\n      template = template.path;\n    }\n\n    const string = this.config.getPath(type, template, locals);\n    if (!this.config.customRender) {\n      const exists = await this.templateExists(string);\n      if (!exists) return;\n    }\n\n    return this.render(\n      string,\n      {\n        ...locals,\n        ...(type === 'html' ? {} : { pretty: false })\n      },\n      juiceRenderResources\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, juiceRenderResources } =\n      await this.getTemplatePath(view);\n    if (paths.ext === 'html' && !map) {\n      const res = await readFile(filePath, 'utf8');\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 util.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, juiceRenderResources);\n    return html;\n  }\n\n  // eslint-disable-next-line complexity\n  async renderAll(template, locals = {}, nodemailerMessage = {}) {\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 && !message.subject) message.subject = subject;\n      if (html && !message.html) message.html = html;\n      if (text && !message.text) message.text = text;\n    }\n\n    if (message.subject && this.config.subjectPrefix)\n      message.subject = this.config.subjectPrefix + message.subject;\n\n    // trim subject\n    if (message.subject) message.subject = message.subject.trim();\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    // if no subject, html, or text content exists then we should\n    // throw an error that says at least one must be found\n    // otherwise the email would be blank (defeats purpose of email-templates)\n    if (\n      (!_.isString(message.subject) || _.isEmpty(_.trim(message.subject))) &&\n      (!_.isString(message.text) || _.isEmpty(_.trim(message.text))) &&\n      (!_.isString(message.html) || _.isEmpty(_.trim(message.html))) &&\n      _.isEmpty(message.attachments)\n    )\n      throw new Error(\n        `No content was passed for subject, html, text, nor attachments message props. Check that the files for the template \"${template}\" exist.`\n      );\n\n    return message;\n  }\n\n  async send(options = {}) {\n    options = {\n      template: '',\n      message: {},\n      locals: {},\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(message, 'attachments'),\n      _.omit(this.config.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 object = await this.renderAll(template, locals, message);\n\n    // assign the object variables over to the message\n    Object.assign(message, object);\n\n    if (this.config.preview) {\n      debug('using `preview-email` to preview email');\n      await (_.isObject(this.config.preview)\n        ? previewEmail(message, this.config.preview)\n        : 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"]}