@technomoron/mail-magic 1.0.4

package/src/models/form.ts

@@ -0,0 +1,198 @@
+import path from 'path';
+
+import { Sequelize, Model, DataTypes } from 'sequelize';
+import { z } from 'zod';
+
+import { StoredFile } from '../types.js';
+import { user_and_domain, normalizeSlug } from '../util.js';
+
+export const api_form_schema = z.object({
+	form_id: z.number().int().nonnegative(),
+	user_id: z.number().int().nonnegative(),
+	domain_id: z.number().int().nonnegative(),
+	locale: z.string().default(''),
+	idname: z.string().min(1),
+	sender: z.string().min(1),
+	recipient: z.string().min(1),
+	subject: z.string(),
+	template: z.string().default(''),
+	filename: z.string().default(''),
+	slug: z.string().default(''),
+	secret: z.string().default(''),
+	files: z
+		.array(
+			z.object({
+				filename: z.string(),
+				path: z.string(),
+				cid: z.string().optional()
+			})
+		)
+		.default([])
+});
+
+export type api_form_type = z.infer<typeof api_form_schema>;
+
+export class api_form extends Model {
+	declare form_id: number;
+	declare user_id: number;
+	declare domain_id: number;
+	declare locale: string;
+	declare idname: string;
+	declare sender: string;
+	declare recipient: string;
+	declare subject: string;
+	declare template: string;
+	declare filename: string;
+	declare slug: string;
+	declare secret: string;
+	declare files: StoredFile[];
+}
+
+export async function init_api_form(api_db: Sequelize): Promise<typeof api_form> {
+	api_form.init(
+		{
+			form_id: {
+				type: DataTypes.INTEGER,
+				autoIncrement: true,
+				allowNull: false,
+				primaryKey: true
+			},
+			user_id: {
+				type: DataTypes.INTEGER,
+				allowNull: false,
+				unique: false,
+				references: {
+					model: 'user',
+					key: 'user_id'
+				},
+				onDelete: 'CASCADE',
+				onUpdate: 'CASCADE'
+			},
+			domain_id: {
+				type: DataTypes.INTEGER,
+				allowNull: false,
+				unique: false,
+				references: {
+					model: 'domain',
+					key: 'domain_id'
+				},
+				onDelete: 'CASCADE',
+				onUpdate: 'CASCADE'
+			},
+			locale: {
+				type: DataTypes.STRING,
+				allowNull: false,
+				defaultValue: '',
+				unique: false
+			},
+			idname: {
+				type: DataTypes.STRING,
+				allowNull: false,
+				unique: false,
+				defaultValue: ''
+			},
+			sender: {
+				type: DataTypes.STRING,
+				allowNull: false,
+				defaultValue: ''
+			},
+			recipient: {
+				type: DataTypes.STRING,
+				allowNull: false,
+				defaultValue: ''
+			},
+			subject: {
+				type: DataTypes.STRING,
+				allowNull: false,
+				defaultValue: ''
+			},
+			filename: {
+				type: DataTypes.STRING,
+				allowNull: false,
+				defaultValue: ''
+			},
+			template: {
+				type: DataTypes.TEXT,
+				allowNull: false,
+				defaultValue: ''
+			},
+			slug: {
+				type: DataTypes.STRING,
+				allowNull: false,
+				defaultValue: ''
+			},
+			secret: {
+				type: DataTypes.STRING,
+				allowNull: false,
+				defaultValue: ''
+			},
+			files: {
+				type: DataTypes.TEXT,
+				allowNull: false,
+				defaultValue: '[]',
+				get() {
+					const raw = this.getDataValue('files') as string | null;
+					return raw ? (JSON.parse(raw) as StoredFile[]) : [];
+				},
+				set(value: StoredFile[] | null | undefined) {
+					this.setDataValue('files', JSON.stringify(value ?? []));
+				}
+			}
+		},
+		{
+			sequelize: api_db,
+			tableName: 'form',
+			charset: 'utf8mb4',
+			collate: 'utf8mb4_unicode_ci',
+			indexes: [
+				{
+					unique: true,
+					fields: ['user_id', 'domain_id', 'locale', 'idname']
+				}
+			]
+		}
+	);
+
+	return api_form;
+}
+
+export async function upsert_form(record: api_form_type): Promise<api_form> {
+	const { user, domain } = await user_and_domain(record.domain_id);
+
+	const idname = normalizeSlug(user.idname);
+	const dname = normalizeSlug(domain.name);
+	const name = normalizeSlug(record.idname);
+	const locale = normalizeSlug(record.locale || domain.locale || user.locale || '');
+
+	if (!record.slug) {
+		record.slug = `${idname}-${dname}${locale ? '-' + locale : ''}-${name}`;
+	}
+
+	if (!record.filename) {
+		const parts = [idname, dname, 'form-template'];
+		if (locale) parts.push(locale);
+		parts.push(name);
+		record.filename = path.join(...parts);
+	} else {
+		record.filename = path.join(idname, dname, 'form-template', record.filename);
+	}
+	if (!record.filename.endsWith('.njk')) {
+		record.filename += '.njk';
+	}
+	record.filename = path.normalize(record.filename);
+
+	let instance: api_form | null = null;
+	instance = await api_form.findByPk(record.form_id);
+	if (instance) {
+		await instance.update(record);
+	} else {
+		console.log('CREATE', JSON.stringify(record, undefined, 2));
+
+		instance = await api_form.create(record);
+		console.log(`INSTANCE IS ${instance}`);
+	}
+	if (!instance) {
+		throw new Error(`Unable to update/create form ${record.form_id}`);
+	}
+	return instance;
+}

package/src/models/init.ts

@@ -0,0 +1,237 @@
+import fs from 'fs';
+import path from 'path';
+
+import { Unyuck } from '@technomoron/unyuck';
+import { z } from 'zod';
+
+import { mailStore } from '../store/store.js';
+import { StoredFile } from '../types.js';
+import { user_and_domain } from '../util.js';
+
+import { api_domain, api_domain_schema } from './domain.js';
+import { api_form_schema, api_form_type, upsert_form } from './form.js';
+import { api_txmail_schema, api_txmail_type, upsert_txmail } from './txmail.js';
+import { api_user, api_user_schema } from './user.js';
+
+interface LoadedTemplate {
+	html: string;
+	assets: StoredFile[];
+}
+
+const init_data_schema = z.object({
+	user: z.array(api_user_schema).default([]),
+	domain: z.array(api_domain_schema).default([]),
+	template: z.array(api_txmail_schema).default([]),
+	form: z.array(api_form_schema).default([])
+});
+
+type InitData = z.infer<typeof init_data_schema>;
+
+/**
+ * Resolve an asset file within ./config/<userid>/<domain>/<type>/assets
+ */
+function resolveAsset(
+	basePath: string,
+	type: 'form-template' | 'tx-template',
+	domainName: string,
+	assetName: string,
+	locale?: string | null
+): string | null {
+	const searchPaths: string[] = [];
+
+	// always domain-scoped
+	if (locale) {
+		searchPaths.push(path.join(domainName, type, locale));
+	}
+	searchPaths.push(path.join(domainName, type));
+
+	// no domain fallback → do not leak assets between domains
+	// but allow locale fallbacks inside type
+	if (locale) {
+		searchPaths.push(path.join(type, locale));
+	}
+	searchPaths.push(type);
+
+	for (const p of searchPaths) {
+		const candidate = path.join(basePath, p, 'assets', assetName);
+		if (fs.existsSync(candidate)) {
+			return candidate;
+		}
+	}
+	return null;
+}
+
+function extractAndReplaceAssets(
+	html: string,
+	opts: {
+		basePath: string;
+		type: 'form-template' | 'tx-template';
+		domainName: string;
+		locale?: string | null;
+		apiUrl: string;
+		idname: string;
+	}
+): { html: string; assets: StoredFile[] } {
+	const regex = /src=["']asset\(['"]([^'"]+)['"](?:,\s*(true|false|[01]))?\)["']/g;
+
+	const assets: StoredFile[] = [];
+
+	const replacedHtml = html.replace(regex, (_m, relPath: string, inlineFlag?: string) => {
+		const fullPath = resolveAsset(opts.basePath, opts.type, opts.domainName, relPath, opts.locale ?? undefined);
+		if (!fullPath) {
+			throw new Error(`Missing asset "${relPath}"`);
+		}
+
+		const isInline = inlineFlag === 'true' || inlineFlag === '1';
+		const storedFile: StoredFile = {
+			filename: relPath,
+			path: fullPath,
+			cid: isInline ? relPath : undefined
+		};
+
+		assets.push(storedFile);
+
+		return isInline
+			? `src="cid:${relPath}"`
+			: `src="${opts.apiUrl}/image/${opts.idname}/${opts.type}/` +
+					`${opts.domainName ? opts.domainName + '/' : ''}` +
+					`${opts.locale ? opts.locale + '/' : ''}` +
+					relPath +
+					'"';
+	});
+
+	return { html: replacedHtml, assets };
+}
+
+async function _load_template(
+	store: mailStore,
+	filename: string,
+	pathname: string,
+	user: api_user,
+	domain: api_domain,
+	locale: string | null,
+	type: 'form-template' | 'tx-template'
+): Promise<LoadedTemplate> {
+	const rootDir = path.join(store.configpath, user.idname, domain.name, type);
+
+	let relFile = filename;
+	const prefix = path.join(user.idname, domain.name, type) + path.sep;
+	if (filename.startsWith(prefix)) {
+		relFile = filename.slice(prefix.length);
+	}
+
+	const absPath = path.resolve(rootDir, pathname || '', relFile);
+
+	if (!absPath.startsWith(rootDir)) {
+		throw new Error(`Invalid template path "${filename}"`);
+	}
+	if (!fs.existsSync(absPath)) {
+		throw new Error(`Missing template file "${absPath}"`);
+	}
+
+	const raw = fs.readFileSync(absPath, 'utf8');
+	if (!raw.trim()) {
+		throw new Error(`Template file "${absPath}" is empty`);
+	}
+
+	try {
+		const baseUserPath = path.join(store.configpath, user.idname);
+		const templateKey = path.relative(baseUserPath, absPath);
+		if (!templateKey) {
+			throw new Error(`Unable to resolve template path for "${absPath}"`);
+		}
+
+		const processor = new Unyuck({ basePath: baseUserPath });
+		const merged = processor.flattenNoAssets(templateKey);
+
+		const { html, assets } = extractAndReplaceAssets(merged, {
+			basePath: path.join(store.configpath, user.idname),
+			type,
+			domainName: domain.name,
+			locale,
+			apiUrl: store.env.API_URL,
+			idname: user.idname
+		});
+
+		return { html, assets };
+	} catch (err) {
+		throw new Error(`Template "${absPath}" failed to preprocess: ${(err as Error).message}`);
+	}
+}
+export async function loadFormTemplate(store: mailStore, form: api_form_type): Promise<LoadedTemplate> {
+	const { user, domain } = await user_and_domain(form.domain_id);
+	const locale = form.locale || domain.locale || user.locale || null;
+
+	return _load_template(store, form.filename, '', user, domain, locale, 'form-template');
+}
+
+export async function loadTxTemplate(store: mailStore, template: api_txmail_type): Promise<LoadedTemplate> {
+	const { user, domain } = await user_and_domain(template.domain_id);
+	const locale = template.locale || domain.locale || user.locale || null;
+
+	return _load_template(store, template.filename, '', user, domain, locale, 'tx-template');
+}
+
+export async function importData(store: mailStore) {
+	const initfile = path.join(store.configpath, 'init-data.json');
+	if (fs.existsSync(initfile)) {
+		store.print_debug(`Loading init data from ${initfile}`);
+		const data = await fs.promises.readFile(initfile, 'utf8');
+
+		let records: InitData;
+		try {
+			records = init_data_schema.parse(JSON.parse(data));
+		} catch (err) {
+			store.print_debug(`Invalid init-data.json: ${err}`);
+			return;
+		}
+
+		const pendingUserDomains: Array<{ user_id: number; domain: number }> = [];
+		if (records.user) {
+			store.print_debug('Creating user records');
+			for (const record of records.user) {
+				const { domain, ...userWithoutDomain } = record;
+
+				await api_user.upsert({ ...userWithoutDomain, domain: null });
+				if (typeof domain === 'number') {
+					pendingUserDomains.push({ user_id: record.user_id, domain });
+				}
+			}
+		}
+		if (records.domain) {
+			store.print_debug('Creating domain records');
+			for (const record of records.domain) {
+				await api_domain.upsert(record);
+			}
+		}
+		if (pendingUserDomains.length) {
+			store.print_debug('Linking user default domains');
+			for (const entry of pendingUserDomains) {
+				await api_user.update({ domain: entry.domain }, { where: { user_id: entry.user_id } });
+			}
+		}
+		if (records.template) {
+			store.print_debug('Creating template records');
+			for (const record of records.template) {
+				const fixed = await upsert_txmail(record);
+				if (!fixed.template) {
+					const { html, assets } = await loadTxTemplate(store, fixed);
+					await fixed.update({ template: html, files: assets });
+				}
+			}
+		}
+		if (records.form) {
+			store.print_debug('Creating form records');
+			for (const record of records.form) {
+				const fixed = await upsert_form(record);
+				if (!fixed.template) {
+					const { html, assets } = await loadFormTemplate(store, fixed);
+					await fixed.update({ template: html, files: assets });
+				}
+			}
+		}
+		store.print_debug('Initdata upserted successfully.');
+	} else {
+		store.print_debug(`No init data file, tried ${initfile}`);
+	}
+}

package/src/models/txmail.ts

@@ -0,0 +1,199 @@
+import path from 'path';
+
+import { Sequelize, Model, DataTypes } from 'sequelize';
+import { z } from 'zod';
+
+import { StoredFile } from '../types.js';
+import { user_and_domain, normalizeSlug } from '../util.js';
+
+export const api_txmail_schema = z.object({
+	template_id: z.number().int().nonnegative(),
+	user_id: z.number().int().nonnegative(),
+	domain_id: z.number().int().nonnegative(),
+	name: z.string().min(1),
+	locale: z.string().default(''),
+	template: z.string().default(''),
+	filename: z.string().default(''),
+	sender: z.string().min(1),
+	subject: z.string(),
+	slug: z.string().default(''),
+	files: z
+		.array(
+			z.object({
+				filename: z.string(),
+				path: z.string(),
+				cid: z.string().optional()
+			})
+		)
+		.default([])
+});
+
+export type api_txmail_type = z.infer<typeof api_txmail_schema>;
+export class api_txmail extends Model {
+	declare template_id: number;
+	declare user_id: number;
+	declare domain_id: number;
+	declare name: string;
+	declare locale: string;
+	declare template: string;
+	declare filename: string;
+	declare sender: string;
+	declare subject: string;
+	declare slug: string;
+	declare files: StoredFile[];
+}
+
+export async function upsert_txmail(record: api_txmail_type): Promise<api_txmail> {
+	const { user, domain } = await user_and_domain(record.domain_id);
+
+	const idname = normalizeSlug(user.idname);
+	const dname = normalizeSlug(domain.name);
+	const name = normalizeSlug(record.name);
+	const locale = normalizeSlug(record.locale || domain.locale || user.locale || '');
+
+	if (!record.slug) {
+		record.slug = `${idname}-${dname}${locale ? '-' + locale : ''}-${name}`;
+	}
+
+	if (!record.filename) {
+		const parts = [idname, dname, 'tx-template'];
+		if (locale) parts.push(locale);
+		parts.push(name);
+		record.filename = path.join(...parts);
+	} else {
+		record.filename = path.join(idname, dname, 'tx-template', record.filename);
+	}
+	if (!record.filename.endsWith('.njk')) {
+		record.filename += '.njk';
+	}
+	record.filename = path.normalize(record.filename);
+
+	const [instance] = await api_txmail.upsert(record);
+	return instance;
+}
+
+export async function init_api_txmail(api_db: Sequelize): Promise<typeof api_txmail> {
+	api_txmail.init(
+		{
+			template_id: {
+				type: DataTypes.INTEGER,
+				autoIncrement: true,
+				allowNull: false,
+				primaryKey: true
+			},
+			user_id: {
+				type: DataTypes.INTEGER,
+				allowNull: false,
+				unique: false,
+				references: {
+					model: 'user',
+					key: 'user_id'
+				},
+				onDelete: 'CASCADE',
+				onUpdate: 'CASCADE'
+			},
+			domain_id: {
+				type: DataTypes.INTEGER,
+				allowNull: false,
+				unique: false,
+				references: {
+					model: 'domain',
+					key: 'domain_id'
+				},
+				onDelete: 'CASCADE',
+				onUpdate: 'CASCADE'
+			},
+			name: {
+				type: DataTypes.STRING,
+				allowNull: false,
+				unique: false
+			},
+			locale: {
+				type: DataTypes.STRING,
+				allowNull: false,
+				defaultValue: '',
+				unique: false
+			},
+			template: {
+				type: DataTypes.STRING,
+				allowNull: false,
+				defaultValue: ''
+			},
+			filename: {
+				type: DataTypes.STRING,
+				allowNull: false,
+				defaultValue: ''
+			},
+			sender: {
+				type: DataTypes.STRING,
+				allowNull: false
+			},
+			subject: {
+				type: DataTypes.STRING,
+				allowNull: false,
+				defaultValue: ''
+			},
+			slug: {
+				type: DataTypes.STRING,
+				allowNull: false,
+				defaultValue: ''
+			},
+			part: {
+				type: DataTypes.BOOLEAN,
+				allowNull: false,
+				defaultValue: false
+			},
+			files: {
+				type: DataTypes.TEXT,
+				allowNull: false,
+				defaultValue: '[]',
+				get() {
+					const raw = this.getDataValue('files') as string | null;
+					return raw ? (JSON.parse(raw) as StoredFile[]) : [];
+				},
+				set(value: StoredFile[] | null | undefined) {
+					this.setDataValue('files', JSON.stringify(value ?? []));
+				}
+			}
+		},
+		{
+			sequelize: api_db,
+			tableName: 'txmail',
+			charset: 'utf8mb4',
+			collate: 'utf8mb4_unicode_ci',
+			indexes: [
+				{
+					unique: true,
+					fields: ['user_id', 'domain_id', 'locale', 'name']
+				}
+			]
+		}
+	);
+
+	api_txmail.addHook('beforeValidate', async (template: api_txmail) => {
+		const { user, domain } = await user_and_domain(template.domain_id);
+
+		console.log('HERE');
+
+		const idname = normalizeSlug(user.idname);
+		const dname = normalizeSlug(domain.name);
+		const name = normalizeSlug(template.name);
+		const locale = normalizeSlug(template.locale || domain.locale || user.locale || '');
+
+		template.slug ||= `${idname}-${dname}${locale ? '-' + locale : ''}-${name}`;
+
+		if (!template.filename) {
+			const parts = [idname, dname, 'tx-template'];
+			if (locale) parts.push(locale);
+			parts.push(name);
+			template.filename = parts.join('/');
+		}
+		if (!template.filename.endsWith('.njk')) {
+			template.filename += '.njk';
+		}
+
+		console.log(`FILENAME IS: ${template.filename}`);
+	});
+
+	return api_txmail;
+}

package/src/models/user.ts

@@ -0,0 +1,79 @@
+import { Sequelize, Model, DataTypes } from 'sequelize';
+import { z } from 'zod';
+
+export const api_user_schema = z.object({
+	user_id: z.number().int().nonnegative(),
+	idname: z.string().min(1),
+	token: z.string().min(1),
+	name: z.string().min(1),
+	email: z.string().email(),
+	domain: z.number().int().nonnegative().nullable().optional(),
+	locale: z.string().default('')
+});
+
+export type api_user_type = z.infer<typeof api_user_schema>;
+export class api_user extends Model {
+	declare user_id: number;
+	declare idname: string;
+	declare token: string;
+	declare name: string;
+	declare email: string;
+	declare domain: number;
+	declare locale: string;
+}
+
+export async function init_api_user(api_db: Sequelize): Promise<typeof api_user> {
+	await api_user.init(
+		{
+			user_id: {
+				type: DataTypes.INTEGER,
+				autoIncrement: true,
+				allowNull: false,
+				primaryKey: true
+			},
+			idname: {
+				type: DataTypes.STRING,
+				allowNull: false,
+				defaultValue: ''
+			},
+			token: {
+				type: DataTypes.STRING,
+				allowNull: false,
+				defaultValue: ''
+			},
+			name: {
+				type: DataTypes.STRING,
+				allowNull: false,
+				defaultValue: ''
+			},
+			email: {
+				type: DataTypes.STRING,
+				allowNull: false,
+				defaultValue: ''
+			},
+			domain: {
+				type: DataTypes.INTEGER,
+				allowNull: true,
+				references: {
+					model: 'domain',
+					key: 'domain_id'
+				},
+				onDelete: 'SET NULL',
+				onUpdate: 'CASCADE',
+				defaultValue: null
+			},
+			locale: {
+				type: DataTypes.STRING,
+				allowNull: false,
+				defaultValue: ''
+			}
+		},
+		{
+			sequelize: api_db,
+			tableName: 'user',
+			charset: 'utf8mb4',
+			collate: 'utf8mb4_unicode_ci'
+		}
+	);
+	return api_user;
+}