@contentgrowth/content-emailing 0.6.2 → 0.7.2

package/dist/backend/EmailService.cjs

@@ -268,6 +268,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 {
   /**
@@ -275,6 +491,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) {
@@ -302,6 +519,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 {
@@ -551,13 +778,30 @@ var EmailService = class {
    * @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 = {} }) {
+  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);
@@ -567,22 +811,91 @@ var EmailService = class {
           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) {
-        return { success: true, messageId: crypto.randomUUID() };
+        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 };
     }
   }