How to Send Emails in Elixir / Phoenix (2026 Guide)

defp deps do
[
  {:phoenix, "~> 1.7"},
  {:req, "~> 0.5"},
  # Req is all you need - direct API calls
]
end

defp deps do
[
  {:phoenix, "~> 1.7"},
  {:swoosh, "~> 1.16"},
  # Swoosh includes a built-in Resend adapter
]
end

defp deps do
[
  {:phoenix, "~> 1.7"},
  {:swoosh, "~> 1.16"},
  # Swoosh includes a built-in SendGrid adapter
]
end

# config/runtime.exs
config :my_app, :sequenzy_api_key,
System.get_env("SEQUENZY_API_KEY") ||
  raise "SEQUENZY_API_KEY not set"

# config/runtime.exs
config :my_app, MyApp.Mailer,
adapter: Swoosh.Adapters.Resend,
api_key:
  System.get_env("RESEND_API_KEY") ||
    raise "RESEND_API_KEY not set"

# config/runtime.exs
config :my_app, MyApp.Mailer,
adapter: Swoosh.Adapters.Sendgrid,
api_key:
  System.get_env("SENDGRID_API_KEY") ||
    raise "SENDGRID_API_KEY not set"

defmodule MyApp.Emails do
@moduledoc "Sends transactional emails via Sequenzy API."

@base_url "https://api.sequenzy.com/v1"

def send_email(to, subject, body) do
  api_key = Application.fetch_env!(:my_app, :sequenzy_api_key)

  case Req.post("#{@base_url}/transactional/send",
         headers: [{"authorization", "Bearer #{api_key}"}],
         json: %{to: to, subject: subject, body: body}
       ) do
    {:ok, %Req.Response{status: 200, body: body}} ->
      {:ok, body}

    {:ok, %Req.Response{status: status, body: body}} ->
      {:error, %{status: status, body: body}}

    {:error, reason} ->
      {:error, reason}
  end
end
end

defmodule MyApp.Emails do
@moduledoc "Composes and sends emails via Swoosh + Resend."

import Swoosh.Email

alias MyApp.Mailer

@from {"Your App", "noreply@yourdomain.com"}

def send_email(to, subject, html_body) do
  new()
  |> to(to)
  |> from(@from)
  |> subject(subject)
  |> html_body(html_body)
  |> Mailer.deliver()
end
end

# lib/my_app/mailer.ex (generated by Phoenix)
defmodule MyApp.Mailer do
use Swoosh.Mailer, otp_app: :my_app
end

defmodule MyApp.Emails do
@moduledoc "Composes and sends emails via Swoosh + SendGrid."

import Swoosh.Email

alias MyApp.Mailer

@from {"Your App", "noreply@yourdomain.com"}

def send_email(to, subject, html_body) do
  new()
  |> to(to)
  |> from(@from)
  |> subject(subject)
  |> html_body(html_body)
  |> Mailer.deliver()
end
end

# lib/my_app/mailer.ex (generated by Phoenix)
defmodule MyApp.Mailer do
use Swoosh.Mailer, otp_app: :my_app
end

defmodule MyAppWeb.EmailController do
use MyAppWeb, :controller

alias MyApp.Emails

def send(conn, _params) do
  case Emails.send_email(
         "user@example.com",
         "Hello from Phoenix",
         "<p>Your app is sending emails. Nice.</p>"
       ) do
    {:ok, body} ->
      json(conn, %{jobId: body["jobId"]})

    {:error, reason} ->
      conn
      |> put_status(500)
      |> json(%{error: "Failed to send", details: inspect(reason)})
  end
end
end

defmodule MyAppWeb.EmailController do
use MyAppWeb, :controller

alias MyApp.Emails

def send(conn, _params) do
  case Emails.send_email(
         "user@example.com",
         "Hello from Phoenix",
         "<p>Your app is sending emails. Nice.</p>"
       ) do
    {:ok, _metadata} ->
      json(conn, %{sent: true})

    {:error, reason} ->
      conn
      |> put_status(500)
      |> json(%{error: "Failed to send", details: inspect(reason)})
  end
end
end

defmodule MyAppWeb.EmailController do
use MyAppWeb, :controller

alias MyApp.Emails

def send(conn, _params) do
  case Emails.send_email(
         "user@example.com",
         "Hello from Phoenix",
         "<p>Your app is sending emails. Nice.</p>"
       ) do
    {:ok, _metadata} ->
      json(conn, %{sent: true})

    {:error, reason} ->
      conn
      |> put_status(500)
      |> json(%{error: "Failed to send", details: inspect(reason)})
  end
end
end

defmodule MyApp.Emails do
alias MyApp.Emails.Renderer

@base_url "https://api.sequenzy.com/v1"

def welcome(email, name) do
  html = Renderer.render("welcome", %{
    name: name,
    login_url: "#{MyAppWeb.Endpoint.url()}/dashboard"
  })

  send_email(email, "Welcome, #{name}", html)
end

def send_email(to, subject, body) do
  api_key = Application.fetch_env!(:my_app, :sequenzy_api_key)

  case Req.post("#{@base_url}/transactional/send",
         headers: [{"authorization", "Bearer #{api_key}"}],
         json: %{to: to, subject: subject, body: body}
       ) do
    {:ok, %Req.Response{status: 200, body: body}} ->
      {:ok, body}

    {:ok, %Req.Response{status: status, body: body}} ->
      {:error, %{status: status, body: body}}

    {:error, reason} ->
      {:error, reason}
  end
end
end

defmodule MyApp.Emails do
import Swoosh.Email

alias MyApp.Emails.Renderer
alias MyApp.Mailer

@from {"Your App", "noreply@yourdomain.com"}

def welcome(email, name) do
  html = Renderer.render("welcome", %{
    name: name,
    login_url: "#{MyAppWeb.Endpoint.url()}/dashboard"
  })

  new()
  |> to(email)
  |> from(@from)
  |> subject("Welcome, #{name}")
  |> html_body(html)
  |> Mailer.deliver()
end
end

defmodule MyApp.Emails do
import Swoosh.Email

alias MyApp.Emails.Renderer
alias MyApp.Mailer

@from {"Your App", "noreply@yourdomain.com"}

def welcome(email, name) do
  html = Renderer.render("welcome", %{
    name: name,
    login_url: "#{MyAppWeb.Endpoint.url()}/dashboard"
  })

  new()
  |> to(email)
  |> from(@from)
  |> subject("Welcome, #{name}")
  |> html_body(html)
  |> Mailer.deliver()
end
end

defmodule MyAppWeb.ContactLive do
use MyAppWeb, :live_view

alias MyApp.Emails

def mount(_params, _session, socket) do
  {:ok, assign(socket, form: to_form(%{}))}
end

def handle_event("send_message", %{"email" => email, "message" => message}, socket) do
  case Emails.send_email(
         "you@yourcompany.com",
         "Contact form: #{email}",
         "<p><strong>From:</strong> #{email}</p><p>#{message}</p>"
       ) do
    {:ok, _} ->
      {:noreply,
       socket
       |> put_flash(:info, "Message sent!")
       |> assign(form: to_form(%{}))}

    {:error, _reason} ->
      {:noreply, put_flash(socket, :error, "Failed to send. Try again.")}
  end
end

def render(assigns) do
  ~H"""
  <.form for={@form} phx-submit="send_message">
    <.input field={@form[:email]} type="email" label="Your email" required />
    <.input field={@form[:message]} type="textarea" label="Message" required />
    <.button type="submit">Send</.button>
  </.form>
  """
end
end

defmodule MyAppWeb.ContactLive do
use MyAppWeb, :live_view

alias MyApp.Emails

def mount(_params, _session, socket) do
  {:ok, assign(socket, form: to_form(%{}))}
end

def handle_event("send_message", %{"email" => email, "message" => message}, socket) do
  case Emails.send_email(
         "you@yourcompany.com",
         "Contact form: #{email}",
         "<p><strong>From:</strong> #{email}</p><p>#{message}</p>"
       ) do
    {:ok, _} ->
      {:noreply,
       socket
       |> put_flash(:info, "Message sent!")
       |> assign(form: to_form(%{}))}

    {:error, _reason} ->
      {:noreply, put_flash(socket, :error, "Failed to send. Try again.")}
  end
end

def render(assigns) do
  ~H"""
  <.form for={@form} phx-submit="send_message">
    <.input field={@form[:email]} type="email" label="Your email" required />
    <.input field={@form[:message]} type="textarea" label="Message" required />
    <.button type="submit">Send</.button>
  </.form>
  """
end
end

defmodule MyAppWeb.ContactLive do
use MyAppWeb, :live_view

alias MyApp.Emails

def mount(_params, _session, socket) do
  {:ok, assign(socket, form: to_form(%{}))}
end

def handle_event("send_message", %{"email" => email, "message" => message}, socket) do
  case Emails.send_email(
         "you@yourcompany.com",
         "Contact form: #{email}",
         "<p><strong>From:</strong> #{email}</p><p>#{message}</p>"
       ) do
    {:ok, _} ->
      {:noreply,
       socket
       |> put_flash(:info, "Message sent!")
       |> assign(form: to_form(%{}))}

    {:error, _reason} ->
      {:noreply, put_flash(socket, :error, "Failed to send. Try again.")}
  end
end

def render(assigns) do
  ~H"""
  <.form for={@form} phx-submit="send_message">
    <.input field={@form[:email]} type="email" label="Your email" required />
    <.input field={@form[:message]} type="textarea" label="Message" required />
    <.button type="submit">Send</.button>
  </.form>
  """
end
end

def password_reset(email, reset_token) do
reset_url = "#{MyAppWeb.Endpoint.url()}/reset-password?token=#{reset_token}"

html = Renderer.render("password_reset", %{reset_url: reset_url})

send_email(email, "Reset your password", html)
end

# priv/emails/templates/password_reset.html.eex
# <h2 style="font-size:20px;">Password Reset</h2>
# <p style="font-size:16px;line-height:1.6;color:#374151;">
#   Click the link below to reset your password. This link expires in 1 hour.
# </p>
# <a href="<%= @reset_url %>"
#    style="display:inline-block;background:#f97316;color:#fff;padding:12px 24px;
#           border-radius:6px;text-decoration:none;font-size:14px;font-weight:600;
#           margin-top:16px;">
#   Reset Password
# </a>
# <p style="color:#6b7280;font-size:14px;margin-top:24px;">
#   If you didn't request this, ignore this email.
# </p>

def password_reset(email, reset_token) do
reset_url = "#{MyAppWeb.Endpoint.url()}/reset-password?token=#{reset_token}"

html = Renderer.render("password_reset", %{reset_url: reset_url})

new()
|> to(email)
|> from(@from)
|> subject("Reset your password")
|> html_body(html)
|> Mailer.deliver()
end

def password_reset(email, reset_token) do
reset_url = "#{MyAppWeb.Endpoint.url()}/reset-password?token=#{reset_token}"

html = Renderer.render("password_reset", %{reset_url: reset_url})

new()
|> to(email)
|> from(@from)
|> subject("Reset your password")
|> html_body(html)
|> Mailer.deliver()
end

def payment_receipt(email, %{amount: amount, plan: plan, invoice_url: invoice_url}) do
formatted = :erlang.float_to_binary(amount / 100, decimals: 2)

html = Renderer.render("receipt", %{
  formatted: "$#{formatted}",
  plan: plan,
  invoice_url: invoice_url
})

send_email(email, "Payment receipt - $#{formatted}", html)
end

# priv/emails/templates/receipt.html.eex
# <h2 style="font-size:20px;">Payment Received</h2>
# <p style="font-size:16px;color:#374151;">Thanks for your payment.</p>
# <table style="width:100%;border-collapse:collapse;margin:16px 0;">
#   <tr>
#     <td style="padding:8px;border-bottom:1px solid #e5e7eb;">Plan</td>
#     <td style="padding:8px;border-bottom:1px solid #e5e7eb;text-align:right;">
#       <%= @plan %>
#     </td>
#   </tr>
#   <tr>
#     <td style="padding:8px;font-weight:600;">Total</td>
#     <td style="padding:8px;text-align:right;font-weight:600;"><%= @formatted %></td>
#   </tr>
# </table>
# <a href="<%= @invoice_url %>" style="color:#f97316;">View full invoice</a>

def payment_receipt(email, %{amount: amount, plan: plan, invoice_url: invoice_url}) do
formatted = :erlang.float_to_binary(amount / 100, decimals: 2)

html = Renderer.render("receipt", %{
  formatted: "$#{formatted}",
  plan: plan,
  invoice_url: invoice_url
})

new()
|> to(email)
|> from({"Your App", "billing@yourdomain.com"})
|> subject("Payment receipt - $#{formatted}")
|> html_body(html)
|> Mailer.deliver()
end

def payment_receipt(email, %{amount: amount, plan: plan, invoice_url: invoice_url}) do
formatted = :erlang.float_to_binary(amount / 100, decimals: 2)

html = Renderer.render("receipt", %{
  formatted: "$#{formatted}",
  plan: plan,
  invoice_url: invoice_url
})

new()
|> to(email)
|> from({"Your App", "billing@yourdomain.com"})
|> subject("Payment receipt - $#{formatted}")
|> html_body(html)
|> Mailer.deliver()
end

defmodule MyAppWeb.StripeWebhookController do
use MyAppWeb, :controller

alias MyApp.Emails

@webhook_secret Application.compile_env(:my_app, :stripe_webhook_secret)

def handle(conn, _params) do
  with {:ok, payload} <- read_raw_body(conn),
       {:ok, event} <- verify_signature(payload, conn) do
    process_event(event)
    json(conn, %{received: true})
  else
    {:error, reason} ->
      conn
      |> put_status(400)
      |> json(%{error: reason})
  end
end

defp read_raw_body(conn) do
  case Plug.Conn.read_body(conn) do
    {:ok, body, _conn} -> {:ok, body}
    _ -> {:error, "Failed to read body"}
  end
end

defp verify_signature(payload, conn) do
  signature = Plug.Conn.get_req_header(conn, "stripe-signature") |> List.first()

  # Extract timestamp and signature from header
  parts =
    signature
    |> String.split(",")
    |> Enum.map(&String.split(&1, "="))
    |> Enum.into(%{}, fn [k, v] -> {k, v} end)

  timestamp = parts["t"]
  expected = parts["v1"]

  signed_payload = "#{timestamp}.#{payload}"
  computed = :crypto.mac(:hmac, :sha256, @webhook_secret, signed_payload)
             |> Base.encode16(case: :lower)

  if Plug.Crypto.secure_compare(computed, expected) do
    {:ok, Jason.decode!(payload)}
  else
    {:error, "Invalid signature"}
  end
end

defp process_event(%{"type" => "checkout.session.completed", "data" => %{"object" => session}}) do
  email = session["customer_email"]

  Emails.send_email(
    email,
    "Payment confirmed",
    "<h1>Thanks for your purchase!</h1><p>Your subscription is now active.</p>"
  )
end

defp process_event(%{"type" => "invoice.payment_failed", "data" => %{"object" => invoice}}) do
  email = invoice["customer_email"]

  Emails.send_email(
    email,
    "Payment failed",
    "<h1>Payment issue</h1><p>We couldn't process your payment. Please update your card.</p>"
  )
end

defp process_event(_event), do: :ok
end

defmodule MyAppWeb.StripeWebhookController do
use MyAppWeb, :controller

import Swoosh.Email
alias MyApp.Mailer

@webhook_secret Application.compile_env(:my_app, :stripe_webhook_secret)
@from {"Your App", "noreply@yourdomain.com"}

def handle(conn, _params) do
  with {:ok, payload} <- read_raw_body(conn),
       {:ok, event} <- verify_signature(payload, conn) do
    process_event(event)
    json(conn, %{received: true})
  else
    {:error, reason} ->
      conn
      |> put_status(400)
      |> json(%{error: reason})
  end
end

defp read_raw_body(conn) do
  case Plug.Conn.read_body(conn) do
    {:ok, body, _conn} -> {:ok, body}
    _ -> {:error, "Failed to read body"}
  end
end

defp verify_signature(payload, conn) do
  signature = Plug.Conn.get_req_header(conn, "stripe-signature") |> List.first()

  parts =
    signature
    |> String.split(",")
    |> Enum.map(&String.split(&1, "="))
    |> Enum.into(%{}, fn [k, v] -> {k, v} end)

  timestamp = parts["t"]
  expected = parts["v1"]

  signed_payload = "#{timestamp}.#{payload}"
  computed = :crypto.mac(:hmac, :sha256, @webhook_secret, signed_payload)
             |> Base.encode16(case: :lower)

  if Plug.Crypto.secure_compare(computed, expected) do
    {:ok, Jason.decode!(payload)}
  else
    {:error, "Invalid signature"}
  end
end

defp process_event(%{"type" => "checkout.session.completed", "data" => %{"object" => session}}) do
  new()
  |> to(session["customer_email"])
  |> from(@from)
  |> subject("Payment confirmed")
  |> html_body("<h1>Thanks for your purchase!</h1><p>Your subscription is now active.</p>")
  |> Mailer.deliver()
end

defp process_event(%{"type" => "invoice.payment_failed", "data" => %{"object" => invoice}}) do
  new()
  |> to(invoice["customer_email"])
  |> from(@from)
  |> subject("Payment failed")
  |> html_body("<h1>Payment issue</h1><p>Please update your payment method.</p>")
  |> Mailer.deliver()
end

defp process_event(_event), do: :ok
end

defmodule MyAppWeb.StripeWebhookController do
use MyAppWeb, :controller

import Swoosh.Email
alias MyApp.Mailer

@webhook_secret Application.compile_env(:my_app, :stripe_webhook_secret)
@from {"Your App", "noreply@yourdomain.com"}

def handle(conn, _params) do
  with {:ok, payload} <- read_raw_body(conn),
       {:ok, event} <- verify_signature(payload, conn) do
    process_event(event)
    json(conn, %{received: true})
  else
    {:error, reason} ->
      conn
      |> put_status(400)
      |> json(%{error: reason})
  end
end

defp read_raw_body(conn) do
  case Plug.Conn.read_body(conn) do
    {:ok, body, _conn} -> {:ok, body}
    _ -> {:error, "Failed to read body"}
  end
end

defp verify_signature(payload, conn) do
  signature = Plug.Conn.get_req_header(conn, "stripe-signature") |> List.first()

  parts =
    signature
    |> String.split(",")
    |> Enum.map(&String.split(&1, "="))
    |> Enum.into(%{}, fn [k, v] -> {k, v} end)

  timestamp = parts["t"]
  expected = parts["v1"]

  signed_payload = "#{timestamp}.#{payload}"
  computed = :crypto.mac(:hmac, :sha256, @webhook_secret, signed_payload)
             |> Base.encode16(case: :lower)

  if Plug.Crypto.secure_compare(computed, expected) do
    {:ok, Jason.decode!(payload)}
  else
    {:error, "Invalid signature"}
  end
end

defp process_event(%{"type" => "checkout.session.completed", "data" => %{"object" => session}}) do
  new()
  |> to(session["customer_email"])
  |> from(@from)
  |> subject("Payment confirmed")
  |> html_body("<h1>Thanks for your purchase!</h1><p>Your subscription is now active.</p>")
  |> Mailer.deliver()
end

defp process_event(%{"type" => "invoice.payment_failed", "data" => %{"object" => invoice}}) do
  new()
  |> to(invoice["customer_email"])
  |> from(@from)
  |> subject("Payment failed")
  |> html_body("<h1>Payment issue</h1><p>Please update your payment method.</p>")
  |> Mailer.deliver()
end

defp process_event(_event), do: :ok
end

defmodule MyApp.Emails do
require Logger

alias MyApp.Emails.Renderer

@base_url "https://api.sequenzy.com/v1"

defmodule SendError do
  @moduledoc "Structured email send error."
  defexception [:message, :status, :retryable?]

  def new(status, body) do
    %__MODULE__{
      message: "Email send failed (#{status}): #{inspect(body)}",
      status: status,
      retryable?: status in [429, 500, 502, 503, 504]
    }
  end
end

def send_email(to, subject, body) do
  api_key = Application.fetch_env!(:my_app, :sequenzy_api_key)

  case Req.post("#{@base_url}/transactional/send",
         headers: [{"authorization", "Bearer #{api_key}"}],
         json: %{to: to, subject: subject, body: body}
       ) do
    {:ok, %Req.Response{status: 200, body: resp_body}} ->
      Logger.info("Email sent", to: to, subject: subject)
      {:ok, resp_body}

    {:ok, %Req.Response{status: 429, body: resp_body}} ->
      Logger.warning("Rate limited sending email", to: to)
      {:error, SendError.new(429, resp_body)}

    {:ok, %Req.Response{status: 401}} ->
      Logger.error("Invalid API key for email send")
      {:error, SendError.new(401, "Invalid API key")}

    {:ok, %Req.Response{status: status, body: resp_body}} ->
      Logger.error("Email send failed", to: to, status: status)
      {:error, SendError.new(status, resp_body)}

    {:error, %Req.TransportError{reason: reason}} ->
      Logger.error("Network error sending email", to: to, reason: inspect(reason))
      {:error, SendError.new(0, reason)}
  end
end

def send_email_with_retry(to, subject, body, max_retries \\ 3) do
  do_send_with_retry(to, subject, body, 0, max_retries)
end

defp do_send_with_retry(to, subject, body, attempt, max_retries) do
  case send_email(to, subject, body) do
    {:ok, result} ->
      {:ok, result}

    {:error, %SendError{retryable?: true}} when attempt < max_retries ->
      delay = :math.pow(2, attempt) |> round() |> :timer.seconds()
      Process.sleep(delay)
      do_send_with_retry(to, subject, body, attempt + 1, max_retries)

    {:error, error} ->
      {:error, error}
  end
end
end

defmodule MyApp.Emails do
require Logger

import Swoosh.Email

alias MyApp.Emails.Renderer
alias MyApp.Mailer

@from {"Your App", "noreply@yourdomain.com"}

def send_email(to, subject, html_body) do
  email =
    new()
    |> to(to)
    |> from(@from)
    |> subject(subject)
    |> html_body(html_body)

  case Mailer.deliver(email) do
    {:ok, metadata} ->
      Logger.info("Email sent", to: to, subject: subject)
      {:ok, metadata}

    {:error, {_code, %{"message" => message}}} ->
      Logger.error("Email send failed", to: to, error: message)
      {:error, message}

    {:error, reason} ->
      Logger.error("Email send failed", to: to, reason: inspect(reason))
      {:error, reason}
  end
end

def send_email_with_retry(to, subject, html_body, max_retries \\ 3) do
  do_send_with_retry(to, subject, html_body, 0, max_retries)
end

defp do_send_with_retry(to, subject, html_body, attempt, max_retries)
     when attempt < max_retries do
  case send_email(to, subject, html_body) do
    {:ok, result} ->
      {:ok, result}

    {:error, _reason} ->
      delay = :math.pow(2, attempt) |> round() |> :timer.seconds()
      Process.sleep(delay)
      do_send_with_retry(to, subject, html_body, attempt + 1, max_retries)
  end
end

defp do_send_with_retry(to, subject, html_body, _attempt, _max_retries) do
  send_email(to, subject, html_body)
end
end

defmodule MyApp.Emails do
require Logger

import Swoosh.Email

alias MyApp.Emails.Renderer
alias MyApp.Mailer

@from {"Your App", "noreply@yourdomain.com"}

def send_email(to, subject, html_body) do
  email =
    new()
    |> to(to)
    |> from(@from)
    |> subject(subject)
    |> html_body(html_body)

  case Mailer.deliver(email) do
    {:ok, metadata} ->
      Logger.info("Email sent", to: to, subject: subject)
      {:ok, metadata}

    {:error, {_code, %{"errors" => errors}}} ->
      message = errors |> Enum.map(& &1["message"]) |> Enum.join(", ")
      Logger.error("Email send failed", to: to, error: message)
      {:error, message}

    {:error, reason} ->
      Logger.error("Email send failed", to: to, reason: inspect(reason))
      {:error, reason}
  end
end

def send_email_with_retry(to, subject, html_body, max_retries \\ 3) do
  do_send_with_retry(to, subject, html_body, 0, max_retries)
end

defp do_send_with_retry(to, subject, html_body, attempt, max_retries)
     when attempt < max_retries do
  case send_email(to, subject, html_body) do
    {:ok, result} ->
      {:ok, result}

    {:error, _reason} ->
      delay = :math.pow(2, attempt) |> round() |> :timer.seconds()
      Process.sleep(delay)
      do_send_with_retry(to, subject, html_body, attempt + 1, max_retries)
  end
end

defp do_send_with_retry(to, subject, html_body, _attempt, _max_retries) do
  send_email(to, subject, html_body)
end
end

defmodule MyApp.Workers.EmailWorker do
use Oban.Worker,
  queue: :emails,
  max_attempts: 5,
  priority: 1

alias MyApp.Emails

@impl Oban.Worker
def perform(%Oban.Job{args: %{"type" => "welcome", "email" => email, "name" => name}}) do
  case Emails.welcome(email, name) do
    {:ok, _} -> :ok
    {:error, %Emails.SendError{retryable?: true} = error} -> {:error, error.message}
    {:error, %Emails.SendError{retryable?: false}} -> :discard
    {:error, reason} -> {:error, inspect(reason)}
  end
end

def perform(%Oban.Job{args: %{"type" => "password_reset", "email" => email, "token" => token}}) do
  case Emails.password_reset(email, token) do
    {:ok, _} -> :ok
    {:error, _} = error -> error
  end
end

def perform(%Oban.Job{args: %{"type" => "receipt"} = args}) do
  case Emails.payment_receipt(args["email"], %{
         amount: args["amount"],
         plan: args["plan"],
         invoice_url: args["invoice_url"]
       }) do
    {:ok, _} -> :ok
    {:error, _} = error -> error
  end
end

# Custom backoff: 1s, 10s, 60s, 5m, 30m
@impl Oban.Worker
def backoff(%Oban.Job{attempt: attempt}) do
  [1, 10, 60, 300, 1800]
  |> Enum.at(attempt - 1, 1800)
end
end

# Queue an email from anywhere:
%{type: "welcome", email: "user@example.com", name: "Jane"}
|> MyApp.Workers.EmailWorker.new()
|> Oban.insert()

defmodule MyApp.Workers.EmailWorker do
use Oban.Worker,
  queue: :emails,
  max_attempts: 5,
  priority: 1

alias MyApp.Emails

@impl Oban.Worker
def perform(%Oban.Job{args: %{"type" => "welcome", "email" => email, "name" => name}}) do
  case Emails.welcome(email, name) do
    {:ok, _} -> :ok
    {:error, reason} -> {:error, inspect(reason)}
  end
end

def perform(%Oban.Job{args: %{"type" => "password_reset", "email" => email, "token" => token}}) do
  case Emails.password_reset(email, token) do
    {:ok, _} -> :ok
    {:error, reason} -> {:error, inspect(reason)}
  end
end

def perform(%Oban.Job{args: %{"type" => "receipt"} = args}) do
  case Emails.payment_receipt(args["email"], %{
         amount: args["amount"],
         plan: args["plan"],
         invoice_url: args["invoice_url"]
       }) do
    {:ok, _} -> :ok
    {:error, reason} -> {:error, inspect(reason)}
  end
end

@impl Oban.Worker
def backoff(%Oban.Job{attempt: attempt}) do
  [1, 10, 60, 300, 1800]
  |> Enum.at(attempt - 1, 1800)
end
end

# Queue from anywhere:
%{type: "welcome", email: "user@example.com", name: "Jane"}
|> MyApp.Workers.EmailWorker.new()
|> Oban.insert()

defmodule MyApp.Workers.EmailWorker do
use Oban.Worker,
  queue: :emails,
  max_attempts: 5,
  priority: 1

alias MyApp.Emails

@impl Oban.Worker
def perform(%Oban.Job{args: %{"type" => "welcome", "email" => email, "name" => name}}) do
  case Emails.welcome(email, name) do
    {:ok, _} -> :ok
    {:error, reason} -> {:error, inspect(reason)}
  end
end

def perform(%Oban.Job{args: %{"type" => "password_reset", "email" => email, "token" => token}}) do
  case Emails.password_reset(email, token) do
    {:ok, _} -> :ok
    {:error, reason} -> {:error, inspect(reason)}
  end
end

def perform(%Oban.Job{args: %{"type" => "receipt"} = args}) do
  case Emails.payment_receipt(args["email"], %{
         amount: args["amount"],
         plan: args["plan"],
         invoice_url: args["invoice_url"]
       }) do
    {:ok, _} -> :ok
    {:error, reason} -> {:error, inspect(reason)}
  end
end

@impl Oban.Worker
def backoff(%Oban.Job{attempt: attempt}) do
  [1, 10, 60, 300, 1800]
  |> Enum.at(attempt - 1, 1800)
end
end

# Queue from anywhere:
%{type: "welcome", email: "user@example.com", name: "Jane"}
|> MyApp.Workers.EmailWorker.new()
|> Oban.insert()