@contentgrowth/content-emailing 0.4.1 → 0.5.0

package/src/backend/EmailService.js

@@ -1,537 +0,0 @@
-/**
- * Email Service
- * Unified service for email delivery and template management.
- */
-import { marked } from 'marked';
-import Mustache from 'mustache';
-import { wrapInEmailTemplate } from '../common/htmlWrapper.js';
-import { createDOCacheProvider } from './EmailingCacheDO.js';
-
-export class EmailService {
-    /**
-     * @param {Object} env - Cloudflare environment bindings (DB, etc.)
-     * @param {Object} config - Configuration options
-     * @param {string} [config.emailTablePrefix='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 = {
-            emailTablePrefix: config.emailTablePrefix || config.tableNamePrefix || 'system_email_',
-            defaults: config.defaults || {
-                fromName: 'System',
-                fromAddress: 'noreply@example.com',
-                provider: 'mailchannels'
-            },
-            // Loader function to fetch settings from backend (DB, KV, etc.)
-            // Signature: async (profile, tenantId) => SettingsObject
-            settingsLoader: config.settingsLoader || null,
-
-            // Updater function to save settings to backend
-            // Signature: async (profile, tenantId, settings) => void
-            settingsUpdater: config.settingsUpdater || null,
-
-            // Branding configuration for email templates
-            branding: {
-                brandName: config.branding?.brandName || 'Your App',
-                portalUrl: config.branding?.portalUrl || 'https://app.example.com',
-                primaryColor: config.branding?.primaryColor || '#667eea',
-                ...config.branding
-            },
-            ...config
-        };
-
-        // Cache Auto-detection:
-        // If no provider explicitly passed, try to use built-in DO provider if binding exists
-        if (!cacheProvider && env.EMAIL_TEMPLATE_CACHE) {
-            this.cache = createDOCacheProvider(env.EMAIL_TEMPLATE_CACHE);
-        } else {
-            this.cache = cacheProvider;
-        }
-    }
-
-    // --- Configuration & Settings ---
-
-    /**
-     * Load email configuration
-     * @param {string} profile - 'system' or 'tenant' (or custom profile string)
-     * @param {string} tenantId - Context ID (optional)
-     * @returns {Promise<Object>} Email configuration
-     */
-    async loadSettings(profile = 'system', tenantId = null) {
-        // 1. Try cache (now with Read-Through logic in DO)
-        if (this.cache && this.cache.getSettings) {
-            try {
-                const cached = await this.cache.getSettings(profile, tenantId);
-                if (cached) return this._normalizeConfig(cached);
-            } catch (e) {
-                // Ignore cache/rpc errors
-            }
-        }
-
-        let settings = null;
-
-        // 2. Use settingsLoader (Custom Worker Logic) if provided
-        if (this.config.settingsLoader) {
-            try {
-                settings = await this.config.settingsLoader(profile, tenantId);
-            } catch (e) {
-                console.warn('[EmailService] settingsLoader failed:', e);
-            }
-        }
-
-        // Note: The "Magical D1 Fallback" for system settings has been moved 
-        // INSIDE the EmailTemplateCacheDO (fetchSettingsFromD1).
-        // If the DO failed to find it (or is missing), we fall back to generic defaults below.
-
-        if (settings) {
-            // 3. Populate Cache (Write-Back for custom loaded settings)
-            if (this.cache && this.cache.putSettings) {
-                try {
-                    this.cache.putSettings(profile, tenantId, settings);
-                } catch (e) { /* ignore */ }
-            }
-            return this._normalizeConfig(settings);
-        }
-
-        // 4. Fallback to defaults
-        return {
-            ...this.config.defaults,
-        };
-    }
-
-    /**
-     * Normalize config keys to standard format
-     * Handles both snake_case (DB) and camelCase inputs
-     */
-    _normalizeConfig(config) {
-        return {
-            provider: config.email_provider || config.provider || this.config.defaults.provider,
-            fromAddress: config.email_from_address || config.fromAddress || this.config.defaults.fromAddress,
-            fromName: config.email_from_name || config.fromName || this.config.defaults.fromName,
-
-            // Provider-specific settings (normalize DB keys to service keys)
-            sendgridApiKey: config.sendgrid_api_key || config.sendgridApiKey,
-            resendApiKey: config.resend_api_key || config.resendApiKey,
-            sendpulseClientId: config.sendpulse_client_id || config.sendpulseClientId,
-            sendpulseClientSecret: config.sendpulse_client_secret || config.sendpulseClientSecret,
-
-            // SMTP
-            smtpHost: config.smtp_host || config.smtpHost,
-            smtpPort: config.smtp_port || config.smtpPort,
-            smtpUsername: config.smtp_username || config.smtpUsername,
-            smtpPassword: config.smtp_password || config.smtpPassword,
-
-            // Tracking
-            trackingUrl: config.tracking_url || config.trackingUrl,
-
-            // Pass through others
-            // Pass through others
-            ...config,
-            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.emailTablePrefix}templates`;
-        return await this.db.prepare(`SELECT * FROM ${table} WHERE template_id = ?`)
-            .bind(templateId)
-            .first();
-    }
-
-    async getAllTemplates() {
-        const table = `${this.config.emailTablePrefix}templates`;
-        const result = await this.db.prepare(`SELECT * FROM ${table} ORDER BY template_name`).all();
-        return result.results || [];
-    }
-
-    /**
-     * Save email configuration
-     * @param {Object} settings - Config object
-     * @param {string} profile - 'system' or 'tenant'
-     * @param {string} tenantId - Context ID
-     */
-    async saveSettings(settings, profile = 'system', tenantId = null) {
-        // 1. Convert to DB format if needed (not implemented here, assumes settingsUpdater handles it)
-
-        // 2. Use settingsUpdater if provided (Write-Aside)
-        if (this.config.settingsUpdater) {
-            try {
-                await this.config.settingsUpdater(profile, tenantId, settings);
-            } catch (e) {
-                console.error('[EmailService] settingsUpdater failed:', e);
-                throw e;
-            }
-        }
-        // 3. Helper for saving to D1 (if no updater, legacy/default tables)
-        else if (profile === 'system' && this.db) {
-            // NOTE: We could implement a default D1 upsert here similar to the DO fallback,
-            // but for writing it's safer to rely on explicit updaters or the DO write-through if implemented.
-            // Currently DO supports write-through for 'system' keys.
-        }
-
-        // 4. Update Cache (Write-Invalidate)
-        if (this.cache && this.cache.invalidateSettings) {
-            try {
-                await this.cache.invalidateSettings(profile, tenantId);
-            } catch (e) {
-                console.warn('[EmailService] Failed to invalidate settings cache:', e);
-            }
-        }
-    }
-
-    async saveTemplate(template, userId = 'system') {
-        const table = `${this.config.emailTablePrefix}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.emailTablePrefix}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 = {}) {
-        // Merge branding config with template data
-        const templateData = {
-            ...data,
-            brandName: data.brandName || this.config.branding.brandName,
-            portalUrl: data.portalUrl || this.config.branding.portalUrl,
-            unsubscribeUrl: data.unsubscribeUrl || '{{unsubscribe_url}}'
-        };
-
-        // Use the full branded HTML wrapper from common
-        return wrapInEmailTemplate(content, subject, templateData);
-    }
-
-    // --- 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, htmlBody, text, textBody, provider, profile = 'system', tenantId = null, metadata = {} }) {
-        // Backward compatibility: accept htmlBody/textBody as aliases
-        const htmlContent = html || htmlBody;
-        const textContent = text || textBody;
-
-        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, htmlContent, textContent, settings, metadata);
-                    break;
-                case 'sendgrid':
-                    result = await this.sendViaSendGrid(to, subject, htmlContent, textContent, settings, metadata);
-                    break;
-                case 'resend':
-                    result = await this.sendViaResend(to, subject, htmlContent, textContent, settings, metadata);
-                    break;
-                case 'sendpulse':
-                    result = await this.sendViaSendPulse(to, subject, htmlContent, textContent, 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;
-
-            // Safe base64 encoding
-            const toBase64 = (str) => {
-                if (!str) return '';
-                return Buffer.from(String(str)).toString('base64');
-            };
-
-            // Ensure html/text are strings
-            const htmlSafe = html || '';
-            const textSafe = text || (htmlSafe ? htmlSafe.replace(/<[^>]*>/g, '') : '');
-
-            // 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(htmlSafe),
-                        text: toBase64(textSafe),
-                        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;
-        }
-    }
-}
-