Email Routing with Workers -- Custom Processing

# Step 1: Configure MX records in Cloudflare DNS
# Priority 10: mx.cloudflare.com

# Step 2: Enable Email Routing in the Cloudflare Dashboard
# Email -> Email Routing -> Get Started

# Step 3: Create a catch-all or route-specific email address
# Route: support@example.com -> Worker: email-processor

# Step 4: Write the worker and deploy
npx wrangler deploy src/email-worker.js

// wrangler.toml
name = "email-processor"
main = "src/email-worker.js"

[env.production]
# No special bindings required for basic Email Routing
# Environment variables for forwarding rules:
vars = { FORWARD_TO = "team@company.com", ARCHIVE_BUCKET = "email-archive" }

export default {
  async email(message, env, ctx) {
    const from = message.from;
    const to = message.to;
    const subject = message.headers.get('subject') || 'No Subject';

    // Filter spam senders
    const blockedDomains = ['spam.com', 'mailer.example.com'];
    const senderDomain = from.split('@')[1];
    if (blockedDomains.includes(senderDomain)) {
      console.log(`Blocked email from ${from}`);
      // Reject the email -- it will not be delivered
      return;
    }

    // Auto-reply to specific senders
    if (subject.includes('Unsubscribe')) {
      await message.reply('You have been unsubscribed successfully.');
      console.log(`Sent unsubscribe confirmation to ${from}`);
      return;
    }

    // Forward to the team inbox
    await message.forward(env.FORWARD_TO);
    console.log(`Forwarded email from ${from} about "${subject}" to ${env.FORWARD_TO}`);
  }
};

// Expected behavior:
// Email from spam.com -> Blocked, rejected, not forwarded
// Email with "Unsubscribe" subject -> Auto-reply sent, not forwarded
// Normal email from legitimate sender -> Forwarded to team@company.com

export default {
  async email(message, env, ctx) {
    const emailId = crypto.randomUUID();
    const timestamp = new Date().toISOString();

    // Store the raw email in R2 for archival
    const rawEmail = await new Response(message.raw).arrayBuffer();
    await env.ARCHIVE.put(
      `emails/${timestamp}-${emailId}.eml`,
      rawEmail,
      { httpMetadata: { contentType: 'message/rfc822' } }
    );

    // Store metadata in D1 for searchability
    await env.DB.prepare(`
      INSERT INTO email_log (id, from_addr, to_addr, subject, received_at, has_attachments)
      VALUES (?, ?, ?, ?, ?, ?)
    `).bind(
      emailId,
      message.from,
      message.to,
      message.headers.get('subject') || '',
      timestamp,
      message.attachments.length > 0 ? 1 : 0
    ).run();

    // Forward the original email
    await message.forward(env.FORWARD_TO);

    console.log(`Archived email ${emailId} from ${message.from}`);
  }
};

// Expected behavior:
// 1. Email arrives for support@example.com
// 2. Raw .eml file saved to R2 at emails/2026-06-23T10:30:00Z-uuid.eml
// 3. Metadata row inserted into D1 email_log table
// 4. Original email forwarded to the team inbox
// 5. All processing completes within a few hundred milliseconds

const routes = [
  {
    pattern: /^support@/,
    handler: async (message, env) => {
      await message.forward('support-team"@company".com');
      await env.DB.prepare('INSERT INTO ticket_queue (from_addr, subject) VALUES (?, ?)')
        .bind(message.from, message.headers.get('subject'))
        .run();
    }
  },
  {
    pattern: /^billing@/,
    handler: async (message, env) => {
      const body = await new Response(message.raw).text();
      if (body.includes('REFUND')) {
        await message.forward('billing-manager"@company".com');
      } else {
        await message.forward('billing-team"@company".com');
      }
    }
  },
  {
    pattern: /^noreply@/,
    handler: async (message) => {
      // Silently discard
      console.log(`Discarded noreply email from ${message.from}`);
    }
  }
];

export default {
  async email(message, env, ctx) {
    for (const route of routes) {
      if (route.pattern.test(message.to)) {
        await route.handler(message, env);
        return;
      }
    }
    // Default: forward to general inbox
    await message.forward('general@company.com');
  }
};

// Expected behavior:
// support@example.com -> Forwarded to support-team, logged to D1
// billing@example.com with REFUND -> Forwarded to billing-manager
// billing@example.com without REFUND -> Forwarded to billing-team
// noreply@example.com -> Silently discarded
// unknown@example.com -> Forwarded to general@company.com