@technomoron/mail-magic 1.0.4

package/src/api/forms.ts

@@ -0,0 +1,209 @@
+import path from 'path';
+
+import { ApiRoute, ApiRequest, 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 { mailApiServer } from '../server.js';
+import { buildRequestMeta, normalizeSlug } from '../util.js';
+
+import type { mailApiRequest, UploadedFile } from '../types.js';
+
+export class FormAPI extends ApiModule<mailApiServer> {
+	private async assertDomainAndUser(apireq: mailApiRequest): Promise<void> {
+		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;
+	}
+
+	private async postFormTemplate(apireq: mailApiRequest): Promise<[number, { Status: string }]> {
+		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: unknown) {
+			throw new ApiError({
+				code: 500,
+				message: this.server!.guessExceptionText(error, 'Unknown Sequelize Error on upsert form template')
+			});
+		}
+
+		return [200, { Status: 'OK' }];
+	}
+
+	private async postSendForm(apireq: ApiRequest): Promise<[number, Record<string, unknown>]> {
+		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: unknown = 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 as Record<string, unknown>;
+
+		/*
+		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 as UploadedFile[]) : [];
+		const attachments = rawFiles.map((file) => ({
+			filename: file.originalname,
+			path: file.path
+		}));
+
+		const attachmentMap: Record<string, string> = {};
+		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, {}];
+	}
+
+	override defineRoutes(): ApiRoute[] {
+		return [
+			{
+				method: 'post',
+				path: '/v1/form/template',
+				handler: (req) => this.postFormTemplate(req as mailApiRequest),
+				auth: { type: 'yes', req: 'any' }
+			},
+			{
+				method: 'post',
+				path: '/v1/form/message',
+				handler: (req) => this.postSendForm(req),
+				auth: { type: 'none', req: 'any' }
+			}
+		];
+	}
+}

package/src/api/mailer.ts

@@ -0,0 +1,242 @@
+import { ApiModule, ApiRoute, ApiError } from '@technomoron/api-server-base';
+import emailAddresses, { ParsedMailbox } 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 { mailApiServer } from '../server.js';
+import { buildRequestMeta } from '../util.js';
+
+import type { mailApiRequest, UploadedFile } from '../types.js';
+
+export class MailerAPI extends ApiModule<mailApiServer> {
+	//
+	// Validate and return the parsed email address
+	//
+	validateEmail(email: string): string | null {
+		const parsed = emailAddresses.parseOneAddress(email);
+		if (parsed) {
+			return (parsed as ParsedMailbox).address;
+		}
+		return null;
+	}
+
+	//
+	// Validate a set of email addresses. Return arrays of invalid
+	// and valid email addresses.
+	//
+
+	validateEmails(list: string): { valid: string[]; invalid: string[] } {
+		const valid = [] as string[],
+			invalid = [] as string[];
+
+		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: mailApiRequest) {
+		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
+
+	private async post_template(apireq: mailApiRequest): Promise<[number, { Status: string }]> {
+		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: unknown) {
+			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.
+
+	private async post_send(apireq: mailApiRequest): Promise<[number, Record<string, unknown>]> {
+		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: unknown = 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 as Record<string, unknown>;
+
+		// 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: api_txmail | null = 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: unknown) {
+			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 as UploadedFile[]) : [];
+		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: Record<string, string> = {};
+		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: unknown) {
+			// console.log(JSON.stringify(e, null, 2));
+			throw new ApiError({
+				code: 500,
+				message: error instanceof Error ? error.message : String(error)
+			});
+		}
+	}
+
+	override defineRoutes(): ApiRoute[] {
+		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/src/index.ts

@@ -0,0 +1,67 @@
+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';
+
+import type { ApiServerConf } from '@technomoron/api-server-base';
+
+export type MailMagicServerOptions = Partial<ApiServerConf>;
+
+export type MailMagicServerBootstrap = {
+	server: mailApiServer;
+	store: mailStore;
+	env: mailStore['env'];
+};
+
+function buildServerConfig(store: mailStore, overrides: MailMagicServerOptions): MailMagicServerOptions {
+	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: MailMagicServerOptions = {}): Promise<MailMagicServerBootstrap> {
+	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: MailMagicServerOptions = {}): Promise<MailMagicServerBootstrap> {
+	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/src/models/db.ts

@@ -0,0 +1,112 @@
+import { Sequelize } from 'sequelize';
+
+import { mailStore } from './../store/store.js';
+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';
+
+import type { Dialect, Options } from 'sequelize';
+
+export async function init_api_db(db: Sequelize, store: mailStore) {
+	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: mailStore): Promise<Sequelize> {
+	console.log('DB INIT');
+
+	const env = store.env;
+	const dbparams: Options = {
+		logging: false, // env.DB_LOG ? console.log : false,
+		dialect: env.DB_TYPE as Dialect,
+		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/src/models/domain.ts

@@ -0,0 +1,72 @@
+import { Sequelize, 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 type api_domain_type = z.infer<typeof api_domain_schema>;
+
+export class api_domain extends Model {
+	declare domain_id: number;
+	declare user_id: number;
+	declare name: string;
+	declare sender: string;
+	declare locale: string;
+	declare is_default: boolean;
+}
+
+export async function init_api_domain(api_db: Sequelize): Promise<typeof api_domain> {
+	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;
+}