npm - @contentgrowth/content-emailing - Versions diffs - 0.7.4 → 0.7.6 - Mend

@contentgrowth/content-emailing 0.7.4 → 0.7.6

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 (19) hide show

package/dist/backend/index.cjs +1771 -0
package/dist/backend/index.cjs.map +1 -0
package/dist/backend/index.d.cts +70 -0
package/dist/backend/index.d.ts +70 -0
package/dist/backend/index.js +1722 -0
package/dist/backend/index.js.map +1 -0
package/dist/backend/routes/index.cjs +87 -42
package/dist/backend/routes/index.cjs.map +1 -1
package/dist/backend/routes/index.d.cts +10 -6
package/dist/backend/routes/index.d.ts +10 -6
package/dist/backend/routes/index.js +86 -42
package/dist/backend/routes/index.js.map +1 -1
package/dist/index.cjs +85 -42
package/dist/index.cjs.map +1 -1
package/dist/index.d.cts +1 -65
package/dist/index.d.ts +1 -65
package/dist/index.js +85 -42
package/dist/index.js.map +1 -1
package/package.json +1 -1

package/dist/backend/index.cjs ADDED Viewed

@@ -0,0 +1,1771 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+// src/backend/index.js
+var backend_exports = {};
+__export(backend_exports, {
+  EmailLogger: () => EmailLogger,
+  EmailService: () => EmailService,
+  EmailingCacheDO: () => EmailingCacheDO,
+  createDOCacheProvider: () => createDOCacheProvider,
+  createEmailLoggerCallback: () => createEmailLoggerCallback,
+  createEmailRoutes: () => createEmailRoutes,
+  createTemplateRoutes: () => createTemplateRoutes,
+  createTrackingRoutes: () => createTrackingRoutes,
+  encodeTrackingLinks: () => encodeTrackingLinks,
+  extractVariables: () => extractVariables,
+  getWebsiteUrl: () => getWebsiteUrl,
+  markdownToPlainText: () => markdownToPlainText,
+  resetWebsiteUrlCache: () => resetWebsiteUrlCache,
+  wrapInEmailTemplate: () => wrapInEmailTemplate
+});
+module.exports = __toCommonJS(backend_exports);
+// src/backend/EmailService.js
+var import_marked = require("marked");
+var import_mustache = __toESM(require("mustache"), 1);
+// 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
+var EmailingCacheDO = class {
+  constructor(state, env) {
+    this.state = state;
+    this.env = env;
+    this.cache = /* @__PURE__ */ new Map();
+    this.settingsCache = /* @__PURE__ */ new Map();
+    this.cacheTTL = 36e5;
+    this.emailTablePrefix = env.EMAIL_TABLE_PREFIX || "system_email_";
+    this.settingsTableName = env.EMAIL_SETTINGS_TABLE || "system_settings";
+    this.settingsKeyPrefix = env.EMAIL_SETTINGS_KEY_PREFIX || "";
+  }
+  /**
+   * Handle HTTP requests to this Durable Object
+   */
+  async fetch(request) {
+    const url = new URL(request.url);
+    const path = url.pathname;
+    try {
+      if (path === "/get" && request.method === "GET") {
+        return this.handleGet(request);
+      } else if (path === "/invalidate" && request.method === "POST") {
+        return this.handleInvalidate(request);
+      } else if (path === "/clear" && request.method === "POST") {
+        return this.handleClear(request);
+      } else if (path === "/stats" && request.method === "GET") {
+        return this.handleStats(request);
+      } else if (path === "/settings/get" && request.method === "GET") {
+        return this.handleGetSettings(request);
+      } else if (path === "/settings/put" && request.method === "POST") {
+        return this.handlePutSettings(request);
+      } else if (path === "/settings/invalidate" && request.method === "POST") {
+        return this.handleInvalidateSettings(request);
+      } else {
+        return new Response("Not Found", { status: 404 });
+      }
+    } catch (error) {
+      console.error("[EmailingCacheDO] Error:", error);
+      return new Response(JSON.stringify({ error: error.message }), {
+        status: 500,
+        headers: { "Content-Type": "application/json" }
+      });
+    }
+  }
+  /**
+   * Get template (from cache or D1)
+   */
+  async handleGet(request) {
+    const url = new URL(request.url);
+    const templateId = url.searchParams.get("templateId");
+    const forceRefresh = url.searchParams.get("refresh") === "true";
+    if (!templateId) {
+      return new Response(JSON.stringify({ error: "templateId is required" }), {
+        status: 400,
+        headers: { "Content-Type": "application/json" }
+      });
+    }
+    if (!forceRefresh) {
+      const cached = this.cache.get(templateId);
+      if (cached && Date.now() - cached.timestamp < this.cacheTTL) {
+        console.log("[EmailingCacheDO] Cache HIT:", templateId);
+        return new Response(JSON.stringify({
+          template: cached.data,
+          cached: true,
+          age: Date.now() - cached.timestamp
+        }), {
+          headers: { "Content-Type": "application/json" }
+        });
+      }
+    }
+    console.log("[EmailingCacheDO] Cache MISS - fetching from D1:", templateId);
+    const template = await this.fetchTemplateFromD1(templateId);
+    if (!template) {
+      return new Response(JSON.stringify({
+        error: "Template not found",
+        templateId
+      }), {
+        status: 404,
+        headers: { "Content-Type": "application/json" }
+      });
+    }
+    this.cache.set(templateId, {
+      data: template,
+      timestamp: Date.now()
+    });
+    return new Response(JSON.stringify({
+      template,
+      cached: false
+    }), {
+      headers: { "Content-Type": "application/json" }
+    });
+  }
+  // --- Settings Cache Handlers ---
+  async handleGetSettings(request) {
+    const url = new URL(request.url);
+    const key = url.searchParams.get("key");
+    if (!key) return new Response("Key required", { status: 400 });
+    const cached = this.settingsCache.get(key);
+    if (cached && Date.now() - cached.timestamp < this.cacheTTL) {
+      console.log("[EmailingCacheDO] Settings Cache HIT:", key);
+      return new Response(JSON.stringify({ settings: cached.data }), {
+        headers: { "Content-Type": "application/json" }
+      });
+    }
+    if (key.startsWith("system")) {
+      console.log("[EmailingCacheDO] Settings Cache MISS - fetching from D1:", key);
+      const settings = await this.fetchSettingsFromD1(key);
+      if (settings) {
+        this.settingsCache.set(key, {
+          data: settings,
+          timestamp: Date.now()
+        });
+        return new Response(JSON.stringify({ settings }), {
+          headers: { "Content-Type": "application/json" }
+        });
+      }
+    }
+    return new Response(JSON.stringify({ settings: null }), {
+      headers: { "Content-Type": "application/json" }
+    });
+  }
+  async handlePutSettings(request) {
+    try {
+      const body = await request.json();
+      const { key, settings } = body;
+      if (!key || !settings) return new Response("Key and settings required", { status: 400 });
+      this.settingsCache.set(key, {
+        data: settings,
+        timestamp: Date.now()
+      });
+      if (key.startsWith("system")) {
+        await this.saveSettingsToD1(settings);
+      }
+      return new Response(JSON.stringify({ success: true }), {
+        headers: { "Content-Type": "application/json" }
+      });
+    } catch (e) {
+      console.error("[EmailingCacheDO] PutSettings error:", e);
+      return new Response("Error parsing body/saving", { status: 400 });
+    }
+  }
+  async handleInvalidateSettings(request) {
+    try {
+      const body = await request.json();
+      const { key } = body;
+      if (!key) return new Response("Key required", { status: 400 });
+      const existed = this.settingsCache.has(key);
+      this.settingsCache.delete(key);
+      console.log("[EmailingCacheDO] Invalidated settings:", key, existed ? "(existed)" : "(not in cache)");
+      return new Response(JSON.stringify({ success: true, existed }), {
+        headers: { "Content-Type": "application/json" }
+      });
+    } catch (e) {
+      console.error("[EmailingCacheDO] InvalidateSettings error:", e);
+      return new Response("Error invalidated settings", { status: 400 });
+    }
+  }
+  /**
+   * Invalidate specific template(s) from cache
+   * Body: { templateId: 'template_id' } or { templateId: '*' } for all
+   */
+  async handleInvalidate(request) {
+    const body = await request.json();
+    const { templateId } = body;
+    if (!templateId) {
+      return new Response(JSON.stringify({ error: "templateId is required" }), {
+        status: 400,
+        headers: { "Content-Type": "application/json" }
+      });
+    }
+    if (templateId === "*") {
+      const count = this.cache.size;
+      this.cache.clear();
+      console.log("[EmailingCacheDO] Invalidated ALL templates:", count);
+      return new Response(JSON.stringify({
+        success: true,
+        message: `Invalidated ${count} templates`
+      }), {
+        headers: { "Content-Type": "application/json" }
+      });
+    }
+    const existed = this.cache.has(templateId);
+    this.cache.delete(templateId);
+    console.log("[EmailingCacheDO] Invalidated template:", templateId, existed ? "(existed)" : "(not in cache)");
+    return new Response(JSON.stringify({
+      success: true,
+      message: existed ? "Template invalidated" : "Template was not in cache",
+      templateId
+    }), {
+      headers: { "Content-Type": "application/json" }
+    });
+  }
+  /**
+   * Clear entire cache (admin operation)
+   */
+  async handleClear(request) {
+    const count = this.cache.size + this.settingsCache.size;
+    this.cache.clear();
+    this.settingsCache.clear();
+    console.log("[EmailingCacheDO] Cache cleared:", count, "entries (templates + settings)");
+    return new Response(JSON.stringify({
+      success: true,
+      message: `Cleared ${count} cached items`
+    }), {
+      headers: { "Content-Type": "application/json" }
+    });
+  }
+  /**
+   * Get cache statistics
+   */
+  async handleStats(request) {
+    const stats = {
+      templates: this.cache.size,
+      settings: this.settingsCache.size,
+      cacheTTL: this.cacheTTL
+    };
+    return new Response(JSON.stringify(stats), {
+      headers: { "Content-Type": "application/json" }
+    });
+  }
+  /**
+   * Fetch template from D1
+   */
+  async fetchTemplateFromD1(templateId) {
+    const db = this.env.DB;
+    const tableName = `${this.emailTablePrefix}templates`;
+    try {
+      const template = await db.prepare(`SELECT * FROM ${tableName} WHERE template_id = ? AND is_active = 1`).bind(templateId).first();
+      return template;
+    } catch (e) {
+      console.error(`[EmailingCacheDO] DB Error (${tableName}):`, e);
+      return null;
+    }
+  }
+  /**
+   * Fetch settings from D1
+   * Only supports default table (e.g. system_settings) for now
+   */
+  async fetchSettingsFromD1(key) {
+    const db = this.env.DB;
+    const tableName = this.settingsTableName;
+    const prefix = this.settingsKeyPrefix;
+    try {
+      let results;
+      if (prefix) {
+        try {
+          results = await db.prepare(`SELECT * FROM ${tableName} WHERE setting_key LIKE ?`).bind(`${prefix}%`).all();
+        } catch (e) {
+          results = await db.prepare(`SELECT * FROM ${tableName} WHERE key LIKE ?`).bind(`${prefix}%`).all();
+        }
+      } else {
+        results = await db.prepare(`SELECT * FROM ${tableName}`).all();
+      }
+      if (!results.results || results.results.length === 0) return null;
+      const settings = {};
+      results.results.forEach((row) => {
+        const k = row.setting_key || row.key;
+        const v = row.setting_value || row.value;
+        if (k) settings[k] = v;
+      });
+      return settings;
+    } catch (e) {
+      console.warn(`[EmailingCacheDO] Failed to load settings from ${tableName}:`, e);
+      return null;
+    }
+  }
+  async saveSettingsToD1(settings) {
+    const db = this.env.DB;
+    const tableName = this.settingsTableName;
+    const entries = Object.entries(settings);
+    for (const [k, v] of entries) {
+      try {
+        try {
+          const res = await db.prepare(`UPDATE ${tableName} SET setting_value = ? WHERE setting_key = ?`).bind(v, k).run();
+          if (res.meta.changes === 0) {
+            await db.prepare(`INSERT INTO ${tableName} (setting_key, setting_value) VALUES (?, ?)`).bind(k, v).run();
+          }
+        } catch (e) {
+          await db.prepare(`INSERT OR REPLACE INTO ${tableName} (key, value) VALUES (?, ?)`).bind(k, v).run();
+        }
+      } catch (e) {
+        console.warn("[EmailingCacheDO] Failed to save setting to D1:", k);
+      }
+    }
+  }
+};
+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) {
+        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/EmailLogger.js
+var EmailLogger = class {
+  /**
+   * @param {Object} db - D1 database binding
+   * @param {Object} options - Configuration options
+   * @param {string} [options.tableName='system_email_logs'] - Table name for logs
+   */
+  constructor(db, options = {}) {
+    this.db = db;
+    this.tableName = options.tableName || "system_email_logs";
+  }
+  /**
+   * Creates a logger callback function for use with EmailService.
+   * Usage: new EmailService(env, { emailLogger: emailLogger.createCallback() })
+   */
+  createCallback() {
+    return async (entry) => {
+      await this.log(entry);
+    };
+  }
+  /**
+   * Log an email event (pending, sent, or failed)
+   * @param {Object} entry - Log entry
+   */
+  async log(entry) {
+    const {
+      event,
+      recipientEmail,
+      recipientUserId,
+      templateId,
+      subject,
+      provider,
+      messageId,
+      batchId,
+      error,
+      errorCode,
+      metadata
+    } = entry;
+    try {
+      if (event === "pending") {
+        const id = crypto.randomUUID().replace(/-/g, "");
+        await this.db.prepare(`
+                    INSERT INTO ${this.tableName}
+                    (id, batch_id, recipient_email, recipient_user_id, template_id, subject, status, metadata, created_at)
+                    VALUES (?, ?, ?, ?, ?, ?, 'pending', ?, strftime('%s', 'now'))
+                `).bind(
+          id,
+          batchId || null,
+          recipientEmail,
+          recipientUserId || null,
+          templateId || "direct",
+          subject || null,
+          metadata ? JSON.stringify(metadata) : null
+        ).run();
+      } else if (event === "sent") {
+        await this.db.prepare(`
+                    UPDATE ${this.tableName}
+                    SET status = 'sent',
+                        provider = ?,
+                        provider_message_id = ?,
+                        sent_at = strftime('%s', 'now')
+                    WHERE recipient_email = ?
+                      AND template_id = ?
+                      AND status = 'pending'
+                    ORDER BY created_at DESC
+                    LIMIT 1
+                `).bind(
+          provider || null,
+          messageId || null,
+          recipientEmail,
+          templateId || "direct"
+        ).run();
+      } else if (event === "failed") {
+        await this.db.prepare(`
+                    UPDATE ${this.tableName}
+                    SET status = 'failed',
+                        provider = ?,
+                        error_message = ?,
+                        error_code = ?
+                    WHERE recipient_email = ?
+                      AND template_id = ?
+                      AND status = 'pending'
+                    ORDER BY created_at DESC
+                    LIMIT 1
+                `).bind(
+          provider || null,
+          error || null,
+          errorCode || null,
+          recipientEmail,
+          templateId || "direct"
+        ).run();
+      }
+    } catch (e) {
+      console.error("[EmailLogger] Failed to log:", e);
+    }
+  }
+  /**
+   * Query email logs with filtering
+   * @param {Object} options - Query options
+   */
+  async query(options = {}) {
+    const {
+      recipientEmail,
+      recipientUserId,
+      templateId,
+      status,
+      batchId,
+      limit = 50,
+      offset = 0
+    } = options;
+    const conditions = [];
+    const bindings = [];
+    if (recipientEmail) {
+      conditions.push("recipient_email = ?");
+      bindings.push(recipientEmail);
+    }
+    if (recipientUserId) {
+      conditions.push("recipient_user_id = ?");
+      bindings.push(recipientUserId);
+    }
+    if (templateId) {
+      conditions.push("template_id = ?");
+      bindings.push(templateId);
+    }
+    if (status) {
+      conditions.push("status = ?");
+      bindings.push(status);
+    }
+    if (batchId) {
+      conditions.push("batch_id = ?");
+      bindings.push(batchId);
+    }
+    const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+    const countResult = await this.db.prepare(
+      `SELECT COUNT(*) as count FROM ${this.tableName} ${whereClause}`
+    ).bind(...bindings).first();
+    const { results } = await this.db.prepare(`
+            SELECT id, batch_id, recipient_email, recipient_user_id, template_id, subject,
+                   status, provider, provider_message_id, error_message, error_code, metadata,
+                   created_at, sent_at
+            FROM ${this.tableName}
+            ${whereClause}
+            ORDER BY created_at DESC
+            LIMIT ? OFFSET ?
+        `).bind(...bindings, limit, offset).all();
+    const logs = (results || []).map((row) => ({
+      id: row.id,
+      batchId: row.batch_id,
+      recipientEmail: row.recipient_email,
+      recipientUserId: row.recipient_user_id,
+      templateId: row.template_id,
+      subject: row.subject,
+      status: row.status,
+      provider: row.provider,
+      providerMessageId: row.provider_message_id,
+      errorMessage: row.error_message,
+      errorCode: row.error_code,
+      metadata: row.metadata ? JSON.parse(row.metadata) : void 0,
+      createdAt: row.created_at,
+      sentAt: row.sent_at
+    }));
+    return { logs, total: countResult?.count || 0 };
+  }
+  /**
+   * Get email sending statistics
+   * @param {number} sinceDays - Number of days to look back
+   */
+  async getStats(sinceDays = 7) {
+    const sinceTimestamp = Math.floor(Date.now() / 1e3) - sinceDays * 24 * 60 * 60;
+    const statusResult = await this.db.prepare(`
+            SELECT status, COUNT(*) as count
+            FROM ${this.tableName}
+            WHERE created_at >= ?
+            GROUP BY status
+        `).bind(sinceTimestamp).all();
+    const templateResult = await this.db.prepare(`
+            SELECT template_id, COUNT(*) as count
+            FROM ${this.tableName}
+            WHERE created_at >= ?
+            GROUP BY template_id
+        `).bind(sinceTimestamp).all();
+    const stats = {
+      total: 0,
+      sent: 0,
+      failed: 0,
+      pending: 0,
+      byTemplate: {}
+    };
+    (statusResult.results || []).forEach((row) => {
+      const count = row.count || 0;
+      stats.total += count;
+      if (row.status === "sent") stats.sent = count;
+      if (row.status === "failed") stats.failed = count;
+      if (row.status === "pending") stats.pending = count;
+    });
+    (templateResult.results || []).forEach((row) => {
+      stats.byTemplate[row.template_id] = row.count;
+    });
+    return stats;
+  }
+  /**
+   * Get recent failed emails for debugging
+   * @param {number} limit - Number of failed emails to retrieve
+   */
+  async getRecentFailures(limit = 20) {
+    const { results } = await this.db.prepare(`
+            SELECT id, recipient_email, template_id, subject, error_message, error_code, created_at
+            FROM ${this.tableName}
+            WHERE status = 'failed'
+            ORDER BY created_at DESC
+            LIMIT ?
+        `).bind(limit).all();
+    return results || [];
+  }
+};
+function createEmailLoggerCallback(db, tableName = "system_email_logs") {
+  const logger = new EmailLogger(db, { tableName });
+  return logger.createCallback();
+}
+// 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 {boolean|Function} [config.emailLogger] - Email logger: true (default), false (disabled), or custom callback
+   * @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
+    };
+    if (config.emailLogger === false) {
+      this.emailLogger = null;
+    } else if (typeof config.emailLogger === "function") {
+      this.emailLogger = config.emailLogger;
+    } else if (env.DB) {
+      const logger = new EmailLogger(env.DB);
+      this.emailLogger = logger.createCallback();
+    } else {
+      this.emailLogger = null;
+    }
+    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 ---
+  /**
+   * Pre-process template data to auto-format URLs
+   * Scans for strings starting with http:// or https:// and wraps them in Markdown links
+   */
+  _preprocessData(data) {
+    if (!data || typeof data !== "object") return data;
+    const processed = { ...data };
+    for (const [key, value] of Object.entries(processed)) {
+      if (typeof value === "string" && (value.startsWith("http://") || value.startsWith("https://"))) {
+        if (!value.trim().startsWith("[") && !value.includes("](")) {
+          processed[key] = `[${value}](${value})`;
+        }
+      }
+    }
+    return processed;
+  }
+  async renderTemplate(templateId, data) {
+    const template = await this.getTemplate(templateId);
+    if (!template) throw new Error(`Template not found: ${templateId}`);
+    const processedData = this._preprocessData(data);
+    const subject = import_mustache.default.render(template.subject_template, processedData);
+    let markdown = import_mustache.default.render(template.body_markdown, processedData);
+    markdown = markdown.replace(/\\n/g, "\n");
+    import_marked.marked.use({
+      mangle: false,
+      headerIds: false,
+      breaks: true
+      // Convert single line breaks to <br>
+    });
+    const htmlContent = import_marked.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 an email using a template
+   * @param {string} templateId - Template ID
+   * @param {Object} data - Template variables
+   * @param {Object} options - Sending options (to, provider, etc.)
+   * @returns {Promise<Object>} Delivery result
+   */
+  async sendViaTemplate(templateId, data, options) {
+    try {
+      const { subject, html, plainText } = await this.renderTemplate(templateId, data);
+      return await this.sendEmail({
+        ...options,
+        subject,
+        // Can be overridden by options.subject if needed, but usually template subject is preferred
+        html,
+        text: plainText,
+        metadata: {
+          ...options.metadata,
+          templateId
+        }
+      });
+    } catch (error) {
+      console.error(`[EmailService] sendViaTemplate failed for ${templateId}:`, error);
+      return { success: false, error: error.message };
+    }
+  }
+  /**
+   * 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 = {}, batchId = null, userId = null }) {
+    const htmlContent = html || htmlBody;
+    const textContent = text || textBody;
+    const templateId = metadata?.templateId || "direct";
+    if (this.emailLogger) {
+      try {
+        await this.emailLogger({
+          event: "pending",
+          recipientEmail: to,
+          recipientUserId: userId,
+          templateId,
+          subject,
+          batchId,
+          metadata
+        });
+      } catch (e) {
+        console.warn("[EmailService] emailLogger pending failed:", e);
+      }
+    }
+    try {
+      const settings = await this.loadSettings(profile, tenantId);
+      const useProvider = provider || settings.provider || "mailchannels";
+      let result;
+      let providerMessageId = null;
+      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);
+          if (result && typeof result === "object" && result.id) {
+            providerMessageId = result.id;
+            result = true;
+          }
+          break;
+        case "sendpulse":
+          result = await this.sendViaSendPulse(to, subject, htmlContent, textContent, settings, metadata);
+          break;
+        default:
+          console.error(`[EmailService] Unknown provider: ${useProvider}`);
+          if (this.emailLogger) {
+            try {
+              await this.emailLogger({
+                event: "failed",
+                recipientEmail: to,
+                recipientUserId: userId,
+                templateId,
+                subject,
+                provider: useProvider,
+                batchId,
+                error: `Unknown email provider: ${useProvider}`,
+                metadata
+              });
+            } catch (e) {
+            }
+          }
+          return { success: false, error: `Unknown email provider: ${useProvider}` };
+      }
+      if (result) {
+        const messageId = providerMessageId || crypto.randomUUID();
+        if (this.emailLogger) {
+          try {
+            await this.emailLogger({
+              event: "sent",
+              recipientEmail: to,
+              recipientUserId: userId,
+              templateId,
+              subject,
+              provider: useProvider,
+              messageId,
+              batchId,
+              metadata
+            });
+          } catch (e) {
+            console.warn("[EmailService] emailLogger sent failed:", e);
+          }
+        }
+        return { success: true, messageId };
+      } else {
+        console.error("[EmailService] Failed to send email to:", to);
+        if (this.emailLogger) {
+          try {
+            await this.emailLogger({
+              event: "failed",
+              recipientEmail: to,
+              recipientUserId: userId,
+              templateId,
+              subject,
+              provider: useProvider,
+              batchId,
+              error: "Failed to send email",
+              metadata
+            });
+          } catch (e) {
+          }
+        }
+        return { success: false, error: "Failed to send email" };
+      }
+    } catch (error) {
+      console.error("[EmailService] Error sending email:", error);
+      if (this.emailLogger) {
+        try {
+          await this.emailLogger({
+            event: "failed",
+            recipientEmail: to,
+            recipientUserId: userId,
+            templateId,
+            subject,
+            batchId,
+            error: error.message,
+            metadata
+          });
+        } catch (e) {
+        }
+      }
+      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;
+      }
+      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 "";
+        try {
+          return btoa(unescape(encodeURIComponent(String(str))));
+        } catch (e) {
+          console.error("[EmailService] Base64 encoding failed:", e);
+          return "";
+        }
+      };
+      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/index.js
+var import_hono4 = require("hono");
+// src/backend/routes/templates.js
+var import_hono = require("hono");
+function createTemplateRoutes(config = {}) {
+  const app = new import_hono.Hono();
+  app.get("/", async (c) => {
+    const emailService = new EmailService(c.env, config);
+    try {
+      const templates = await emailService.getAllTemplates();
+      return c.json(templates);
+    } catch (err) {
+      return c.json({ error: err.message }, 500);
+    }
+  });
+  app.get("/:id", async (c) => {
+    const emailService = new EmailService(c.env, config);
+    try {
+      const template = await emailService.getTemplate(c.req.param("id"));
+      if (!template) return c.json({ error: "Template not found" }, 404);
+      return c.json(template);
+    } catch (err) {
+      return c.json({ error: err.message }, 500);
+    }
+  });
+  app.post("/", async (c) => {
+    const emailService = new EmailService(c.env, config);
+    try {
+      const data = await c.req.json();
+      let userId = "admin";
+      const user = c.get("dbUser") || c.get("user");
+      if (user && user.id) userId = user.id;
+      if (!data.template_id || !data.subject_template) {
+        return c.json({ error: "Missing required fields (template_id, subject_template)" }, 400);
+      }
+      const result = await emailService.saveTemplate(data, userId);
+      return c.json({ success: true, message: "Template saved", result });
+    } catch (err) {
+      return c.json({ error: err.message }, 500);
+    }
+  });
+  app.post("/send-test", async (c) => {
+    const emailService = new EmailService(c.env, config);
+    try {
+      const { template_id, to, variables } = await c.req.json();
+      let tid = template_id;
+      if (!tid || !to) {
+        return c.json({ error: "Missing required fields (template_id, to)" }, 400);
+      }
+      const user = c.get("dbUser") || c.get("user");
+      const recipientUserId = user?.id || null;
+      const result = await emailService.sendViaTemplate(tid, variables || {}, {
+        to,
+        profile: "test",
+        recipientUserId
+      });
+      return c.json({ success: true, result });
+    } catch (err) {
+      return c.json({ error: `Failed to send test email: ${err.message}` }, 500);
+    }
+  });
+  app.delete("/:id", async (c) => {
+    const emailService = new EmailService(c.env, config);
+    try {
+      await emailService.deleteTemplate(c.req.param("id"));
+      return c.json({ success: true, message: "Template deleted" });
+    } catch (err) {
+      return c.json({ error: err.message }, 500);
+    }
+  });
+  app.post("/:id/preview", async (c) => {
+    const emailService = new EmailService(c.env, config);
+    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({ error: err.message }, 500);
+    }
+  });
+  return app;
+}
+// src/backend/routes/tracking.js
+var import_hono2 = require("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 import_hono2.Hono();
+  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/logs.js
+var import_hono3 = require("hono");
+function createLogRoutes(config = {}) {
+  const app = new import_hono3.Hono();
+  app.get("/", async (c) => {
+    const limit = Math.min(parseInt(c.req.query("limit") || "50"), 100);
+    const offset = parseInt(c.req.query("offset") || "0");
+    const env = c.env;
+    try {
+      const table = `${config.emailTablePrefix || "system_email_"}logs`;
+      const { results } = await env.DB.prepare(`
+                SELECT * FROM ${table}
+                ORDER BY created_at DESC
+                LIMIT ? OFFSET ?
+            `).bind(limit, offset).all();
+      const countResult = await env.DB.prepare(`SELECT COUNT(*) as exact_count FROM ${table}`).first();
+      return c.json({
+        logs: results.map((row) => ({
+          ...row,
+          metadata: row.metadata ? JSON.parse(row.metadata) : null
+        })),
+        total: countResult.exact_count,
+        limit,
+        offset
+      });
+    } catch (error) {
+      console.error("Failed to fetch logs:", error);
+      return c.json({ error: "Failed to fetch logs" }, 500);
+    }
+  });
+  return app;
+}
+// src/backend/routes/index.js
+function createEmailRoutes(config = {}, cacheProvider = null) {
+  const app = new import_hono4.Hono();
+  app.route("/templates", createTemplateRoutes(config, cacheProvider));
+  app.route("/logs", createLogRoutes(config));
+  return app;
+}
+// src/common/utils.js
+var import_mustache2 = __toESM(require("mustache"), 1);
+var cachedWebsiteUrl = null;
+function getWebsiteUrl(env) {
+  if (cachedWebsiteUrl) {
+    return cachedWebsiteUrl;
+  }
+  const domain = env.DOMAIN || "x0start.com";
+  const isDev = env.ENVIRONMENT === "development" || !env.ENVIRONMENT;
+  const protocol = isDev ? "http" : "https";
+  cachedWebsiteUrl = `${protocol}://www.${domain}`;
+  return cachedWebsiteUrl;
+}
+function resetWebsiteUrlCache() {
+  cachedWebsiteUrl = null;
+}
+function encodeTrackingLinks(html, sendId, env = null, websiteUrl = null) {
+  const baseUrl = websiteUrl || (env ? getWebsiteUrl(env) : "https://www.x0start.com");
+  const decodeHtmlEntities = (text) => {
+    return text.replace(/&#x2F;/g, "/").replace(/&#x3A;/g, ":").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'");
+  };
+  return html.replace(/href="([^"]+)"/g, (match, url) => {
+    if (url.startsWith("mailto:") || url.startsWith("tel:") || url.startsWith("#") || url.includes("{{") || // Skip template variables
+    url.includes("/email/unsubscribe/") || url.includes("/email/track/")) {
+      return match;
+    }
+    const decodedUrl = decodeHtmlEntities(url);
+    const encodedUrl = Buffer.from(decodedUrl).toString("base64");
+    const trackingUrl = `${baseUrl}/r/${sendId}?url=${encodedUrl}`;
+    return `href="${trackingUrl}"`;
+  });
+}
+function markdownToPlainText(markdown) {
+  return markdown.replace(/#{1,6}\s+/g, "").replace(/\*\*(.+?)\*\*/g, "$1").replace(/\*(.+?)\*/g, "$1").replace(/\[(.+?)\]\((.+?)\)/g, "$1: $2").replace(/`(.+?)`/g, "$1").replace(/>\s+/g, "").replace(/\n{3,}/g, "\n\n").trim();
+}
+function extractVariables(templateString) {
+  if (!templateString) return [];
+  try {
+    const tokens = import_mustache2.default.parse(templateString);
+    const variables = /* @__PURE__ */ new Set();
+    const collectVariables = (tokenList) => {
+      tokenList.forEach((token) => {
+        const type = token[0];
+        const value = token[1];
+        if (type === "name" || type === "#" || type === "^" || type === "&") {
+          variables.add(value);
+        }
+        if ((type === "#" || type === "^") && token[4]) {
+          collectVariables(token[4]);
+        }
+      });
+    };
+    collectVariables(tokens);
+    return Array.from(variables);
+  } catch (error) {
+    console.error("Error parsing template variables:", error);
+    return [];
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  EmailLogger,
+  EmailService,
+  EmailingCacheDO,
+  createDOCacheProvider,
+  createEmailLoggerCallback,
+  createEmailRoutes,
+  createTemplateRoutes,
+  createTrackingRoutes,
+  encodeTrackingLinks,
+  extractVariables,
+  getWebsiteUrl,
+  markdownToPlainText,
+  resetWebsiteUrlCache,
+  wrapInEmailTemplate
+});
+//# sourceMappingURL=index.cjs.map