@technomoron/mail-magic 1.0.4

package/dist/models/form.js

@@ -0,0 +1,168 @@
+import path from 'path';
+import { Model, DataTypes } from 'sequelize';
+import { z } from 'zod';
+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 class api_form extends Model {
+}
+export async function init_api_form(api_db) {
+    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');
+                return raw ? JSON.parse(raw) : [];
+            },
+            set(value) {
+                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) {
+    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 = 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/dist/models/init.js

@@ -0,0 +1,176 @@
+import fs from 'fs';
+import path from 'path';
+import { Unyuck } from '@technomoron/unyuck';
+import { z } from 'zod';
+import { user_and_domain } from '../util.js';
+import { api_domain, api_domain_schema } from './domain.js';
+import { api_form_schema, upsert_form } from './form.js';
+import { api_txmail_schema, upsert_txmail } from './txmail.js';
+import { api_user, api_user_schema } from './user.js';
+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([])
+});
+/**
+ * Resolve an asset file within ./config/<userid>/<domain>/<type>/assets
+ */
+function resolveAsset(basePath, type, domainName, assetName, locale) {
+    const searchPaths = [];
+    // 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, opts) {
+    const regex = /src=["']asset\(['"]([^'"]+)['"](?:,\s*(true|false|[01]))?\)["']/g;
+    const assets = [];
+    const replacedHtml = html.replace(regex, (_m, relPath, inlineFlag) => {
+        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 = {
+            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, filename, pathname, user, domain, locale, type) {
+    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.message}`);
+    }
+}
+export async function loadFormTemplate(store, form) {
+    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, template) {
+    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) {
+    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;
+        try {
+            records = init_data_schema.parse(JSON.parse(data));
+        }
+        catch (err) {
+            store.print_debug(`Invalid init-data.json: ${err}`);
+            return;
+        }
+        const pendingUserDomains = [];
+        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/dist/models/txmail.js

@@ -0,0 +1,167 @@
+import path from 'path';
+import { Model, DataTypes } from 'sequelize';
+import { z } from 'zod';
+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 class api_txmail extends Model {
+}
+export async function upsert_txmail(record) {
+    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) {
+    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');
+                return raw ? JSON.parse(raw) : [];
+            },
+            set(value) {
+                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) => {
+        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/dist/models/user.js

@@ -0,0 +1,65 @@
+import { 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 class api_user extends Model {
+}
+export async function init_api_user(api_db) {
+    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;
+}

package/dist/server.js

@@ -0,0 +1,22 @@
+import { ApiServer } from '@technomoron/api-server-base';
+import { api_user } from './models/user.js';
+export class mailApiServer extends ApiServer {
+    store;
+    storage;
+    constructor(config, store) {
+        super(config);
+        this.store = store;
+        this.storage = store;
+    }
+    async getApiKey(token) {
+        this.storage.print_debug(`Looking up api key ${token}`);
+        const user = await api_user.findOne({ where: { token: token } });
+        if (!user) {
+            this.storage.print_debug(`Unable to find user for token ${token}`);
+            return null;
+        }
+        else {
+            return { uid: user.user_id };
+        }
+    }
+}