Relay transactional email through Salesforce instead of SMTP (#9)

Reviewed-on: #9
Co-authored-by: Patrick Müller <patrick@mueller-patrick.tech>
Co-committed-by: Patrick Müller <patrick@mueller-patrick.tech>

package.json

@@ -22,7 +22,6 @@
 		"express": "^4.18.2",
 		"guid-typescript": "^1.0.9",
 		"mariadb": "^3.0.2",
-		"nodemailer": "^6.9.8",
 		"random-words": "^1.1.1",
 		"swagger-jsdoc": "^6.1.0",
 		"swagger-ui-express": "^4.3.0",
@@ -35,7 +34,6 @@
 		"@types/express": "^4.17.15",
 		"@types/jest": "^28.1.3",
 		"@types/node": "^18.11.17",
-		"@types/nodemailer": "^6.4.14",
 		"@types/random-words": "^1.1.2",
 		"@types/swagger-jsdoc": "^6.0.1",
 		"@types/swagger-ui-express": "^4.1.3",

sql/tickets/003_add_confirmation_email_status.sql

@@ -0,0 +1,7 @@
+-- Nachklang e.V. Tickets module — records the outcome of the redemption
+-- confirmation email on the redemption itself, so the admin UI can flag a
+-- failed send and offer a resend. NULL until the post-commit send resolves.
+-- Apply manually against TICKETS_DB, after 002_add_require_address.sql:
+--   mysql -h <DB_HOST> -u <DB_USER> -p <TICKETS_DB> < 003_add_confirmation_email_status.sql
+ALTER TABLE redemptions
+    ADD COLUMN confirmation_email_status ENUM('SENT','FAILED') NULL DEFAULT NULL AFTER redeemed_at;

src/common/common.mail.nodemailer.ts

@@ -1,42 +0,0 @@
-import * as nodemailer from 'nodemailer';
-
-export namespace MailService {
-    const transporter = nodemailer.createTransport({
-        host: process.env.EMAIL_HOST,
-        pool: true,
-        port: 465,
-        secure: true,
-        auth: {
-            user: process.env.EMAIL_USERNAME,
-            pass: process.env.EMAIL_PASSWORD
-        },
-        tls: {rejectUnauthorized: false}
-    });
-
-    export interface MailAttachment {
-        filename: string;
-        content: string | Buffer;
-        contentType?: string;
-    }
-
-    export interface SendMailOptions {
-        html?: string;
-        attachments?: MailAttachment[];
-    }
-
-    // Builds a fresh options object per call rather than mutating a shared
-    // module-level one - the transporter is pooled, so overlapping sendMail
-    // calls (e.g. two guests redeeming at once) previously risked one
-    // call's recipient/subject/body being overwritten by another's before
-    // transporter.sendMail() read it.
-    export const sendMail = async (recipientAddress: string, subject: string, body: string, options?: SendMailOptions) => {
-        await transporter.sendMail({
-            from: 'noreply@nachklang.art',
-            to: recipientAddress,
-            subject: subject,
-            text: body,
-            html: options?.html,
-            attachments: options?.attachments
-        });
-    };
-}

src/common/common.mail.ts

@@ -0,0 +1,107 @@
+import logger from '../middleware/logger';
+import {salesforceApexRestPost, salesforceEnabled} from './salesforce.client';
+
+// Transactional email for the ticketing/calendar flows (voucher redemption
+// confirmations, account activation links, password-reset tokens) is relayed
+// through the Nachklang Salesforce org rather than sent over our own SMTP host:
+// that host's IP reputation gets it blocked by allowlist-based receivers
+// (notably t-online.de). Salesforce's MTA plus the org's DKIM signature for
+// nachklang.art get the mail delivered. The org endpoint is EmailSendResource
+// (POST /services/apexrest/email/send); the From address is fixed server-side
+// there and is never sent from here.
+//
+// sendMail never throws on a delivery problem. Every caller has already
+// committed its own work (a registration, a password-reset token, a
+// redemption) by the time mail goes out, so a mail failure must not surface as
+// a user-facing error. It returns whether the mail was accepted so the one
+// caller that shows failures to staff (the voucher confirmation) can record it.
+
+export namespace MailService {
+	export interface MailAttachment {
+		filename: string;
+		content: string | Buffer;
+		contentType?: string;
+	}
+
+	export interface SendMailOptions {
+		html?: string;
+		attachments?: MailAttachment[];
+	}
+
+	interface EmailSendResponse {
+		status: 'SENT';
+	}
+
+	// Practical ceiling, well under Apex REST's 6 MB request-body limit once
+	// base64 inflation (~33%) is accounted for. The only attachment today is a
+	// ~1 KB .ics file.
+	const MAX_ATTACHMENT_BYTES = 3 * 1024 * 1024;
+
+	const isRetriable = (err: any): boolean => {
+		const status = err?.response?.status;
+		if (status !== undefined) {
+			return status >= 500;
+		}
+		// No response at all - network error or timeout.
+		return true;
+	};
+
+	/**
+	 * Relays one email through the Salesforce org. Retries once on a transient
+	 * failure (5xx / network / timeout), then logs and returns false rather
+	 * than throwing. Returns false immediately (without a callout) when the
+	 * Salesforce integration is disabled.
+	 */
+	export const sendMail = async (
+		recipientAddress: string,
+		subject: string,
+		body: string,
+		options?: SendMailOptions
+	): Promise<boolean> => {
+		if (!salesforceEnabled()) {
+			logger.info('MailService: SALESFORCE_ENABLED is false, would have sent', {recipientAddress, subject});
+			return false;
+		}
+
+		let attachments: {filename: string; contentType?: string; contentBase64: string}[];
+		try {
+			attachments = (options?.attachments ?? []).map(attachment => {
+				const buffer = Buffer.isBuffer(attachment.content)
+					? attachment.content
+					: Buffer.from(attachment.content, 'utf-8');
+				if (buffer.byteLength > MAX_ATTACHMENT_BYTES) {
+					throw new Error(`attachment ${attachment.filename} is ${buffer.byteLength} bytes, over the ${MAX_ATTACHMENT_BYTES} limit`);
+				}
+				return {filename: attachment.filename, contentType: attachment.contentType, contentBase64: buffer.toString('base64')};
+			});
+		} catch (err: any) {
+			logger.error('MailService: could not prepare attachments', {recipientAddress, subject, detail: err?.message});
+			return false;
+		}
+
+		const payload = {
+			to: recipientAddress,
+			subject,
+			textBody: body,
+			htmlBody: options?.html ?? null,
+			attachments
+		};
+
+		for (let attempt = 1; attempt <= 2; attempt++) {
+			try {
+				await salesforceApexRestPost<EmailSendResponse>('/services/apexrest/email/send', payload);
+				return true;
+			} catch (err: any) {
+				const status = err?.response?.status;
+				const detail = err?.response?.data?.errorCode || err?.response?.data?.message || err?.message || 'unknown error';
+				if (attempt === 1 && isRetriable(err)) {
+					logger.warn('MailService: send failed, retrying once', {recipientAddress, subject, status, detail});
+					continue;
+				}
+				logger.error('MailService: send failed', {recipientAddress, subject, status, detail});
+				return false;
+			}
+		}
+		return false;
+	};
+}

src/common/salesforce.client.ts

@@ -0,0 +1,66 @@
+import axios from 'axios';
+
+// Shared server-to-server access to the one Nachklang Salesforce org. Both the
+// newsletter-signup sync (feedback module) and the transactional-email relay
+// (common.mail) authenticate the same way - OAuth 2.0 client credentials
+// against the nk_Nachklang_API_Integration external client app - so the token
+// cache and the retry-once-on-401 live here rather than being duplicated.
+//
+// Salesforce's client-credentials token response does not reliably include
+// expires_in, so the cache lifetime is a conservative guess rather than a
+// value read from the response - a 401 on the next call just triggers a fresh
+// fetch (see salesforceApexRestPost).
+
+const TOKEN_CACHE_MS = 15 * 60 * 1000;
+let cachedToken: {accessToken: string; fetchedAt: number} | null = null;
+
+export const salesforceEnabled = (): boolean => process.env.SALESFORCE_ENABLED === 'true';
+
+const readConfig = (): {instanceUrl: string; clientId: string; clientSecret: string} => {
+	const instanceUrl = process.env.SALESFORCE_API_URL;
+	const clientId = process.env.SALESFORCE_CLIENT_ID;
+	const clientSecret = process.env.SALESFORCE_CLIENT_SECRET;
+	if (!instanceUrl || !clientId || !clientSecret) {
+		throw new Error('SALESFORCE_ENABLED is true but SALESFORCE_API_URL/SALESFORCE_CLIENT_ID/SALESFORCE_CLIENT_SECRET are not fully configured.');
+	}
+	return {instanceUrl, clientId, clientSecret};
+};
+
+const getAccessToken = async (forceRefresh: boolean): Promise<string> => {
+	if (!forceRefresh && cachedToken && Date.now() - cachedToken.fetchedAt < TOKEN_CACHE_MS) {
+		return cachedToken.accessToken;
+	}
+
+	const {instanceUrl, clientId, clientSecret} = readConfig();
+	const res = await axios.post(
+		`${instanceUrl}/services/oauth2/token`,
+		new URLSearchParams({grant_type: 'client_credentials', client_id: clientId, client_secret: clientSecret}).toString(),
+		{headers: {'Content-Type': 'application/x-www-form-urlencoded'}, timeout: 10000}
+	);
+	cachedToken = {accessToken: res.data.access_token, fetchedAt: Date.now()};
+	return cachedToken.accessToken;
+};
+
+/**
+ * POSTs a JSON body to an Apex REST path (e.g. '/services/apexrest/newsletter/signup')
+ * and returns the parsed response body. Retries once with a forced token
+ * refresh on a 401 - the server-side token may have expired even though our
+ * conservative local TTL has not. All other errors propagate to the caller.
+ */
+export const salesforceApexRestPost = async <T>(path: string, body: unknown): Promise<T> => {
+	const {instanceUrl} = readConfig();
+	const url = `${instanceUrl}${path}`;
+
+	try {
+		const token = await getAccessToken(false);
+		const res = await axios.post<T>(url, body, {headers: {Authorization: `Bearer ${token}`}, timeout: 10000});
+		return res.data;
+	} catch (err: any) {
+		if (err?.response?.status === 401) {
+			const token = await getAccessToken(true);
+			const res = await axios.post<T>(url, body, {headers: {Authorization: `Bearer ${token}`}, timeout: 10000});
+			return res.data;
+		}
+		throw err;
+	}
+};

src/models/calendar/users/users.service.ts

@@ -4,7 +4,7 @@ import {Guid} from 'guid-typescript';
 import {User} from './user.interface';
 import {Session} from './session.interface';
 import {NachklangCalendarDB} from '../Calendar.db';
-import {MailService} from "../../../common/common.mail.nodemailer";
+import {MailService} from "../../../common/common.mail";
 
 dotenv.config();
 
@@ -54,7 +54,10 @@ export const createUser = async (email: string, password: string, fullName: stri
 			sessionId = row.session_id;
 		}
 
-		// Send email with activation link (after commit so we don't block on email delivery)
+		// Send email with activation link (after commit so we don't block on email
+		// delivery). sendMail never throws on a delivery failure - it logs and
+		// returns false - so a mail-server problem here can't roll back the
+		// already-committed user and leave registration reporting a false error.
 		await MailService.sendMail(email, 'Activate your Nachklang account', `Hi ${fullName},\n\nPlease click on the following link to activate your account:\n\nhttps://api.nachklang.art/calendar/users/activate?id=${userId}&token=${activationToken}`);
 
 		return {

src/models/feedback/integrations/salesforce.service.ts

@@ -1,6 +1,6 @@
-import axios from 'axios';
 import {NachklangFeedbackDB} from '../Feedback.db';
 import logger from '../../../middleware/logger';
+import {salesforceApexRestPost} from '../../../common/salesforce.client';
 
 // Newsletter opt-ins sync to Salesforce, which already runs a full
 // double-opt-in subscription flow (Person Account for existing constituents,
@@ -9,7 +9,8 @@ import logger from '../../../middleware/logger';
 // This is the one file that knows that contract exists; submissions.service.ts
 // only ever calls syncNewsletterSignup(signupId) after its own transaction
 // commits, fire-and-forget, so a Salesforce outage can never delay or fail a
-// visitor's feedback submission.
+// visitor's feedback submission. The OAuth token cache and retry-once-on-401
+// live in common/salesforce.client.ts, shared with the transactional-email relay.
 
 interface SalesforceSuccessResponse {
 	status: 'PENDING_CONFIRMATION' | 'ALREADY_SUBSCRIBED';
@@ -26,54 +27,8 @@ interface NewsletterSignupRow {
 	event_name: string;
 }
 
-// Salesforce's client-credentials token response does not reliably include
+const postSignup = (payload: {firstName: string; lastName: string; email: string; eventName: string}): Promise<SalesforceSuccessResponse> =>
-// expires_in, so the cache lifetime is a conservative guess rather than a
+	salesforceApexRestPost<SalesforceSuccessResponse>('/services/apexrest/newsletter/signup', payload);
-// value read from the response - a 401 on the next call just triggers a
-// fresh fetch (see the retry-once logic in postSignup).
-const TOKEN_CACHE_MS = 15 * 60 * 1000;
-let cachedToken: {accessToken: string; fetchedAt: number} | null = null;
-
-const getAccessToken = async (forceRefresh: boolean): Promise<string> => {
-	if (!forceRefresh && cachedToken && Date.now() - cachedToken.fetchedAt < TOKEN_CACHE_MS) {
-		return cachedToken.accessToken;
-	}
-
-	const instanceUrl = process.env.SALESFORCE_API_URL;
-	const clientId = process.env.SALESFORCE_CLIENT_ID;
-	const clientSecret = process.env.SALESFORCE_CLIENT_SECRET;
-	if (!instanceUrl || !clientId || !clientSecret) {
-		throw new Error('SALESFORCE_ENABLED is true but SALESFORCE_API_URL/SALESFORCE_CLIENT_ID/SALESFORCE_CLIENT_SECRET are not fully configured.');
-	}
-
-	const res = await axios.post(
-		`${instanceUrl}/services/oauth2/token`,
-		new URLSearchParams({grant_type: 'client_credentials', client_id: clientId, client_secret: clientSecret}).toString(),
-		{headers: {'Content-Type': 'application/x-www-form-urlencoded'}, timeout: 10000}
-	);
-	cachedToken = {accessToken: res.data.access_token, fetchedAt: Date.now()};
-	return cachedToken.accessToken;
-};
-
-const postSignup = async (payload: {firstName: string; lastName: string; email: string; eventName: string}): Promise<SalesforceSuccessResponse> => {
-	const instanceUrl = process.env.SALESFORCE_API_URL;
-	const url = `${instanceUrl}/services/apexrest/newsletter/signup`;
-
-	try {
-		const token = await getAccessToken(false);
-		const res = await axios.post<SalesforceSuccessResponse>(url, payload, {headers: {Authorization: `Bearer ${token}`}, timeout: 10000});
-		return res.data;
-	} catch (err: any) {
-		// The cached token may have expired server-side even though our
-		// conservative local TTL hasn't - retry once with a forced refresh
-		// before treating this as a real failure.
-		if (err?.response?.status === 401) {
-			const token = await getAccessToken(true);
-			const res = await axios.post<SalesforceSuccessResponse>(url, payload, {headers: {Authorization: `Bearer ${token}`}, timeout: 10000});
-			return res.data;
-		}
-		throw err;
-	}
-};
 
 const markSynced = async (signupId: number, externalId: string): Promise<void> => {
 	let conn = await NachklangFeedbackDB.getConnection();

src/models/tickets/admin/redemptions.admin.router.ts

@@ -204,6 +204,55 @@ redemptionsAdminRouter.post('/:redemptionId/undo', async (req: Request, res: Res
 	}
 });
 
+/**
+ * @swagger
+ * /tickets/admin/redemptions/{redemptionId}/resend-confirmation:
+ *      post:
+ *          summary: Resend the redemption confirmation email
+ *          description: Rebuilds the confirmation email from the stored redemption data and sends it again, then records the outcome on the redemption. Intended for redemptions whose original confirmation email failed.
+ *          tags: [tickets-admin]
+ *          parameters:
+ *              - $ref: '#/components/parameters/SessionIdHeader'
+ *              - $ref: '#/components/parameters/SessionKeyHeader'
+ *              - in: path
+ *                name: redemptionId
+ *                required: true
+ *                schema:
+ *                    type: integer
+ *          responses:
+ *              200:
+ *                  description: The email was accepted for delivery
+ *              404:
+ *                  description: Unknown redemption
+ *              409:
+ *                  description: Redemption is not active
+ *              502:
+ *                  description: The email relay rejected the send
+ *              401:
+ *                  description: Unauthorized
+ */
+redemptionsAdminRouter.post('/:redemptionId/resend-confirmation', async (req: Request, res: Response) => {
+	try {
+		const result = await RedemptionsAdminService.resendRedemptionConfirmation(Number(req.params.redemptionId));
+		switch (result) {
+			case 'SENT':
+				res.status(200).send({status: 'OK'});
+				return;
+			case 'NOT_FOUND':
+				res.status(404).send({status: 'NOT_FOUND'});
+				return;
+			case 'NOT_ACTIVE':
+				res.status(409).send({status: 'NOT_ACTIVE', message: 'This redemption is not active.'});
+				return;
+			case 'FAILED':
+				res.status(502).send({status: 'SEND_FAILED', message: 'Die E-Mail konnte nicht versendet werden. Bitte später erneut versuchen.'});
+				return;
+		}
+	} catch (e: any) {
+		sendServerError(res, e);
+	}
+});
+
 /**
  * @swagger
  * /tickets/admin/vouchers/{code}/history:

src/models/tickets/admin/redemptions.admin.service.ts

@@ -1,5 +1,6 @@
 import {NachklangTicketsDB} from '../Tickets.db';
 import {getEventTicketState} from '../tickets.capacity';
+import {recordConfirmationEmailResult, sendRedemptionConfirmation} from '../tickets.confirmation-email';
 import {AuditLogEntry, RedemptionSummary} from '../tickets.interface';
 import {isValidEmail} from '../tickets.validation';
 
@@ -13,7 +14,8 @@ const mapRedemptionRow = (row: any, guests: string[]): RedemptionSummary => ({
 	contactAddress: row.contact_address,
 	guestCount: row.guest_count,
 	guests,
-	redeemedAt: row.redeemed_at
+	redeemedAt: row.redeemed_at,
+	confirmationEmailStatus: row.confirmation_email_status ?? null
 });
 
 export interface ListRedemptionsFilter {
@@ -227,6 +229,29 @@ export const editRedemption = async (redemptionId: number, input: EditRedemption
 	}
 };
 
+export type ResendConfirmationResult = 'SENT' | 'FAILED' | 'NOT_FOUND' | 'NOT_ACTIVE';
+
+/**
+ * Rebuilds and re-sends the redemption confirmation email from the stored
+ * redemption data, then records the new outcome on the row. Used by the admin
+ * UI's "resend" action on a redemption whose confirmation email failed. Only
+ * active redemptions can be resent.
+ */
+export const resendRedemptionConfirmation = async (redemptionId: number): Promise<ResendConfirmationResult> => {
+	const redemption = await getRedemption(redemptionId);
+	if (!redemption) return 'NOT_FOUND';
+	if (redemption.status !== 'ACTIVE') return 'NOT_ACTIVE';
+
+	const sent = await sendRedemptionConfirmation({
+		eventId: redemption.eventId,
+		contactName: redemption.contactName,
+		contactEmail: redemption.contactEmail,
+		guestNames: redemption.guests
+	});
+	await recordConfirmationEmailResult(redemptionId, sent);
+	return sent ? 'SENT' : 'FAILED';
+};
+
 export const getAuditHistory = async (code: string): Promise<AuditLogEntry[]> => {
 	let conn = await NachklangTicketsDB.getConnection();
 	try {

src/models/tickets/public/voucher.public.service.ts

@@ -1,20 +1,11 @@
 import * as EventsService from '../../calendar/events/events.service';
-import * as IcalService from '../../calendar/events/icalgenerator.service';
-import {MailService} from '../../../common/common.mail.nodemailer';
 import logger from '../../../middleware/logger';
 import {NachklangTicketsDB} from '../Tickets.db';
 import {getEventTicketState} from '../tickets.capacity';
+import {recordConfirmationEmailResult, sendRedemptionConfirmation} from '../tickets.confirmation-email';
 import {EligibleEvent, RedeemRequest, VoucherValidation} from '../tickets.interface';
 import {isValidEmail} from '../tickets.validation';
 
-const formatGermanDateTime = (date: Date): string => {
-	return new Intl.DateTimeFormat('de-DE', {
-		dateStyle: 'full',
-		timeStyle: 'short',
-		timeZone: 'Europe/Berlin'
-	}).format(date);
-};
-
 /**
  * Builds the eligible-events list for a code: for each event it's linked
  * to, merges live Calendar event details with the Tickets module's own
@@ -173,43 +164,21 @@ export const redeemVoucher = async (code: string, request: RedeemRequest): Promi
 	}
 
 	// Sent after commit, mirroring the Calendar/Feedback convention: a mail
-	// delivery failure shouldn't roll back a successful redemption. Caught
+	// delivery failure shouldn't roll back a successful redemption, and the
-	// rather than left to propagate - the redemption already succeeded, so
+	// guest has in fact already secured their spot. The send itself no longer
-	// a mail-server hiccup must not turn into a false failure response to
+	// throws on a delivery problem; its result is recorded on the redemption
-	// a guest who has, in fact, already secured their spot.
+	// so staff can spot and resend a failed confirmation from the admin UI.
 	try {
-		await sendConfirmationEmail(eventId, request, redemptionId);
+		const sent = await sendRedemptionConfirmation({
+			eventId,
+			contactName: request.contactName,
+			contactEmail: request.contactEmail,
+			guestNames: request.guests.map(g => g.name)
+		});
+		await recordConfirmationEmailResult(redemptionId, sent);
 	} catch (e: any) {
-		logger.error('Redemption ' + redemptionId + ' succeeded but confirmation email failed to send: ' + e.message);
+		logger.error('Redemption ' + redemptionId + ' committed but the confirmation email step failed: ' + e.message);
 	}
 
 	return {status: 'OK', redemptionId};
 };
-
-const sendConfirmationEmail = async (eventId: number, request: RedeemRequest, redemptionId: number): Promise<void> => {
-	const event = await EventsService.getEventById(eventId);
-	if (!event) return;
-
-	const guestList = request.guests.map(g => `- ${g.name}`).join('\n');
-	const body = `Hallo ${request.contactName},\n\n` +
-		`vielen Dank für deine Anmeldung zu "${event.name}"!\n\n` +
-		`Termin: ${formatGermanDateTime(event.startDateTime)}\n` +
-		`Ort: ${event.location}\n\n` +
-		`Angemeldete Gäste:\n${guestList}\n\n` +
-		`Wir freuen uns auf dich!\n\nDein Nachklang-Team`;
-
-	let icsAttachment;
-	try {
-		const ics = await IcalService.convertToIcal([event]);
-		icsAttachment = [{filename: 'konzert.ics', content: ics, contentType: 'text/calendar'}];
-	} catch {
-		icsAttachment = undefined;
-	}
-
-	await MailService.sendMail(
-		request.contactEmail,
-		`Bestätigung: ${event.name}`,
-		body,
-		{attachments: icsAttachment}
-	);
-};

src/models/tickets/tickets.confirmation-email.ts

@@ -0,0 +1,76 @@
+import * as EventsService from '../calendar/events/events.service';
+import * as IcalService from '../calendar/events/icalgenerator.service';
+import {MailService} from '../../common/common.mail';
+import logger from '../../middleware/logger';
+import {NachklangTicketsDB} from './Tickets.db';
+
+export type ConfirmationEmailStatus = 'SENT' | 'FAILED';
+
+// The redemption confirmation email is built and sent from here so the public
+// redeem path and the admin "resend" action share one copy of the German text
+// and the .ics attachment logic.
+
+const formatGermanDateTime = (date: Date): string =>
+	new Intl.DateTimeFormat('de-DE', {
+		dateStyle: 'full',
+		timeStyle: 'short',
+		timeZone: 'Europe/Berlin'
+	}).format(date);
+
+export interface ConfirmationRecipient {
+	eventId: number;
+	contactName: string;
+	contactEmail: string;
+	guestNames: string[];
+}
+
+/**
+ * Sends the redemption confirmation email for one redemption. Returns whether
+ * the mail was accepted by the relay. Never throws: a missing event is treated
+ * as "not sent", and MailService.sendMail already swallows delivery failures.
+ */
+export const sendRedemptionConfirmation = async (recipient: ConfirmationRecipient): Promise<boolean> => {
+	const event = await EventsService.getEventById(recipient.eventId);
+	if (!event) {
+		logger.error('Confirmation email skipped: event ' + recipient.eventId + ' no longer exists');
+		return false;
+	}
+
+	const guestList = recipient.guestNames.map(name => `- ${name}`).join('\n');
+	const body =
+		`Hallo ${recipient.contactName},\n\n` +
+		`vielen Dank für deine Anmeldung zu "${event.name}"!\n\n` +
+		`Termin: ${formatGermanDateTime(event.startDateTime)}\n` +
+		`Ort: ${event.location}\n\n` +
+		`Angemeldete Gäste:\n${guestList}\n\n` +
+		`Wir freuen uns auf dich!\n\nDein Nachklang-Team`;
+
+	let icsAttachment;
+	try {
+		const ics = await IcalService.convertToIcal([event]);
+		icsAttachment = [{filename: 'konzert.ics', content: ics, contentType: 'text/calendar'}];
+	} catch (e: any) {
+		// Non-fatal: the confirmation still goes out, just without the calendar file.
+		logger.warn('Confirmation email for event ' + recipient.eventId + ' sent without .ics attachment: ' + e?.message);
+		icsAttachment = undefined;
+	}
+
+	return MailService.sendMail(recipient.contactEmail, `Bestätigung: ${event.name}`, body, {attachments: icsAttachment});
+};
+
+/**
+ * Records the outcome of a confirmation-email send on the redemption row so the
+ * admin UI can flag failures. Best-effort: a failure to write the flag is
+ * logged, never thrown - the redemption itself already succeeded.
+ */
+export const recordConfirmationEmailResult = async (redemptionId: number, sent: boolean): Promise<void> => {
+	const status: ConfirmationEmailStatus = sent ? 'SENT' : 'FAILED';
+	let conn = await NachklangTicketsDB.getConnection();
+	try {
+		await conn.query('UPDATE redemptions SET confirmation_email_status = ? WHERE redemption_id = ?', [status, redemptionId]);
+	} catch (err: any) {
+		logger.error('Could not record confirmation email status for redemption ' + redemptionId + ': ' + err?.message);
+	} finally {
+		await conn.end();
+	}
+};

src/models/tickets/tickets.interface.ts

@@ -109,6 +109,11 @@
  *         redeemedAt:
  *           type: string
  *           format: date-time
+ *         confirmationEmailStatus:
+ *           type: string
+ *           enum: [SENT, FAILED]
+ *           nullable: true
+ *           description: Outcome of the redemption confirmation email. null until the send resolves.
  *     VoucherCode:
  *       type: object
  *       required: [code, status, maxGuests, createdByEmail, createdAt, eligibleEventIds]
@@ -258,6 +263,8 @@ export interface RedemptionSummary {
 	guestCount: number;
 	guests: string[];
 	redeemedAt: Date;
+	// null until the post-redemption confirmation email send resolves.
+	confirmationEmailStatus: 'SENT' | 'FAILED' | null;
 }
 
 export interface VoucherCode {

test/common/common.mail.test.ts

@@ -0,0 +1,115 @@
+// common.mail relays one email through the Salesforce org (see
+// src/common/common.mail.ts). These tests mock the shared Salesforce client so
+// no network is touched, and check: the payload shape, base64 attachment
+// encoding, the attachment size cap, the retry-once-on-transient-failure
+// behaviour, and that a delivery failure is swallowed (returns false, never
+// throws).
+
+jest.mock('../../src/common/salesforce.client');
+jest.mock('../../src/middleware/logger', () => ({
+	__esModule: true,
+	default: {info: jest.fn(), warn: jest.fn(), error: jest.fn()}
+}));
+
+import {MailService} from '../../src/common/common.mail';
+import {salesforceApexRestPost, salesforceEnabled} from '../../src/common/salesforce.client';
+
+const mockPost = salesforceApexRestPost as jest.Mock;
+const mockEnabled = salesforceEnabled as jest.Mock;
+
+const httpError = (status: number, body?: any): any => {
+	const err: any = new Error('request failed with ' + status);
+	err.response = {status, data: body};
+	return err;
+};
+
+beforeEach(() => {
+	jest.clearAllMocks();
+	mockEnabled.mockReturnValue(true);
+	mockPost.mockResolvedValue({status: 'SENT'});
+});
+
+describe('MailService.sendMail', () => {
+	it('returns false without a callout when Salesforce is disabled', async () => {
+		mockEnabled.mockReturnValue(false);
+
+		const result = await MailService.sendMail('guest@example.com', 'Hi', 'Hallo');
+
+		expect(result).toBe(false);
+		expect(mockPost).not.toHaveBeenCalled();
+	});
+
+	it('posts the email to the Apex REST endpoint and returns true on success', async () => {
+		const result = await MailService.sendMail('guest@example.com', 'Bestätigung', 'Hallo', {html: '<p>Hallo</p>'});
+
+		expect(result).toBe(true);
+		expect(mockPost).toHaveBeenCalledWith('/services/apexrest/email/send', {
+			to: 'guest@example.com',
+			subject: 'Bestätigung',
+			textBody: 'Hallo',
+			htmlBody: '<p>Hallo</p>',
+			attachments: []
+		});
+	});
+
+	it('sends htmlBody as null when no HTML is given', async () => {
+		await MailService.sendMail('guest@example.com', 'Hi', 'Hallo');
+
+		expect(mockPost).toHaveBeenCalledWith('/services/apexrest/email/send', expect.objectContaining({htmlBody: null}));
+	});
+
+	it('base64-encodes attachments', async () => {
+		await MailService.sendMail('guest@example.com', 'Hi', 'Hallo', {
+			attachments: [{filename: 'konzert.ics', content: 'BEGIN:VCALENDAR', contentType: 'text/calendar'}]
+		});
+
+		expect(mockPost).toHaveBeenCalledWith(
+			'/services/apexrest/email/send',
+			expect.objectContaining({
+				attachments: [{
+					filename: 'konzert.ics',
+					contentType: 'text/calendar',
+					contentBase64: Buffer.from('BEGIN:VCALENDAR', 'utf-8').toString('base64')
+				}]
+			})
+		);
+	});
+
+	it('rejects an attachment over the size cap without sending', async () => {
+		const huge = Buffer.alloc(3 * 1024 * 1024 + 1);
+
+		const result = await MailService.sendMail('guest@example.com', 'Hi', 'Hallo', {
+			attachments: [{filename: 'big.pdf', content: huge}]
+		});
+
+		expect(result).toBe(false);
+		expect(mockPost).not.toHaveBeenCalled();
+	});
+
+	it('retries once on a 5xx and returns false when the retry also fails', async () => {
+		mockPost.mockRejectedValue(httpError(503));
+
+		const result = await MailService.sendMail('guest@example.com', 'Hi', 'Hallo');
+
+		expect(result).toBe(false);
+		expect(mockPost).toHaveBeenCalledTimes(2);
+	});
+
+	it('retries once on a network error (no response) then succeeds', async () => {
+		mockPost.mockRejectedValueOnce(new Error('socket hang up')).mockResolvedValueOnce({status: 'SENT'});
+
+		const result = await MailService.sendMail('guest@example.com', 'Hi', 'Hallo');
+
+		expect(result).toBe(true);
+		expect(mockPost).toHaveBeenCalledTimes(2);
+	});
+
+	it('does not retry on a 4xx (e.g. the 429 limit response) and returns false', async () => {
+		mockPost.mockRejectedValue(httpError(429, {errorCode: 'LIMIT_REACHED'}));
+
+		const result = await MailService.sendMail('guest@example.com', 'Hi', 'Hallo');
+
+		expect(result).toBe(false);
+		expect(mockPost).toHaveBeenCalledTimes(1);
+	});
+});

test/common/salesforce.client.test.ts

@@ -0,0 +1,124 @@
+// salesforce.client caches the OAuth token at module scope, so every test
+// resets the module registry for a clean cache and re-requires axios + the
+// module under test after the reset (same approach as
+// test/feedback/salesforce.service.test.ts).
+
+export {}; // isolate module scope from other script-style test files
+
+jest.mock('axios');
+
+const freshImports = () => {
+	const axios = require('axios');
+	const {salesforceApexRestPost, salesforceEnabled} = require('../../src/common/salesforce.client');
+	return {axios, salesforceApexRestPost, salesforceEnabled};
+};
+
+const ORIGINAL_ENV = {...process.env};
+const ENABLED_ENV = {
+	...ORIGINAL_ENV,
+	SALESFORCE_ENABLED: 'true',
+	SALESFORCE_API_URL: 'https://example.my.salesforce.com',
+	SALESFORCE_CLIENT_ID: 'client-id',
+	SALESFORCE_CLIENT_SECRET: 'client-secret'
+};
+
+beforeEach(() => {
+	jest.resetModules();
+	process.env = {...ENABLED_ENV};
+});
+
+afterAll(() => {
+	process.env = {...ORIGINAL_ENV};
+});
+
+describe('salesforceEnabled', () => {
+	it('is true only when SALESFORCE_ENABLED === "true"', () => {
+		process.env.SALESFORCE_ENABLED = 'true';
+		expect(freshImports().salesforceEnabled()).toBe(true);
+
+		jest.resetModules();
+		process.env.SALESFORCE_ENABLED = 'false';
+		expect(freshImports().salesforceEnabled()).toBe(false);
+	});
+});
+
+describe('salesforceApexRestPost', () => {
+	it('fetches a token, posts to the given Apex REST path, and returns the response body', async () => {
+		const {axios, salesforceApexRestPost} = freshImports();
+		axios.post.mockImplementation((url: string) => {
+			if (url.endsWith('/services/oauth2/token')) return Promise.resolve({data: {access_token: 'tok-1'}});
+			return Promise.resolve({data: {ok: true}});
+		});
+
+		const result = await salesforceApexRestPost('/services/apexrest/email/send', {to: 'x@example.com'});
+
+		expect(result).toEqual({ok: true});
+		expect(axios.post).toHaveBeenCalledWith(
+			'https://example.my.salesforce.com/services/oauth2/token',
+			expect.any(String),
+			expect.objectContaining({headers: {'Content-Type': 'application/x-www-form-urlencoded'}})
+		);
+		expect(axios.post).toHaveBeenCalledWith(
+			'https://example.my.salesforce.com/services/apexrest/email/send',
+			{to: 'x@example.com'},
+			expect.objectContaining({headers: {Authorization: 'Bearer tok-1'}})
+		);
+	});
+
+	it('reuses the cached token across calls instead of fetching twice', async () => {
+		const {axios, salesforceApexRestPost} = freshImports();
+		axios.post.mockImplementation((url: string) => {
+			if (url.endsWith('/services/oauth2/token')) return Promise.resolve({data: {access_token: 'tok-1'}});
+			return Promise.resolve({data: {}});
+		});
+
+		await salesforceApexRestPost('/services/apexrest/email/send', {});
+		await salesforceApexRestPost('/services/apexrest/email/send', {});
+
+		const tokenCalls = axios.post.mock.calls.filter(([url]: [string]) => url.endsWith('/services/oauth2/token'));
+		expect(tokenCalls).toHaveLength(1);
+	});
+
+	it('retries once with a fresh token on a 401, then succeeds', async () => {
+		const {axios, salesforceApexRestPost} = freshImports();
+		let tokenFetches = 0;
+		axios.post.mockImplementation((url: string) => {
+			if (url.endsWith('/services/oauth2/token')) {
+				tokenFetches += 1;
+				return Promise.resolve({data: {access_token: `tok-${tokenFetches}`}});
+			}
+			if (tokenFetches === 1) {
+				const err: any = new Error('Unauthorized');
+				err.response = {status: 401};
+				return Promise.reject(err);
+			}
+			return Promise.resolve({data: {ok: true}});
+		});
+
+		const result = await salesforceApexRestPost('/services/apexrest/email/send', {});
+
+		expect(result).toEqual({ok: true});
+		expect(tokenFetches).toBe(2);
+	});
+
+	it('does not retry on a non-401 error and rethrows it', async () => {
+		const {axios, salesforceApexRestPost} = freshImports();
+		axios.post.mockImplementation((url: string) => {
+			if (url.endsWith('/services/oauth2/token')) return Promise.resolve({data: {access_token: 'tok-1'}});
+			const err: any = new Error('Server error');
+			err.response = {status: 500};
+			return Promise.reject(err);
+		});
+
+		await expect(salesforceApexRestPost('/services/apexrest/email/send', {})).rejects.toThrow('Server error');
+		const endpointCalls = axios.post.mock.calls.filter(([url]: [string]) => url.endsWith('/email/send'));
+		expect(endpointCalls).toHaveLength(1);
+	});
+
+	it('throws a clear error when client credentials are not configured', async () => {
+		process.env.SALESFORCE_CLIENT_ID = '';
+		const {salesforceApexRestPost} = freshImports();
+
+		await expect(salesforceApexRestPost('/services/apexrest/email/send', {})).rejects.toThrow('SALESFORCE_CLIENT_ID');
+	});
+});

test/tickets/confirmation-email.test.ts

@@ -0,0 +1,131 @@
+// tickets.confirmation-email builds and sends the redemption confirmation
+// email, shared by the public redeem path and the admin resend action.
+
+jest.mock('../../src/models/calendar/events/events.service', () => ({
+	getEventById: jest.fn()
+}));
+jest.mock('../../src/models/calendar/events/icalgenerator.service', () => ({
+	convertToIcal: jest.fn()
+}));
+jest.mock('../../src/common/common.mail', () => ({
+	MailService: {sendMail: jest.fn()}
+}));
+jest.mock('../../src/models/tickets/Tickets.db', () => ({
+	NachklangTicketsDB: {getConnection: jest.fn()}
+}));
+jest.mock('../../src/middleware/logger', () => ({
+	__esModule: true,
+	default: {info: jest.fn(), warn: jest.fn(), error: jest.fn()}
+}));
+
+import * as EventsService from '../../src/models/calendar/events/events.service';
+import * as IcalService from '../../src/models/calendar/events/icalgenerator.service';
+import {MailService} from '../../src/common/common.mail';
+import logger from '../../src/middleware/logger';
+import {NachklangTicketsDB} from '../../src/models/tickets/Tickets.db';
+import {recordConfirmationEmailResult, sendRedemptionConfirmation} from '../../src/models/tickets/tickets.confirmation-email';
+
+const mockGetEvent = EventsService.getEventById as jest.Mock;
+const mockToIcal = IcalService.convertToIcal as jest.Mock;
+const mockSendMail = MailService.sendMail as jest.Mock;
+const mockLogger = logger as unknown as {info: jest.Mock; warn: jest.Mock; error: jest.Mock};
+const mockGetConnection = NachklangTicketsDB.getConnection as jest.Mock;
+
+const EVENT = {
+	eventId: 42,
+	name: 'Sommerkonzert 2026',
+	startDateTime: new Date('2026-07-01T19:00:00Z'),
+	location: 'Christuskirche',
+	status: 'PUBLISHED'
+};
+
+const RECIPIENT = {
+	eventId: 42,
+	contactName: 'Erika Mustermann',
+	contactEmail: 'erika@example.com',
+	guestNames: ['Erika Mustermann', 'Hans Mustermann']
+};
+
+beforeEach(() => {
+	jest.clearAllMocks();
+	mockGetEvent.mockResolvedValue(EVENT);
+	mockToIcal.mockResolvedValue('BEGIN:VCALENDAR\nEND:VCALENDAR');
+	mockSendMail.mockResolvedValue(true);
+});
+
+describe('sendRedemptionConfirmation', () => {
+	it('sends the German confirmation with the event details, guest list and .ics attachment', async () => {
+		const result = await sendRedemptionConfirmation(RECIPIENT);
+
+		expect(result).toBe(true);
+		expect(mockSendMail).toHaveBeenCalledTimes(1);
+		const [to, subject, body, options] = mockSendMail.mock.calls[0];
+		expect(to).toBe('erika@example.com');
+		expect(subject).toBe('Bestätigung: Sommerkonzert 2026');
+		expect(body).toContain('Hallo Erika Mustermann,');
+		expect(body).toContain('"Sommerkonzert 2026"');
+		expect(body).toContain('- Hans Mustermann');
+		expect(options.attachments).toEqual([
+			{filename: 'konzert.ics', content: 'BEGIN:VCALENDAR\nEND:VCALENDAR', contentType: 'text/calendar'}
+		]);
+	});
+
+	it('still sends (without an attachment) and warns when the .ics build fails', async () => {
+		mockToIcal.mockRejectedValue(new Error('ical boom'));
+
+		await sendRedemptionConfirmation(RECIPIENT);
+
+		const options = mockSendMail.mock.calls[0][3];
+		expect(options.attachments).toBeUndefined();
+		expect(mockLogger.warn).toHaveBeenCalledWith(expect.stringContaining('without .ics attachment'));
+	});
+
+	it('returns false and does not send when the event no longer exists', async () => {
+		mockGetEvent.mockResolvedValue(null);
+
+		const result = await sendRedemptionConfirmation(RECIPIENT);
+
+		expect(result).toBe(false);
+		expect(mockSendMail).not.toHaveBeenCalled();
+	});
+
+	it('propagates the relay result', async () => {
+		mockSendMail.mockResolvedValue(false);
+
+		expect(await sendRedemptionConfirmation(RECIPIENT)).toBe(false);
+	});
+});
+
+describe('recordConfirmationEmailResult', () => {
+	const makeConn = () => ({query: jest.fn().mockResolvedValue(undefined), end: jest.fn().mockResolvedValue(undefined)});
+
+	it('writes SENT when the mail was accepted', async () => {
+		const conn = makeConn();
+		mockGetConnection.mockResolvedValue(conn);
+
+		await recordConfirmationEmailResult(7, true);
+
+		expect(conn.query).toHaveBeenCalledWith(
+			'UPDATE redemptions SET confirmation_email_status = ? WHERE redemption_id = ?',
+			['SENT', 7]
+		);
+		expect(conn.end).toHaveBeenCalled();
+	});
+
+	it('writes FAILED when the mail was not accepted', async () => {
+		const conn = makeConn();
+		mockGetConnection.mockResolvedValue(conn);
+
+		await recordConfirmationEmailResult(7, false);
+
+		expect(conn.query).toHaveBeenCalledWith(expect.any(String), ['FAILED', 7]);
+	});
+
+	it('swallows a DB error rather than throwing', async () => {
+		const conn = {query: jest.fn().mockRejectedValue(new Error('db down')), end: jest.fn().mockResolvedValue(undefined)};
+		mockGetConnection.mockResolvedValue(conn);
+
+		await expect(recordConfirmationEmailResult(7, true)).resolves.toBeUndefined();
+		expect(conn.end).toHaveBeenCalled();
+	});
+});

test/tickets/redemptions.admin.resend.test.ts

@@ -0,0 +1,88 @@
+// resendRedemptionConfirmation rebuilds the confirmation email from stored
+// redemption data and records the new outcome. Only the resend path is
+// exercised here; the shared send/record logic is covered by
+// confirmation-email.test.ts.
+
+jest.mock('../../src/models/tickets/Tickets.db', () => ({
+	NachklangTicketsDB: {getConnection: jest.fn()}
+}));
+jest.mock('../../src/models/tickets/tickets.confirmation-email', () => ({
+	sendRedemptionConfirmation: jest.fn(),
+	recordConfirmationEmailResult: jest.fn()
+}));
+
+import {NachklangTicketsDB} from '../../src/models/tickets/Tickets.db';
+import {recordConfirmationEmailResult, sendRedemptionConfirmation} from '../../src/models/tickets/tickets.confirmation-email';
+import {resendRedemptionConfirmation} from '../../src/models/tickets/admin/redemptions.admin.service';
+
+const mockGetConnection = NachklangTicketsDB.getConnection as jest.Mock;
+const mockSend = sendRedemptionConfirmation as jest.Mock;
+const mockRecord = recordConfirmationEmailResult as jest.Mock;
+
+const ACTIVE_ROW = {
+	redemption_id: 5,
+	code: 'ABC123',
+	event_id: 42,
+	status: 'ACTIVE',
+	contact_name: 'Erika Mustermann',
+	contact_email: 'erika@example.com',
+	contact_address: null,
+	guest_count: 2,
+	redeemed_at: new Date('2026-06-01T10:00:00Z'),
+	confirmation_email_status: 'FAILED'
+};
+
+// getRedemption issues: 1) SELECT redemptions, 2) SELECT redemption_guests
+const connFor = (redemptionRows: any[], guestRows: any[] = []) => ({
+	query: jest
+		.fn()
+		.mockResolvedValueOnce(redemptionRows)
+		.mockResolvedValueOnce(guestRows),
+	end: jest.fn().mockResolvedValue(undefined)
+});
+
+beforeEach(() => {
+	jest.clearAllMocks();
+	mockSend.mockResolvedValue(true);
+});
+
+describe('resendRedemptionConfirmation', () => {
+	it('returns NOT_FOUND when the redemption does not exist', async () => {
+		mockGetConnection.mockResolvedValue(connFor([]));
+
+		expect(await resendRedemptionConfirmation(5)).toBe('NOT_FOUND');
+		expect(mockSend).not.toHaveBeenCalled();
+	});
+
+	it('returns NOT_ACTIVE for an undone redemption', async () => {
+		mockGetConnection.mockResolvedValue(connFor([{...ACTIVE_ROW, status: 'UNDONE'}]));
+
+		expect(await resendRedemptionConfirmation(5)).toBe('NOT_ACTIVE');
+		expect(mockSend).not.toHaveBeenCalled();
+	});
+
+	it('resends from the stored data and records SENT on success', async () => {
+		mockGetConnection.mockResolvedValue(connFor([ACTIVE_ROW], [{name: 'Erika Mustermann'}, {name: 'Hans Mustermann'}]));
+
+		const result = await resendRedemptionConfirmation(5);
+
+		expect(result).toBe('SENT');
+		expect(mockSend).toHaveBeenCalledWith({
+			eventId: 42,
+			contactName: 'Erika Mustermann',
+			contactEmail: 'erika@example.com',
+			guestNames: ['Erika Mustermann', 'Hans Mustermann']
+		});
+		expect(mockRecord).toHaveBeenCalledWith(5, true);
+	});
+
+	it('records FAILED and returns FAILED when the relay rejects the send', async () => {
+		mockGetConnection.mockResolvedValue(connFor([ACTIVE_ROW], [{name: 'Erika Mustermann'}]));
+		mockSend.mockResolvedValue(false);
+
+		const result = await resendRedemptionConfirmation(5);
+
+		expect(result).toBe('FAILED');
+		expect(mockRecord).toHaveBeenCalledWith(5, false);
+	});
+});