@contentgrowth/content-emailing 0.1.0

package/src/backend/EmailService.js

@@ -0,0 +1,474 @@
+/**
+ * Email Service
+ * Unified service for email delivery and template management.
+ */
+import { marked } from 'marked';
+import Mustache from 'mustache';
+
+export class EmailService {
+    /**
+     * @param {Object} env - Cloudflare environment bindings (DB, etc.)
+     * @param {Object} config - Configuration options
+     * @param {string} [config.tableNamePrefix='system_email_'] - Prefix for D1 tables
+     * @param {Object} [config.defaults] - Default settings (fromName, fromAddress)
+     * @param {Object} [cacheProvider] - Optional cache interface (DO stub or KV wrapper)
+     */
+    constructor(env, config = {}, cacheProvider = null) {
+        this.env = env;
+        this.db = env.DB;
+        this.config = {
+            tableNamePrefix: config.tableNamePrefix || 'system_email_',
+            defaults: config.defaults || {
+                fromName: 'System',
+                fromAddress: 'noreply@example.com',
+                provider: 'mailchannels'
+            },
+            ...config
+        };
+        this.cache = cacheProvider;
+    }
+
+    // --- Configuration & Settings ---
+
+    /**
+     * Load email configuration
+     * @param {string} profile - 'system' or 'tenant'
+     * @param {string} tenantId - Required if profile is 'tenant'
+     * @returns {Promise<Object>} Email configuration
+     */
+    async loadSettings(profile = 'system', tenantId = null) {
+        // 1. Try cache if available (for system profile)
+        if (this.cache && profile === 'system') {
+            try {
+                const cached = await this.cache.getSettings();
+                if (cached) return this._normalizeConfig(cached);
+            } catch (e) {
+                console.warn('[EmailService] Cache lookup failed:', e);
+            }
+        }
+
+        // 2. Load from D1 based on profile
+        if (profile === 'system') {
+            try {
+                // Try to load from system_settings table
+                const settings = await this.db
+                    .prepare(`SELECT setting_key, setting_value FROM system_settings`)
+                    .all();
+
+                if (settings.results && settings.results.length > 0) {
+                    const config = {};
+                    settings.results.forEach((row) => {
+                        config[row.setting_key] = row.setting_value;
+                    });
+                    return this._normalizeConfig(config);
+                }
+            } catch (e) {
+                console.warn('[EmailService] D1 settings lookup failed:', e);
+            }
+        } else if (profile === 'tenant' && tenantId) {
+            try {
+                const tenant = await this.db
+                    .prepare(`SELECT settings FROM tenants WHERE tenant_id = ?`)
+                    .bind(tenantId)
+                    .first();
+
+                if (tenant?.settings) {
+                    const settings = JSON.parse(tenant.settings);
+                    const emailConfig = settings.email || {};
+                    return {
+                        provider: emailConfig.provider || this.config.defaults.provider,
+                        fromAddress: emailConfig.fromAddress || this.config.defaults.fromAddress,
+                        fromName: emailConfig.fromName || this.config.defaults.fromName,
+                        ...emailConfig
+                    };
+                }
+            } catch (e) {
+                console.warn('[EmailService] Tenant settings lookup failed:', e);
+            }
+        }
+
+        // 3. Fallback to defaults
+        return {
+            ...this.config.defaults,
+        };
+    }
+
+    /**
+     * Normalize config keys from D1 format
+     */
+    _normalizeConfig(config) {
+        return {
+            provider: config.email_provider || this.config.defaults.provider,
+            fromAddress: config.email_from_address || this.config.defaults.fromAddress,
+            fromName: config.email_from_name || this.config.defaults.fromName,
+            // Provider-specific settings
+            sendgridApiKey: config.sendgrid_api_key,
+            resendApiKey: config.resend_api_key,
+            sendpulseClientId: config.sendpulse_client_id,
+            sendpulseClientSecret: config.sendpulse_client_secret,
+            smtpHost: config.smtp_host,
+            smtpPort: config.smtp_port,
+            smtpUsername: config.smtp_username,
+            smtpPassword: config.smtp_password,
+            smtpSecure: config.smtp_secure === 'true',
+        };
+    }
+
+    // --- Template Management ---
+
+    async getTemplate(templateId) {
+        // Try cache first
+        if (this.cache) {
+            try {
+                const cached = await this.cache.getTemplate(templateId);
+                if (cached) return cached;
+            } catch (e) {
+                console.warn('[EmailService] Template cache lookup failed:', e);
+            }
+        }
+
+        const table = `${this.config.tableNamePrefix}templates`;
+        return await this.db.prepare(`SELECT * FROM ${table} WHERE template_id = ?`)
+            .bind(templateId)
+            .first();
+    }
+
+    async getAllTemplates() {
+        const table = `${this.config.tableNamePrefix}templates`;
+        const result = await this.db.prepare(`SELECT * FROM ${table} ORDER BY template_name`).all();
+        return result.results || [];
+    }
+
+    async saveTemplate(template, userId = 'system') {
+        const table = `${this.config.tableNamePrefix}templates`;
+        const now = Math.floor(Date.now() / 1000);
+        const existing = await this.getTemplate(template.template_id);
+
+        if (existing) {
+            await this.db.prepare(`
+        UPDATE ${table} SET 
+          template_name = ?, template_type = ?, subject_template = ?, 
+          body_markdown = ?, variables = ?, description = ?, is_active = ?, 
+          updated_at = ?, updated_by = ?
+        WHERE template_id = ?
+      `).bind(
+                template.template_name, template.template_type, template.subject_template,
+                template.body_markdown, template.variables, template.description,
+                template.is_active, now, userId, template.template_id
+            ).run();
+        } else {
+            await this.db.prepare(`
+        INSERT INTO ${table} (
+          template_id, template_name, template_type, subject_template,
+          body_markdown, variables, description, is_active, created_at, updated_at, updated_by
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `).bind(
+                template.template_id, template.template_name, template.template_type,
+                template.subject_template, template.body_markdown, template.variables || '[]',
+                template.description, template.is_active || 1, now, now, userId
+            ).run();
+        }
+
+        // Invalidate cache if exists
+        if (this.cache) {
+            await this.cache.putTemplate(template);
+        }
+    }
+
+    async deleteTemplate(templateId) {
+        const table = `${this.config.tableNamePrefix}templates`;
+        await this.db.prepare(`DELETE FROM ${table} WHERE template_id = ?`).bind(templateId).run();
+        if (this.cache) {
+            await this.cache.deleteTemplate(templateId);
+        }
+    }
+
+    // --- Rendering ---
+
+    async renderTemplate(templateId, data) {
+        const template = await this.getTemplate(templateId);
+        if (!template) throw new Error(`Template not found: ${templateId}`);
+
+        // Render Subject
+        const subject = Mustache.render(template.subject_template, data);
+
+        // Render Body (Markdown -> HTML)
+        const markdown = Mustache.render(template.body_markdown, data);
+        marked.use({ mangle: false, headerIds: false });
+        const htmlContent = marked.parse(markdown);
+
+        // Wrap in Base Template (could be another template or hardcoded default)
+        const html = this.wrapInBaseTemplate(htmlContent, subject, data);
+        const plainText = markdown.replace(/<[^>]*>/g, ''); // Simple strip
+
+        return { subject, html, plainText };
+    }
+
+    wrapInBaseTemplate(content, subject, data) {
+        // Simple default wrapper
+        // In a real usage, this might load a 'base' template from DB
+        return `
+<!DOCTYPE html>
+<html>
+<head><title>${subject}</title></head>
+<body style="font-family: sans-serif; line-height: 1.6; color: #333;">
+  <div style="max-width: 600px; margin: 0 auto; padding: 20px;">
+    ${content}
+    <div style="margin-top: 20px; font-size: 12px; color: #999;">
+      <p>Sent via X0 Start</p>
+    </div>
+  </div>
+</body>
+</html>`;
+    }
+
+    // --- Delivery ---
+
+    /**
+     * Send a single email
+     * @param {Object} params - Email parameters
+     * @param {string} params.to - Recipient email
+     * @param {string} params.subject - Email subject
+     * @param {string} params.html - HTML body
+     * @param {string} params.text - Plain text body
+     * @param {string} [params.provider] - Override provider
+     * @param {string} [params.profile='system'] - 'system' or 'tenant'
+     * @param {string} [params.tenantId] - Required if profile is 'tenant'
+     * @param {Object} [params.metadata] - Additional metadata
+     * @returns {Promise<Object>} Delivery result
+     */
+    async sendEmail({ to, subject, html, text, provider, profile = 'system', tenantId = null, metadata = {} }) {
+        try {
+            const settings = await this.loadSettings(profile, tenantId);
+            const useProvider = provider || settings.provider || 'mailchannels';
+
+            let result;
+
+            switch (useProvider) {
+                case 'mailchannels':
+                    result = await this.sendViaMailChannels(to, subject, html, text, settings, metadata);
+                    break;
+                case 'sendgrid':
+                    result = await this.sendViaSendGrid(to, subject, html, text, settings, metadata);
+                    break;
+                case 'resend':
+                    result = await this.sendViaResend(to, subject, html, text, settings, metadata);
+                    break;
+                case 'sendpulse':
+                    result = await this.sendViaSendPulse(to, subject, html, text, settings, metadata);
+                    break;
+                default:
+                    console.error(`[EmailService] Unknown provider: ${useProvider}`);
+                    return { success: false, error: `Unknown email provider: ${useProvider}` };
+            }
+
+            if (result) {
+                return { success: true, messageId: crypto.randomUUID() };
+            } else {
+                console.error('[EmailService] Failed to send email to:', to);
+                return { success: false, error: 'Failed to send email' };
+            }
+        } catch (error) {
+            console.error('[EmailService] Error sending email:', error);
+            return { success: false, error: error.message };
+        }
+    }
+
+    /**
+     * Send multiple emails in batch
+     * @param {Array} emails - Array of email objects
+     * @returns {Promise<Array>} Array of delivery results
+     */
+    async sendBatch(emails) {
+        console.log('[EmailService] Sending batch of', emails.length, 'emails');
+        const results = await Promise.all(
+            emails.map(email => this.sendEmail(email))
+        );
+        return results;
+    }
+
+    /**
+     * Send email via MailChannels HTTP API
+     * MailChannels is specifically designed for Cloudflare Workers
+     */
+    async sendViaMailChannels(to, subject, html, text, settings, metadata) {
+        try {
+            const response = await fetch('https://api.mailchannels.net/tx/v1/send', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    personalizations: [{ to: [{ email: to, name: metadata.recipientName || '' }] }],
+                    from: { email: settings.fromAddress, name: settings.fromName },
+                    subject,
+                    content: [
+                        { type: 'text/plain', value: text || html.replace(/<[^>]*>/g, '') },
+                        { type: 'text/html', value: html }
+                    ]
+                })
+            });
+
+            if (response.status === 202) {
+                return true;
+            } else {
+                const contentType = response.headers.get('content-type');
+                const errorBody = contentType?.includes('application/json')
+                    ? await response.json()
+                    : await response.text();
+                console.error('[EmailService] MailChannels error:', response.status, errorBody);
+                return false;
+            }
+        } catch (error) {
+            console.error('[EmailService] MailChannels exception:', error.message);
+            return false;
+        }
+    }
+
+    /**
+     * Send email via SendGrid HTTP API
+     */
+    async sendViaSendGrid(to, subject, html, text, settings, metadata) {
+        try {
+            if (!settings.sendgridApiKey) {
+                console.error('[EmailService] SendGrid API key missing');
+                return false;
+            }
+
+            const response = await fetch('https://api.sendgrid.com/v3/mail/send', {
+                method: 'POST',
+                headers: {
+                    'Authorization': `Bearer ${settings.sendgridApiKey}`,
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({
+                    personalizations: [{ to: [{ email: to, name: metadata.recipientName || '' }] }],
+                    from: { email: settings.fromAddress, name: settings.fromName },
+                    subject,
+                    content: [
+                        { type: 'text/html', value: html },
+                        { type: 'text/plain', value: text || html.replace(/<[^>]*>/g, '') },
+                    ],
+                }),
+            });
+
+            if (response.status === 202) {
+                return true;
+            } else {
+                const errorText = await response.text();
+                console.error('[EmailService] SendGrid error:', response.status, errorText);
+                return false;
+            }
+        } catch (error) {
+            console.error('[EmailService] SendGrid exception:', error.message);
+            return false;
+        }
+    }
+
+    /**
+     * Send email via Resend HTTP API
+     */
+    async sendViaResend(to, subject, html, text, settings, metadata) {
+        try {
+            if (!settings.resendApiKey) {
+                console.error('[EmailService] Resend API key missing');
+                return false;
+            }
+
+            const response = await fetch('https://api.resend.com/emails', {
+                method: 'POST',
+                headers: {
+                    'Authorization': `Bearer ${settings.resendApiKey}`,
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({
+                    from: `${settings.fromName} <${settings.fromAddress}>`,
+                    to: [to],
+                    subject,
+                    html,
+                    text: text || html.replace(/<[^>]*>/g, ''),
+                }),
+            });
+
+            if (response.ok) {
+                return true;
+            } else {
+                const errorText = await response.text();
+                console.error('[EmailService] Resend error:', response.status, errorText);
+                return false;
+            }
+        } catch (error) {
+            console.error('[EmailService] Resend exception:', error.message);
+            return false;
+        }
+    }
+
+    /**
+     * Send email via SendPulse HTTP API
+     * SendPulse offers 15,000 free emails/month
+     */
+    async sendViaSendPulse(to, subject, html, text, settings, metadata) {
+        try {
+            if (!settings.sendpulseClientId || !settings.sendpulseClientSecret) {
+                console.error('[EmailService] SendPulse credentials missing');
+                return false;
+            }
+
+            // SendPulse uses OAuth2 token-based authentication
+            const tokenParams = new URLSearchParams({
+                grant_type: 'client_credentials',
+                client_id: settings.sendpulseClientId,
+                client_secret: settings.sendpulseClientSecret,
+            });
+
+            const tokenResponse = await fetch('https://api.sendpulse.com/oauth/access_token', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+                body: tokenParams.toString(),
+            });
+
+            if (!tokenResponse.ok) {
+                const error = await tokenResponse.text();
+                console.error('[EmailService] SendPulse auth error:', error);
+                return false;
+            }
+
+            const tokenData = await tokenResponse.json();
+            if (!tokenData.access_token) {
+                console.error('[EmailService] SendPulse: No access token in response');
+                return false;
+            }
+
+            const { access_token } = tokenData;
+            const toBase64 = (str) => Buffer.from(str).toString('base64');
+
+            // Send the email
+            const response = await fetch('https://api.sendpulse.com/smtp/emails', {
+                method: 'POST',
+                headers: {
+                    'Authorization': `Bearer ${access_token}`,
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({
+                    email: {
+                        html: toBase64(html),
+                        text: toBase64(text || html.replace(/<[^>]*>/g, '')),
+                        subject,
+                        from: { name: settings.fromName, email: settings.fromAddress },
+                        to: [{ name: metadata.recipientName || '', email: to }],
+                    },
+                }),
+            });
+
+            if (response.ok) {
+                return true;
+            } else {
+                const errorText = await response.text();
+                console.error('[EmailService] SendPulse send error:', response.status, errorText);
+                return false;
+            }
+        } catch (error) {
+            console.error('[EmailService] SendPulse exception:', error.message);
+            return false;
+        }
+    }
+}
+