メール

node ace add @adonisjs/mail

# CLIフラグを使用して使用するトランスポートを事前に定義する
node ace add @adonisjs/mail --transports=resend --transports=smtp

import env from '#start/env'
import { defineConfig, transports } from '@adonisjs/mail'

const mailConfig = defineConfig({
  default: 'smtp',

  /**
   * "from"プロパティのための静的なアドレス。メールで明示的なfromアドレスが設定されていない場合に使用されます。
   */
  from: {
    address: '',
    name: '',
  },

  /**
   * "reply-to"プロパティのための静的なアドレス。メールで明示的なreplyToアドレスが設定されていない場合に使用されます。
   */
  replyTo: {
    address: '',
    name: '',
  },

  /**
   * mailersオブジェクトは、異なるトランスポートまたは異なるオプションを使用する同じトランスポートを使用して複数のメーラーを設定するために使用できます。
   */
  mailers: {
    smtp: transports.smtp({
      host: env.get('SMTP_HOST'),
      port: env.get('SMTP_PORT'),
    }),

    resend: transports.resend({
      key: env.get('RESEND_API_KEY'),
      baseUrl: 'https://api.resend.com',
    }),
  },
})

import User from '#models/user'
import { HttpContext } from '@adonisjs/core/http'
import mail from '@adonisjs/mail/services/main'

export default class UsersController {
  async store({ request }: HttpContext) {
    /**
     * デモンストレーションのためだけです。データをデータベースに保存する前にデータをバリデーションする必要があります。
     */
    const user = await User.create(request.all())

    await mail.send((message) => {
      message
        .to(user.email)
        .from('info@example.org')
        .subject('メールアドレスの確認')
        .htmlView('emails/verify_email', { user })
    })
  }
}

await mail.send((message) => {
await mail.sendLater((message) => {
  message
    .to(user.email)
    .from('info@example.org')
    .subject('メールアドレスの確認')
    .htmlView('emails/verify_email', { user })
})

npm i bullmq

import { Queue } from 'bullmq'
import mail from '@adonisjs/mail/services/main'

const emailsQueue = new Queue('emails')

mail.setMessenger((mailer) => {
  return {
    async queue(mailMessage, config) {
      await emailsQueue.add('send_email', {
        mailMessage,
        config,
        mailerName: mailer.name,
      })
    }
  }
})

import { Worker } from 'bullmq'
import mail from '@adonisjs/mail/services/main'

new Worker('emails', async (job) => {
  if (job.name === 'send_email') {
    const {
      mailMessage,
      config,
      mailerName
    } = job.data

    await mail
      .use(mailerName)
      .sendCompiled(mailMessage, config)
  }
})

import mail from '@adonisjs/mail/services/main'

mail.use() // Instance of default mailer
mail.use('mailgun') // Mailgun mailer instance

await mail
  .use('mailgun')
  .send((message) => {
  })

await mail
  .use('mailgun')
  .sendLater((message) => {
  })

import mail from '@adonisjs/mail/services/main'

/**
 * トランスポートを閉じてインスタンスをキャッシュから削除します
 */
await mail.close('mailgun')

/**
 * 新しいインスタンスを作成します
 */
mail.use('mailgun')

import { Message } from '@adonisjs/mail'

Message.templateEngine = {
  async render(templatePath, data) {
    return someTemplateEngine.render(templatePath, data)
  }
}

import { Message } from '@adonisjs/mail'
import mail from '@adonisjs/mail/services/main'

await mail.send((message) => {
  console.log(message instanceof Message) // true
})

await mail.sendLater((message) => {
  console.log(message instanceof Message) // true
})

await mail.send((message) => {
  message
    .subject('メールアドレスの確認')
    .from('info@example.org')
})

message
  .from({
    address: 'info@example.com',
    name: 'AdonisJS'
  })

const mailConfig = defineConfig({
  from: {
    address: 'info@example.com',
    name: 'AdonisJS'
  }
})

await mail.send((message) => {
  message
    .to(user.email)
    .cc(user.team.email)
    .bcc(user.team.admin.email)
})

await mail.send((message) => {
  message
    .to({
      address: user.email,
      name: user.fullName,
    })
    .cc({
      address: user.team.email,
      name: user.team.name,
    })
    .bcc({
      address: user.team.admin.email,
      name: user.team.admin.fullName,
    })
})

await mail.send((message) => {
  message
    .cc(['first@example.com', 'second@example.com'])
    .bcc([
      {
        name: 'First recipient',
        address: 'first@example.com'
      },
      {
        name: 'Second recipient',
        address: 'second@example.com'
      }
    ])
})

await mail.send((message) => {
  message
    .from('info@example.org')
    .replyTo('noreply@example.org')
})

await mail.send((message) => {
  /**
   * HTML コンテンツ
   */
  message.html(`
    <h1> メールアドレスの確認 </h1>
    <p> <a href="https://myapp.com">こちらをクリック</a>してメールアドレスを確認してください</a>
  `)

  /**
   * プレーンテキストコンテンツ
   */
  message.text(`
    メールアドレスの確認
    メールアドレスを確認するには、https://myapp.com にアクセスしてください
  `)
})

node ace make:view emails/verify_email_html
node ace make:view emails/verify_email_text

await mail.send((message) => {
  message.htmlView('emails/verify_email_html', stateToShare)
  message.textView('emails/verify_email_text', stateToShare)
})

npm i mjml

@mjml()
  <mjml>
    <mj-body>
      <mj-section>
        <mj-column>
          <mj-text>
            Hello World!
          </mj-text>
        </mj-column>
      </mj-section>
    </mj-body>
  </mjml>
@end

@mjml({
  keepComments: false,
  fonts: {
    Lato: 'https://fonts.googleapis.com/css?family=Lato:400,500,700'
  }
})

import app from '@adonisjs/core/services/app'

await mail.send((message) => {
  message.attach(app.makePath('uploads/invoice.pdf'))
})

message.attach(app.makePath('uploads/invoice.pdf'), {
  filename: 'invoice_october_2023.pdf'
})

message.attachData(fs.createReadStream('./invoice.pdf'), {
  filename: 'invoice_october_2023.pdf'
})

message.attachData(Buffer.from('aGVsbG8gd29ybGQh'), {
  encoding: 'base64',
  filename: 'greeting.txt',
})

<img src="{{
  embedImage(app.makePath('assets/hero.jpg'))
}}" />

<img src="cid:a-random-content-id" />

{
  attachments: [{
    path: '/root/app/assets/hero.jpg',
    filename: 'hero.jpg',
    cid: 'a-random-content-id'
  }]
}

<img src="{{
  embedImageData(rawBuffer, { filename: 'hero.jpg' })
}}" />

const contents = 'BEGIN:VCALENDAR\r\nPRODID:-//ACME/DesktopCalendar//EN\r\nMETHOD:REQUEST\r\n...'

await mail.send((message) => {
  message.icalEvent(contents, {
    method: 'PUBLISH',
    filename: 'invite.ics',
  })
})

message.icalEvent((calendar) => {
  calendar
    .createEvent({
      summary: 'ALS のサポートを追加',
      start: DateTime.local().plus({ minutes: 30 }),
      end: DateTime.local().plus({ minutes: 60 }),
    })
}, {
  method: 'PUBLISH',
  filename: 'invite.ics',
})

message.icalEventFromFile(
  app.resourcesPath('calendar-invites/invite.ics'),
  {
    filename: 'invite.ics',
    method: 'PUBLISH'
  }
)

message.icalEventFromFile(
  'https://myapp.com/users/1/invite.ics',
  {
    filename: 'invite.ics',
    method: 'PUBLISH'
  }
)

message.header('x-my-key', 'ヘッダの値')

/**
 * 値の配列を定義することもできます
 */
message.header('x-my-key', ['ヘッダの値', '別の値'])

message.preparedHeader(
  'x-unprocessed',
  '非ASCII文字を含む非常に長いヘッダまたは値 👮',
)

message.listHelp('admin@example.com?subject=help')
// List-Help: <mailto:admin@example.com?subject=help>

message.listUnsubscribe({
  url: 'http://example.com',
  comment: 'コメント'
})
// List-Unsubscribe: <http://example.com> (コメント)

/**
 * ヘッダを複数回繰り返す
 */
message.listSubscribe('admin@example.com?subject=subscribe')
message.listSubscribe({
  url: 'http://example.com',
  comment: '購読'
})
// List-Subscribe: <mailto:admin@example.com?subject=subscribe>
// List-Subscribe: <http://example.com> (購読)

message.addListHeader('post', 'http://example.com/post')
// List-Post: <http://example.com/post>

node ace make:mail verify_email

import User from '#models/user'
import { BaseMail } from '@adonisjs/mail'

export default class VerifyEmailNotification extends BaseMail {
  from = 'sender_email@example.org'
  subject = 'Verify email'

  prepare() {
    this.message.to('user_email@example.org')
  }
}

import mail from '@adonisjs/mail/services/main'
import VerifyEmailNotification from '#mails/verify_email'

await mail.send(new VerifyEmailNotification())

import mail from '@adonisjs/mail/services/main'
import VerifyEmailNotification from '#mails/verify_email'

await mail.sendLater(new VerifyEmailNotification())

/**
 * ユーザーを作成する
 */
const user = await User.create(payload)

await mail.send(
  /**
   * メールクラスにユーザーを渡す
   */
  new VerifyEmailNotification(user)
)

import { test } from '@japa/runner'
import VerifyEmailNotification from '#mails/verify_email'

test.group('Verify email notification', () => {
  test('prepare email for sending', async () => {
    const email = new VerifyEmailNotification()

    /**
     * メールメッセージをビルドし、テンプレートをレンダリングして
     * メールのHTMLとプレーンテキストの内容を計算します
     */
    await email.buildWithContents()

    /**
     * メッセージが期待どおりにビルドされたことを確認するためのアサーションを記述します
     */
    email.message.assertTo('user@example.org')
    email.message.assertFrom('info@example.org')
    email.message.assertSubject('Verify email address')
    email.message.assertReplyTo('no-reply@example.org')
  })
})

const email = new VerifyEmailNotification()
await email.buildWithContents()

email.message.assertHtmlIncludes(
  `<a href="/emails/1/verify"> メールアドレスを確認する </a>`
)
email.message.assertTextIncludes('メールアドレスを確認する')

const email = new VerifyEmailNotification()
await email.buildWithContents()

email.message.assertAttachment(
  app.makePath('uploads/invoice.pdf')
)

import { test } from '@japa/runner'
import mail from '@adonisjs/mail/services/main'
import VerifyEmailNotification from '#mails/verify_email'

test.group('Users | register', () => {
  test('create a new user account', async ({ client, route }) => {
    /**
     * フェイクモードをオンにする
     */
    const { mails } = mail.fake()

    /**
     * APIコールを行う
     */
    await client
      .post(route('users.store'))
      .send(userData)

    /**
     * コントローラが VerifyEmailNotification メールを送信したことをアサートする
     */
    mails.assertSent(VerifyEmailNotification, ({ message }) => {
      return message
        .hasTo(userData.email)
        .hasSubject('メールアドレスの確認')
    })
  })
})

test('create a new user account', async ({ client, route, cleanup }) => {
  const { mails } = mail.fake()

  /**
   * cleanupフックは、テストが正常に終了するかエラーが発生すると実行されます。
   */
  cleanup(() => {
    mail.restore()
  })
})

const { mails } = mail.fake()

/**
 * メールが送信されたことをアサートする
 */
mails.assertSent(VerifyEmailNotification)

mails.assertSent(VerifyEmailNotification, (email) => {
  return email.message.hasTo(userData.email)
})

mails.assertSent(VerifyEmailNotification, (email) => {
  email.message.assertTo(userData.email)
  email.message.assertFrom('info@example.org')
  email.message.assertSubject('メールアドレスの確認')

  /**
   * すべてのアサーションがパスしたため、メールが送信されたとみなすために true を返します。
   */
  return true
})

const { mails } = mail.fake()

mails.assertNotSent(PasswordResetNotification)

const { mails } = mail.fake()

// 2通のメールが合計で送信されたことをアサートする
mails.assertSentCount(2)

// VerifyEmailNotification が1回だけ送信されたことをアサートする
mails.assertSentCount(VerifyEmailNotification, 1)

const { mails } = mail.fake()

// 送信されたメールがないことをアサートする
mails.assertNoneSent()

const { mails } = mail.fake()

/**
 * VerifyEmailNotification メールがキューに入れられたことをアサートする
 * オプションで、メールを絞り込むためのファインダ関数を渡すこともできます
 */
mails.assertQueued(VerifyEmailNotification)

/**
 * PasswordResetNotification メールがキューに入れられなかったことをアサートする
 * オプションで、メールを絞り込むためのファインダ関数を渡すこともできます
 */
mails.assertNotQueued(PasswordResetNotification)

/**
 * 合計2通のメールがキューに入れられたことをアサートする
 */
mails.assertQueuedCount(2)

/**
 * VerifyEmailNotification メールが1回だけキューに入れられたことをアサートする
 */
mails.assertQueuedCount(VerifyEmailNotification , 1)

/**
 * キューに何も入っていないことをアサートする
 */
mails.assertNoneQueued()

const { mails } = mail.fake()

const sentEmails = mails.sent()
const queuedEmails = mails.queued()

const email = sentEmails.find((email) => {
  return email instanceof VerifyEmailNotification
})

if (email) {
  email.message.assertTo(userData.email)
  email.message.assertFrom(userData.email)
  email.message.assertHtmlIncludes('<a href="/verify/email"> メールアドレスを確認する</a>')
}

npm i nodemailer nodemailer-postmark-transport

import nodemailer from 'nodemailer'
import nodemailerTransport from 'nodemailer-postmark-transport'

import { MailResponse } from '@adonisjs/mail'
import type {
  NodeMailerMessage,
  MailTransportContract
} from '@adonisjs/mail/types'

/**
 * トランスポートが受け入れる設定
 */
export type PostMarkConfig = {
  auth: {
    apiKey: string
  }
}

/**
 * トランスポートの実装
 */
export class PostMarkTransport implements MailTransportContract {
  #config: PostMarkConfig
  constructor(config: PostMarkConfig) {
    this.#config = config
  }

  #createNodemailerTransport(config: PostMarkConfig) {
    return nodemailer.createTransport(nodemailerTransport(config))
  }

  async send(
    message: NodeMailerMessage,
    config?: PostMarkConfig
  ): Promise<MailResponse> {
    /**
     * Nodemailerトランスポートを作成する
     */
    const transporter = this.#createNodemailerTransport({
      ...this.#config,
      ...config,
    })

    /**
     * メールを送信する
     */
    const response = await transporter.sendMail(message)

    /**
     * 応答を「MailResponse」クラスのインスタンスに正規化する
     */
    return new MailResponse(response.messageId, response.envelope, response)
  }
}

import type {
  NodeMailerMessage,
  MailTransportContract,
  MailManagerTransportFactory
} from '@adonisjs/mail/types'

export function postMarkTransport(
  config: PostMarkConfig
): MailManagerTransportFactory {
  return () => {
    return new PostMarkTransport(config)
  }
}

import env from '#start/env'
import { defineConfig } from '@adonisjs/mail'
import { postMarkTransport } from 'my-custom-package'

const mailConfig = defineConfig({
  mailers: {
    postmark: postMarkTransport({
      auth: {
        apiKey: env.get('POSTMARK_API_KEY'),
      },
    }),
  },
})