Skip to main content

EmailPlugin

EmailPlugin​

@vendure/email-pluginplugin.ts

The EmailPlugin creates and sends transactional emails based on Vendure events. By default, it uses an MJML-based email generator to generate the email body and Nodemailer to send the emails.

High-level description​

Vendure has an internal events system (see EventBus) that allows plugins to subscribe to events. The EmailPlugin is configured with EmailEventHandlers that listen for a specific event and when it is published, the handler defines which template to use to generate the resulting email.

The plugin comes with a set of default handler for the following events:

  • Order confirmation
  • New customer email address verification
  • Password reset request
  • Email address change request

You can also create your own handler and register them with the plugin - see the EmailEventHandler docs for more details.

Installation​

yarn add @vendure/email-plugin

or

npm install @vendure/email-plugin

Example

import { defaultEmailHandlers, EmailPlugin } from '@vendure/email-plugin';

const config: VendureConfig = {
  // Add an instance of the plugin to the plugins array
  plugins: [
    EmailPlugin.init({
      handler: defaultEmailHandlers,
      templatePath: path.join(__dirname, 'static/email/templates'),
      transport: {
        type: 'smtp',
        host: 'smtp.example.com',
        port: 587,
        auth: {
          user: 'username',
          pass: 'password',
        }
      },
    }),
  ],
};

Email templates​

In the example above, the plugin has been configured to look in <app-root>/static/email/templates for the email template files. If you used @vendure/create to create your application, the templates will have been copied to that location during setup.

If you are installing the EmailPlugin separately, then you'll need to copy the templates manually from node_modules/@vendure/email-plugin/templates to a location of your choice, and then point the templatePath config property at that directory.

  • Dynamic Email Templates​

Instead of passing a static value to templatePath, use templateLoader to define a template path.

  EmailPlugin.init({
   ...,
   templateLoader: new FileBasedTemplateLoader(my/order-confirmation/templates)
  })

Customizing templates​

Emails are generated from templates which use MJML syntax. MJML is an open-source HTML-like markup language which makes the task of creating responsive email markup simple. By default, the templates are installed to <project root>/vendure/email/templates and can be freely edited.

Dynamic data such as the recipient's name or order items are specified using Handlebars syntax:

<p>Dear {{ order.customer.firstName }} {{ order.customer.lastName }},</p>

<p>Thank you for your order!</p>

<mj-table cellpadding="6px">
  {{#each order.lines }}
    <tr class="order-row">
      <td>{{ quantity }} x {{ productVariant.name }}</td>
      <td>{{ productVariant.quantity }}</td>
      <td>{{ formatMoney totalPrice }}</td>
    </tr>
  {{/each}}
</mj-table>

Handlebars helpers​

The following helper functions are available for use in email templates:

  • formatMoney: Formats an amount of money (which are always stored as integers in Vendure) as a decimal, e.g. 123 => 1.23
  • formatDate: Formats a Date value with the dateformat package.

Extending the default email handler​

The defaultEmailHandlers array defines the default handler such as for handling new account registration, order confirmation, password reset etc. These defaults can be extended by adding custom templates for languages other than the default, or even completely new types of emails which respond to any of the available VendureEvents.

A good way to learn how to create your own email handler is to take a look at the source code of the default handler. New handler are defined in exactly the same way.

It is also possible to modify the default handler:

// Rather than importing `defaultEmailHandlers`, you can
// import the handler individually
import {
  orderConfirmationHandler,
  emailVerificationHandler,
  passwordResetHandler,
  emailAddressChangeHandler,
} from '@vendure/email-plugin';
import { CustomerService } from '@vendure/core';

// This allows you to then customize each handler to your needs.
// For example, let's set a new subject line to the order confirmation:
const myOrderConfirmationHandler = orderConfirmationHandler
  .setSubject(`We received your order!`);

// Another example: loading additional data and setting new
// template variables.
const myPasswordResetHandler = passwordResetHandler
  .loadData(async ({ event, injector }) => {
    const customerService = injector.get(CustomerService);
    const customer = await customerService.findOneByUserId(event.ctx, event.user.id);
    return { customer };
  })
  .setTemplateVars(event => ({
    passwordResetToken: event.user.getNativeAuthenticationMethod().passwordResetToken,
    customer: event.data.customer,
  }));

// Then you pass the handler to the EmailPlugin init method
// individually
EmailPlugin.init({
  handler: [
    myOrderConfirmationHandler,
    myPasswordResetHandler,
    emailVerificationHandler,
    emailAddressChangeHandler,
  ],
  // ...
}),

For all available methods of extending a handler, see the EmailEventHandler documentation.

Dynamic SMTP settings​

Instead of defining static transport settings, you can also provide a function that dynamically resolves channel aware transport settings.

Example

import { defaultEmailHandlers, EmailPlugin } from '@vendure/email-plugin';
import { MyTransportService } from './transport.services.ts';
const config: VendureConfig = {
  plugins: [
    EmailPlugin.init({
      handler: defaultEmailHandlers,
      templatePath: path.join(__dirname, 'static/email/templates'),
      transport: (injector, ctx) => {
        if (ctx) {
          return injector.get(MyTransportService).getSettings(ctx);
        } else {
          return {
            type: 'smtp',
            host: 'smtp.example.com',
            // ... etc.
          }
        }
      }
    }),
  ],
};

Dev mode​

For development, the transport option can be replaced by devMode: true. Doing so configures Vendure to use the file transport (See FileTransportOptions) and outputs emails as rendered HTML files in the directory specified by the outputPath property.

EmailPlugin.init({
  devMode: true,
  route: 'mailbox',
  handler: defaultEmailHandlers,
  templatePath: path.join(__dirname, 'vendure/email/templates'),
  outputPath: path.join(__dirname, 'test-emails'),
})

Dev mailbox​

In dev mode, a webmail-like interface available at the /mailbox path, e.g. http://localhost:3000/mailbox. This is a simple way to view the output of all emails generated by the EmailPlugin while in dev mode.

Troubleshooting SMTP Connections​

If you are having trouble sending email over and SMTP connection, set the logging and debug options to true. This will send detailed information from the SMTP transporter to the configured logger (defaults to console). For maximum detail combine this with a detail log level in the configured VendureLogger:

const config: VendureConfig = {
  logger: new DefaultLogger({ level: LogLevel.Debug })
  // ...
  plugins: [
    EmailPlugin.init({
      // ...
      transport: {
        type: 'smtp',
        host: 'smtp.example.com',
        port: 587,
        auth: {
          user: 'username',
          pass: 'password',
        },
        logging: true,
        debug: true,
      },
    }),
  ],
};
Signature
class EmailPlugin implements OnApplicationBootstrap, OnApplicationShutdown, NestModule {
    init(options: EmailPluginOptions | EmailPluginDevModeOptions) => Type<EmailPlugin>;
    onApplicationShutdown() => ;
    configure(consumer: MiddlewareConsumer) => ;
}
  • Implements: OnApplicationBootstrap, OnApplicationShutdown, NestModule

init​

method
(options: EmailPluginOptions | EmailPluginDevModeOptions) => Type<EmailPlugin>

onApplicationShutdown​

method
() =>

configure​

method
(consumer: MiddlewareConsumer) =>