@stacksjs/ts-cloud-core 0.1.1

package/src/email/handlers/converter.ts

@@ -0,0 +1,227 @@
+/**
+ * Email Conversion Lambda Handler
+ *
+ * Converts raw MIME emails to readable formats:
+ * - Converts raw MIME to HTML/text
+ * - Extracts and saves attachments separately
+ * - Generates email previews
+ * - Creates searchable metadata JSON
+ */
+
+export const handler = `
+const { S3Client, GetObjectCommand, PutObjectCommand } = require('@aws-sdk/client-s3');
+const s3 = new S3Client({});
+
+exports.handler = async (event) => {
+  console.log('Email conversion event:', JSON.stringify(event, null, 2));
+
+  const bucket = process.env.EMAIL_BUCKET;
+
+  for (const record of event.Records) {
+    try {
+      const s3Event = record.s3 || {};
+      const key = decodeURIComponent(s3Event.object?.key?.replace(/\\+/g, ' ') || '');
+
+      // Only process raw.eml files in mailboxes
+      if (!key.endsWith('/raw.eml') || !key.startsWith('mailboxes/')) {
+        continue;
+      }
+
+      const basePath = key.replace('/raw.eml', '');
+
+      // Get raw email
+      const getResult = await s3.send(new GetObjectCommand({
+        Bucket: bucket,
+        Key: key,
+      }));
+
+      const rawEmail = await getResult.Body.transformToString();
+
+      // Parse email
+      const parsed = parseEmail(rawEmail);
+
+      // Save HTML version
+      if (parsed.html) {
+        await s3.send(new PutObjectCommand({
+          Bucket: bucket,
+          Key: \`\${basePath}/body.html\`,
+          Body: parsed.html,
+          ContentType: 'text/html',
+        }));
+      }
+
+      // Save text version
+      if (parsed.text) {
+        await s3.send(new PutObjectCommand({
+          Bucket: bucket,
+          Key: \`\${basePath}/body.txt\`,
+          Body: parsed.text,
+          ContentType: 'text/plain',
+        }));
+      }
+
+      // Save attachments
+      if (parsed.attachments && parsed.attachments.length > 0) {
+        for (let i = 0; i < parsed.attachments.length; i++) {
+          const attachment = parsed.attachments[i];
+          await s3.send(new PutObjectCommand({
+            Bucket: bucket,
+            Key: \`\${basePath}/attachments/\${attachment.filename}\`,
+            Body: Buffer.from(attachment.content, 'base64'),
+            ContentType: attachment.contentType,
+          }));
+        }
+
+        // Update metadata with attachment info
+        try {
+          const metaResult = await s3.send(new GetObjectCommand({
+            Bucket: bucket,
+            Key: \`\${basePath}/metadata.json\`,
+          }));
+          const metadata = JSON.parse(await metaResult.Body.transformToString());
+
+          metadata.attachments = parsed.attachments.map(a => ({
+            filename: a.filename,
+            contentType: a.contentType,
+            size: a.size,
+          }));
+          metadata.converted = true;
+          metadata.convertedAt = new Date().toISOString();
+
+          await s3.send(new PutObjectCommand({
+            Bucket: bucket,
+            Key: \`\${basePath}/metadata.json\`,
+            Body: JSON.stringify(metadata, null, 2),
+            ContentType: 'application/json',
+          }));
+        } catch (err) {
+          console.log('Could not update metadata:', err.message);
+        }
+      }
+
+      // Generate preview (first 200 chars of text)
+      const preview = (parsed.text || parsed.html?.replace(/<[^>]+>/g, '') || '')
+        .substring(0, 200)
+        .replace(/\\s+/g, ' ')
+        .trim();
+
+      await s3.send(new PutObjectCommand({
+        Bucket: bucket,
+        Key: \`\${basePath}/preview.txt\`,
+        Body: preview,
+        ContentType: 'text/plain',
+      }));
+
+      console.log(\`Converted email: \${key}\`);
+
+    } catch (error) {
+      console.error('Error converting email:', error);
+    }
+  }
+
+  return { statusCode: 200, body: 'OK' };
+};
+
+// Simple MIME parser
+function parseEmail(rawEmail) {
+  const result = {
+    headers: {},
+    text: null,
+    html: null,
+    attachments: [],
+  };
+
+  // Split headers and body
+  const parts = rawEmail.split(/\\r?\\n\\r?\\n/);
+  const headerSection = parts[0];
+  const bodySection = parts.slice(1).join('\\n\\n');
+
+  // Parse headers
+  let currentHeader = '';
+  for (const line of headerSection.split(/\\r?\\n/)) {
+    if (line.match(/^[A-Za-z-]+:/)) {
+      const colonIndex = line.indexOf(':');
+      currentHeader = line.substring(0, colonIndex).toLowerCase();
+      result.headers[currentHeader] = line.substring(colonIndex + 1).trim();
+    } else if (currentHeader && (line.startsWith(' ') || line.startsWith('\\t'))) {
+      result.headers[currentHeader] += ' ' + line.trim();
+    }
+  }
+
+  // Check content type
+  const contentType = result.headers['content-type'] || 'text/plain';
+
+  if (contentType.includes('multipart/')) {
+    // Extract boundary
+    const boundaryMatch = contentType.match(/boundary="?([^";]+)"?/);
+    if (boundaryMatch) {
+      const boundary = boundaryMatch[1];
+      const mimeParts = bodySection.split('--' + boundary);
+
+      for (const part of mimeParts) {
+        if (part.trim() === '' || part.trim() === '--') continue;
+
+        const partParts = part.split(/\\r?\\n\\r?\\n/);
+        const partHeaders = partParts[0];
+        const partBody = partParts.slice(1).join('\\n\\n').trim();
+
+        const partContentType = (partHeaders.match(/Content-Type:\\s*([^;\\r\\n]+)/i) || [])[1] || '';
+        const partEncoding = (partHeaders.match(/Content-Transfer-Encoding:\\s*([^\\r\\n]+)/i) || [])[1] || '';
+        const partDisposition = (partHeaders.match(/Content-Disposition:\\s*([^;\\r\\n]+)/i) || [])[1] || '';
+
+        if (partDisposition.includes('attachment') || partContentType.includes('application/')) {
+          // Attachment
+          const filenameMatch = partHeaders.match(/filename="?([^"\\r\\n]+)"?/i);
+          const filename = filenameMatch ? filenameMatch[1] : \`attachment_\${result.attachments.length + 1}\`;
+
+          let content = partBody;
+          if (partEncoding.toLowerCase() === 'base64') {
+            content = partBody.replace(/\\s/g, '');
+          }
+
+          result.attachments.push({
+            filename,
+            contentType: partContentType.trim(),
+            content,
+            size: Buffer.from(content, 'base64').length,
+          });
+        } else if (partContentType.includes('text/html')) {
+          result.html = decodeContent(partBody, partEncoding);
+        } else if (partContentType.includes('text/plain')) {
+          result.text = decodeContent(partBody, partEncoding);
+        } else if (partContentType.includes('multipart/')) {
+          // Nested multipart - recursively parse
+          const nestedResult = parseEmail(partHeaders + '\\n\\n' + partBody);
+          if (nestedResult.html) result.html = nestedResult.html;
+          if (nestedResult.text) result.text = nestedResult.text;
+          result.attachments.push(...nestedResult.attachments);
+        }
+      }
+    }
+  } else if (contentType.includes('text/html')) {
+    result.html = bodySection;
+  } else {
+    result.text = bodySection;
+  }
+
+  return result;
+}
+
+function decodeContent(content, encoding) {
+  if (!encoding) return content;
+
+  encoding = encoding.toLowerCase().trim();
+
+  if (encoding === 'base64') {
+    return Buffer.from(content.replace(/\\s/g, ''), 'base64').toString('utf-8');
+  } else if (encoding === 'quoted-printable') {
+    return content
+      .replace(/=\\r?\\n/g, '')
+      .replace(/=([0-9A-F]{2})/gi, (_, hex) => String.fromCharCode(parseInt(hex, 16)));
+  }
+
+  return content;
+}
+`
+
+export default handler

package/src/email/handlers/feedback.ts

@@ -0,0 +1,228 @@
+/**
+ * Email Feedback Lambda Handler
+ *
+ * Processes SES bounce and complaint notifications:
+ * - Processes SES bounce notifications
+ * - Processes complaint notifications
+ * - Updates suppression list
+ * - Sends admin notifications
+ */
+
+export const handler = `
+const { S3Client, GetObjectCommand, PutObjectCommand } = require('@aws-sdk/client-s3');
+const { SNSClient, PublishCommand } = require('@aws-sdk/client-sns');
+
+const s3 = new S3Client({});
+const sns = new SNSClient({});
+
+exports.handler = async (event) => {
+  console.log('Email feedback event:', JSON.stringify(event, null, 2));
+
+  const bucket = process.env.EMAIL_BUCKET;
+  const adminTopicArn = process.env.ADMIN_TOPIC_ARN;
+
+  for (const record of event.Records) {
+    try {
+      const message = JSON.parse(record.Sns?.Message || record.body || '{}');
+      const notificationType = message.notificationType || message.eventType;
+
+      if (!notificationType) {
+        console.log('Unknown notification type, skipping');
+        continue;
+      }
+
+      const timestamp = new Date().toISOString();
+
+      if (notificationType === 'Bounce') {
+        await handleBounce(message, bucket, adminTopicArn, timestamp);
+      } else if (notificationType === 'Complaint') {
+        await handleComplaint(message, bucket, adminTopicArn, timestamp);
+      } else if (notificationType === 'Delivery') {
+        await handleDelivery(message, bucket, timestamp);
+      }
+
+    } catch (error) {
+      console.error('Error processing feedback:', error);
+    }
+  }
+
+  return { statusCode: 200, body: 'OK' };
+};
+
+async function handleBounce(message, bucket, adminTopicArn, timestamp) {
+  const bounce = message.bounce || {};
+  const mail = message.mail || {};
+
+  console.log(\`Processing bounce: \${bounce.bounceType} - \${bounce.bounceSubType}\`);
+
+  // Get bounced recipients
+  const bouncedRecipients = bounce.bouncedRecipients || [];
+
+  for (const recipient of bouncedRecipients) {
+    const email = recipient.emailAddress;
+
+    // Add to suppression list
+    await addToSuppressionList(bucket, email, 'bounce', {
+      type: bounce.bounceType,
+      subType: bounce.bounceSubType,
+      diagnosticCode: recipient.diagnosticCode,
+      action: recipient.action,
+      status: recipient.status,
+      timestamp,
+      originalMessageId: mail.messageId,
+    });
+
+    console.log(\`Added \${email} to suppression list (bounce)\`);
+  }
+
+  // Log bounce event
+  await logFeedbackEvent(bucket, 'bounces', {
+    type: 'bounce',
+    bounceType: bounce.bounceType,
+    bounceSubType: bounce.bounceSubType,
+    recipients: bouncedRecipients.map(r => r.emailAddress),
+    messageId: mail.messageId,
+    timestamp,
+  });
+
+  // Notify admin for hard bounces
+  if (bounce.bounceType === 'Permanent' && adminTopicArn) {
+    await sns.send(new PublishCommand({
+      TopicArn: adminTopicArn,
+      Subject: \`Email Bounce Alert: \${bounce.bounceSubType}\`,
+      Message: JSON.stringify({
+        type: 'bounce',
+        bounceType: bounce.bounceType,
+        bounceSubType: bounce.bounceSubType,
+        recipients: bouncedRecipients.map(r => ({
+          email: r.emailAddress,
+          diagnosticCode: r.diagnosticCode,
+        })),
+        originalSubject: mail.commonHeaders?.subject,
+        timestamp,
+      }, null, 2),
+    }));
+  }
+}
+
+async function handleComplaint(message, bucket, adminTopicArn, timestamp) {
+  const complaint = message.complaint || {};
+  const mail = message.mail || {};
+
+  console.log(\`Processing complaint: \${complaint.complaintFeedbackType}\`);
+
+  // Get complained recipients
+  const complainedRecipients = complaint.complainedRecipients || [];
+
+  for (const recipient of complainedRecipients) {
+    const email = recipient.emailAddress;
+
+    // Add to suppression list
+    await addToSuppressionList(bucket, email, 'complaint', {
+      feedbackType: complaint.complaintFeedbackType,
+      userAgent: complaint.userAgent,
+      timestamp,
+      originalMessageId: mail.messageId,
+    });
+
+    console.log(\`Added \${email} to suppression list (complaint)\`);
+  }
+
+  // Log complaint event
+  await logFeedbackEvent(bucket, 'complaints', {
+    type: 'complaint',
+    feedbackType: complaint.complaintFeedbackType,
+    recipients: complainedRecipients.map(r => r.emailAddress),
+    messageId: mail.messageId,
+    timestamp,
+  });
+
+  // Always notify admin for complaints
+  if (adminTopicArn) {
+    await sns.send(new PublishCommand({
+      TopicArn: adminTopicArn,
+      Subject: \`Email Complaint Alert: \${complaint.complaintFeedbackType || 'Unknown'}\`,
+      Message: JSON.stringify({
+        type: 'complaint',
+        feedbackType: complaint.complaintFeedbackType,
+        recipients: complainedRecipients.map(r => r.emailAddress),
+        originalSubject: mail.commonHeaders?.subject,
+        timestamp,
+      }, null, 2),
+    }));
+  }
+}
+
+async function handleDelivery(message, bucket, timestamp) {
+  const delivery = message.delivery || {};
+  const mail = message.mail || {};
+
+  console.log(\`Processing delivery confirmation for \${delivery.recipients?.join(', ')}\`);
+
+  // Log delivery event
+  await logFeedbackEvent(bucket, 'deliveries', {
+    type: 'delivery',
+    recipients: delivery.recipients,
+    messageId: mail.messageId,
+    processingTimeMillis: delivery.processingTimeMillis,
+    smtpResponse: delivery.smtpResponse,
+    timestamp,
+  });
+}
+
+async function addToSuppressionList(bucket, email, reason, details) {
+  const key = 'suppression/list.json';
+  let list = [];
+
+  try {
+    const result = await s3.send(new GetObjectCommand({
+      Bucket: bucket,
+      Key: key,
+    }));
+    list = JSON.parse(await result.Body.transformToString());
+  } catch {
+    // List doesn't exist yet
+  }
+
+  // Check if already in list
+  const existing = list.find(item => item.email === email);
+  if (existing) {
+    existing.lastUpdated = details.timestamp;
+    existing.count = (existing.count || 1) + 1;
+  } else {
+    list.push({
+      email,
+      reason,
+      addedAt: details.timestamp,
+      lastUpdated: details.timestamp,
+      count: 1,
+      details,
+    });
+  }
+
+  await s3.send(new PutObjectCommand({
+    Bucket: bucket,
+    Key: key,
+    Body: JSON.stringify(list, null, 2),
+    ContentType: 'application/json',
+  }));
+}
+
+async function logFeedbackEvent(bucket, type, event) {
+  const date = new Date();
+  const year = date.getFullYear();
+  const month = String(date.getMonth() + 1).padStart(2, '0');
+  const day = String(date.getDate()).padStart(2, '0');
+
+  const key = \`feedback/\${type}/\${year}/\${month}/\${day}/\${Date.now()}-\${Math.random().toString(36).substr(2)}.json\`;
+
+  await s3.send(new PutObjectCommand({
+    Bucket: bucket,
+    Key: key,
+    Body: JSON.stringify(event, null, 2),
+    ContentType: 'application/json',
+  }));
+}
+`
+
+export default handler

package/src/email/handlers/inbound.ts

@@ -0,0 +1,169 @@
+/**
+ * Inbound Email Lambda Handler
+ *
+ * Processes incoming emails from SES:
+ * - Parses raw MIME emails
+ * - Extracts metadata (from, to, subject, date, attachments)
+ * - Organizes by domain/account/sender structure
+ * - Supports + addressing (user+tag@domain.com)
+ * - Stores in S3 with proper structure
+ * - Triggers SNS notifications
+ */
+
+export const handler = `
+const { S3Client, GetObjectCommand, PutObjectCommand, CopyObjectCommand } = require('@aws-sdk/client-s3');
+const s3 = new S3Client({});
+
+exports.handler = async (event) => {
+  console.log('Inbound email event:', JSON.stringify(event, null, 2));
+
+  for (const record of event.Records) {
+    try {
+      // Handle SES notification via SNS
+      const sesNotification = JSON.parse(record.Sns?.Message || record.body || '{}');
+      const mail = sesNotification.mail || {};
+      const receipt = sesNotification.receipt || {};
+
+      const bucket = process.env.EMAIL_BUCKET;
+      const messageId = mail.messageId;
+
+      if (!messageId) {
+        console.log('No messageId found, skipping');
+        continue;
+      }
+
+      // Get the raw email from S3
+      const sourceKey = \`incoming/\${messageId}\`;
+      let rawEmail;
+
+      try {
+        const getResult = await s3.send(new GetObjectCommand({
+          Bucket: bucket,
+          Key: sourceKey,
+        }));
+        rawEmail = await getResult.Body.transformToString();
+      } catch (err) {
+        console.log('Could not retrieve raw email:', err.message);
+        continue;
+      }
+
+      // Parse email headers
+      const headers = {};
+      const headerSection = rawEmail.split('\\n\\n')[0];
+      let currentHeader = '';
+
+      for (const line of headerSection.split('\\n')) {
+        if (line.match(/^[A-Za-z-]+:/)) {
+          const colonIndex = line.indexOf(':');
+          currentHeader = line.substring(0, colonIndex).toLowerCase();
+          headers[currentHeader] = line.substring(colonIndex + 1).trim();
+        } else if (currentHeader && (line.startsWith(' ') || line.startsWith('\\t'))) {
+          headers[currentHeader] += ' ' + line.trim();
+        }
+      }
+
+      // Extract key metadata
+      const from = headers['from'] || '';
+      const to = headers['to'] || '';
+      const subject = headers['subject'] || '(no subject)';
+      const date = headers['date'] || new Date().toISOString();
+
+      // Parse sender email
+      const fromMatch = from.match(/<([^>]+)>/) || [null, from];
+      const fromEmail = fromMatch[1] || from;
+      const fromDomain = fromEmail.split('@')[1] || 'unknown';
+
+      // Parse recipient email (handle + addressing)
+      const toMatch = to.match(/<([^>]+)>/) || [null, to];
+      const toEmail = toMatch[1] || to;
+      const [localPart, toDomain] = toEmail.split('@');
+      const baseLocalPart = localPart.split('+')[0]; // Handle user+tag@domain.com
+      const tag = localPart.includes('+') ? localPart.split('+')[1] : null;
+
+      // Create timestamp-based path
+      const timestamp = new Date(date);
+      const year = timestamp.getFullYear();
+      const month = String(timestamp.getMonth() + 1).padStart(2, '0');
+      const day = String(timestamp.getDate()).padStart(2, '0');
+
+      // Organize by: domain/mailbox/year/month/day/sender/messageId
+      const destPath = \`mailboxes/\${toDomain}/\${baseLocalPart}/\${year}/\${month}/\${day}/\${fromDomain}/\${messageId}\`;
+
+      // Copy raw email to organized location
+      await s3.send(CopyObjectCommand({
+        Bucket: bucket,
+        CopySource: \`\${bucket}/\${sourceKey}\`,
+        Key: \`\${destPath}/raw.eml\`,
+      }));
+
+      // Create metadata JSON
+      const metadata = {
+        messageId,
+        from: fromEmail,
+        fromName: from.replace(/<[^>]+>/, '').trim(),
+        to: toEmail,
+        toName: to.replace(/<[^>]+>/, '').trim(),
+        subject,
+        date: timestamp.toISOString(),
+        receivedAt: new Date().toISOString(),
+        tag,
+        spamVerdict: receipt.spamVerdict?.status || 'UNKNOWN',
+        virusVerdict: receipt.virusVerdict?.status || 'UNKNOWN',
+        spfVerdict: receipt.spfVerdict?.status || 'UNKNOWN',
+        dkimVerdict: receipt.dkimVerdict?.status || 'UNKNOWN',
+        dmarcVerdict: receipt.dmarcVerdict?.status || 'UNKNOWN',
+        hasAttachments: rawEmail.includes('Content-Disposition: attachment'),
+      };
+
+      await s3.send(new PutObjectCommand({
+        Bucket: bucket,
+        Key: \`\${destPath}/metadata.json\`,
+        Body: JSON.stringify(metadata, null, 2),
+        ContentType: 'application/json',
+      }));
+
+      // Update inbox index
+      const indexKey = \`mailboxes/\${toDomain}/\${baseLocalPart}/inbox.json\`;
+      let inbox = [];
+
+      try {
+        const indexResult = await s3.send(new GetObjectCommand({
+          Bucket: bucket,
+          Key: indexKey,
+        }));
+        inbox = JSON.parse(await indexResult.Body.transformToString());
+      } catch {
+        // Index doesn't exist yet
+      }
+
+      inbox.unshift({
+        messageId,
+        from: fromEmail,
+        subject,
+        date: timestamp.toISOString(),
+        read: false,
+        path: destPath,
+      });
+
+      // Keep only last 1000 emails in index
+      inbox = inbox.slice(0, 1000);
+
+      await s3.send(new PutObjectCommand({
+        Bucket: bucket,
+        Key: indexKey,
+        Body: JSON.stringify(inbox, null, 2),
+        ContentType: 'application/json',
+      }));
+
+      console.log(\`Processed email: \${messageId} from \${fromEmail} to \${toEmail}\`);
+
+    } catch (error) {
+      console.error('Error processing email:', error);
+    }
+  }
+
+  return { statusCode: 200, body: 'OK' };
+};
+`
+
+export default handler