@technomoron/mail-magic-client 1.0.23

package/dist/mail-magic-client.js

@@ -0,0 +1,281 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const email_addresses_1 = __importDefault(require("email-addresses"));
+const nunjucks_1 = __importDefault(require("nunjucks"));
+class templateClient {
+    constructor(baseURL, apiKey) {
+        this.baseURL = baseURL;
+        this.apiKey = apiKey;
+        if (!apiKey || !baseURL) {
+            throw new Error('Apikey/api-url required');
+        }
+    }
+    async request(method, command, body) {
+        const url = `${this.baseURL}${command}`;
+        const options = {
+            method,
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer apikey-${this.apiKey}`
+            },
+            body: body ? JSON.stringify(body) : '{}'
+        };
+        //        console.log(JSON.stringify({ options, url }));
+        const response = await fetch(url, options);
+        const j = await response.json();
+        if (response.ok) {
+            return j;
+        }
+        // console.log(JSON.stringify(j, undefined, 2));
+        if (j && j.message) {
+            throw new Error(`FETCH FAILED: ${response.status} ${j.message}`);
+        }
+        else {
+            throw new Error(`FETCH FAILED: ${response.status} ${response.statusText}`);
+        }
+    }
+    async get(command) {
+        return this.request('GET', command);
+    }
+    async post(command, body) {
+        return this.request('POST', command, body);
+    }
+    async put(command, body) {
+        return this.request('PUT', command, body);
+    }
+    async delete(command, body) {
+        return this.request('DELETE', command, body);
+    }
+    validateEmails(list) {
+        const valid = [], invalid = [];
+        const emails = list
+            .split(',')
+            .map((email) => email.trim())
+            .filter((email) => email !== '');
+        emails.forEach((email) => {
+            const parsed = email_addresses_1.default.parseOneAddress(email);
+            if (parsed && parsed.address) {
+                valid.push(parsed.address);
+            }
+            else {
+                invalid.push(email);
+            }
+        });
+        return { valid, invalid };
+    }
+    validateTemplate(template) {
+        try {
+            const env = new nunjucks_1.default.Environment(new nunjucks_1.default.FileSystemLoader(['./templates']));
+            const t = env.renderString(template, {});
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                throw new Error(`Template validation failed: ${error.message}`);
+            }
+            else {
+                throw new Error('Template validation failed with an unknown error');
+            }
+        }
+    }
+    validateSender(sender) {
+        const exp = /^[^<>]+<[^<>]+@[^<>]+\.[^<>]+>$/;
+        if (!exp.test(sender)) {
+            throw new Error('Invalid sender format. Expected "Name <email@example.com>"');
+        }
+    }
+    createAttachmentPayload(attachments) {
+        const formData = new FormData();
+        const usedFields = [];
+        for (const attachment of attachments) {
+            if (!attachment?.path) {
+                throw new Error('Attachment path is required');
+            }
+            const raw = fs_1.default.readFileSync(attachment.path);
+            const filename = attachment.filename || path_1.default.basename(attachment.path);
+            const blob = new Blob([raw], attachment.contentType ? { type: attachment.contentType } : undefined);
+            const field = attachment.field || 'attachment';
+            formData.append(field, blob, filename);
+            usedFields.push(field);
+        }
+        return { formData, usedFields };
+    }
+    appendFields(formData, fields) {
+        for (const [key, value] of Object.entries(fields)) {
+            if (value === undefined || value === null) {
+                continue;
+            }
+            if (typeof value === 'string') {
+                formData.append(key, value);
+            }
+            else if (typeof value === 'number' || typeof value === 'boolean') {
+                formData.append(key, String(value));
+            }
+            else {
+                formData.append(key, JSON.stringify(value));
+            }
+        }
+    }
+    async postFormData(command, formData) {
+        const url = `${this.baseURL}${command}`;
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: {
+                Authorization: `Bearer apikey-${this.apiKey}`
+            },
+            body: formData
+        });
+        const j = await response.json();
+        if (response.ok) {
+            return j;
+        }
+        if (j && j.message) {
+            throw new Error(`FETCH FAILED: ${response.status} ${j.message}`);
+        }
+        throw new Error(`FETCH FAILED: ${response.status} ${response.statusText}`);
+    }
+    async storeTemplate(td) {
+        if (!td.template) {
+            throw new Error('No template data provided');
+        }
+        this.validateTemplate(td.template);
+        if (td.sender) {
+            this.validateSender(td.sender);
+        }
+        return this.storeTxTemplate(td);
+    }
+    async sendTemplate(std) {
+        if (!std.name || !std.rcpt) {
+            throw new Error('Invalid request body; name/rcpt required');
+        }
+        return this.sendTxMessage(std);
+    }
+    async storeTxTemplate(td) {
+        if (!td.template) {
+            throw new Error('No template data provided');
+        }
+        this.validateTemplate(td.template);
+        if (td.sender) {
+            this.validateSender(td.sender);
+        }
+        return this.post('/api/v1/tx/template', td);
+    }
+    async sendTxMessage(std) {
+        if (!std.name || !std.rcpt) {
+            throw new Error('Invalid request body; name/rcpt required');
+        }
+        const { valid, invalid } = this.validateEmails(std.rcpt);
+        if (invalid.length > 0) {
+            throw new Error('Invalid email address(es): ' + invalid.join(','));
+        }
+        // this.validateTemplate(template);
+        const body = {
+            name: std.name,
+            rcpt: std.rcpt,
+            domain: std.domain || '',
+            locale: std.locale || '',
+            vars: std.vars || {},
+            replyTo: std.replyTo,
+            headers: std.headers
+        };
+        // console.log(JSON.stringify(body, undefined, 2));
+        if (std.attachments && std.attachments.length > 0) {
+            if (std.headers) {
+                throw new Error('Headers are not supported with attachment uploads');
+            }
+            const { formData } = this.createAttachmentPayload(std.attachments);
+            this.appendFields(formData, {
+                name: std.name,
+                rcpt: std.rcpt,
+                domain: std.domain || '',
+                locale: std.locale || '',
+                vars: JSON.stringify(std.vars || {}),
+                replyTo: std.replyTo
+            });
+            return this.postFormData('/api/v1/tx/message', formData);
+        }
+        return this.post('/api/v1/tx/message', body);
+    }
+    async storeFormTemplate(data) {
+        if (!data.template) {
+            throw new Error('No template data provided');
+        }
+        if (!data.idname) {
+            throw new Error('Missing form identifier');
+        }
+        if (!data.sender) {
+            throw new Error('Missing sender address');
+        }
+        if (!data.recipient) {
+            throw new Error('Missing recipient address');
+        }
+        this.validateTemplate(data.template);
+        this.validateSender(data.sender);
+        return this.post('/api/v1/form/template', data);
+    }
+    async sendFormMessage(data) {
+        if (!data.formid) {
+            throw new Error('Invalid request body; formid required');
+        }
+        const fields = data.fields || {};
+        const baseFields = {
+            formid: data.formid,
+            secret: data.secret,
+            recipient: data.recipient,
+            domain: data.domain,
+            locale: data.locale,
+            vars: data.vars || {},
+            replyTo: data.replyTo,
+            ...fields
+        };
+        if (data.attachments && data.attachments.length > 0) {
+            const { formData } = this.createAttachmentPayload(data.attachments);
+            this.appendFields(formData, {
+                formid: data.formid,
+                secret: data.secret,
+                recipient: data.recipient,
+                domain: data.domain,
+                locale: data.locale,
+                vars: JSON.stringify(data.vars || {}),
+                replyTo: data.replyTo
+            });
+            this.appendFields(formData, fields);
+            return this.postFormData('/api/v1/form/message', formData);
+        }
+        return this.post('/api/v1/form/message', baseFields);
+    }
+    async uploadAssets(data) {
+        if (!data.domain) {
+            throw new Error('domain is required');
+        }
+        if (!data.files || data.files.length === 0) {
+            throw new Error('At least one asset file is required');
+        }
+        if (data.templateType && !data.template) {
+            throw new Error('template is required when templateType is provided');
+        }
+        if (data.template && !data.templateType) {
+            throw new Error('templateType is required when template is provided');
+        }
+        const attachments = data.files.map((input) => {
+            if (typeof input === 'string') {
+                return { path: input, field: 'asset' };
+            }
+            return { ...input, field: input.field || 'asset' };
+        });
+        const { formData } = this.createAttachmentPayload(attachments);
+        this.appendFields(formData, {
+            domain: data.domain,
+            templateType: data.templateType,
+            template: data.template,
+            locale: data.locale,
+            path: data.path
+        });
+        return this.postFormData('/api/v1/assets', formData);
+    }
+}
+exports.default = templateClient;

package/dist/preprocess.js

@@ -0,0 +1,310 @@
+"use strict";
+/*
+ *  Merge templates in source dir using nunjucks blocks and layouts.
+ *  Preserve flow control and variable expansion for later dynamic data.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.do_the_template_thing = do_the_template_thing;
+exports.compileTemplate = compileTemplate;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const cheerio_1 = require("cheerio");
+const juice_1 = __importDefault(require("juice"));
+const nunjucks_1 = __importDefault(require("nunjucks"));
+const cfg = {
+    env: null,
+    src_dir: 'templates',
+    dist_dir: 'templates-dist',
+    css_path: node_path_1.default.join(process.cwd(), 'templates', 'foundation-emails.css'),
+    css_content: null,
+    inline_includes: true
+};
+function resolvePathRoot(dir) {
+    return node_path_1.default.isAbsolute(dir) ? dir : node_path_1.default.join(process.cwd(), dir);
+}
+function resolveCssPath(cssPath) {
+    if (!cssPath) {
+        return '';
+    }
+    return node_path_1.default.isAbsolute(cssPath) ? cssPath : node_path_1.default.join(process.cwd(), cssPath);
+}
+function inlineIncludes(content, baseDir, srcRoot, stack) {
+    const includeExp = /\{%\s*include\s+['"]([^'"]+)['"][^%]*%\}/g;
+    return content.replace(includeExp, (_match, includePath) => {
+        const cleaned = includePath.replace(/^\/+/, '');
+        const candidates = [node_path_1.default.resolve(baseDir, cleaned), node_path_1.default.resolve(srcRoot, cleaned)];
+        const found = candidates.find((candidate) => node_fs_1.default.existsSync(candidate));
+        if (!found) {
+            throw new Error(`Include not found: ${includePath}`);
+        }
+        const resolved = node_fs_1.default.realpathSync(found);
+        if (stack.has(resolved)) {
+            throw new Error(`Circular include detected for ${includePath}`);
+        }
+        stack.add(resolved);
+        const raw = node_fs_1.default.readFileSync(resolved, 'utf8');
+        const inlined = inlineIncludes(raw, node_path_1.default.dirname(resolved), srcRoot, stack);
+        stack.delete(resolved);
+        return inlined;
+    });
+}
+class PreprocessExtension {
+    constructor() {
+        this.tags = ['process_layout'];
+    }
+    // types from nunjucks are not exported for parser/nodes; use any
+    parse(parser, nodes) {
+        const token = parser.nextToken();
+        const args = parser.parseSignature(null, true);
+        parser.advanceAfterBlockEnd(token.value);
+        return new nodes.CallExtension(this, 'run', args);
+    }
+    run(_context, tplname) {
+        const template = cfg.env.getTemplate(tplname);
+        const src = template.tmplStr;
+        const extmatch = src.match(/\{%\s*extends\s+['"]([^'"]+)['"]\s*%\}/);
+        if (!extmatch)
+            return src;
+        const layoutName = extmatch[1];
+        const layoutTemplate = cfg.env.getTemplate(layoutName);
+        const layoutSrc = layoutTemplate.tmplStr;
+        const blocks = {};
+        const blockexp = /\{%\s*block\s+([a-zA-Z0-9_]+)\s*%\}([\s\S]*?)\{%\s*endblock\s*%\}/g;
+        let match;
+        while ((match = blockexp.exec(src)) !== null) {
+            const bname = match[1];
+            const bcontent = match[2];
+            blocks[bname] = bcontent.trim();
+        }
+        let merged = layoutSrc;
+        for (const [bname, bcontent] of Object.entries(blocks)) {
+            const lbexpt = new RegExp(`\\{%\\s*block\\s+${bname}\\s*%\\}[\\s\\S]*?\\{%\\s*endblock\\s*%\\}`, 'g');
+            merged = merged.replace(lbexpt, bcontent);
+        }
+        merged = merged.replace(/\{%\s*extends\s+['"][^'"]+['"]\s*%\}/, '');
+        if (merged.match(/\{%\s*extends\s+['"]([^'"]+)['"]\s*%\}/)) {
+            return this.run(_context, layoutName);
+        }
+        merged = merged.replace(/\{%\s*block\s+([a-zA-Z0-9_]+)\s*%\}\s*\{%\s*endblock\s*%\}/g, '');
+        return merged;
+    }
+}
+function process_template(tplname, writeOutput = true) {
+    console.log(`Processing template: ${tplname}`);
+    try {
+        const srcRoot = resolvePathRoot(cfg.src_dir);
+        const templateFile = node_path_1.default.join(srcRoot, `${tplname}.njk`);
+        // 1) Resolve template inheritance
+        const mergedTemplate = cfg.env.renderString(`{% process_layout "${tplname}.njk" %}`, {});
+        // 1.5) Inline partials/includes so the server doesn't need a loader
+        const mergedWithPartials = cfg.inline_includes
+            ? inlineIncludes(mergedTemplate, node_path_1.default.dirname(templateFile), srcRoot, new Set())
+            : mergedTemplate;
+        // 2) Protect variables/flow
+        const protectedTemplate = cfg.env.filters.protect_variables(mergedWithPartials);
+        // 3) Light HTML transforms for email compatibility
+        console.log('Processing HTML for email compatibility');
+        let processedHtml = protectedTemplate;
+        try {
+            const $ = (0, cheerio_1.load)(protectedTemplate, {
+                xmlMode: false
+                // decodeEntities: false
+            });
+            // <container> -> <table>
+            $('container').each(function () {
+                const $container = $(this);
+                const $table = $('<table/>').attr({
+                    align: 'center',
+                    class: $container.attr('class') || '',
+                    width: '100%',
+                    cellpadding: '0',
+                    cellspacing: '0',
+                    border: '0'
+                });
+                const $tbody = $('<tbody/>');
+                $table.append($tbody);
+                $tbody.append($container.contents());
+                $container.replaceWith($table);
+            });
+            // <row> -> <tr>
+            $('row').each(function () {
+                const $row = $(this);
+                const background = $row.attr('background') || '';
+                const $tr = $('<tr/>').attr({ class: $row.attr('class') || '' });
+                if (background)
+                    $tr.css('background', background);
+                $tr.append($row.contents());
+                $row.replaceWith($tr);
+            });
+            // <columns> -> <td>
+            $('columns').each(function () {
+                const $columns = $(this);
+                const padding = $columns.attr('padding') || '0';
+                const $td = $('<td/>').attr({
+                    class: $columns.attr('class') || '',
+                    style: `padding: ${padding};`
+                });
+                $td.append($columns.contents());
+                $columns.replaceWith($td);
+            });
+            // <button> -> <a>
+            $('button').each(function () {
+                const $button = $(this);
+                const href = $button.attr('href') || '#';
+                const buttonClass = $button.attr('class') || '';
+                const $a = $('<a/>').attr({
+                    href,
+                    class: buttonClass,
+                    style: $button.attr('style') ||
+                        'display: inline-block; padding: 8px 16px; border-radius: 3px; text-decoration: none;'
+                });
+                $a.append($button.contents());
+                $button.replaceWith($a);
+            });
+            processedHtml = $.html();
+            console.log('HTML processing complete');
+        }
+        catch (htmlError) {
+            console.error('HTML processing error:', htmlError);
+            processedHtml = protectedTemplate;
+        }
+        // 4) Inline CSS
+        let inlinedHtml;
+        try {
+            inlinedHtml = (0, juice_1.default)(processedHtml, {
+                extraCss: cfg.css_content ?? undefined,
+                removeStyleTags: false,
+                preserveMediaQueries: true,
+                preserveFontFaces: true
+            });
+        }
+        catch (juiceError) {
+            console.error('CSS inlining error:', juiceError);
+            inlinedHtml = processedHtml;
+        }
+        // 5) Restore variables/flow
+        const finalHtml = cfg.env.filters.restore_variables(inlinedHtml);
+        // Write
+        if (writeOutput) {
+            const distRoot = resolvePathRoot(cfg.dist_dir);
+            const outputPath = node_path_1.default.join(distRoot, `${tplname}.njk`);
+            node_fs_1.default.mkdirSync(node_path_1.default.dirname(outputPath), { recursive: true });
+            node_fs_1.default.writeFileSync(outputPath, finalHtml);
+        }
+        if (writeOutput) {
+            console.log(`Created ${tplname}.njk`);
+        }
+        return finalHtml;
+    }
+    catch (error) {
+        console.error(`Error processing ${tplname}:`, error);
+        throw error;
+    }
+}
+function get_all_files(dir, filelist = []) {
+    const files = node_fs_1.default.readdirSync(dir);
+    files.forEach((file) => {
+        const file_path = node_path_1.default.join(dir, file);
+        if (node_fs_1.default.statSync(file_path).isDirectory()) {
+            get_all_files(file_path, filelist);
+        }
+        else {
+            filelist.push(file_path);
+        }
+    });
+    return filelist;
+}
+function find_templates() {
+    const srcRoot = resolvePathRoot(cfg.src_dir);
+    const all = get_all_files(srcRoot);
+    return all
+        .filter((file) => file.endsWith('.njk'))
+        .filter((file) => {
+        const basename = node_path_1.default.basename(file);
+        const content = node_fs_1.default.readFileSync(file, 'utf8');
+        return (!basename.startsWith('_') &&
+            !basename.includes('layout') &&
+            !basename.includes('part') &&
+            content.includes('{% extends'));
+    })
+        .map((file) => {
+        const name = node_path_1.default.relative(srcRoot, file);
+        return name.substring(0, name.length - 4);
+    });
+}
+async function process_all_templates() {
+    const distRoot = resolvePathRoot(cfg.dist_dir);
+    if (!node_fs_1.default.existsSync(distRoot)) {
+        node_fs_1.default.mkdirSync(distRoot, { recursive: true });
+    }
+    const templates = find_templates();
+    console.log(`Found ${templates.length} templates to process: ${templates.join(', ')}`);
+    for (const template of templates) {
+        try {
+            process_template(template);
+        }
+        catch (error) {
+            console.error(`Failed to process ${template}:`, error);
+        }
+    }
+    console.log('All templates processed!');
+}
+function init_env() {
+    const loader = new nunjucks_1.default.FileSystemLoader(resolvePathRoot(cfg.src_dir));
+    cfg.env = new nunjucks_1.default.Environment(loader, { autoescape: false });
+    if (!cfg.env)
+        throw Error('Unable to init nunjucks environment');
+    // Load CSS if present
+    const cssPath = resolveCssPath(cfg.css_path);
+    if (cssPath && node_fs_1.default.existsSync(cssPath)) {
+        cfg.css_content = node_fs_1.default.readFileSync(cssPath, 'utf8');
+    }
+    else {
+        cfg.css_content = null;
+    }
+    // Extension
+    cfg.env.addExtension('PreprocessExtension', new PreprocessExtension());
+    // Filters
+    cfg.env.addFilter('protect_variables', function (content) {
+        return content
+            .replace(/(\{\{[\s\S]*?\}\})/g, (m) => `<!--VAR:${Buffer.from(m).toString('base64')}-->`)
+            .replace(/(\{%(?!\s*block|\s*endblock|\s*extends)[\s\S]*?%\})/g, (m) => {
+            return `<!--FLOW:${Buffer.from(m).toString('base64')}-->`;
+        });
+    });
+    cfg.env.addFilter('restore_variables', function (content) {
+        return content
+            .replace(/<!--VAR:(.*?)-->/g, (_m, enc) => Buffer.from(enc, 'base64').toString('utf8'))
+            .replace(/<!--FLOW:(.*?)-->/g, (_m, enc) => Buffer.from(enc, 'base64').toString('utf8'));
+    });
+}
+async function do_the_template_thing(options = {}) {
+    if (options.src_dir)
+        cfg.src_dir = options.src_dir;
+    if (options.dist_dir)
+        cfg.dist_dir = options.dist_dir;
+    if (options.css_path)
+        cfg.css_path = options.css_path;
+    if (options.inline_includes !== undefined)
+        cfg.inline_includes = options.inline_includes;
+    init_env();
+    if (options.tplname) {
+        process_template(options.tplname);
+    }
+    else {
+        await process_all_templates();
+    }
+}
+async function compileTemplate(options) {
+    if (options.src_dir)
+        cfg.src_dir = options.src_dir;
+    if (options.css_path)
+        cfg.css_path = options.css_path;
+    if (options.inline_includes !== undefined)
+        cfg.inline_includes = options.inline_includes;
+    init_env();
+    return process_template(options.tplname, false);
+}

package/package.json

@@ -0,0 +1,69 @@
+{
+	"name": "@technomoron/mail-magic-client",
+	"version": "1.0.23",
+	"description": "Client library for mail-magic",
+	"main": "dist/cjs/mail-magic-client.js",
+	"types": "dist/cjs/mail-magic-client.d.ts",
+	"module": "dist/esm/mail-magic-client.js",
+	"bin": {
+		"mm-cli": "dist/cli.js"
+	},
+	"scripts": {
+		"prepare": "npm run build",
+		"scrub": "rm -rf node_modules pnpm-lock.yaml lib/ dist/",
+		"build:cjs": "tsc --project tsconfig/tsconfig.cjs.json",
+		"build:esm": "tsc --project tsconfig/tsconfig.esm.json",
+		"build:cli": "tsc --project tsconfig/tsconfig.cli.json",
+		"build": "npm run build:cjs && npm run build:esm && npm run build:cli",
+		"test": "vitest run",
+		"test:watch": "vitest",
+		"lint": "eslint --ext .js,.ts,.vue ./src",
+		"lintfix": "eslint --fix --ext .js,.ts,.vue,.json ./src",
+		"format": "npm run lintfix && npm run pretty",
+		"pretty": "prettier --write \"**/*.{js,ts,vue,json,css,scss,md}\"",
+		"cleanbuild": "rm -rf ./dist/ && npm run lintfix && npm run format && npm run build"
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/technomoron/mail-magic.git",
+		"directory": "packages/mail-magic-client"
+	},
+	"author": "Bjørn Erik Jacobsen",
+	"license": "MIT",
+	"files": [
+		"dist/**/*.js",
+		"dist/**/*.d.ts",
+		"package.json",
+		"CHANGES"
+	],
+	"dependencies": {
+		"cheerio": "^1.1.2",
+		"commander": "^10.0.1",
+		"email-addresses": "^5.0.0",
+		"foundation-emails": "^2.4.0",
+		"inky": "^0.1.0",
+		"juice": "^11.0.1",
+		"node-fetch": "^3.3.2",
+		"nunjucks": "^3.2.4"
+	},
+	"devDependencies": {
+		"@types/cheerio": "^1.0.0",
+		"@types/node": "^20.19.11",
+		"@types/nunjucks": "^3.2.6",
+		"@typescript-eslint/eslint-plugin": "^8.30.1",
+		"@typescript-eslint/parser": "^8.30.1",
+		"@vue/eslint-config-prettier": "^10.2.0",
+		"@vue/eslint-config-typescript": "^14.5.0",
+		"eslint": "^9.34.0",
+		"eslint-config-prettier": "^10.1.5",
+		"eslint-import-resolver-alias": "^1.1.2",
+		"eslint-plugin-import": "^2.31.0",
+		"eslint-plugin-nuxt": "^4.0.0",
+		"eslint-plugin-prettier": "^5.4.1",
+		"eslint-plugin-vue": "^10.0.0",
+		"prettier": "^3.5.3",
+		"typescript": "^5.9.2",
+		"vitest": "^4.0.16",
+		"vue-eslint-parser": "^10.1.3"
+	}
+}