npm - @contentgrowth/content-emailing - Versions diffs - 0.4.1 → 0.5.0 - Mend

@contentgrowth/content-emailing 0.4.1 → 0.5.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (46) hide show

package/dist/backend/EmailService.cjs +728 -0
package/dist/backend/EmailService.cjs.map +1 -0
package/dist/backend/EmailService.js +694 -0
package/dist/backend/EmailService.js.map +1 -0
package/dist/backend/EmailingCacheDO.cjs +390 -0
package/dist/backend/EmailingCacheDO.cjs.map +1 -0
package/dist/backend/EmailingCacheDO.js +365 -0
package/dist/backend/EmailingCacheDO.js.map +1 -0
package/dist/backend/routes/index.cjs +992 -0
package/dist/backend/routes/index.cjs.map +1 -0
package/dist/backend/routes/index.js +956 -0
package/dist/backend/routes/index.js.map +1 -0
package/dist/cli.cjs +53 -0
package/dist/cli.cjs.map +1 -0
package/dist/cli.js +53 -0
package/dist/cli.js.map +1 -0
package/dist/common/index.cjs +267 -0
package/dist/common/index.cjs.map +1 -0
package/{src/common/htmlWrapper.js → dist/common/index.js} +75 -18
package/dist/common/index.js.map +1 -0
package/dist/index.cjs +1537 -0
package/dist/index.cjs.map +1 -0
package/dist/index.js +1488 -0
package/dist/index.js.map +1 -0
package/package.json +27 -12
package/examples/.env.example +0 -16
package/examples/README.md +0 -55
package/examples/mocks/MockD1.js +0 -311
package/examples/mocks/MockEmailSender.js +0 -64
package/examples/mocks/index.js +0 -5
package/examples/package-lock.json +0 -73
package/examples/package.json +0 -18
package/examples/portal/index.html +0 -919
package/examples/server.js +0 -314
package/release.sh +0 -56
package/src/backend/EmailService.js +0 -537
package/src/backend/EmailingCacheDO.js +0 -466
package/src/backend/routes/index.js +0 -30
package/src/backend/routes/templates.js +0 -98
package/src/backend/routes/tracking.js +0 -215
package/src/backend/routes.js +0 -98
package/src/common/index.js +0 -11
package/src/common/utils.js +0 -141
package/src/frontend/TemplateEditor.jsx +0 -117
package/src/frontend/TemplateManager.jsx +0 -117
package/src/index.js +0 -24

package/dist/backend/routes/index.js ADDED Viewed

@@ -0,0 +1,956 @@
+// src/backend/routes/index.js
+import { Hono as Hono3 } from "hono";
+// src/backend/routes/templates.js
+import { Hono } from "hono";
+// src/backend/EmailService.js
+import { marked } from "marked";
+import Mustache from "mustache";
+// src/common/htmlWrapper.js
+function wrapInEmailTemplate(contentHtml, subject, data = {}) {
+  const portalUrl = data.portalUrl || "https://app.x0start.com";
+  const unsubscribeUrl = data.unsubscribeUrl || "{{unsubscribe_url}}";
+  const brandName = data.brandName || "X0 Start";
+  return `
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>${subject}</title>
+  <style>
+    body {
+      margin: 0;
+      padding: 0;
+      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, 'Helvetica Neue', Arial, sans-serif;
+      background-color: #f5f5f5;
+      line-height: 1.6;
+    }
+    .email-wrapper {
+      background-color: #f5f5f5;
+      padding: 40px 20px;
+    }
+    .email-container {
+      max-width: 600px;
+      margin: 0 auto;
+      background-color: #ffffff;
+      border-radius: 8px;
+      overflow: hidden;
+      box-shadow: 0 2px 8px rgba(0,0,0,0.1);
+    }
+    .email-header {
+      padding: 40px 40px 20px;
+      text-align: center;
+      background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+      color: #ffffff;
+    }
+    .email-header h1 {
+      margin: 0;
+      font-size: 28px;
+      font-weight: 600;
+    }
+    .email-content {
+      padding: 30px 40px;
+      color: #333333;
+    }
+    .email-content h1 {
+      font-size: 24px;
+      margin-top: 0;
+      margin-bottom: 20px;
+      color: #333333;
+    }
+    .email-content h2 {
+      font-size: 20px;
+      margin-top: 30px;
+      margin-bottom: 15px;
+      color: #333333;
+    }
+    .email-content h3 {
+      font-size: 16px;
+      margin-top: 20px;
+      margin-bottom: 10px;
+      color: #333333;
+    }
+    .email-content p {
+      margin: 0 0 15px;
+      color: #666666;
+    }
+    .email-content a {
+      color: #667eea;
+      text-decoration: none;
+    }
+    .email-content ul, .email-content ol {
+      margin: 0 0 15px;
+      padding-left: 25px;
+    }
+    .email-content li {
+      margin-bottom: 8px;
+      color: #666666;
+    }
+    .email-content blockquote {
+      margin: 20px 0;
+      padding: 15px 20px;
+      background-color: #f8f9fa;
+      border-left: 4px solid #667eea;
+      color: #666666;
+    }
+    .email-content code {
+      padding: 2px 6px;
+      background-color: #f8f9fa;
+      border-radius: 3px;
+      font-family: 'Courier New', monospace;
+      font-size: 14px;
+    }
+    .email-content pre {
+      padding: 15px;
+      background-color: #f8f9fa;
+      border-radius: 6px;
+      overflow-x: auto;
+    }
+    .email-content pre code {
+      padding: 0;
+      background: none;
+    }
+    .btn {
+      display: inline-block;
+      padding: 12px 24px;
+      background-color: #667eea;
+      color: #ffffff !important;
+      text-decoration: none;
+      border-radius: 6px;
+      font-weight: 600;
+      margin: 10px 0;
+    }
+    .btn:hover {
+      background-color: #5568d3;
+    }
+    .email-footer {
+      padding: 20px 40px;
+      background-color: #f8f9fa;
+      text-align: center;
+      font-size: 12px;
+      color: #666666;
+    }
+    .email-footer a {
+      color: #667eea;
+      text-decoration: none;
+    }
+    hr {
+      border: none;
+      border-top: 1px solid #e0e0e0;
+      margin: 30px 0;
+    }
+  </style>
+</head>
+<body>
+  <div class="email-wrapper">
+    <div class="email-container">
+      <div class="email-content">
+        ${contentHtml}
+      </div>
+      <div class="email-footer">
+        <p style="margin: 0 0 10px;">
+          You're receiving this email from ${brandName}.
+        </p>
+        <p style="margin: 0;">
+          <a href="${unsubscribeUrl}">Unsubscribe</a> |
+          <a href="${portalUrl}/settings/notifications">Manage Preferences</a>
+        </p>
+      </div>
+    </div>
+  </div>
+</body>
+</html>
+  `.trim();
+}
+// src/backend/EmailingCacheDO.js
+function createDOCacheProvider(doStub, instanceName = "global") {
+  if (!doStub) {
+    return null;
+  }
+  const stub = doStub.get(doStub.idFromName(instanceName));
+  return {
+    async getTemplate(templateId) {
+      try {
+        const response = await stub.fetch(`http://do/get?templateId=${templateId}`);
+        const data = await response.json();
+        return data.template || null;
+      } catch (e) {
+        console.warn("[DOCacheProvider] Failed to get template:", e);
+        return null;
+      }
+    },
+    async getSettings(profile, tenantId) {
+      const key = `${profile}:${tenantId || ""}`;
+      try {
+        const response = await stub.fetch(`http://do/settings/get?key=${encodeURIComponent(key)}`);
+        const data = await response.json();
+        return data.settings || null;
+      } catch (e) {
+        return null;
+      }
+    },
+    async putSettings(profile, tenantId, settings) {
+      const key = `${profile}:${tenantId || ""}`;
+      try {
+        await stub.fetch("http://do/settings/put", {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ key, settings })
+        });
+      } catch (e) {
+        console.warn("[DOCacheProvider] Failed to cache settings:", e);
+      }
+    },
+    async putTemplate(template) {
+      try {
+        await stub.fetch("http://do/invalidate", {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ templateId: template.template_id })
+        });
+      } catch (e) {
+        console.warn("[DOCacheProvider] Failed to invalidate template:", e);
+      }
+    },
+    async deleteTemplate(templateId) {
+      try {
+        await stub.fetch("http://do/invalidate", {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ templateId })
+        });
+      } catch (e) {
+        console.warn("[DOCacheProvider] Failed to invalidate template:", e);
+      }
+    },
+    async invalidateSettings(profile, tenantId) {
+      const key = `${profile}:${tenantId || ""}`;
+      try {
+        await stub.fetch("http://do/settings/invalidate", {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ key })
+        });
+      } catch (e) {
+        console.warn("[DOCacheProvider] Failed to invalidate settings:", e);
+      }
+    }
+  };
+}
+// src/backend/EmailService.js
+var EmailService = class {
+  /**
+   * @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) {
+    var _a, _b, _c;
+    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: ((_a = config.branding) == null ? void 0 : _a.brandName) || "Your App",
+        portalUrl: ((_b = config.branding) == null ? void 0 : _b.portalUrl) || "https://app.example.com",
+        primaryColor: ((_c = config.branding) == null ? void 0 : _c.primaryColor) || "#667eea",
+        ...config.branding
+      },
+      ...config
+    };
+    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) {
+    if (this.cache && this.cache.getSettings) {
+      try {
+        const cached = await this.cache.getSettings(profile, tenantId);
+        if (cached) return this._normalizeConfig(cached);
+      } catch (e) {
+      }
+    }
+    let settings = null;
+    if (this.config.settingsLoader) {
+      try {
+        settings = await this.config.settingsLoader(profile, tenantId);
+      } catch (e) {
+        console.warn("[EmailService] settingsLoader failed:", e);
+      }
+    }
+    if (settings) {
+      if (this.cache && this.cache.putSettings) {
+        try {
+          this.cache.putSettings(profile, tenantId, settings);
+        } catch (e) {
+        }
+      }
+      return this._normalizeConfig(settings);
+    }
+    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) {
+    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) {
+    if (this.config.settingsUpdater) {
+      try {
+        await this.config.settingsUpdater(profile, tenantId, settings);
+      } catch (e) {
+        console.error("[EmailService] settingsUpdater failed:", e);
+        throw e;
+      }
+    } else if (profile === "system" && this.db) {
+    }
+    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() / 1e3);
+    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();
+    }
+    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}`);
+    const subject = Mustache.render(template.subject_template, data);
+    const markdown = Mustache.render(template.body_markdown, data);
+    marked.use({ mangle: false, headerIds: false });
+    const htmlContent = marked.parse(markdown);
+    const html = this.wrapInBaseTemplate(htmlContent, subject, data);
+    const plainText = markdown.replace(/<[^>]*>/g, "");
+    return { subject, html, plainText };
+  }
+  wrapInBaseTemplate(content, subject, data = {}) {
+    const templateData = {
+      ...data,
+      brandName: data.brandName || this.config.branding.brandName,
+      portalUrl: data.portalUrl || this.config.branding.portalUrl,
+      unsubscribeUrl: data.unsubscribeUrl || "{{unsubscribe_url}}"
+    };
+    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 = {} }) {
+    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 == null ? void 0 : 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;
+      }
+      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) => {
+        if (!str) return "";
+        return Buffer.from(String(str)).toString("base64");
+      };
+      const htmlSafe = html || "";
+      const textSafe = text || (htmlSafe ? htmlSafe.replace(/<[^>]*>/g, "") : "");
+      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;
+    }
+  }
+};
+// src/backend/routes/templates.js
+function createTemplateRoutes(env, config = {}, cacheProvider = null) {
+  const app = new Hono();
+  const emailService = new EmailService(env, config, cacheProvider);
+  app.get("/templates", async (c) => {
+    try {
+      const templates = await emailService.getAllTemplates();
+      return c.json({ success: true, templates });
+    } catch (err) {
+      return c.json({ success: false, error: err.message }, 500);
+    }
+  });
+  app.get("/templates/:id", async (c) => {
+    try {
+      const template = await emailService.getTemplate(c.req.param("id"));
+      if (!template) return c.json({ success: false, error: "Template not found" }, 404);
+      return c.json({ success: true, template });
+    } catch (err) {
+      return c.json({ success: false, error: err.message }, 500);
+    }
+  });
+  app.post("/templates", async (c) => {
+    try {
+      const data = await c.req.json();
+      await emailService.saveTemplate(data, "admin");
+      return c.json({ success: true, message: "Template saved" });
+    } catch (err) {
+      return c.json({ success: false, error: err.message }, 500);
+    }
+  });
+  app.delete("/templates/:id", async (c) => {
+    try {
+      await emailService.deleteTemplate(c.req.param("id"));
+      return c.json({ success: true, message: "Template deleted" });
+    } catch (err) {
+      return c.json({ success: false, error: err.message }, 500);
+    }
+  });
+  app.post("/templates/:id/preview", async (c) => {
+    try {
+      const id = c.req.param("id");
+      const data = await c.req.json();
+      const result = await emailService.renderTemplate(id, data);
+      return c.json({ success: true, preview: result });
+    } catch (err) {
+      return c.json({ success: false, error: err.message }, 500);
+    }
+  });
+  app.post("/templates/:id/test", async (c) => {
+    try {
+      const id = c.req.param("id");
+      const { to, data } = await c.req.json();
+      const { subject, html, plainText } = await emailService.renderTemplate(id, data);
+      const result = await emailService.sendEmail({
+        to,
+        subject: `[TEST] ${subject}`,
+        html,
+        text: plainText
+      });
+      if (result.success) {
+        return c.json({ success: true, message: "Test email sent" });
+      } else {
+        return c.json({ success: false, error: result.error }, 500);
+      }
+    } catch (err) {
+      return c.json({ success: false, error: err.message }, 500);
+    }
+  });
+  return app;
+}
+// src/backend/routes/tracking.js
+import { Hono as Hono2 } from "hono";
+var TRACKING_PIXEL = new Uint8Array([
+  71,
+  73,
+  70,
+  56,
+  57,
+  97,
+  1,
+  0,
+  1,
+  0,
+  128,
+  0,
+  0,
+  0,
+  0,
+  0,
+  255,
+  255,
+  255,
+  33,
+  249,
+  4,
+  1,
+  0,
+  0,
+  0,
+  0,
+  44,
+  0,
+  0,
+  0,
+  0,
+  1,
+  0,
+  1,
+  0,
+  0,
+  2,
+  1,
+  68,
+  0,
+  59
+]);
+function createTrackingRoutes(env, config = {}) {
+  const app = new Hono2();
+  const db = env.DB;
+  const tablePrefix = config.emailTablePrefix || config.tableNamePrefix || "system_email_";
+  app.get("/track/open/:token", async (c) => {
+    const token = c.req.param("token");
+    try {
+      const sendId = token;
+      const send = await db.prepare(`SELECT * FROM ${tablePrefix}sends WHERE send_id = ?`).bind(sendId).first();
+      if (send) {
+        const eventId = crypto.randomUUID();
+        const now = Math.floor(Date.now() / 1e3);
+        await db.prepare(
+          `INSERT INTO ${tablePrefix}events (
+              event_id, send_id, user_id, tenant_id, email_kind, event_type, metadata, created_at
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`
+        ).bind(
+          eventId,
+          sendId,
+          send.user_id,
+          send.tenant_id,
+          send.email_kind,
+          "opened",
+          JSON.stringify({
+            user_agent: c.req.header("user-agent"),
+            referer: c.req.header("referer")
+          }),
+          now
+        ).run();
+      }
+    } catch (error) {
+      console.error("[EmailTracking] Error tracking email open:", error);
+    }
+    return new Response(TRACKING_PIXEL, {
+      headers: {
+        "Content-Type": "image/gif",
+        "Cache-Control": "no-cache, no-store, must-revalidate",
+        "Pragma": "no-cache",
+        "Expires": "0"
+      }
+    });
+  });
+  app.post("/track/click/:token", async (c) => {
+    const token = c.req.param("token");
+    let url;
+    try {
+      const body = await c.req.json();
+      url = body.url;
+    } catch {
+      return c.json({ success: false, error: "Invalid request body" }, 400);
+    }
+    if (!url) {
+      return c.json({ success: false, error: "Missing URL" }, 400);
+    }
+    try {
+      const sendId = token;
+      const send = await db.prepare(`SELECT * FROM ${tablePrefix}sends WHERE send_id = ?`).bind(sendId).first();
+      if (send) {
+        const eventId = crypto.randomUUID();
+        const now = Math.floor(Date.now() / 1e3);
+        await db.prepare(
+          `INSERT INTO ${tablePrefix}events (
+              event_id, send_id, user_id, tenant_id, email_kind, event_type, metadata, created_at
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`
+        ).bind(
+          eventId,
+          sendId,
+          send.user_id,
+          send.tenant_id,
+          send.email_kind,
+          "clicked",
+          JSON.stringify({
+            url,
+            user_agent: c.req.header("user-agent"),
+            referer: c.req.header("referer")
+          }),
+          now
+        ).run();
+      }
+      return c.json({ success: true, tracked: !!send });
+    } catch (error) {
+      console.error("[EmailTracking] Error tracking email click:", error);
+      return c.json({ success: false, error: "Failed to track click" }, 500);
+    }
+  });
+  app.get("/unsubscribe/:token", async (c) => {
+    const unsubToken = c.req.param("token");
+    try {
+      const prefs = await db.prepare(`SELECT * FROM ${tablePrefix}preferences WHERE unsub_token = ?`).bind(unsubToken).first();
+      if (!prefs) {
+        return c.json({ success: false, error: "Invalid unsubscribe link" }, 404);
+      }
+      const currentSettings = JSON.parse(prefs.email_settings || "{}");
+      const alreadyUnsubscribed = Object.keys(currentSettings).length === 0;
+      if (!alreadyUnsubscribed) {
+        const now = Math.floor(Date.now() / 1e3);
+        await db.prepare(
+          `UPDATE ${tablePrefix}preferences
+             SET email_settings = '{}',
+                 updated_at = ?
+             WHERE unsub_token = ?`
+        ).bind(now, unsubToken).run();
+        const eventId = crypto.randomUUID();
+        await db.prepare(
+          `INSERT INTO ${tablePrefix}events (
+              event_id, send_id, user_id, tenant_id, email_kind, event_type, metadata, created_at
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`
+        ).bind(
+          eventId,
+          "unsubscribe",
+          prefs.user_id,
+          prefs.tenant_id,
+          "all",
+          "unsubscribed",
+          JSON.stringify({
+            user_agent: c.req.header("user-agent")
+          }),
+          now
+        ).run();
+      }
+      return c.json({ success: true, alreadyUnsubscribed });
+    } catch (error) {
+      console.error("[EmailTracking] Error processing unsubscribe:", error);
+      return c.json({ success: false, error: "An error occurred" }, 500);
+    }
+  });
+  return app;
+}
+// src/backend/routes/index.js
+function createEmailRoutes(env, config = {}, cacheProvider = null) {
+  const app = new Hono3();
+  app.route("/api/email", createTemplateRoutes(env, config, cacheProvider));
+  app.route("/email", createTrackingRoutes(env, config));
+  return app;
+}
+export {
+  createEmailRoutes,
+  createTemplateRoutes,
+  createTrackingRoutes
+};
+//# sourceMappingURL=index.js.map