Set up initial project and files

src/utils/email-parser.ts

@@ -0,0 +1,114 @@
+import { EmailData } from '../types';
+
+/**
+ * Simple email parser specialized for ForwardEmail.net's webhook format
+ */
+export class EmailParser {
+  /**
+   * Extract the feed ID from an email address
+   * @param emailAddress The email address (e.g., newsletter-xyz@domain.com)
+   * @returns The feed ID or null if not found
+   */
+  static extractFeedId(emailAddress: string): string | null {
+    const match = emailAddress.match(/^newsletter-([a-zA-Z0-9]+)@/);
+    return match ? match[1] : null;
+  }
+  
+  /**
+   * Parse email data from ForwardEmail.net's webhook payload
+   * @param payload ForwardEmail.net webhook payload
+   */
+  static parseForwardEmailPayload(payload: any): EmailData {
+    if (!payload) {
+      throw new Error('Missing or invalid webhook payload');
+    }
+    
+    // Extract the "to" address
+    const toAddress = payload.recipients?.[0] || '';
+    
+    // Extract the sender information using ForwardEmail's structure
+    const fromAddress = payload.from?.text || 
+                     (payload.from?.value?.[0]?.address ? 
+                       `${payload.from.value[0].name || ''} <${payload.from.value[0].address}>` : 
+                       'Unknown Sender');
+    
+    // Extract subject
+    let subject = payload.subject || 'No Subject';
+    // Decode any encoded words in the subject
+    subject = this.decodeEncodedWords(subject);
+    
+    // Get content, preferring HTML over plain text
+    const content = payload.html || payload.text || '';
+    
+    // Create simple email data object
+    return {
+      subject,
+      from: fromAddress,
+      content,
+      receivedAt: payload.date ? new Date(payload.date).getTime() : Date.now(),
+      headers: this.extractHeaders(payload)
+    };
+  }
+  
+  /**
+   * Extract headers from ForwardEmail payload
+   */
+  private static extractHeaders(payload: any): Record<string, string> {
+    const headers: Record<string, string> = {};
+    
+    // Extract headers from headerLines if available
+    if (payload.headerLines && Array.isArray(payload.headerLines)) {
+      payload.headerLines.forEach((h: {key: string; line: string}) => {
+        const key = h.key.toLowerCase();
+        const value = h.line.replace(new RegExp(`^${h.key}:\\s*`, 'i'), '').trim();
+        headers[key] = value;
+      });
+    }
+    // Or from headers string if provided
+    else if (typeof payload.headers === 'string') {
+      payload.headers.split(/\r?\n/).forEach((line: string) => {
+        const match = line.match(/^([^:]+):\s*(.*)$/);
+        if (match) {
+          headers[match[1].toLowerCase()] = match[2];
+        }
+      });
+    }
+    
+    return headers;
+  }
+  
+  /**
+   * Decode RFC 2047 encoded words in headers
+   * @param text Text that may contain encoded words like =?UTF-8?Q?Hello_World?=
+   */
+  static decodeEncodedWords(text: string): string {
+    if (!text) return '';
+    
+    // Simple RFC 2047 encoded-word decoder
+    return text.replace(/=\?([^?]+)\?([BQ])\?([^?]+)\?=/gi, (_, charset, encoding, text) => {
+      if (encoding.toUpperCase() === 'B') {
+        // Base64 encoding
+        try {
+          const decoded = atob(text);
+          return decoded;
+        } catch (e) {
+          return text;
+        }
+      } else if (encoding.toUpperCase() === 'Q') {
+        // Quoted-printable encoding
+        return this.decodeQuotedPrintable(text.replace(/_/g, ' '));
+      }
+      return text;
+    });
+  }
+  
+  /**
+   * Decode quoted-printable encoded text
+   * @param text Quoted-printable encoded text
+   */
+  private static decodeQuotedPrintable(text: string): string {
+    return text.replace(/=([0-9A-F]{2})/gi, (_, hex) => {
+      return String.fromCharCode(parseInt(hex, 16));
+    });
+  }
+} 

src/utils/feed-generator.ts

@@ -0,0 +1,53 @@
+import { Feed } from 'feed';
+import { FeedConfig, EmailData } from '../types';
+
+/**
+ * Generate an RSS feed from a list of emails
+ */
+export function generateRssFeed(
+  feedConfig: FeedConfig, 
+  emails: EmailData[],
+  baseUrl: string
+): string {
+  // Create a new feed
+  const feed = new Feed({
+    title: feedConfig.title,
+    description: feedConfig.description || '',
+    id: feedConfig.feed_url,
+    link: feedConfig.site_url,
+    language: feedConfig.language,
+    updated: new Date(),
+    generator: 'Email-to-RSS',
+    copyright: `Copyright © ${new Date().getFullYear()} ${feedConfig.title}`,
+    feedLinks: {
+      rss: feedConfig.feed_url
+    },
+    author: feedConfig.author ? {
+      name: feedConfig.author,
+      email: `noreply@${new URL(feedConfig.site_url).hostname}`
+    } : undefined
+  });
+
+  // Add each email as a feed item
+  for (const email of emails) {
+    const date = new Date(email.receivedAt);
+    const uniqueId = `${email.receivedAt}-${Buffer.from(email.subject).toString('base64').substring(0, 10)}`;
+    
+    feed.addItem({
+      title: email.subject,
+      id: uniqueId,
+      link: `${baseUrl}/emails/${uniqueId}`,
+      description: email.content,
+      content: email.content,
+      author: [
+        {
+          name: email.from,
+        },
+      ],
+      date: date,
+    });
+  }
+
+  // Return the RSS feed as XML
+  return feed.rss2();
+} 

src/utils/storage.ts

@@ -0,0 +1,136 @@
+import { EmailData, FeedConfig, FeedMetadata, FeedList, EmailMetadata } from '../types';
+
+/**
+ * Store email data in KV
+ */
+export async function storeEmail(
+  kv: KVNamespace,
+  feedId: string,
+  emailData: EmailData
+): Promise<string> {
+  // Generate a unique key for this email
+  const timestamp = Date.now();
+  const key = `feed:${feedId}:email:${timestamp}`;
+  
+  // Store the email content
+  await kv.put(key, JSON.stringify(emailData));
+  
+  // Update the feed's metadata (list of emails)
+  await updateFeedMetadata(kv, feedId, {
+    key,
+    subject: emailData.subject,
+    receivedAt: timestamp
+  });
+  
+  return key;
+}
+
+/**
+ * Update feed metadata with a new email
+ */
+async function updateFeedMetadata(
+  kv: KVNamespace,
+  feedId: string,
+  emailMetadata: EmailMetadata
+): Promise<void> {
+  const feedMetadataKey = `feed:${feedId}:metadata`;
+  const existingMetadata = await kv.get(feedMetadataKey, { type: 'json' }) as FeedMetadata | null;
+  
+  const metadata: FeedMetadata = existingMetadata || { emails: [] };
+  
+  // Add new email to the beginning of the list
+  metadata.emails.unshift(emailMetadata);
+  
+  // Keep only the last 50 emails in the metadata
+  if (metadata.emails.length > 50) {
+    metadata.emails = metadata.emails.slice(0, 50);
+  }
+  
+  // Store updated metadata
+  await kv.put(feedMetadataKey, JSON.stringify(metadata));
+}
+
+/**
+ * Get feed metadata
+ */
+export async function getFeedMetadata(
+  kv: KVNamespace,
+  feedId: string
+): Promise<FeedMetadata | null> {
+  const feedMetadataKey = `feed:${feedId}:metadata`;
+  return await kv.get(feedMetadataKey, { type: 'json' }) as FeedMetadata | null;
+}
+
+/**
+ * Get feed configuration
+ */
+export async function getFeedConfig(
+  kv: KVNamespace,
+  feedId: string
+): Promise<FeedConfig | null> {
+  const feedConfigKey = `feed:${feedId}:config`;
+  return await kv.get(feedConfigKey, { type: 'json' }) as FeedConfig | null;
+}
+
+/**
+ * Get email data
+ */
+export async function getEmailData(
+  kv: KVNamespace,
+  key: string
+): Promise<EmailData | null> {
+  return await kv.get(key, { type: 'json' }) as EmailData | null;
+}
+
+/**
+ * Create a new feed
+ */
+export async function createFeed(
+  kv: KVNamespace,
+  feedId: string,
+  feedConfig: FeedConfig
+): Promise<void> {
+  // Store feed configuration
+  const feedConfigKey = `feed:${feedId}:config`;
+  await kv.put(feedConfigKey, JSON.stringify(feedConfig));
+  
+  // Create empty metadata for the feed
+  const feedMetadataKey = `feed:${feedId}:metadata`;
+  await kv.put(feedMetadataKey, JSON.stringify({
+    emails: []
+  }));
+  
+  // Add feed to the list of all feeds
+  await addFeedToList(kv, feedId, feedConfig.title);
+}
+
+/**
+ * Add a feed to the global list
+ */
+export async function addFeedToList(
+  kv: KVNamespace,
+  feedId: string,
+  title: string
+): Promise<void> {
+  const feedListKey = 'feeds:list';
+  const existingList = await kv.get(feedListKey, { type: 'json' }) as FeedList | null;
+  
+  const feedList: FeedList = existingList || { feeds: [] };
+  
+  feedList.feeds.push({
+    id: feedId,
+    title
+  });
+  
+  await kv.put(feedListKey, JSON.stringify(feedList));
+}
+
+/**
+ * Get all feeds
+ */
+export async function getAllFeeds(kv: KVNamespace): Promise<FeedList> {
+  const feedListKey = 'feeds:list';
+  const feedList = await kv.get(feedListKey, { type: 'json' }) as FeedList | null;
+  
+  return feedList || { feeds: [] };
+}