Configurer le serveur d'envoi de courrier

Sans serveur SMTP, PlanFlow ne peut ni inviter un salarié, ni notifier une
publication de planning, ni délivrer l'information due au retour d'un arrêt.
L'application n'expédie rien par elle-même : elle se connecte au serveur du
client, pour que les messages partent de son domaine et que les salariés
reconnaissent l'expéditeur.

Le mot de passe SMTP est traité comme le NIR et l'IBAN — chiffré au repos avec
la même clé, jamais renvoyé à l'écran (la page ne le charge même pas chiffré),
jamais recopié dans un message d'erreur ni dans le journal d'audit. Les erreurs
SMTP passent par une passe de masquage : les serveurs renvoient volontiers la
commande AUTH en clair. Laisser le champ vide conserve le mot de passe
enregistré, sans quoi changer un numéro de port casserait l'envoi.

Enregistrer et éprouver sont deux gestes distincts : toute modification remet
le réglage en « non vérifié », car un réglage non éprouvé n'est pas un réglage,
c'est une intention. L'envoi de test vérifie d'abord la connexion — ce qui
sépare une adresse de serveur fautive d'un mot de passe faux — puis expédie
réellement.

Les messages sont rendus en texte et en HTML depuis le même contenu, sans
image, script ni ressource distante : la charte de télémétrie vaut aussi pour
le courrier, un pixel de suivi dans un message RH est une collecte que personne
n'a acceptée. Le journal d'envoi retient le destinataire et l'issue, pas le
corps du message.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Cr9dkEHwbDgkWPnyGj1Rjv

src/server/email/mailer.ts

@@ -0,0 +1,173 @@
+import 'server-only';
+
+import nodemailer from 'nodemailer';
+
+import {
+  formatSender,
+  redactSmtpError,
+  type Message,
+  type Sender,
+} from '@/domain/email/message';
+import { decryptOptional } from '@/server/crypto';
+import type { ScopedClient } from '@/server/tenant';
+
+/**
+ * Envoi de courrier — configuration par compte.
+ *
+ * Les réglages vivent en base, pas dans l'environnement : chaque client
+ * auto-hébergé a sa propre boîte, et en changer ne doit exiger ni accès au
+ * serveur ni redémarrage.
+ *
+ * Le mot de passe est chiffré au repos et **n'est déchiffré qu'ici**, au moment
+ * d'ouvrir la connexion. Il ne remonte jamais vers un écran, jamais vers un
+ * journal, jamais vers un message d'erreur.
+ */
+
+export interface SmtpConfig {
+  host: string;
+  port: number;
+  secure: boolean;
+  username: string | null;
+  password: string | null;
+  sender: Sender;
+}
+
+export type EmailKind =
+  | 'TEST'
+  | 'INVITATION'
+  | 'PASSWORD_RESET'
+  | 'PLANNING_PUBLISHED'
+  | 'TIMEOFF_DECISION'
+  | 'LEAVE_NOTICE';
+
+export interface SendResult {
+  ok: boolean;
+  messageId?: string;
+  error?: string;
+}
+
+/** Charge la configuration du compte, mot de passe déchiffré. */
+export async function loadSmtpConfig(
+  db: ScopedClient,
+): Promise<SmtpConfig | null> {
+  const settings = await db.emailSettings.findFirst();
+  if (!settings) return null;
+
+  return {
+    host: settings.host,
+    port: settings.port,
+    secure: settings.secure,
+    username: settings.username,
+    password: decryptOptional(settings.passwordEnc),
+    sender: {
+      name: settings.fromName,
+      address: settings.fromAddress,
+      replyTo: settings.replyTo,
+    },
+  };
+}
+
+/**
+ * Envoie un message et journalise le résultat.
+ *
+ * Le corps n'est **pas** conservé : il porte des données personnelles et se
+ * régénère. Ce qui compte, quand un salarié dit n'avoir rien reçu, c'est de
+ * savoir si le serveur a accepté le message et à quelle adresse.
+ */
+export async function sendEmail(
+  db: ScopedClient,
+  message: Message,
+  kind: EmailKind,
+  membershipId?: string | null,
+): Promise<SendResult> {
+  const config = await loadSmtpConfig(db);
+
+  if (!config) {
+    const error =
+      'Aucun serveur d’envoi configuré. Réglages · Envoi de courrier.';
+    await logEmail(db, message, kind, 'FAILED', { error, membershipId });
+    return { ok: false, error };
+  }
+
+  try {
+    const result = await transportFor(config).sendMail({
+      from: formatSender(config.sender),
+      ...(config.sender.replyTo ? { replyTo: config.sender.replyTo } : {}),
+      to: message.to,
+      subject: message.subject,
+      text: message.text,
+      html: message.html,
+    });
+
+    await logEmail(db, message, kind, 'SENT', {
+      messageId: result.messageId,
+      membershipId,
+    });
+    return { ok: true, messageId: result.messageId };
+  } catch (error) {
+    const redacted = redactSmtpError(error, config.username);
+    await logEmail(db, message, kind, 'FAILED', {
+      error: redacted,
+      membershipId,
+    });
+    return { ok: false, error: redacted };
+  }
+}
+
+/**
+ * Vérifie la configuration sans envoyer.
+ *
+ * `verify` ouvre la connexion et authentifie : c'est ce qui distingue une
+ * adresse de serveur fautive d'un mot de passe faux, alors qu'un envoi raté ne
+ * dit que « ça n'a pas marché ».
+ */
+export async function verifySmtp(config: SmtpConfig): Promise<SendResult> {
+  try {
+    await transportFor(config).verify();
+    return { ok: true };
+  } catch (error) {
+    return { ok: false, error: redactSmtpError(error, config.username) };
+  }
+}
+
+function transportFor(config: SmtpConfig) {
+  return nodemailer.createTransport({
+    host: config.host,
+    port: config.port,
+    // 465 chiffre dès la connexion ; 587 négocie STARTTLS. Se tromper produit
+    // une erreur illisible côté serveur.
+    secure: config.secure,
+    ...(config.username && config.password
+      ? { auth: { user: config.username, pass: config.password } }
+      : {}),
+    // Ne jamais accepter un certificat invalide : un envoi RH transporte des
+    // noms et des adresses.
+    tls: { rejectUnauthorized: true },
+    connectionTimeout: 10_000,
+    greetingTimeout: 10_000,
+  });
+}
+
+async function logEmail(
+  db: ScopedClient,
+  message: Message,
+  kind: EmailKind,
+  status: 'SENT' | 'FAILED',
+  extra: {
+    error?: string;
+    messageId?: string;
+    membershipId?: string | null | undefined;
+  },
+): Promise<void> {
+  await db.emailLog.create({
+    data: {
+      to: message.to,
+      subject: message.subject,
+      kind,
+      status,
+      error: extra.error ?? null,
+      messageId: extra.messageId ?? null,
+      membershipId: extra.membershipId ?? null,
+    } as never,
+  });
+}