@stacksjs/ts-cloud-core 0.1.2 → 0.1.6

package/src/email/handlers/outbound.ts

@@ -1,178 +0,0 @@
-/**
- * Outbound Email Lambda Handler
- *
- * Processes outgoing emails:
- * - Accepts JSON email payloads from S3
- * - Generates proper MIME messages
- * - Supports HTML and plain text
- * - Handles attachments (base64 encoded)
- * - Tracks via configuration set
- * - Stores sent emails in S3
- */
-
-export const handler = `
-const { S3Client, GetObjectCommand, PutObjectCommand, DeleteObjectCommand } = require('@aws-sdk/client-s3');
-const { SESClient, SendRawEmailCommand } = require('@aws-sdk/client-ses');
-
-const s3 = new S3Client({});
-const ses = new SESClient({});
-
-exports.handler = async (event) => {
-  console.log('Outbound email event:', JSON.stringify(event, null, 2));
-
-  const bucket = process.env.EMAIL_BUCKET;
-  const configSet = process.env.CONFIG_SET || 'default';
-
-  for (const record of event.Records) {
-    try {
-      // Get the email payload from S3
-      const s3Event = record.s3 || {};
-      const key = decodeURIComponent(s3Event.object?.key?.replace(/\\+/g, ' ') || '');
-
-      if (!key || !key.startsWith('outbox/')) {
-        continue;
-      }
-
-      const getResult = await s3.send(new GetObjectCommand({
-        Bucket: bucket,
-        Key: key,
-      }));
-
-      const emailData = JSON.parse(await getResult.Body.transformToString());
-
-      // Build MIME message
-      const boundary = \`----=_Part_\${Date.now()}_\${Math.random().toString(36).substr(2)}\`;
-      const mixedBoundary = \`----=_Mixed_\${Date.now()}_\${Math.random().toString(36).substr(2)}\`;
-
-      let rawMessage = '';
-
-      // Headers
-      rawMessage += \`From: \${emailData.from}\\r\\n\`;
-      rawMessage += \`To: \${Array.isArray(emailData.to) ? emailData.to.join(', ') : emailData.to}\\r\\n\`;
-
-      if (emailData.cc) {
-        rawMessage += \`Cc: \${Array.isArray(emailData.cc) ? emailData.cc.join(', ') : emailData.cc}\\r\\n\`;
-      }
-
-      if (emailData.replyTo) {
-        rawMessage += \`Reply-To: \${emailData.replyTo}\\r\\n\`;
-      }
-
-      rawMessage += \`Subject: =?UTF-8?B?\${Buffer.from(emailData.subject || '').toString('base64')}?=\\r\\n\`;
-      rawMessage += \`Date: \${new Date().toUTCString()}\\r\\n\`;
-      rawMessage += \`Message-ID: <\${Date.now()}.\${Math.random().toString(36)}@\${emailData.from.split('@')[1] || 'local'}>\\r\\n\`;
-      rawMessage += 'MIME-Version: 1.0\\r\\n';
-
-      const hasAttachments = emailData.attachments && emailData.attachments.length > 0;
-
-      if (hasAttachments) {
-        rawMessage += \`Content-Type: multipart/mixed; boundary="\${mixedBoundary}"\\r\\n\\r\\n\`;
-        rawMessage += \`--\${mixedBoundary}\\r\\n\`;
-      }
-
-      // Body (multipart alternative for HTML + text)
-      if (emailData.html && emailData.text) {
-        rawMessage += \`Content-Type: multipart/alternative; boundary="\${boundary}"\\r\\n\\r\\n\`;
-
-        // Plain text part
-        rawMessage += \`--\${boundary}\\r\\n\`;
-        rawMessage += 'Content-Type: text/plain; charset=UTF-8\\r\\n';
-        rawMessage += 'Content-Transfer-Encoding: quoted-printable\\r\\n\\r\\n';
-        rawMessage += emailData.text + '\\r\\n\\r\\n';
-
-        // HTML part
-        rawMessage += \`--\${boundary}\\r\\n\`;
-        rawMessage += 'Content-Type: text/html; charset=UTF-8\\r\\n';
-        rawMessage += 'Content-Transfer-Encoding: quoted-printable\\r\\n\\r\\n';
-        rawMessage += emailData.html + '\\r\\n\\r\\n';
-
-        rawMessage += \`--\${boundary}--\\r\\n\`;
-      } else if (emailData.html) {
-        if (!hasAttachments) {
-          rawMessage += 'Content-Type: text/html; charset=UTF-8\\r\\n';
-          rawMessage += 'Content-Transfer-Encoding: quoted-printable\\r\\n\\r\\n';
-        } else {
-          rawMessage += 'Content-Type: text/html; charset=UTF-8\\r\\n\\r\\n';
-        }
-        rawMessage += emailData.html + '\\r\\n';
-      } else {
-        if (!hasAttachments) {
-          rawMessage += 'Content-Type: text/plain; charset=UTF-8\\r\\n';
-          rawMessage += 'Content-Transfer-Encoding: quoted-printable\\r\\n\\r\\n';
-        } else {
-          rawMessage += 'Content-Type: text/plain; charset=UTF-8\\r\\n\\r\\n';
-        }
-        rawMessage += (emailData.text || emailData.body || '') + '\\r\\n';
-      }
-
-      // Attachments
-      if (hasAttachments) {
-        for (const attachment of emailData.attachments) {
-          rawMessage += \`--\${mixedBoundary}\\r\\n\`;
-          rawMessage += \`Content-Type: \${attachment.contentType || 'application/octet-stream'}; name="\${attachment.filename}"\\r\\n\`;
-          rawMessage += 'Content-Transfer-Encoding: base64\\r\\n';
-          rawMessage += \`Content-Disposition: attachment; filename="\${attachment.filename}"\\r\\n\\r\\n\`;
-          rawMessage += attachment.content + '\\r\\n';
-        }
-        rawMessage += \`--\${mixedBoundary}--\\r\\n\`;
-      }
-
-      // Send via SES
-      const sendResult = await ses.send(new SendRawEmailCommand({
-        RawMessage: { Data: Buffer.from(rawMessage) },
-        ConfigurationSetName: configSet,
-      }));
-
-      console.log(\`Email sent: \${sendResult.MessageId}\`);
-
-      // Store in sent folder
-      const timestamp = new Date();
-      const year = timestamp.getFullYear();
-      const month = String(timestamp.getMonth() + 1).padStart(2, '0');
-      const day = String(timestamp.getDate()).padStart(2, '0');
-
-      const fromEmail = emailData.from.match(/<([^>]+)>/) ? emailData.from.match(/<([^>]+)>/)[1] : emailData.from;
-      const [localPart, domain] = fromEmail.split('@');
-
-      const sentPath = \`mailboxes/\${domain}/\${localPart}/sent/\${year}/\${month}/\${day}/\${sendResult.MessageId}\`;
-
-      // Save sent email metadata
-      await s3.send(new PutObjectCommand({
-        Bucket: bucket,
-        Key: \`\${sentPath}/metadata.json\`,
-        Body: JSON.stringify({
-          messageId: sendResult.MessageId,
-          from: emailData.from,
-          to: emailData.to,
-          cc: emailData.cc,
-          subject: emailData.subject,
-          sentAt: timestamp.toISOString(),
-          hasAttachments,
-        }, null, 2),
-        ContentType: 'application/json',
-      }));
-
-      // Save raw message
-      await s3.send(new PutObjectCommand({
-        Bucket: bucket,
-        Key: \`\${sentPath}/raw.eml\`,
-        Body: rawMessage,
-        ContentType: 'message/rfc822',
-      }));
-
-      // Delete from outbox
-      await s3.send(new DeleteObjectCommand({
-        Bucket: bucket,
-        Key: key,
-      }));
-
-    } catch (error) {
-      console.error('Error sending email:', error);
-    }
-  }
-
-  return { statusCode: 200, body: 'OK' };
-};
-`
-
-export default handler

package/src/email/index.ts

@@ -1,15 +0,0 @@
-/**
- * Email Advanced Features
- * Bounce handling, analytics, reputation monitoring, and template management
- */
-
-export * from './bounce-handling'
-export * from './analytics'
-export * from './reputation'
-export * from './templates'
-
-// Advanced features (namespaced to avoid conflicts)
-export * as EmailAdvanced from './advanced'
-
-// Handlers (namespaced)
-export * as EmailHandlers from './handlers/inbound'

package/src/email/reputation.ts

@@ -1,303 +0,0 @@
-/**
- * SES Sender Reputation Monitoring
- * Reputation tracking, sending limits, and deliverability monitoring
- */
-
-export interface ReputationDashboard {
-  id: string
-  timestamp: Date
-  overallScore: number
-  bounceRate: number
-  complaintRate: number
-  spamReports: number
-  blacklistStatus: BlacklistStatus[]
-  dkimStatus: 'VERIFIED' | 'PENDING' | 'FAILED'
-  spfStatus: 'PASS' | 'FAIL' | 'SOFTFAIL'
-  dmarcStatus: 'PASS' | 'FAIL' | 'NONE'
-  sendingLimits: SendingLimits
-  recommendations: string[]
-}
-
-export interface BlacklistStatus {
-  listName: string
-  listed: boolean
-  listedAt?: Date
-  delistUrl?: string
-}
-
-export interface SendingLimits {
-  maxSendRate: number // emails per second
-  max24HourSend: number
-  sentLast24Hours: number
-  remainingQuota: number
-  quotaResetTime: Date
-}
-
-export interface WarmupPlan {
-  id: string
-  name: string
-  startDate: Date
-  currentDay: number
-  totalDays: number
-  dailyLimits: number[]
-  currentLimit: number
-  status: 'active' | 'paused' | 'completed'
-}
-
-export interface DomainReputation {
-  id: string
-  domain: string
-  reputationScore: number
-  totalSent: number
-  deliveryRate: number
-  openRate: number
-  clickRate: number
-  bounceRate: number
-  complaintRate: number
-  engagementScore: number
-}
-
-/**
- * Sender reputation manager
- */
-export class SenderReputationManager {
-  private dashboards: Map<string, ReputationDashboard> = new Map()
-  private warmupPlans: Map<string, WarmupPlan> = new Map()
-  private domainReputations: Map<string, DomainReputation> = new Map()
-  private dashboardCounter = 0
-  private warmupCounter = 0
-  private domainCounter = 0
-
-  /**
-   * Get reputation dashboard
-   */
-  getReputationDashboard(): ReputationDashboard {
-    const id = `dashboard-${Date.now()}-${this.dashboardCounter++}`
-
-    const bounceRate = Math.random() * 5 // 0-5%
-    const complaintRate = Math.random() * 0.5 // 0-0.5%
-    const spamReports = Math.floor(Math.random() * 10)
-
-    // Calculate overall score (0-100)
-    const overallScore = Math.max(0, 100 - (bounceRate * 10) - (complaintRate * 100) - (spamReports * 2))
-
-    const recommendations: string[] = []
-    if (bounceRate > 2) recommendations.push('Reduce bounce rate by cleaning email list')
-    if (complaintRate > 0.1) recommendations.push('Review email content and unsubscribe process')
-    if (spamReports > 5) recommendations.push('Improve email relevance and targeting')
-
-    const dashboard: ReputationDashboard = {
-      id,
-      timestamp: new Date(),
-      overallScore,
-      bounceRate,
-      complaintRate,
-      spamReports,
-      blacklistStatus: this.checkBlacklists(),
-      dkimStatus: 'VERIFIED',
-      spfStatus: 'PASS',
-      dmarcStatus: 'PASS',
-      sendingLimits: {
-        maxSendRate: 14,
-        max24HourSend: 50000,
-        sentLast24Hours: 12000,
-        remainingQuota: 38000,
-        quotaResetTime: new Date(Date.now() + 24 * 60 * 60 * 1000),
-      },
-      recommendations,
-    }
-
-    this.dashboards.set(id, dashboard)
-
-    return dashboard
-  }
-
-  /**
-   * Check blacklists
-   */
-  private checkBlacklists(): BlacklistStatus[] {
-    const blacklists = [
-      'Spamhaus ZEN',
-      'Spamcop',
-      'SORBS',
-      'Barracuda',
-      'URIBL',
-    ]
-
-    return blacklists.map(listName => ({
-      listName,
-      listed: Math.random() > 0.95, // 5% chance of being listed
-      delistUrl: `https://www.${listName.toLowerCase().replace(/\s/g, '')}.org/delist`,
-    }))
-  }
-
-  /**
-   * Create warmup plan
-   */
-  createWarmupPlan(options: {
-    name: string
-    initialDailyLimit: number
-    targetDailyLimit: number
-    durationDays: number
-  }): WarmupPlan {
-    const id = `warmup-${Date.now()}-${this.warmupCounter++}`
-
-    const dailyLimits: number[] = []
-    const increment = (options.targetDailyLimit - options.initialDailyLimit) / options.durationDays
-
-    for (let day = 0; day < options.durationDays; day++) {
-      dailyLimits.push(Math.floor(options.initialDailyLimit + (increment * day)))
-    }
-
-    const warmupPlan: WarmupPlan = {
-      id,
-      name: options.name,
-      startDate: new Date(),
-      currentDay: 1,
-      totalDays: options.durationDays,
-      dailyLimits,
-      currentLimit: dailyLimits[0],
-      status: 'active',
-    }
-
-    this.warmupPlans.set(id, warmupPlan)
-
-    return warmupPlan
-  }
-
-  /**
-   * Create aggressive warmup plan
-   */
-  createAggressiveWarmupPlan(options: {
-    name: string
-  }): WarmupPlan {
-    return this.createWarmupPlan({
-      name: options.name,
-      initialDailyLimit: 500,
-      targetDailyLimit: 50000,
-      durationDays: 14,
-    })
-  }
-
-  /**
-   * Create conservative warmup plan
-   */
-  createConservativeWarmupPlan(options: {
-    name: string
-  }): WarmupPlan {
-    return this.createWarmupPlan({
-      name: options.name,
-      initialDailyLimit: 200,
-      targetDailyLimit: 50000,
-      durationDays: 30,
-    })
-  }
-
-  /**
-   * Advance warmup plan
-   */
-  advanceWarmupPlan(warmupId: string): WarmupPlan {
-    const warmup = this.warmupPlans.get(warmupId)
-
-    if (!warmup) {
-      throw new Error(`Warmup plan not found: ${warmupId}`)
-    }
-
-    if (warmup.currentDay < warmup.totalDays) {
-      warmup.currentDay++
-      warmup.currentLimit = warmup.dailyLimits[warmup.currentDay - 1]
-    }
-
-    if (warmup.currentDay >= warmup.totalDays) {
-      warmup.status = 'completed'
-    }
-
-    return warmup
-  }
-
-  /**
-   * Track domain reputation
-   */
-  trackDomainReputation(options: {
-    domain: string
-    totalSent: number
-    delivered: number
-    opened: number
-    clicked: number
-    bounced: number
-    complained: number
-  }): DomainReputation {
-    const id = `domain-${Date.now()}-${this.domainCounter++}`
-
-    const deliveryRate = (options.delivered / options.totalSent) * 100
-    const openRate = options.delivered > 0 ? (options.opened / options.delivered) * 100 : 0
-    const clickRate = options.delivered > 0 ? (options.clicked / options.delivered) * 100 : 0
-    const bounceRate = (options.bounced / options.totalSent) * 100
-    const complaintRate = options.delivered > 0 ? (options.complained / options.delivered) * 100 : 0
-
-    const engagementScore = (openRate * 0.4) + (clickRate * 0.6)
-    const reputationScore = Math.max(0, 100 - (bounceRate * 10) - (complaintRate * 100) + (engagementScore * 0.2))
-
-    const domainReputation: DomainReputation = {
-      id,
-      domain: options.domain,
-      reputationScore,
-      totalSent: options.totalSent,
-      deliveryRate,
-      openRate,
-      clickRate,
-      bounceRate,
-      complaintRate,
-      engagementScore,
-    }
-
-    this.domainReputations.set(options.domain, domainReputation)
-
-    return domainReputation
-  }
-
-  /**
-   * Get domain reputation
-   */
-  getDomainReputation(domain: string): DomainReputation | undefined {
-    return this.domainReputations.get(domain)
-  }
-
-  /**
-   * List all domain reputations
-   */
-  listDomainReputations(): DomainReputation[] {
-    return Array.from(this.domainReputations.values())
-  }
-
-  /**
-   * Get warmup plan
-   */
-  getWarmupPlan(id: string): WarmupPlan | undefined {
-    return this.warmupPlans.get(id)
-  }
-
-  /**
-   * List warmup plans
-   */
-  listWarmupPlans(): WarmupPlan[] {
-    return Array.from(this.warmupPlans.values())
-  }
-
-  /**
-   * Clear all data
-   */
-  clear(): void {
-    this.dashboards.clear()
-    this.warmupPlans.clear()
-    this.domainReputations.clear()
-    this.dashboardCounter = 0
-    this.warmupCounter = 0
-    this.domainCounter = 0
-  }
-}
-
-/**
- * Global sender reputation manager instance
- */
-export const senderReputationManager: SenderReputationManager = new SenderReputationManager()