@technomoron/mail-magic 1.0.32 → 1.0.34

package/dist/api/forms.js

@@ -1,193 +1,40 @@
-import fs from 'node:fs';
-import path from 'path';
 import { ApiModule, ApiError } from '@technomoron/api-server-base';
-import emailAddresses from 'email-addresses';
 import { nanoid } from 'nanoid';
 import nunjucks from 'nunjucks';
-import { Op } from 'sequelize';
+import { UniqueConstraintError } from 'sequelize';
 import { api_domain } from '../models/domain.js';
 import { api_form } from '../models/form.js';
 import { api_recipient } from '../models/recipient.js';
-import { buildRequestMeta, normalizeSlug } from '../util.js';
+import { buildFormTemplateRecord, buildFormTemplatePaths, buildRecipientTo, buildReplyToValue, buildSubmissionContext, enforceAttachmentPolicy, enforceCaptchaPolicy, filterSubmissionFields, getPrimaryRecipientInfo, normalizeRecipientEmail, normalizeRecipientIdname, normalizeRecipientName, parseIdnameList, parseFormTemplatePayload, parseRecipientPayload, parsePublicSubmissionOrThrow, resolveFormKeyForTemplate, resolveFormKeyForRecipient, resolveRecipients, validateFormTemplatePayload } from '../util/forms.js';
+import { FixedWindowRateLimiter, enforceFormRateLimit } from '../util/ratelimit.js';
+import { buildAttachments, cleanupUploadedFiles } from '../util/uploads.js';
+import { buildRequestMeta, getBodyValue } from '../util.js';
 import { assert_domain_and_user } from './auth.js';
-function getBodyValue(body, ...keys) {
-    for (const key of keys) {
-        const value = body[key];
-        if (Array.isArray(value) && value.length > 0) {
-            return String(value[0]);
-        }
-        if (value !== undefined && value !== null) {
-            return String(value);
-        }
-    }
-    return '';
-}
-async function verifyCaptcha(params) {
-    const endpoints = {
-        turnstile: 'https://challenges.cloudflare.com/turnstile/v0/siteverify',
-        hcaptcha: 'https://hcaptcha.com/siteverify',
-        recaptcha: 'https://www.google.com/recaptcha/api/siteverify'
-    };
-    const endpoint = endpoints[params.provider] ?? endpoints.turnstile;
-    const body = new URLSearchParams();
-    body.set('secret', params.secret);
-    body.set('response', params.token);
-    if (params.remoteip) {
-        body.set('remoteip', params.remoteip);
-    }
-    const res = await fetch(endpoint, {
-        method: 'POST',
-        headers: { 'content-type': 'application/x-www-form-urlencoded' },
-        body
-    });
-    if (!res.ok) {
-        return false;
-    }
-    const data = (await res.json().catch(() => null));
-    return Boolean(data?.success);
-}
-async function cleanupUploadedFiles(files) {
-    await Promise.all(files.map(async (file) => {
-        if (!file?.path) {
-            return;
-        }
-        try {
-            await fs.promises.unlink(file.path);
-        }
-        catch {
-            // best effort cleanup
-        }
-    }));
-}
-class FixedWindowRateLimiter {
-    maxKeys;
-    buckets = new Map();
-    constructor(maxKeys = 10_000) {
-        this.maxKeys = maxKeys;
-    }
-    check(key, max, windowMs) {
-        if (!key || max <= 0 || windowMs <= 0) {
-            return { allowed: true, retryAfterSec: 0 };
-        }
-        const now = Date.now();
-        const bucket = this.buckets.get(key);
-        if (!bucket || now - bucket.windowStartMs >= windowMs) {
-            this.buckets.delete(key);
-            this.buckets.set(key, { windowStartMs: now, count: 1 });
-            this.prune();
-            return { allowed: true, retryAfterSec: 0 };
-        }
-        bucket.count += 1;
-        // Refresh insertion order to keep active entries at the end for pruning.
-        this.buckets.delete(key);
-        this.buckets.set(key, bucket);
-        if (bucket.count <= max) {
-            return { allowed: true, retryAfterSec: 0 };
-        }
-        const retryAfterSec = Math.max(1, Math.ceil((bucket.windowStartMs + windowMs - now) / 1000));
-        return { allowed: false, retryAfterSec };
-    }
-    prune() {
-        while (this.buckets.size > this.maxKeys) {
-            const oldest = this.buckets.keys().next().value;
-            if (!oldest) {
-                break;
-            }
-            this.buckets.delete(oldest);
-        }
-    }
-}
 export class FormAPI extends ApiModule {
     rateLimiter = new FixedWindowRateLimiter();
-    validateEmail(email) {
-        const parsed = emailAddresses.parseOneAddress(email);
-        if (parsed) {
-            return parsed.address;
-        }
-        return undefined;
-    }
-    parseMailbox(value) {
-        const parsed = emailAddresses.parseOneAddress(value);
-        if (!parsed) {
-            return undefined;
-        }
-        const mailbox = parsed;
-        if (!mailbox?.address) {
-            return undefined;
-        }
-        return mailbox;
-    }
     async postFormRecipient(apireq) {
         await assert_domain_and_user(apireq);
         const body = (apireq.req.body ?? {});
-        const idnameRaw = getBodyValue(body, 'idname', 'recipient_idname', 'recipientIdname');
-        const emailRaw = getBodyValue(body, 'email');
-        const nameRaw = getBodyValue(body, 'name');
-        const formKeyRaw = getBodyValue(body, 'form_key', 'formKey', 'formkey');
-        const formid = getBodyValue(body, 'formid');
-        const localeRaw = getBodyValue(body, 'locale');
-        if (!idnameRaw) {
-            throw new ApiError({ code: 400, message: 'Missing recipient identifier (idname)' });
-        }
-        const idname = normalizeSlug(idnameRaw);
-        if (!idname) {
-            throw new ApiError({ code: 400, message: 'Invalid recipient identifier (idname)' });
-        }
-        if (!emailRaw) {
-            throw new ApiError({ code: 400, message: 'Missing recipient email address' });
-        }
-        const mailbox = this.parseMailbox(emailRaw);
-        if (!mailbox) {
-            throw new ApiError({ code: 400, message: 'Invalid recipient email address' });
-        }
-        const email = mailbox.address;
-        if (/[\r\n]/.test(email)) {
-            throw new ApiError({ code: 400, message: 'Invalid recipient email address' });
-        }
-        const name = String(nameRaw || mailbox.name || '')
-            .trim()
-            .slice(0, 200);
-        if (/[\r\n]/.test(name)) {
-            throw new ApiError({ code: 400, message: 'Invalid recipient name' });
-        }
+        const payload = parseRecipientPayload({
+            idname: getBodyValue(body, 'idname'),
+            email: getBodyValue(body, 'email'),
+            name: getBodyValue(body, 'name'),
+            form_key: getBodyValue(body, 'form_key'),
+            formid: getBodyValue(body, 'formid'),
+            locale: getBodyValue(body, 'locale')
+        });
+        const idname = normalizeRecipientIdname(payload.idnameRaw);
+        const { email, mailbox } = normalizeRecipientEmail(payload.emailRaw);
+        const name = normalizeRecipientName(payload.nameRaw, mailbox.name);
         const user = apireq.user;
         const domain = apireq.domain;
-        let form_key = '';
-        if (formKeyRaw) {
-            const form = await api_form.findOne({ where: { form_key: formKeyRaw } });
-            if (!form || form.domain_id !== domain.domain_id || form.user_id !== user.user_id) {
-                throw new ApiError({ code: 404, message: 'No such form_key for this domain' });
-            }
-            form_key = form.form_key ?? '';
-        }
-        else if (formid) {
-            const locale = localeRaw ? normalizeSlug(localeRaw) : '';
-            if (locale) {
-                const form = await api_form.findOne({
-                    where: { user_id: user.user_id, domain_id: domain.domain_id, locale, idname: formid }
-                });
-                if (!form) {
-                    throw new ApiError({ code: 404, message: 'No such form for this domain/locale' });
-                }
-                form_key = form.form_key ?? '';
-            }
-            else {
-                const matches = await api_form.findAll({
-                    where: { user_id: user.user_id, domain_id: domain.domain_id, idname: formid },
-                    limit: 2
-                });
-                if (matches.length === 0) {
-                    throw new ApiError({ code: 404, message: 'No such form for this domain' });
-                }
-                if (matches.length > 1) {
-                    throw new ApiError({
-                        code: 409,
-                        message: 'Form identifier is ambiguous; provide locale or form_key'
-                    });
-                }
-                form_key = matches[0].form_key ?? '';
-            }
-        }
+        const form_key = await resolveFormKeyForRecipient({
+            formKeyRaw: payload.formKeyRaw,
+            formid: payload.formid,
+            localeRaw: payload.localeRaw,
+            user,
+            domain
+        });
         const record = {
             domain_id: domain.domain_id,
             form_key,
@@ -213,332 +60,125 @@ export class FormAPI extends ApiModule {
     }
     async postFormTemplate(apireq) {
         await assert_domain_and_user(apireq);
-        const { template, sender = '', recipient = '', idname, subject = '', locale = '', secret = '', captcha_required: captchaRequiredRaw, captchaRequired: captchaRequiredAlt } = apireq.req.body;
-        const captcha_required = (() => {
-            const value = captchaRequiredRaw ?? captchaRequiredAlt;
-            if (typeof value === 'boolean') {
-                return value;
-            }
-            if (typeof value === 'number') {
-                return value !== 0;
-            }
-            const normalized = String(value ?? '')
-                .trim()
-                .toLowerCase();
-            return ['true', '1', 'yes', 'on'].includes(normalized);
-        })();
-        if (!template) {
-            throw new ApiError({ code: 400, message: 'Missing template data' });
-        }
-        if (!idname) {
-            throw new ApiError({ code: 400, message: 'Missing form identifier' });
-        }
-        if (!sender) {
-            throw new ApiError({ code: 400, message: 'Missing sender address' });
-        }
-        if (!recipient) {
-            throw new ApiError({ code: 400, message: 'Missing recipient address' });
-        }
+        const payload = parseFormTemplatePayload(apireq.req.body ?? {});
+        validateFormTemplatePayload(payload);
         const user = apireq.user;
         const domain = apireq.domain;
-        const resolvedLocale = locale || apireq.locale || '';
-        const userSlug = normalizeSlug(user.idname);
-        const domainSlug = normalizeSlug(domain.name);
-        const formSlug = normalizeSlug(idname);
-        const localeSlug = normalizeSlug(resolvedLocale || domain.locale || user.locale || '');
-        const slug = `${userSlug}-${domainSlug}${localeSlug ? '-' + localeSlug : ''}-${formSlug}`;
-        const filenameParts = [domainSlug, 'form-template'];
-        if (localeSlug) {
-            filenameParts.push(localeSlug);
-        }
-        filenameParts.push(formSlug);
-        let filename = path.join(...filenameParts);
-        if (!filename.endsWith('.njk')) {
-            filename += '.njk';
-        }
-        let form_key = '';
-        try {
-            const existing = await api_form.findOne({
-                where: {
-                    user_id: user.user_id,
-                    domain_id: domain.domain_id,
-                    locale: localeSlug,
-                    idname
-                }
-            });
-            form_key = existing?.form_key || nanoid();
-        }
-        catch {
-            form_key = nanoid();
-        }
-        const record = {
+        const resolvedLocale = payload.locale || apireq.locale || '';
+        const { localeSlug, slug, filename } = buildFormTemplatePaths({
+            user,
+            domain,
+            idname: payload.idname,
+            locale: resolvedLocale
+        });
+        let form_key = (await resolveFormKeyForTemplate({
+            user_id: user.user_id,
+            domain_id: domain.domain_id,
+            locale: localeSlug,
+            idname: payload.idname
+        })) || nanoid();
+        const record = buildFormTemplateRecord({
             form_key,
             user_id: user.user_id,
             domain_id: domain.domain_id,
             locale: localeSlug,
-            idname,
-            sender,
-            recipient,
-            subject,
-            template,
             slug,
             filename,
-            secret,
-            captcha_required,
-            files: []
-        };
+            payload
+        });
         let created = false;
-        try {
-            const [form, wasCreated] = await api_form.upsert(record, {
-                returning: true,
-                conflictFields: ['user_id', 'domain_id', 'locale', 'idname']
-            });
-            created = wasCreated ?? false;
-            form_key = form.form_key || form_key;
-            this.server.storage.print_debug(`Form template upserted: ${form.idname} (created=${wasCreated})`);
-        }
-        catch (error) {
-            throw new ApiError({
-                code: 500,
-                message: this.server.guessExceptionText(error, 'Unknown Sequelize Error on upsert form template')
-            });
+        for (let attempt = 0; attempt < 10; attempt++) {
+            try {
+                const [form, wasCreated] = await api_form.upsert(record, {
+                    returning: true,
+                    conflictFields: ['user_id', 'domain_id', 'locale', 'idname']
+                });
+                created = wasCreated ?? false;
+                form_key = form.form_key || form_key;
+                this.server.storage.print_debug(`Form template upserted: ${form.idname} (created=${wasCreated})`);
+                break;
+            }
+            catch (error) {
+                if (error instanceof UniqueConstraintError) {
+                    const conflicted = error.errors?.some((e) => e.path === 'form_key');
+                    if (conflicted) {
+                        record.form_key = nanoid();
+                        form_key = record.form_key;
+                        continue;
+                    }
+                }
+                throw new ApiError({
+                    code: 500,
+                    message: this.server.guessExceptionText(error, 'Unknown Sequelize Error on upsert form template')
+                });
+            }
         }
         return [200, { Status: 'OK', created, form_key }];
     }
     async postSendForm(apireq) {
-        const env = this.server.storage.env;
+        const env = this.server.storage.vars;
         const rawFiles = Array.isArray(apireq.req.files) ? apireq.req.files : [];
         const keepUploads = env.FORM_KEEP_UPLOADS;
         try {
-            const body = (apireq.req.body ?? {});
-            const formid = getBodyValue(body, 'formid');
-            const form_key = getBodyValue(body, 'form_key', 'formkey', 'formKey');
-            const domainName = getBodyValue(body, 'domain');
-            const localeRaw = getBodyValue(body, 'locale');
-            const secret = getBodyValue(body, 'secret');
-            const recipient = getBodyValue(body, 'recipient');
-            const recipientIdnameRaw = getBodyValue(body, 'recipient_idname', 'recipientIdname', 'recipient_slug', 'recipientSlug', 'recipient_key', 'recipientKey');
-            const replyTo = getBodyValue(body, 'replyTo', 'reply_to');
-            const vars = body.vars ?? {};
-            const clientIp = apireq.getClientIp() ?? '';
-            const windowMs = Math.max(0, env.FORM_RATE_LIMIT_WINDOW_SEC) * 1000;
-            const decision = this.rateLimiter.check(`form-message:${clientIp || 'unknown'}`, env.FORM_RATE_LIMIT_MAX, windowMs);
-            if (!decision.allowed) {
-                apireq.res.set('Retry-After', String(decision.retryAfterSec));
-                throw new ApiError({ code: 429, message: 'Too many form submissions; try again later' });
-            }
-            if (env.FORM_MAX_ATTACHMENTS === 0 && rawFiles.length > 0) {
-                throw new ApiError({ code: 413, message: 'This endpoint does not accept file attachments' });
-            }
-            if (env.FORM_MAX_ATTACHMENTS > 0 && rawFiles.length > env.FORM_MAX_ATTACHMENTS) {
-                throw new ApiError({
-                    code: 413,
-                    message: `Too many attachments: ${rawFiles.length} > ${env.FORM_MAX_ATTACHMENTS}`
-                });
-            }
-            if (!form_key && !formid) {
-                throw new ApiError({ code: 404, message: 'Missing formid field in form' });
-            }
-            let form = null;
-            if (form_key) {
-                form = await api_form.findOne({ where: { form_key } });
-                if (!form) {
-                    throw new ApiError({ code: 404, message: 'No such form_key' });
-                }
-            }
-            else {
-                if (!domainName) {
-                    throw new ApiError({ code: 400, message: 'Missing domain (or form_key)' });
-                }
-                const domains = await api_domain.findAll({ where: { name: domainName } });
-                if (domains.length === 0) {
-                    throw new ApiError({ code: 404, message: `No such domain: ${domainName}` });
-                }
-                const domainIds = domains.map((domain) => domain.domain_id);
-                const domainWhere = { [Op.in]: domainIds };
-                if (localeRaw) {
-                    const locale = normalizeSlug(localeRaw);
-                    form = await api_form.findOne({
-                        where: {
-                            idname: formid,
-                            domain_id: domainWhere,
-                            locale
-                        }
-                    });
-                }
-                else if (domains.length === 1) {
-                    const locale = normalizeSlug(domains[0].locale || '');
-                    if (locale) {
-                        form = await api_form.findOne({
-                            where: {
-                                idname: formid,
-                                domain_id: domainWhere,
-                                locale
-                            }
-                        });
-                    }
-                }
-                if (!form) {
-                    const matches = await api_form.findAll({
-                        where: {
-                            idname: formid,
-                            domain_id: domainWhere
-                        },
-                        limit: 2
-                    });
-                    if (matches.length === 1) {
-                        form = matches[0];
-                    }
-                    else if (matches.length > 1) {
-                        throw new ApiError({
-                            code: 409,
-                            message: 'Form identifier is ambiguous; provide locale or form_key'
-                        });
-                    }
-                }
-            }
+            const parsedInput = parsePublicSubmissionOrThrow(apireq);
+            const form_key = parsedInput.mm.form_key;
+            const localeRaw = parsedInput.mm.locale;
+            const captchaToken = parsedInput.mm.captcha_token;
+            const recipientsRaw = parsedInput.mm.recipients_raw;
+            enforceFormRateLimit(this.rateLimiter, env, apireq);
+            enforceAttachmentPolicy(env, rawFiles);
+            if (!form_key) {
+                throw new ApiError({ code: 400, message: 'Missing form_key' });
+            }
+            const form = await api_form.findOne({ where: { form_key } });
             if (!form) {
-                throw new ApiError({ code: 404, message: `No such form: ${formid}` });
-            }
-            if (form.secret && !secret) {
-                throw new ApiError({ code: 401, message: 'This form requires a secret key' });
-            }
-            if (form.secret && form.secret !== secret) {
-                throw new ApiError({ code: 401, message: 'Bad form secret' });
-            }
-            const captchaRequired = Boolean(env.FORM_CAPTCHA_REQUIRED || form.captcha_required);
-            const captchaSecret = String(env.FORM_CAPTCHA_SECRET ?? '').trim();
-            const captchaToken = getBodyValue(body, 'cf-turnstile-response', 'h-captcha-response', 'g-recaptcha-response', 'captcha', 'captchaToken', 'captcha_token');
-            if (!captchaSecret) {
-                if (captchaRequired) {
-                    throw new ApiError({ code: 500, message: 'Captcha is required but not configured on the server' });
-                }
-            }
-            else if (!captchaToken) {
-                if (captchaRequired) {
-                    throw new ApiError({ code: 403, message: 'Captcha token required' });
-                }
-            }
-            else {
-                const provider = env.FORM_CAPTCHA_PROVIDER;
-                const ok = await verifyCaptcha({
-                    provider,
-                    secret: captchaSecret,
-                    token: captchaToken,
-                    remoteip: clientIp
-                });
-                if (!ok) {
-                    throw new ApiError({ code: 403, message: 'Captcha verification failed' });
-                }
+                throw new ApiError({ code: 404, message: 'No such form_key' });
             }
-            if (recipient && !form.secret) {
-                throw new ApiError({ code: 401, message: "'recipient' parameterer requires form secret to be set" });
-            }
-            let normalizedReplyTo;
-            let normalizedRecipient;
-            if (replyTo) {
-                normalizedReplyTo = this.validateEmail(replyTo);
-                if (!normalizedReplyTo) {
-                    throw new ApiError({ code: 400, message: 'Invalid reply-to email address' });
-                }
-            }
-            if (recipient) {
-                normalizedRecipient = this.validateEmail(recipient);
-                if (!normalizedRecipient) {
-                    throw new ApiError({ code: 400, message: 'Invalid recipient email address' });
-                }
-            }
-            if (recipientIdnameRaw && !normalizeSlug(recipientIdnameRaw)) {
-                throw new ApiError({ code: 400, message: 'Invalid recipient identifier (recipient_idname)' });
-            }
-            const recipientIdname = normalizeSlug(recipientIdnameRaw);
-            let resolvedRecipient = null;
-            if (!normalizedRecipient && recipientIdname) {
-                const scopeFormKey = form.form_key ?? '';
-                if (scopeFormKey) {
-                    resolvedRecipient = await api_recipient.findOne({
-                        where: {
-                            domain_id: form.domain_id,
-                            form_key: scopeFormKey,
-                            idname: recipientIdname
-                        }
-                    });
-                }
-                if (!resolvedRecipient) {
-                    resolvedRecipient = await api_recipient.findOne({
-                        where: {
-                            domain_id: form.domain_id,
-                            form_key: '',
-                            idname: recipientIdname
-                        }
-                    });
-                }
-                if (!resolvedRecipient) {
-                    throw new ApiError({ code: 404, message: 'Unknown recipient identifier' });
-                }
-            }
-            let parsedVars = vars ?? {};
-            if (typeof vars === 'string') {
-                try {
-                    parsedVars = JSON.parse(vars);
-                }
-                catch {
-                    throw new ApiError({ code: 400, message: 'Invalid JSON provided in "vars"' });
-                }
-            }
-            const thevars = parsedVars;
-            /*
-        console.log('Headers:', apireq.req.headers);
-        console.log('Body:', JSON.stringify(apireq.req.body, null, 2));
-        console.log('Files:', JSON.stringify(apireq.req.files, null, 2));
-        */
+            const fields = filterSubmissionFields(parsedInput.fields, form.allowed_fields);
+            const clientIp = apireq.getClientIp() ?? '';
+            await enforceCaptchaPolicy({ vars: env, form, captchaToken, clientIp });
+            const resolvedRecipients = await resolveRecipients(form, recipientsRaw);
+            const recipients = parseIdnameList(recipientsRaw, 'recipients');
+            const { rcptEmail, rcptName, rcptIdname, rcptIdnames } = getPrimaryRecipientInfo(form, resolvedRecipients);
             const domainRecord = await api_domain.findOne({ where: { domain_id: form.domain_id } });
             await this.server.storage.relocateUploads(domainRecord?.name ?? null, rawFiles);
-            const attachments = rawFiles.map((file) => ({
-                filename: file.originalname,
-                path: file.path
+            const { attachments, attachmentMap } = buildAttachments(rawFiles);
+            // Attach inline template assets (cid:...) so clients can render embedded images reliably.
+            // Linked assets (asset('...') without inline flag) are kept as URLs and are not attached here.
+            const templateFiles = Array.isArray(form.files) ? form.files : [];
+            const inlineTemplateAttachments = templateFiles
+                .filter((file) => Boolean(file && file.cid))
+                .map((file) => ({
+                filename: file.filename,
+                path: file.path,
+                cid: file.cid
             }));
-            const attachmentMap = {};
-            for (const file of rawFiles) {
-                attachmentMap[file.fieldname] = file.originalname;
-            }
+            const allAttachments = [...inlineTemplateAttachments, ...attachments];
             const meta = buildRequestMeta(apireq.req);
-            const mappedEmailAddress = resolvedRecipient ? this.validateEmail(resolvedRecipient.email) : undefined;
-            if (resolvedRecipient && !mappedEmailAddress) {
-                throw new ApiError({ code: 500, message: 'Recipient mapping has an invalid email address' });
-            }
-            const mappedName = resolvedRecipient?.name ? String(resolvedRecipient.name).trim().slice(0, 200) : '';
-            if (mappedName && /[\r\n]/.test(mappedName)) {
-                throw new ApiError({ code: 500, message: 'Recipient mapping has an invalid name' });
-            }
-            const to = resolvedRecipient
-                ? mappedName
-                    ? { name: mappedName, address: mappedEmailAddress }
-                    : mappedEmailAddress
-                : normalizedRecipient || form.recipient;
-            const rcptEmailForTemplate = resolvedRecipient
-                ? mappedEmailAddress
-                : normalizedRecipient || form.recipient;
-            const context = {
-                ...thevars,
-                _rcpt_email_: rcptEmailForTemplate,
-                _rcpt_name_: mappedName,
-                _rcpt_idname_: recipientIdname,
-                _attachments_: attachmentMap,
-                _vars_: thevars,
-                _fields_: apireq.req.body,
-                _files_: rawFiles,
-                _meta_: meta
-            };
-            nunjucks.configure({ autoescape: this.server.storage.env.AUTOESCAPE_HTML });
+            const to = buildRecipientTo(form, resolvedRecipients);
+            const replyToValue = buildReplyToValue(form, fields);
+            const context = buildSubmissionContext({
+                form_key,
+                localeRaw,
+                recipients,
+                rcptEmail,
+                rcptName,
+                rcptIdname,
+                rcptIdnames,
+                attachmentMap,
+                fields,
+                files: rawFiles,
+                meta
+            });
+            nunjucks.configure({ autoescape: this.server.storage.vars.AUTOESCAPE_HTML });
             const html = nunjucks.renderString(form.template, context);
             const mailOptions = {
                 from: form.sender,
                 to,
                 subject: form.subject,
                 html,
-                attachments,
-                ...(normalizedReplyTo ? { replyTo: normalizedReplyTo } : {})
+                attachments: allAttachments,
+                ...(replyToValue ? { replyTo: replyToValue } : {})
             };
             try {
                 const info = await this.server.storage.transport.sendMail(mailOptions);

package/dist/api/mailer.js

@@ -166,7 +166,7 @@ export class MailerAPI extends ApiModule {
             }
         }
         try {
-            const env = new nunjucks.Environment(null, { autoescape: this.server.storage.env.AUTOESCAPE_HTML });
+            const env = new nunjucks.Environment(null, { autoescape: this.server.storage.vars.AUTOESCAPE_HTML });
             const compiled = nunjucks.compile(template.template, env);
             for (const recipient of valid) {
                 const fullargs = {

package/dist/bin/mail-magic.js

@@ -50,9 +50,9 @@ if (result.error) {
 }
 async function main() {
     try {
-        const { store, env } = await startMailMagicServer();
+        const { store, vars } = await startMailMagicServer();
         console.log(`Using config path: ${store.configpath}`);
-        console.log(`mail-magic server listening on ${env.API_HOST}:${env.API_PORT}`);
+        console.log(`mail-magic server listening on ${vars.API_HOST}:${vars.API_PORT}`);
     }
     catch (error) {
         console.error('Failed to start mail-magic server');