@stacksjs/ts-cloud-core 0.1.2 → 0.1.6

package/src/email/advanced/scheduling.ts

@@ -1,352 +0,0 @@
-/**
- * Email Scheduling (Send Later)
- *
- * Provides scheduled email sending functionality
- */
-
-export interface ScheduledEmail {
-  id: string
-  email: {
-    from: string
-    to: string | string[]
-    cc?: string[]
-    bcc?: string[]
-    subject: string
-    html?: string
-    text?: string
-    attachments?: Array<{
-      filename: string
-      content: string
-      contentType?: string
-    }>
-  }
-  scheduledFor: string
-  timezone?: string
-  status: 'pending' | 'sent' | 'failed' | 'cancelled'
-  createdAt: string
-  sentAt?: string
-  error?: string
-  retryCount?: number
-}
-
-/**
- * Email Scheduling Module
- */
-export class EmailScheduling {
-  /**
-   * Lambda code for processing scheduled emails
-   */
-  static SchedulerLambdaCode = `
-const { S3Client, GetObjectCommand, PutObjectCommand, DeleteObjectCommand, ListObjectsV2Command } = require('@aws-sdk/client-s3');
-const { SESClient, SendRawEmailCommand } = require('@aws-sdk/client-ses');
-
-const s3 = new S3Client({});
-const ses = new SESClient({});
-const EMAIL_BUCKET = process.env.EMAIL_BUCKET;
-
-exports.handler = async (event) => {
-  console.log('Email scheduler event:', JSON.stringify(event, null, 2));
-
-  const now = new Date();
-
-  // List scheduled emails
-  const listResult = await s3.send(new ListObjectsV2Command({
-    Bucket: EMAIL_BUCKET,
-    Prefix: 'scheduled/',
-  }));
-
-  const objects = listResult.Contents || [];
-
-  for (const obj of objects) {
-    if (!obj.Key.endsWith('.json')) continue;
-
-    try {
-      // Get scheduled email
-      const getResult = await s3.send(new GetObjectCommand({
-        Bucket: EMAIL_BUCKET,
-        Key: obj.Key,
-      }));
-
-      const scheduled = JSON.parse(await getResult.Body.transformToString());
-
-      // Skip if not pending
-      if (scheduled.status !== 'pending') continue;
-
-      // Check if it's time to send
-      const scheduledTime = new Date(scheduled.scheduledFor);
-      if (scheduledTime > now) continue;
-
-      console.log(\`Sending scheduled email: \${scheduled.id}\`);
-
-      try {
-        // Build and send email
-        const rawMessage = buildRawEmail(scheduled.email);
-        const sendResult = await ses.send(new SendRawEmailCommand({
-          RawMessage: { Data: Buffer.from(rawMessage) },
-        }));
-
-        // Update status to sent
-        scheduled.status = 'sent';
-        scheduled.sentAt = new Date().toISOString();
-        scheduled.messageId = sendResult.MessageId;
-
-        // Move to sent folder
-        await s3.send(new PutObjectCommand({
-          Bucket: EMAIL_BUCKET,
-          Key: \`scheduled-sent/\${scheduled.id}.json\`,
-          Body: JSON.stringify(scheduled, null, 2),
-          ContentType: 'application/json',
-        }));
-
-        // Delete from scheduled folder
-        await s3.send(new DeleteObjectCommand({
-          Bucket: EMAIL_BUCKET,
-          Key: obj.Key,
-        }));
-
-        console.log(\`Sent scheduled email: \${scheduled.id}\`);
-      } catch (sendError) {
-        console.error(\`Failed to send scheduled email: \${scheduled.id}\`, sendError);
-
-        // Update retry count
-        scheduled.retryCount = (scheduled.retryCount || 0) + 1;
-
-        if (scheduled.retryCount >= 3) {
-          scheduled.status = 'failed';
-          scheduled.error = sendError.message;
-        }
-
-        await s3.send(new PutObjectCommand({
-          Bucket: EMAIL_BUCKET,
-          Key: obj.Key,
-          Body: JSON.stringify(scheduled, null, 2),
-          ContentType: 'application/json',
-        }));
-      }
-    } catch (error) {
-      console.error(\`Error processing scheduled email: \${obj.Key}\`, error);
-    }
-  }
-
-  return { statusCode: 200 };
-};
-
-function buildRawEmail(email) {
-  const boundary = \`----=_Part_\${Date.now()}\`;
-  let raw = '';
-
-  raw += \`From: \${email.from}\\r\\n\`;
-  raw += \`To: \${Array.isArray(email.to) ? email.to.join(', ') : email.to}\\r\\n\`;
-  if (email.cc) raw += \`Cc: \${email.cc.join(', ')}\\r\\n\`;
-  raw += \`Subject: =?UTF-8?B?\${Buffer.from(email.subject).toString('base64')}?=\\r\\n\`;
-  raw += \`Date: \${new Date().toUTCString()}\\r\\n\`;
-  raw += 'MIME-Version: 1.0\\r\\n';
-
-  if (email.html && email.text) {
-    raw += \`Content-Type: multipart/alternative; boundary="\${boundary}"\\r\\n\\r\\n\`;
-    raw += \`--\${boundary}\\r\\n\`;
-    raw += 'Content-Type: text/plain; charset=UTF-8\\r\\n\\r\\n';
-    raw += email.text + '\\r\\n\\r\\n';
-    raw += \`--\${boundary}\\r\\n\`;
-    raw += 'Content-Type: text/html; charset=UTF-8\\r\\n\\r\\n';
-    raw += email.html + '\\r\\n\\r\\n';
-    raw += \`--\${boundary}--\\r\\n\`;
-  } else if (email.html) {
-    raw += 'Content-Type: text/html; charset=UTF-8\\r\\n\\r\\n';
-    raw += email.html;
-  } else {
-    raw += 'Content-Type: text/plain; charset=UTF-8\\r\\n\\r\\n';
-    raw += email.text || '';
-  }
-
-  return raw;
-}
-`
-
-  /**
-   * Create scheduler Lambda function
-   */
-  static createSchedulerLambda(config: {
-    slug: string
-    roleArn: string
-    emailBucket: string
-  }): Record<string, any> {
-    return {
-      [`${config.slug}EmailSchedulerLambda`]: {
-        Type: 'AWS::Lambda::Function',
-        Properties: {
-          FunctionName: `${config.slug}-email-scheduler`,
-          Runtime: 'nodejs20.x',
-          Handler: 'index.handler',
-          Role: config.roleArn,
-          Timeout: 300,
-          MemorySize: 256,
-          Code: {
-            ZipFile: EmailScheduling.SchedulerLambdaCode,
-          },
-          Environment: {
-            Variables: {
-              EMAIL_BUCKET: config.emailBucket,
-            },
-          },
-        },
-      },
-    }
-  }
-
-  /**
-   * Create EventBridge rule to trigger scheduler
-   */
-  static createSchedulerRule(config: {
-    slug: string
-    lambdaArn: string
-    scheduleExpression?: string
-  }): Record<string, any> {
-    return {
-      [`${config.slug}EmailSchedulerRule`]: {
-        Type: 'AWS::Events::Rule',
-        Properties: {
-          Name: `${config.slug}-email-scheduler`,
-          Description: 'Trigger email scheduler every minute',
-          ScheduleExpression: config.scheduleExpression || 'rate(1 minute)',
-          State: 'ENABLED',
-          Targets: [
-            {
-              Id: 'EmailSchedulerTarget',
-              Arn: config.lambdaArn,
-            },
-          ],
-        },
-      },
-      [`${config.slug}EmailSchedulerPermission`]: {
-        Type: 'AWS::Lambda::Permission',
-        Properties: {
-          FunctionName: config.lambdaArn,
-          Action: 'lambda:InvokeFunction',
-          Principal: 'events.amazonaws.com',
-          SourceArn: { 'Fn::GetAtt': [`${config.slug}EmailSchedulerRule`, 'Arn'] },
-        },
-      },
-    }
-  }
-
-  /**
-   * Schedule an email (SDK helper)
-   */
-  static async scheduleEmail(params: {
-    s3Client: any
-    bucket: string
-    email: ScheduledEmail['email']
-    scheduledFor: Date | string
-    timezone?: string
-  }): Promise<ScheduledEmail> {
-    const { s3Client, bucket, email, scheduledFor, timezone } = params
-
-    const id = `sched-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`
-
-    const scheduled: ScheduledEmail = {
-      id,
-      email,
-      scheduledFor: typeof scheduledFor === 'string' ? scheduledFor : scheduledFor.toISOString(),
-      timezone,
-      status: 'pending',
-      createdAt: new Date().toISOString(),
-    }
-
-    await s3Client.send({
-      Bucket: bucket,
-      Key: `scheduled/${id}.json`,
-      Body: JSON.stringify(scheduled, null, 2),
-      ContentType: 'application/json',
-    })
-
-    return scheduled
-  }
-
-  /**
-   * Cancel a scheduled email
-   */
-  static async cancelScheduledEmail(params: {
-    s3Client: any
-    bucket: string
-    id: string
-  }): Promise<boolean> {
-    const { s3Client, bucket, id } = params
-
-    try {
-      // Get scheduled email
-      const result = await s3Client.send({
-        Bucket: bucket,
-        Key: `scheduled/${id}.json`,
-      })
-
-      const scheduled = JSON.parse(result.Body)
-
-      if (scheduled.status !== 'pending') {
-        return false
-      }
-
-      // Update status
-      scheduled.status = 'cancelled'
-
-      await s3Client.send({
-        Bucket: bucket,
-        Key: `scheduled/${id}.json`,
-        Body: JSON.stringify(scheduled, null, 2),
-        ContentType: 'application/json',
-      })
-
-      return true
-    }
-    catch {
-      return false
-    }
-  }
-
-  /**
-   * List scheduled emails
-   */
-  static async listScheduledEmails(params: {
-    s3Client: any
-    bucket: string
-    status?: ScheduledEmail['status']
-  }): Promise<ScheduledEmail[]> {
-    const { s3Client, bucket, status } = params
-
-    const result = await s3Client.send({
-      Bucket: bucket,
-      Prefix: 'scheduled/',
-    })
-
-    const emails: ScheduledEmail[] = []
-
-    for (const obj of result.Contents || []) {
-      if (!obj.Key.endsWith('.json')) continue
-
-      try {
-        const getResult = await s3Client.send({
-          Bucket: bucket,
-          Key: obj.Key,
-        })
-
-        const scheduled = JSON.parse(getResult.Body)
-
-        if (!status || scheduled.status === status) {
-          emails.push(scheduled)
-        }
-      }
-      catch {
-        // Skip invalid files
-      }
-    }
-
-    // Sort by scheduled time
-    emails.sort((a, b) =>
-      new Date(a.scheduledFor).getTime() - new Date(b.scheduledFor).getTime()
-    )
-
-    return emails
-  }
-}
-
-export default EmailScheduling