115 lines
3.6 KiB
TypeScript
115 lines
3.6 KiB
TypeScript
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., [email protected])
|
|
* @returns The feed ID or null if not found
|
|
*/
|
|
static extractFeedId(emailAddress: string): string | null {
|
|
// Match pattern for noun1.noun2.XY before the @ symbol
|
|
const match = emailAddress.match(/^([a-z]+\.[a-z]+\.\d{2})@/i);
|
|
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));
|
|
});
|
|
}
|
|
}
|