@technomoron/mail-magic-client 1.0.23

package/dist/cli.js

@@ -0,0 +1,307 @@
+#!/usr/bin/env node
+"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 readline_1 = __importDefault(require("readline"));
+const commander_1 = require("commander");
+const cli_env_1 = require("./cli-env");
+const cli_helpers_1 = require("./cli-helpers");
+const mail_magic_client_1 = __importDefault(require("./mail-magic-client"));
+const preprocess_1 = require("./preprocess");
+const program = new commander_1.Command();
+const envDefaults = (0, cli_env_1.loadCliEnv)();
+const defaultToken = (0, cli_env_1.resolveToken)(envDefaults);
+const apiDefault = envDefaults.api || 'http://localhost:3000';
+program.option('-a, --api <api>', 'Base API endpoint', apiDefault);
+if (defaultToken) {
+    program.option('-t, --token <token>', 'Authentication token in the format "username:token"', defaultToken);
+}
+else {
+    program.option('-t, --token <token>', 'Authentication token in the format "username:token"');
+}
+program
+    .option('-f, --file <file>', 'Path to the file containing the template data (Nunjucks with MJML)')
+    .option('-s, --sender <sender>', 'Sender email address')
+    .option('-r, --rcpt <rcpt>', 'Recipient email addresses (comma-separated)')
+    .option('-n, --name <name>', 'Template name')
+    .option('-b, --subject <subject>', 'Email subject')
+    .option('-l, --locale <locale>', 'Locale')
+    .option('-d, --domain <domain>', 'Domain', envDefaults.domain)
+    .option('-p, --part <true|false>', 'Part')
+    .option('-v, --vars <vars>', 'Template parameters (JSON string)');
+const readStdin = async () => {
+    if (process.stdin.isTTY) {
+        return '';
+    }
+    return new Promise((resolve, reject) => {
+        const rl = readline_1.default.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+            terminal: false
+        });
+        let data = '';
+        rl.on('line', (line) => {
+            data += line + '\n';
+        });
+        rl.on('close', () => {
+            resolve(data.trim());
+        });
+        rl.on('error', (err) => {
+            reject(err);
+        });
+    });
+};
+const getTemplateData = async () => {
+    if (program.opts().file) {
+        const filePath = program.opts().file;
+        if (!fs_1.default.existsSync(filePath)) {
+            throw new Error(`File not found: ${filePath}`);
+        }
+        return fs_1.default.readFileSync(filePath, 'utf-8');
+    }
+    else {
+        return await readStdin();
+    }
+};
+program
+    .command('template')
+    .description('Store a template on the server')
+    .action(async () => {
+    const client = new mail_magic_client_1.default(program.opts().api, program.opts().token);
+    try {
+        const template = await getTemplateData();
+        const templateData = {
+            template,
+            sender: program.opts().sender,
+            name: program.opts().name,
+            subject: program.opts().subject,
+            locale: program.opts().locale,
+            domain: program.opts().domain,
+            part: !!program.opts().part
+        };
+        const result = await client.storeTemplate(templateData);
+        console.log('Template updated');
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            console.error('Error:', error.message);
+        }
+        else {
+            console.error('An unknown error occurred.');
+        }
+        process.exit(1);
+    }
+});
+program
+    .command('send')
+    .description('Send a template to recipients')
+    .action(async () => {
+    const client = new mail_magic_client_1.default(program.opts().api, program.opts().token);
+    try {
+        const template = await getTemplateData();
+        const vars = program.opts().vars ? JSON.parse(program.opts().vars) : '{}';
+        const templateData = {
+            name: program.opts().name,
+            rcpt: program.opts().rcpt,
+            domain: program.opts().domain,
+            locale: program.opts().locale,
+            vars
+        };
+        const result = await client.sendTemplate(templateData);
+        console.log('Template sent');
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            console.error('Error:', error.message);
+        }
+        else {
+            console.error('An unknown error occurred.');
+        }
+        process.exit(1);
+    }
+});
+program
+    .command('version')
+    .description('Show current client version')
+    .action(async (cmdOptions) => {
+    console.log('1.0.19');
+});
+program
+    .command('compile')
+    .description('Compile templates by resolving inheritance and processing with FFE')
+    .option('-i, --input <input>', 'Input directory', './templates')
+    .option('-o, --output <output>', 'Output directory', './templates-dist')
+    .option('-c, --css <css>', 'Path to Foundation for Emails CSS', './templates/foundation-emails.css')
+    .option('-t, --template <template>', 'Process a specific template only')
+    .action(async (cmdOptions) => {
+    try {
+        await (0, preprocess_1.do_the_template_thing)({
+            src_dir: cmdOptions.input,
+            dist_dir: cmdOptions.output,
+            css_path: cmdOptions.css,
+            tplname: cmdOptions.template // Pass undefined if not specified
+        });
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            console.error('Error:', error.message);
+        }
+        else {
+            console.error('An unknown error occurred.');
+        }
+        process.exit(1);
+    }
+});
+program
+    .command('push')
+    .description('Compile a template with partials and store it on the server')
+    .option('-i, --input <input>', 'Input directory', './templates')
+    .option('-c, --css <css>', 'Path to Foundation for Emails CSS', './templates/foundation-emails.css')
+    .option('-t, --template <template>', 'Template path relative to input (without .njk)')
+    .option('-n, --name <name>', 'Template name (defaults to template basename)')
+    .option('-s, --sender <sender>', 'Sender email address')
+    .option('-b, --subject <subject>', 'Email subject')
+    .option('-l, --locale <locale>', 'Locale')
+    .option('-d, --domain <domain>', 'Domain')
+    .option('--dry-run', 'Show what would be uploaded without sending anything')
+    .action(async (cmdOptions) => {
+    try {
+        const summary = await (0, cli_helpers_1.pushTemplate)({
+            api: program.opts().api,
+            token: program.opts().token,
+            domain: cmdOptions.domain,
+            template: cmdOptions.template,
+            name: cmdOptions.name,
+            locale: cmdOptions.locale,
+            sender: cmdOptions.sender,
+            subject: cmdOptions.subject,
+            input: cmdOptions.input,
+            css: cmdOptions.css,
+            dryRun: !!cmdOptions.dryRun
+        });
+        if (cmdOptions.dryRun) {
+            console.log(`Dry run - template: ${summary.domain} ${summary.locale || ''} ${summary.name}`);
+            console.log(`Source: ${summary.filePath}`);
+        }
+        else {
+            console.log('Template compiled and uploaded');
+        }
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            console.error('Error:', error.message);
+        }
+        else {
+            console.error('An unknown error occurred.');
+        }
+        process.exit(1);
+    }
+});
+program
+    .command('push-dir')
+    .description('Upload templates and assets from a config-style directory')
+    .option('-i, --input <input>', 'Config directory (contains init-data.json)', './data')
+    .option('-c, --css <css>', 'Path to Foundation for Emails CSS (optional)')
+    .option('--dry-run', 'Show what would be uploaded without sending anything')
+    .option('--skip-assets', 'Skip asset uploads')
+    .option('--skip-tx', 'Skip transactional templates')
+    .option('--skip-forms', 'Skip form templates')
+    .option('-d, --domain <domain>', 'Domain to upload (overrides global)')
+    .action(async (cmdOptions) => {
+    try {
+        const summary = await (0, cli_helpers_1.pushTemplateDir)({
+            api: program.opts().api,
+            token: program.opts().token,
+            input: cmdOptions.input,
+            domain: cmdOptions.domain || program.opts().domain,
+            css: cmdOptions.css,
+            includeAssets: !cmdOptions.skipAssets,
+            includeTx: !cmdOptions.skipTx,
+            includeForms: !cmdOptions.skipForms,
+            dryRun: !!cmdOptions.dryRun
+        });
+        if (cmdOptions.dryRun) {
+            console.log('Dry run - planned uploads:');
+            for (const action of summary.actions) {
+                if (action.kind === 'tx-template') {
+                    console.log(`tx-template: ${action.domain} ${action.locale || ''} ${action.template}`);
+                }
+                else if (action.kind === 'form-template') {
+                    console.log(`form-template: ${action.domain} ${action.locale || ''} ${action.template}`);
+                }
+                else if (action.kind === 'domain-assets') {
+                    const files = action.files?.join(', ') || '';
+                    console.log(`domain-assets: ${action.domain} ${action.path || '.'} ${files}`);
+                }
+                else if (action.kind === 'template-assets') {
+                    const files = action.files?.join(', ') || '';
+                    console.log(`template-assets: ${action.domain} ${action.locale || ''} ${action.template} ${action.path || '.'} ${files}`);
+                }
+            }
+            console.log(`Summary: ${summary.templates} tx template(s), ${summary.forms} form template(s), ${summary.assetBatches} asset batch(es)`);
+        }
+        else {
+            console.log('Templates and assets uploaded');
+        }
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            console.error('Error:', error.message);
+        }
+        else {
+            console.error('An unknown error occurred.');
+        }
+        process.exit(1);
+    }
+});
+program
+    .command('assets')
+    .description('Upload asset files to the server')
+    .option('-f, --file <file...>', 'Asset file path(s)')
+    .option('--template-type <type>', 'Template type (tx or form)')
+    .option('--template <template>', 'Template name/idname')
+    .option('--path <path>', 'Destination subdirectory under assets or template')
+    .option('-l, --locale <locale>', 'Locale')
+    .option('--dry-run', 'Show what would be uploaded without sending anything')
+    .action(async (cmdOptions) => {
+    const client = new mail_magic_client_1.default(program.opts().api, program.opts().token);
+    try {
+        const files = cmdOptions.file;
+        if (!files || files.length === 0) {
+            throw new Error('At least one --file is required');
+        }
+        if (cmdOptions.dryRun) {
+            for (const file of files) {
+                if (!fs_1.default.existsSync(file)) {
+                    throw new Error(`File not found: ${file}`);
+                }
+            }
+            console.log('Dry run - assets:');
+            console.log(`domain=${program.opts().domain} templateType=${cmdOptions.templateType || ''} template=${cmdOptions.template || ''} locale=${cmdOptions.locale || ''} path=${cmdOptions.path || ''}`);
+            console.log(`files=${files.join(', ')}`);
+            return;
+        }
+        await client.uploadAssets({
+            domain: program.opts().domain,
+            files,
+            templateType: cmdOptions.templateType,
+            template: cmdOptions.template,
+            locale: cmdOptions.locale,
+            path: cmdOptions.path
+        });
+        console.log('Assets uploaded');
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            console.error('Error:', error.message);
+        }
+        else {
+            console.error('An unknown error occurred.');
+        }
+        process.exit(1);
+    }
+});
+program.parse(process.argv);

package/dist/esm/mail-magic-client.js

@@ -0,0 +1,276 @@
+import fs from 'fs';
+import path from 'path';
+import emailAddresses from 'email-addresses';
+import nunjucks from '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 = emailAddresses.parseOneAddress(email);
+            if (parsed && parsed.address) {
+                valid.push(parsed.address);
+            }
+            else {
+                invalid.push(email);
+            }
+        });
+        return { valid, invalid };
+    }
+    validateTemplate(template) {
+        try {
+            const env = new nunjucks.Environment(new nunjucks.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.readFileSync(attachment.path);
+            const filename = attachment.filename || path.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);
+    }
+}
+export default templateClient;