Emails (SMTP + Reacher)

export function checkInEmail(params: {
  guestName: string;
  hotelName: string;
  roomNumber?: string;
  checkInDate: string;
  checkOutDate: string;
  checkInUrl: string;
}): { subject: string; html: string; text: string } {
  return {
    subject: `Bell — votre check-in à ${params.hotelName}`,
    html: renderCheckInHtml(params),
    text: renderCheckInText(params),
  };
}

export class EmailValidator {
  constructor(private baseUrl: string, private enabled: boolean) {}

  async verify(email: string): Promise<EmailCheckResult> {
    if (!this.enabled) return { reachable: "unknown" };

    try {
      const res = await fetch(`${this.baseUrl}/v0/check_email`, {
        method: "POST",
        headers: { "Content-Type": "application/json" },
        body: JSON.stringify({
          to_email: email,
          from_email: "noreply@hoaiy.com",
        }),
        signal: AbortSignal.timeout(8_000),        // Reacher lent parfois
      });
      if (!res.ok) return { reachable: "unknown" };
      const data = await res.json();
      return {
        reachable: data.is_reachable,              // "safe" | "risky" | "invalid" | "unknown"
        reason: data.mx?.records ?? data.smtp?.error_message,
      };
    } catch (err) {
      logger.warn({ err, email: hashEmail(email) }, "Reacher verify failed, defaulting to unknown");
      return { reachable: "unknown" };
    }
  }
}

import nodemailer from "nodemailer";

const transporter = nodemailer.createTransport({
  host: process.env.SMTP_HOST,
  port: Number(process.env.SMTP_PORT),
  secure: Number(process.env.SMTP_PORT) === 465,
  auth: {
    user: process.env.SMTP_USER,
    pass: process.env.SMTP_PASS,
  },
});

export async function sendMail(params: {
  to: string;
  subject: string;
  html: string;
  text: string;
  replyTo?: string;
}) {
  return transporter.sendMail({
    from: process.env.SMTP_FROM,
    replyTo: params.replyTo ?? "ops@hoaiy.com",
    to: params.to,
    subject: params.subject,
    html: params.html,
    text: params.text,
  });
}

import { Worker } from "bullmq";
import { sendMail } from "@bell/auth/mail";
import { emailValidator } from "@bell/api/services";
import { renderTemplate } from "@bell/auth/mail/templates";
import { logger, hashEmail } from "@bell/observability";

export const emailWorker = new Worker(
  "email",
  async (job) => {
    const { template, to, data, skipValidation } = job.data;

    if (!skipValidation) {
      const check = await emailValidator.verify(to);
      if (check.reachable === "invalid") {
        // Not retryable
        throw new NonRetriableEmailError(`invalid email: ${check.reason}`);
      }
      if (check.reachable === "risky" || check.reachable === "unknown") {
        logger.warn({ emailHash: hashEmail(to), verdict: check.reachable }, "Sending with risky verdict");
      }
    }

    const { subject, html, text } = renderTemplate(template, data);
    await sendMail({ to, subject, html, text });

    logger.info({ emailHash: hashEmail(to), template }, "Email sent");
    return { ok: true };
  },
  {
    connection: redis,
    concurrency: Number(process.env.WORKER_CONCURRENCY_EMAIL ?? 20),
  },
);

mailhog:
  image: mailhog/mailhog:latest
  profiles: [email-dev]
  ports:
    - "1025:1025"           # SMTP
    - "8025:8025"           # Web UI