@contentgrowth/content-emailing 0.7.1 → 0.7.3

package/dist/backend/routes/index.cjs

@@ -276,6 +276,222 @@ function createDOCacheProvider(doStub, instanceName = "global") {
   };
 }
 
+// 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 || [];
+  }
+};
+
 // src/backend/EmailService.js
 var EmailService = class {
   /**
@@ -283,6 +499,7 @@ var EmailService = class {
    * @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) {
@@ -301,10 +518,6 @@ var EmailService = class {
       // Updater function to save settings to backend
       // Signature: async (profile, tenantId, settings) => void
       settingsUpdater: config.settingsUpdater || null,
-      // Email Logger callback for tracking all email sends
-      // Signature: async (logEntry) => void
-      // logEntry: { event: 'pending'|'sent'|'failed', recipientEmail, templateId?, subject?, provider?, messageId?, error?, metadata? }
-      emailLogger: config.emailLogger || null,
       // Branding configuration for email templates
       branding: {
         brandName: config.branding?.brandName || "Your App",
@@ -314,6 +527,16 @@ var EmailService = class {
       },
       ...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 {
@@ -567,9 +790,9 @@ var EmailService = class {
     const htmlContent = html || htmlBody;
     const textContent = text || textBody;
     const templateId = metadata?.templateId || "direct";
-    if (this.config.emailLogger) {
+    if (this.emailLogger) {
       try {
-        await this.config.emailLogger({
+        await this.emailLogger({
           event: "pending",
           recipientEmail: to,
           recipientUserId: userId,
@@ -606,9 +829,9 @@ var EmailService = class {
           break;
         default:
           console.error(`[EmailService] Unknown provider: ${useProvider}`);
-          if (this.config.emailLogger) {
+          if (this.emailLogger) {
             try {
-              await this.config.emailLogger({
+              await this.emailLogger({
                 event: "failed",
                 recipientEmail: to,
                 recipientUserId: userId,
@@ -626,9 +849,9 @@ var EmailService = class {
       }
       if (result) {
         const messageId = providerMessageId || crypto.randomUUID();
-        if (this.config.emailLogger) {
+        if (this.emailLogger) {
           try {
-            await this.config.emailLogger({
+            await this.emailLogger({
               event: "sent",
               recipientEmail: to,
               recipientUserId: userId,
@@ -646,9 +869,9 @@ var EmailService = class {
         return { success: true, messageId };
       } else {
         console.error("[EmailService] Failed to send email to:", to);
-        if (this.config.emailLogger) {
+        if (this.emailLogger) {
           try {
-            await this.config.emailLogger({
+            await this.emailLogger({
               event: "failed",
               recipientEmail: to,
               recipientUserId: userId,
@@ -666,9 +889,9 @@ var EmailService = class {
       }
     } catch (error) {
       console.error("[EmailService] Error sending email:", error);
-      if (this.config.emailLogger) {
+      if (this.emailLogger) {
         try {
-          await this.config.emailLogger({
+          await this.emailLogger({
             event: "failed",
             recipientEmail: to,
             recipientUserId: userId,