add campaign smtp-proxy

Author: lamalex

.devenv/state/minio/data/.minio.sys/tmp/7b08971e-4836-4772-8f90-aa29588a6ef2

@@ -15,11 +15,14 @@
     "@types/mailparser": "^3.4.5",
     "@types/smtp-server": "^3.5.10",
     "dotenv": "^16.5.0",
+    "he": "^1.2.0",
+    "linkedom": "^0.18.12",
     "mailparser": "^3.7.2",
     "nodemailer": "^6.10.1",
     "smtp-server": "^3.13.6"
   },
   "devDependencies": {
+    "@types/he": "^1.2.3",
     "@types/node": "^22.15.2",
     "@types/nodemailer": "^6.4.17",
     "tsup": "^8.4.0",

apps/smtp-server/package.json

@@ -3,6 +3,8 @@ import { Readable } from "stream";
 import dotenv from "dotenv";
 import { simpleParser } from "mailparser";
 import { readFileSync, watch, FSWatcher } from "fs";
+import he from "he";
+import { parseHTML } from "linkedom";
 
 dotenv.config();
 
@@ -15,6 +17,115 @@ const SSL_KEY_PATH =
   process.env.USESEND_API_KEY_PATH ?? process.env.UNSEND_API_KEY_PATH;
 const SSL_CERT_PATH =
   process.env.USESEND_API_CERT_PATH ?? process.env.UNSEND_API_CERT_PATH;
+const CAMPAIGN_DOMAIN = process.env.USESEND_CAMPAIGN_DOMAIN ?? "usesend.com";
+
+interface ParsedRecipients {
+  contactBookIds: string[];
+  emailAddresses: string[];
+}
+
+/**
+ * Parses all recipients from the "to" field.
+ * - Addresses like "listId@usesend.com" (or configured domain) are contact book IDs
+ * - All other addresses are treated as individual email recipients
+ */
+function parseRecipients(to: string | undefined): ParsedRecipients {
+  const result: ParsedRecipients = {
+    contactBookIds: [],
+    emailAddresses: [],
+  };
+
+  if (!to) return result;
+
+  const emailRegex = /<?([^<>\s,]+@[^<>\s,]+)>?/g;
+  let match;
+
+  while ((match = emailRegex.exec(to)) !== null) {
+    const email = match[1].toLowerCase();
+    const [localPart, domain] = email.split("@");
+
+    if (domain === CAMPAIGN_DOMAIN.toLowerCase() && localPart) {
+      result.contactBookIds.push(localPart);
+    } else {
+      result.emailAddresses.push(email);
+    }
+  }
+
+  return result;
+}
+
+interface CampaignData {
+  name: string;
+  from: string;
+  subject: string;
+  contactBookId: string;
+  html: string;
+  replyTo?: string;
+}
+
+interface CampaignResponse {
+  id: string;
+  name: string;
+  status: string;
+}
+
+/**
+ * Creates a campaign and schedules it for immediate sending via the UseSend API.
+ */
+async function sendCampaignToUseSend(
+  campaignData: CampaignData,
+  apiKey: string,
+): Promise<CampaignResponse> {
+  try {
+    const createEndpoint = "/api/v1/campaigns";
+    const createUrl = new URL(createEndpoint, BASE_URL);
+
+    const payload = {
+      name: campaignData.name,
+      from: campaignData.from,
+      subject: campaignData.subject,
+      contactBookId: campaignData.contactBookId,
+      html: campaignData.html,
+      replyTo: campaignData.replyTo,
+      sendNow: true,
+    };
+
+    const response = await fetch(createUrl.href, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify(payload),
+    });
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      let errorDisplay: string;
+      try {
+        // Try to parse and pretty-print JSON error responses
+        errorDisplay = JSON.stringify(JSON.parse(errorText), null, 2);
+      } catch {
+        errorDisplay = errorText;
+      }
+      console.error("useSend Campaign API error response:", errorDisplay);
+      throw new Error(
+        `Failed to create campaign: ${errorText || "Unknown error from server"}`,
+      );
+    }
+
+    const responseData = (await response.json()) as CampaignResponse;
+    return responseData;
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error("Campaign error message:", error.message);
+      throw new Error(`Failed to send campaign: ${error.message}`);
+    } else {
+      console.error("Unexpected campaign error:", error);
+      throw new Error("Failed to send campaign: Unexpected error occurred");
+    }
+  }
+}
 
 async function sendEmailToUseSend(emailData: any, apiKey: string) {
   try {
@@ -34,14 +145,21 @@ async function sendEmailToUseSend(emailData: any, apiKey: string) {
     });
 
     if (!response.ok) {
-      const errorData = await response.text();
+      const errorText = await response.text();
+      let errorDisplay: string;
+      try {
+        // Try to parse and pretty-print JSON error responses
+        errorDisplay = JSON.stringify(JSON.parse(errorText), null, 2);
+      } catch {
+        errorDisplay = errorText;
+      }
       console.error(
-        "useSend API error response: error:",
-        JSON.stringify(errorData, null, 4),
+        "useSend API error response:",
+        errorDisplay,
         `\nemail data: ${emailDataText}`,
       );
       throw new Error(
-        `Failed to send email: ${errorData || "Unknown error from server"}`,
+        `Failed to send email: ${errorText || "Unknown error from server"}`,
       );
     }
 
@@ -58,6 +176,93 @@ async function sendEmailToUseSend(emailData: any, apiKey: string) {
   }
 }
 
+/**
+ * Converts plain text to a basic HTML document.
+ */
+function textToHtml(text: string): string {
+  const escapedText = he.encode(text, { useNamedReferences: true });
+  // Convert newlines to <br> tags
+  const htmlText = escapedText.replace(/\n/g, "<br>\n");
+  return `<!DOCTYPE html><html><body><p>${htmlText}</p></body></html>`;
+}
+
+/**
+ * Creates the unsubscribe footer element.
+ */
+function createUnsubscribeFooter(document: Document): HTMLElement {
+  const footer = document.createElement("p");
+  footer.setAttribute(
+    "style",
+    "margin-top: 20px; padding-top: 20px; border-top: 1px solid #eee; font-size: 12px; color: #666;",
+  );
+
+  const link = document.createElement("a");
+  link.setAttribute("href", "{{usesend_unsubscribe_url}}");
+  link.setAttribute("style", "color: #666;");
+  link.textContent = "Unsubscribe";
+
+  footer.appendChild(link);
+  return footer;
+}
+
+/**
+ * Checks if the document contains an unsubscribe link placeholder.
+ */
+function hasUnsubscribeLink(html: string): boolean {
+  return (
+    html.includes("{{unsend_unsubscribe_url}}") ||
+    html.includes("{{usesend_unsubscribe_url}}")
+  );
+}
+
+/**
+ * Prepares HTML content for campaign sending.
+ * - Converts plain text to HTML if needed
+ * - Adds unsubscribe link if not present
+ * Uses linkedom for proper DOM manipulation.
+ */
+function prepareCampaignHtml(
+  html: string | false | undefined,
+  text: string | undefined,
+): string | null {
+  // Convert plain text to HTML if no HTML provided
+  let htmlContent: string;
+  if (!html && text) {
+    htmlContent = textToHtml(text);
+  } else if (html) {
+    htmlContent = html;
+  } else {
+    return null;
+  }
+
+  // Check if unsubscribe link already exists
+  if (hasUnsubscribeLink(htmlContent)) {
+    return htmlContent;
+  }
+
+  // Parse the HTML and add the unsubscribe footer using DOM APIs
+  const { document } = parseHTML(htmlContent);
+
+  const footer = createUnsubscribeFooter(document);
+
+  // Append to body if it exists, otherwise append to document
+  const body = document.querySelector("body");
+  if (body) {
+    body.appendChild(footer);
+  } else {
+    // No body tag - wrap content and add footer
+    const html = document.querySelector("html");
+    if (html) {
+      html.appendChild(footer);
+    } else {
+      // Minimal HTML - just append
+      document.appendChild(footer);
+    }
+  }
+
+  return document.toString();
+}
+
 function loadCertificates(): { key?: Buffer; cert?: Buffer } {
   return {
     key: SSL_KEY_PATH ? readFileSync(SSL_KEY_PATH) : undefined,
@@ -77,7 +282,7 @@ const serverOptions: SMTPServerOptions = {
     callback: (error?: Error) => void,
   ) {
     console.log("Receiving email data..."); // Debug statement
-    simpleParser(stream, (err, parsed) => {
+    simpleParser(stream, async (err, parsed) => {
       if (err) {
         console.error("Failed to parse email data:", err.message);
         return callback(err);
@@ -88,26 +293,102 @@ const serverOptions: SMTPServerOptions = {
         return callback(new Error("No API key found in session"));
       }
 
-      const emailObject = {
-        to: Array.isArray(parsed.to)
-          ? parsed.to.map((addr) => addr.text).join(", ")
-          : parsed.to?.text,
-        from: Array.isArray(parsed.from)
-          ? parsed.from.map((addr) => addr.text).join(", ")
-          : parsed.from?.text,
-        subject: parsed.subject,
-        text: parsed.text,
-        html: parsed.html,
-        replyTo: parsed.replyTo?.text,
-      };
-
-      sendEmailToUseSend(emailObject, session.user)
-        .then(() => callback())
-        .then(() => console.log("Email sent successfully to: ", emailObject.to))
-        .catch((error) => {
-          console.error("Failed to send email:", error.message);
-          callback(error);
+      const toAddress = Array.isArray(parsed.to)
+        ? parsed.to.map((addr) => addr.text).join(", ")
+        : parsed.to?.text;
+
+      const fromAddress = Array.isArray(parsed.from)
+        ? parsed.from.map((addr) => addr.text).join(", ")
+        : parsed.from?.text;
+
+      const sendPromises: Promise<any>[] = [];
+      const recipients = parseRecipients(toAddress);
+      const hasCampaigns = recipients.contactBookIds.length > 0;
+      const hasIndividualEmails = recipients.emailAddresses.length > 0;
+
+      // Handle campaign sends (one campaign per contact book)
+      if (hasCampaigns) {
+        if (!fromAddress) {
+          console.error("No from address found for campaign");
+          return callback(new Error("From address is required for campaigns"));
+        }
+
+        if (!parsed.subject) {
+          console.error("No subject found for campaign");
+          return callback(new Error("Subject is required for campaigns"));
+        }
+
+        const htmlContent = prepareCampaignHtml(parsed.html, parsed.text);
+        if (!htmlContent) {
+          console.error("No content found for campaign");
+          return callback(
+            new Error("HTML or text content is required for campaigns"),
+          );
+        }
+
+        for (const contactBookId of recipients.contactBookIds) {
+          const campaignData: CampaignData = {
+            name: `SMTP Campaign: ${parsed.subject}`,
+            from: fromAddress,
+            subject: parsed.subject,
+            contactBookId,
+            html: htmlContent,
+            replyTo: parsed.replyTo?.text,
+          };
+
+          const campaignPromise = sendCampaignToUseSend(
+            campaignData,
+            session.user,
+          ).catch((error) => {
+            console.error(
+              `Failed to send campaign to ${contactBookId}:`,
+              error.message,
+            );
+            throw error;
+          });
+
+          sendPromises.push(campaignPromise);
+        }
+      }
+
+      // Handle individual email sends
+      if (hasIndividualEmails) {
+        // Send to all individual recipients in one API call
+        const emailObject = {
+          to: recipients.emailAddresses,
+          from: fromAddress,
+          subject: parsed.subject,
+          text: parsed.text,
+          html: parsed.html,
+          replyTo: parsed.replyTo?.text,
+        };
+
+        const emailPromise = sendEmailToUseSend(
+          emailObject,
+          session.user,
+        ).catch((error) => {
+          console.error("Failed to send individual emails:", error.message);
+          throw error;
         });
+
+        sendPromises.push(emailPromise);
+      }
+
+      if (sendPromises.length === 0) {
+        console.error("No valid recipients found");
+        return callback(new Error("No valid recipients found"));
+      }
+
+      try {
+        await Promise.all(sendPromises);
+        callback();
+      } catch (error) {
+        if (error instanceof Error) {
+          callback(error);
+        } else {
+          callback(new Error("One or more sends failed"));
+        }
+      }
     });
   },
   onAuth(auth, session: any, callback: (error?: Error, user?: any) => void) {