@technomoron/mail-magic 1.0.4

package/dist/api/forms.js

@@ -0,0 +1,175 @@
+import path from 'path';
+import { ApiModule, ApiError } from '@technomoron/api-server-base';
+import nunjucks from 'nunjucks';
+import { api_domain } from '../models/domain.js';
+import { api_form } from '../models/form.js';
+import { api_user } from '../models/user.js';
+import { buildRequestMeta, normalizeSlug } from '../util.js';
+export class FormAPI extends ApiModule {
+    async assertDomainAndUser(apireq) {
+        const { domain, locale } = apireq.req.body;
+        if (!domain) {
+            throw new ApiError({ code: 401, message: 'Missing domain' });
+        }
+        const user = await api_user.findOne({ where: { token: apireq.token } });
+        if (!user) {
+            throw new ApiError({ code: 401, message: `Invalid/Unknown API Key/Token '${apireq.token}'` });
+        }
+        const dbdomain = await api_domain.findOne({ where: { name: domain } });
+        if (!dbdomain) {
+            throw new ApiError({ code: 401, message: `Unable to look up the domain ${domain}` });
+        }
+        apireq.domain = dbdomain;
+        apireq.locale = locale || 'en';
+        apireq.user = user;
+    }
+    async postFormTemplate(apireq) {
+        await this.assertDomainAndUser(apireq);
+        const { template, sender = '', recipient = '', idname, subject = '', locale = '', secret = '' } = apireq.req.body;
+        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 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 = [userSlug, domainSlug, 'form-template'];
+        if (localeSlug) {
+            filenameParts.push(localeSlug);
+        }
+        filenameParts.push(formSlug);
+        let filename = path.join(...filenameParts);
+        if (!filename.endsWith('.njk')) {
+            filename += '.njk';
+        }
+        const record = {
+            user_id: user.user_id,
+            domain_id: domain.domain_id,
+            locale: localeSlug,
+            idname,
+            sender,
+            recipient,
+            subject,
+            template,
+            slug,
+            filename,
+            secret,
+            files: []
+        };
+        try {
+            const [form, created] = await api_form.upsert(record, {
+                returning: true,
+                conflictFields: ['user_id', 'domain_id', 'locale', 'idname']
+            });
+            this.server.storage.print_debug(`Form template upserted: ${form.idname} (created=${created})`);
+        }
+        catch (error) {
+            throw new ApiError({
+                code: 500,
+                message: this.server.guessExceptionText(error, 'Unknown Sequelize Error on upsert form template')
+            });
+        }
+        return [200, { Status: 'OK' }];
+    }
+    async postSendForm(apireq) {
+        const { formid, secret, recipient, vars = {} } = apireq.req.body;
+        if (!formid) {
+            throw new ApiError({ code: 404, message: 'Missing formid field in form' });
+        }
+        const form = await api_form.findOne({ where: { idname: formid } });
+        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' });
+        }
+        if (recipient && !form.secret) {
+            throw new ApiError({ code: 401, message: "'recipient' parameterer requires form secret to be set" });
+        }
+        let parsedVars = vars ?? {};
+        if (typeof vars === 'string') {
+            try {
+                parsedVars = JSON.parse(vars);
+            }
+            catch (error) {
+                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 rawFiles = Array.isArray(apireq.req.files) ? apireq.req.files : [];
+        const attachments = rawFiles.map((file) => ({
+            filename: file.originalname,
+            path: file.path
+        }));
+        const attachmentMap = {};
+        for (const file of rawFiles) {
+            attachmentMap[file.fieldname] = file.originalname;
+        }
+        const meta = buildRequestMeta(apireq.req);
+        const context = {
+            ...thevars,
+            _rcpt_email_: recipient,
+            _attachments_: attachmentMap,
+            _vars_: thevars,
+            _fields_: apireq.req.body,
+            _files_: rawFiles,
+            _meta_: meta
+        };
+        nunjucks.configure({ autoescape: true });
+        const html = nunjucks.renderString(form.template, context);
+        const mailOptions = {
+            from: form.sender,
+            to: recipient || form.recipient,
+            subject: form.subject,
+            html,
+            attachments
+        };
+        try {
+            const info = await this.server.storage.transport.sendMail(mailOptions);
+            this.server.storage.print_debug('Email sent: ' + info.response);
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            this.server.storage.print_debug('Error sending email: ' + errorMessage);
+            return [500, { error: `Error sending email: ${errorMessage}` }];
+        }
+        return [200, {}];
+    }
+    defineRoutes() {
+        return [
+            {
+                method: 'post',
+                path: '/v1/form/template',
+                handler: (req) => this.postFormTemplate(req),
+                auth: { type: 'yes', req: 'any' }
+            },
+            {
+                method: 'post',
+                path: '/v1/form/message',
+                handler: (req) => this.postSendForm(req),
+                auth: { type: 'none', req: 'any' }
+            }
+        ];
+    }
+}

package/dist/api/mailer.js

@@ -0,0 +1,213 @@
+import { ApiModule, ApiError } from '@technomoron/api-server-base';
+import emailAddresses from 'email-addresses';
+import { convert } from 'html-to-text';
+import nunjucks from 'nunjucks';
+import { api_domain } from '../models/domain.js';
+import { api_txmail } from '../models/txmail.js';
+import { api_user } from '../models/user.js';
+import { buildRequestMeta } from '../util.js';
+export class MailerAPI extends ApiModule {
+    //
+    // Validate and return the parsed email address
+    //
+    validateEmail(email) {
+        const parsed = emailAddresses.parseOneAddress(email);
+        if (parsed) {
+            return parsed.address;
+        }
+        return null;
+    }
+    //
+    // Validate a set of email addresses. Return arrays of invalid
+    // and valid email addresses.
+    //
+    validateEmails(list) {
+        const valid = [], invalid = [];
+        const emails = list
+            .split(',')
+            .map((email) => email.trim())
+            .filter((email) => email !== '');
+        emails.forEach((email) => {
+            const addr = this.validateEmail(email);
+            if (addr) {
+                valid.push(addr);
+            }
+            else {
+                invalid.push(email);
+            }
+        });
+        return { valid, invalid };
+    }
+    async assert_domain_and_user(apireq) {
+        const { domain, locale } = apireq.req.body;
+        if (!domain) {
+            throw new ApiError({ code: 401, message: 'Missing domain' });
+        }
+        const user = await api_user.findOne({ where: { token: apireq.token } });
+        if (!user) {
+            throw new ApiError({ code: 401, message: `Invalid/Unknown API Key/Token '${apireq.token}'` });
+        }
+        const dbdomain = await api_domain.findOne({ where: { name: domain } });
+        if (!dbdomain) {
+            throw new ApiError({ code: 401, message: `Unable to look up the domain ${domain}` });
+        }
+        apireq.domain = dbdomain;
+        apireq.locale = locale || 'en';
+        apireq.user = user;
+    }
+    // Store a template in the database
+    async post_template(apireq) {
+        await this.assert_domain_and_user(apireq);
+        const { template, sender = '', name, subject = '', locale = '' } = apireq.req.body;
+        if (!template) {
+            throw new ApiError({ code: 400, message: 'Missing template data' });
+        }
+        if (!name) {
+            throw new ApiError({ code: 400, message: 'Missing template name' });
+        }
+        const data = {
+            user_id: apireq.user.user_id,
+            domain_id: apireq.domain.domain_id,
+            name,
+            subject,
+            locale,
+            sender,
+            template
+        };
+        /*
+        console.log(JSON.stringify({
+        user: apireq.user,
+        domain: apireq.domain,
+        domain_id: apireq.domain.domain_id,
+        data
+        }, undefined, 2)); */
+        try {
+            const [templateRecord, created] = await api_txmail.upsert(data, {
+                returning: true
+            });
+            console.log('Template upserted:', templateRecord.name, 'Created:', created);
+        }
+        catch (error) {
+            throw new ApiError({
+                code: 500,
+                message: this.server.guessExceptionText(error, 'Unknown Sequelize Error on upsert template')
+            });
+        }
+        return [200, { Status: 'OK' }];
+    }
+    // Send a template using posted arguments.
+    async post_send(apireq) {
+        await this.assert_domain_and_user(apireq);
+        const { name, rcpt, domain = '', locale = '', vars = {} } = apireq.req.body;
+        if (!name || !rcpt || !domain) {
+            throw new ApiError({ code: 400, message: 'name/rcpt/domain required' });
+        }
+        let parsedVars = vars ?? {};
+        if (typeof vars === 'string') {
+            try {
+                parsedVars = JSON.parse(vars);
+            }
+            catch (error) {
+                throw new ApiError({ code: 400, message: 'Invalid JSON provided in "vars"' });
+            }
+        }
+        const thevars = parsedVars;
+        // const dbdomain = await api_domain.findOne({ where: { domain } });
+        const { valid, invalid } = this.validateEmails(rcpt);
+        if (invalid.length > 0) {
+            throw new ApiError({ code: 400, message: 'Invalid email address(es): ' + invalid.join(',') });
+        }
+        let template = null;
+        const deflocale = apireq.server.store.deflocale || '';
+        const domain_id = apireq.domain.domain_id;
+        try {
+            template =
+                (await api_txmail.findOne({ where: { name, domain_id, locale } })) ||
+                    (await api_txmail.findOne({ where: { name, domain_id, locale: deflocale } })) ||
+                    (await api_txmail.findOne({ where: { name, domain_id } }));
+        }
+        catch (error) {
+            throw new ApiError({
+                code: 500,
+                message: this.server.guessExceptionText(error, 'Unknown Sequelize Error')
+            });
+        }
+        if (!template) {
+            throw new ApiError({
+                code: 404,
+                message: `Template "${name}" not found for any locale in domain "${domain}"`
+            });
+        }
+        const sender = template.sender || apireq.domain.sender || apireq.user.email;
+        if (!sender) {
+            throw new ApiError({ code: 500, message: `Unable to locate sender for ${template.name}` });
+        }
+        const rawFiles = Array.isArray(apireq.req.files) ? apireq.req.files : [];
+        const templateAssets = Array.isArray(template.files) ? template.files : [];
+        const attachments = [
+            ...templateAssets.map((file) => ({
+                filename: file.filename,
+                path: file.path,
+                cid: file.cid
+            })),
+            ...rawFiles.map((file) => ({
+                filename: file.originalname,
+                path: file.path
+            }))
+        ];
+        const attachmentMap = {};
+        for (const file of rawFiles) {
+            attachmentMap[file.fieldname] = file.originalname;
+        }
+        console.log(JSON.stringify({ vars, thevars }, undefined, 2));
+        const meta = buildRequestMeta(apireq.req);
+        try {
+            const env = new nunjucks.Environment(null, { autoescape: false });
+            const compiled = nunjucks.compile(template.template, env);
+            for (const recipient of valid) {
+                const fullargs = {
+                    ...thevars,
+                    _rcpt_email_: recipient,
+                    _attachments_: attachmentMap,
+                    _vars_: thevars,
+                    _meta_: meta
+                };
+                const html = await compiled.render(fullargs);
+                const text = convert(html);
+                const sendargs = {
+                    from: sender,
+                    to: recipient,
+                    subject: template.subject || apireq.req.body.subject || '',
+                    html,
+                    text,
+                    attachments
+                };
+                await apireq.server.storage.transport.sendMail(sendargs);
+            }
+            return [200, { Status: 'OK', Message: 'Emails sent successfully' }];
+        }
+        catch (error) {
+            // console.log(JSON.stringify(e, null, 2));
+            throw new ApiError({
+                code: 500,
+                message: error instanceof Error ? error.message : String(error)
+            });
+        }
+    }
+    defineRoutes() {
+        return [
+            {
+                method: 'post',
+                path: '/v1/tx/message',
+                handler: this.post_send.bind(this),
+                auth: { type: 'yes', req: 'any' }
+            },
+            {
+                method: 'post',
+                path: '/v1/tx/template',
+                handler: this.post_template.bind(this),
+                auth: { type: 'yes', req: 'any' }
+            }
+        ];
+    }
+}

package/dist/index.js

@@ -0,0 +1,50 @@
+import { pathToFileURL } from 'node:url';
+import { FormAPI } from './api/forms.js';
+import { MailerAPI } from './api/mailer.js';
+import { mailApiServer } from './server.js';
+import { mailStore } from './store/store.js';
+function buildServerConfig(store, overrides) {
+    const env = store.env;
+    return {
+        apiHost: env.API_HOST,
+        apiPort: env.API_PORT,
+        uploadPath: env.UPLOAD_PATH,
+        debug: env.DEBUG,
+        ...overrides
+    };
+}
+export async function createMailMagicServer(overrides = {}) {
+    const store = await new mailStore().init();
+    const config = buildServerConfig(store, overrides);
+    const server = new mailApiServer(config, store).api(new MailerAPI()).api(new FormAPI());
+    return { server, store, env: store.env };
+}
+export async function startMailMagicServer(overrides = {}) {
+    const bootstrap = await createMailMagicServer(overrides);
+    await bootstrap.server.start();
+    return bootstrap;
+}
+async function bootMailMagic() {
+    try {
+        const { env } = await startMailMagicServer();
+        console.log(`mail-magic server listening on ${env.API_HOST}:${env.API_PORT}`);
+    }
+    catch (err) {
+        console.error('Failed to start FormMailer:', err);
+        process.exit(1);
+    }
+}
+const isDirectExecution = (() => {
+    if (!process.argv[1]) {
+        return false;
+    }
+    try {
+        return import.meta.url === pathToFileURL(process.argv[1]).href;
+    }
+    catch {
+        return false;
+    }
+})();
+if (isDirectExecution) {
+    void bootMailMagic();
+}

package/dist/models/db.js

@@ -0,0 +1,99 @@
+import { Sequelize } from 'sequelize';
+import { init_api_domain, api_domain } from './domain.js';
+import { init_api_form, api_form } from './form.js';
+import { importData } from './init.js';
+import { init_api_txmail, api_txmail } from './txmail.js';
+import { init_api_user, api_user } from './user.js';
+export async function init_api_db(db, store) {
+    await init_api_user(db);
+    await init_api_domain(db);
+    await init_api_txmail(db);
+    await init_api_form(db);
+    // User ↔ Domain
+    api_user.hasMany(api_domain, {
+        foreignKey: 'user_id',
+        as: 'domains'
+    });
+    api_domain.belongsTo(api_user, {
+        foreignKey: 'user_id',
+        as: 'user'
+    });
+    // User ↔ Template
+    api_user.hasMany(api_txmail, {
+        foreignKey: 'user_id',
+        as: 'txmail'
+    });
+    api_txmail.belongsTo(api_user, {
+        foreignKey: 'user_id',
+        as: 'user'
+    });
+    // Domain ↔ Template
+    api_domain.hasMany(api_txmail, {
+        foreignKey: 'domain_id',
+        as: 'txmail'
+    });
+    api_txmail.belongsTo(api_domain, {
+        foreignKey: 'domain_id',
+        as: 'domain'
+    });
+    api_user.belongsTo(api_domain, {
+        foreignKey: 'domain',
+        as: 'defaultDomain'
+    });
+    api_domain.hasMany(api_user, {
+        foreignKey: 'domain',
+        as: 'usersWithDefault'
+    });
+    api_user.hasMany(api_form, {
+        foreignKey: 'user_id',
+        as: 'forms'
+    });
+    api_form.belongsTo(api_user, {
+        foreignKey: 'user_id',
+        as: 'user'
+    });
+    api_domain.hasMany(api_form, {
+        foreignKey: 'domain_id',
+        as: 'forms'
+    });
+    api_form.belongsTo(api_domain, {
+        foreignKey: 'domain_id',
+        as: 'domain'
+    });
+    await db.query('PRAGMA foreign_keys = OFF');
+    store.print_debug(`Force alter tables: ${store.env.DB_FORCE_SYNC}`);
+    await db.sync({ alter: true, force: store.env.DB_FORCE_SYNC });
+    await db.query('PRAGMA foreign_keys = ON');
+    await importData(store);
+    store.print_debug('API Database Initialized...');
+}
+export async function connect_api_db(store) {
+    console.log('DB INIT');
+    const env = store.env;
+    const dbparams = {
+        logging: false, // env.DB_LOG ? console.log : false,
+        dialect: env.DB_TYPE,
+        dialectOptions: {
+            charset: 'utf8mb4'
+        },
+        define: {
+            charset: 'utf8mb4',
+            collate: 'utf8mb4_unicode_ci'
+        }
+    };
+    if (env.DB_TYPE === 'sqlite') {
+        dbparams.storage = env.DB_NAME.endsWith('.db') ? env.DB_NAME : `${env.DB_NAME}.db`;
+    }
+    else {
+        dbparams.host = env.DB_HOST;
+        dbparams.database = env.DB_NAME;
+        dbparams.username = env.DB_USER;
+        dbparams.password = env.DB_PASS;
+    }
+    store.print_debug(`Database params are:\n${JSON.stringify(dbparams, undefined, 2)}`);
+    const db = new Sequelize(dbparams);
+    await db.authenticate();
+    store.print_debug('API Database Connected');
+    await init_api_db(db, store);
+    return db;
+}

package/dist/models/domain.js

@@ -0,0 +1,58 @@
+import { Model, DataTypes } from 'sequelize';
+import { z } from 'zod';
+export const api_domain_schema = z.object({
+    domain_id: z.number().int().nonnegative(),
+    user_id: z.number().int().nonnegative(),
+    name: z.string().min(1),
+    sender: z.string().default(''),
+    locale: z.string().default(''),
+    is_default: z.boolean().default(false)
+});
+export class api_domain extends Model {
+}
+export async function init_api_domain(api_db) {
+    api_domain.init({
+        domain_id: {
+            type: DataTypes.INTEGER,
+            autoIncrement: true,
+            allowNull: false,
+            primaryKey: true
+        },
+        user_id: {
+            type: DataTypes.INTEGER,
+            allowNull: false,
+            references: {
+                model: 'user',
+                key: 'user_id'
+            },
+            onDelete: 'CASCADE',
+            onUpdate: 'CASCADE'
+        },
+        name: {
+            type: DataTypes.STRING,
+            allowNull: false,
+            defaultValue: ''
+        },
+        sender: {
+            type: DataTypes.STRING,
+            allowNull: false,
+            defaultValue: ''
+        },
+        locale: {
+            type: DataTypes.STRING,
+            allowNull: false,
+            defaultValue: ''
+        },
+        is_default: {
+            type: DataTypes.BOOLEAN,
+            allowNull: false,
+            defaultValue: false
+        }
+    }, {
+        sequelize: api_db,
+        tableName: 'domain',
+        charset: 'utf8mb4',
+        collate: 'utf8mb4_unicode_ci'
+    });
+    return api_domain;
+}