@bernierllc/email 1.0.1 → 1.1.1

package/packages/core/src/core/scheduler.ts

@@ -1,356 +0,0 @@
-/*
-Copyright (c) 2025 Bernier LLC
-
-This file is licensed to the client under a limited-use license.
-The client may use and modify this code *only within the scope of the project it was delivered for*.
-Redistribution or use in other products or commercial offerings is not permitted without written consent from Bernier LLC.
-*/
-
-/**
- * Email Scheduler - Handles email scheduling and sending
- */
-
-import { EmailProvider } from '../providers/base';
-import { EmailMessage } from '../types/provider';
-import { EmailStatus, ScheduledEmail } from '../types/scheduled';
-import { EmailTemplateManager } from './template-manager';
-
-export interface SchedulerConfig {
-  maxRetries?: number;
-  retryDelay?: number;
-  batchSize?: number;
-  concurrency?: number;
-}
-
-export class EmailScheduler {
-  private templateManager: EmailTemplateManager;
-  private emailProvider: EmailProvider;
-  private config: SchedulerConfig;
-  private scheduledEmails: Map<string, ScheduledEmail> = new Map();
-  private processingQueue: Set<string> = new Set();
-
-  constructor(
-    templateManager: EmailTemplateManager,
-    emailProvider: EmailProvider,
-    config: SchedulerConfig = {}
-  ) {
-    this.templateManager = templateManager;
-    this.emailProvider = emailProvider;
-    this.config = {
-      maxRetries: 3,
-      retryDelay: 1000,
-      batchSize: 10,
-      concurrency: 5,
-      ...config,
-    };
-  }
-
-  /**
-   * Schedule an email to be sent
-   */
-  async scheduleEmail(emailData: Omit<ScheduledEmail, 'id' | 'status' | 'createdAt' | 'updatedAt' | 'attempts'>): Promise<ScheduledEmail> {
-    const scheduledEmail: ScheduledEmail = {
-      ...emailData,
-      id: this.generateId(),
-      status: 'pending',
-      attempts: 0,
-      createdAt: new Date(),
-      updatedAt: new Date(),
-    };
-
-    // Store the scheduled email
-    this.scheduledEmails.set(scheduledEmail.id, scheduledEmail);
-
-    // If it's immediate, process right away
-    if (emailData.triggerType === 'immediate') {
-      // Don't await to avoid blocking
-      this.processEmail(scheduledEmail.id).catch(error => {
-        console.error('Failed to process immediate email:', error);
-      });
-    }
-
-    return scheduledEmail;
-  }
-
-  /**
-   * Process a single email
-   */
-  async processEmail(emailId: string): Promise<boolean> {
-    const scheduledEmail = this.scheduledEmails.get(emailId);
-    if (!scheduledEmail) {
-      throw new Error(`Scheduled email with id ${emailId} not found`);
-    }
-
-    if (this.processingQueue.has(emailId)) {
-      console.log(`Email ${emailId} is already being processed`);
-      return false;
-    }
-
-    this.processingQueue.add(emailId);
-
-    try {
-      // Check if email should be sent now
-      if (!this.shouldSendNow(scheduledEmail)) {
-        this.processingQueue.delete(emailId);
-        return false;
-      }
-
-      // Update status to processing
-      scheduledEmail.status = 'processing';
-      scheduledEmail.updatedAt = new Date();
-
-      // Render the template
-      const rendered = await this.templateManager.renderTemplateByName(
-        scheduledEmail.templateName,
-        scheduledEmail.variables
-      );
-
-      // Create email message
-      const emailMessage: EmailMessage = {
-        toEmail: scheduledEmail.recipientEmail,
-        toName: scheduledEmail.recipientName,
-        subject: rendered.subject,
-        htmlContent: rendered.htmlContent,
-        textContent: rendered.textContent,
-        metadata: {
-          scheduledEmailId: scheduledEmail.id,
-          templateName: scheduledEmail.templateName,
-          ...scheduledEmail.metadata,
-        },
-      };
-
-      // Send the email
-      const result = await this.emailProvider.sendEmail(emailMessage);
-
-      if (result.success) {
-        // Update status to sent
-        scheduledEmail.status = 'sent';
-        scheduledEmail.sentAt = new Date();
-        scheduledEmail.messageId = result.messageId;
-        scheduledEmail.providerResponse = result.providerResponse;
-      } else {
-        // Handle failure
-        scheduledEmail.attempts += 1;
-        scheduledEmail.lastError = result.errorMessage;
-
-        if (scheduledEmail.attempts >= this.config.maxRetries!) {
-          scheduledEmail.status = 'failed';
-        } else {
-          scheduledEmail.status = 'pending';
-          // Schedule retry
-          scheduledEmail.retryAt = new Date(Date.now() + this.config.retryDelay! * Math.pow(2, scheduledEmail.attempts));
-        }
-      }
-
-      scheduledEmail.updatedAt = new Date();
-      this.processingQueue.delete(emailId);
-
-      return result.success;
-    } catch (error) {
-      scheduledEmail.status = 'failed';
-      scheduledEmail.lastError = error instanceof Error ? error.message : 'Unknown error';
-      scheduledEmail.updatedAt = new Date();
-      this.processingQueue.delete(emailId);
-
-      console.error(`Failed to process email ${emailId}:`, error);
-      return false;
-    }
-  }
-
-  /**
-   * Process all pending emails
-   */
-  async processPendingEmails(): Promise<void> {
-    const pendingEmails = Array.from(this.scheduledEmails.values())
-      .filter(email => this.shouldProcessEmail(email))
-      .slice(0, this.config.batchSize);
-
-    if (pendingEmails.length === 0) {
-      return;
-    }
-
-    // Process emails with concurrency limit
-    const chunks = this.chunkArray(pendingEmails, this.config.concurrency!);
-    
-    for (const chunk of chunks) {
-      const promises = chunk.map(email => this.processEmail(email.id));
-      await Promise.allSettled(promises);
-    }
-  }
-
-  /**
-   * Get scheduled email by ID
-   */
-  getScheduledEmail(id: string): ScheduledEmail | null {
-    return this.scheduledEmails.get(id) || null;
-  }
-
-  /**
-   * Get all scheduled emails with optional filtering
-   */
-  getScheduledEmails(filters?: {
-    status?: EmailStatus;
-    templateName?: string;
-    recipientEmail?: string;
-    createdAfter?: Date;
-    createdBefore?: Date;
-  }): ScheduledEmail[] {
-    let emails = Array.from(this.scheduledEmails.values());
-
-    if (filters) {
-      emails = emails.filter(email => {
-        if (filters.status && email.status !== filters.status) {
-          return false;
-        }
-
-        if (filters.templateName && email.templateName !== filters.templateName) {
-          return false;
-        }
-
-        if (filters.recipientEmail && email.recipientEmail !== filters.recipientEmail) {
-          return false;
-        }
-
-        if (filters.createdAfter && email.createdAt < filters.createdAfter) {
-          return false;
-        }
-
-        if (filters.createdBefore && email.createdAt > filters.createdBefore) {
-          return false;
-        }
-
-        return true;
-      });
-    }
-
-    return emails;
-  }
-
-  /**
-   * Cancel a scheduled email
-   */
-  async cancelScheduledEmail(id: string): Promise<boolean> {
-    const scheduledEmail = this.scheduledEmails.get(id);
-    if (!scheduledEmail) {
-      return false;
-    }
-
-    if (scheduledEmail.status === 'sent' || scheduledEmail.status === 'failed') {
-      return false; // Cannot cancel already processed emails
-    }
-
-    scheduledEmail.status = 'cancelled';
-    scheduledEmail.updatedAt = new Date();
-
-    return true;
-  }
-
-  /**
-   * Retry a failed email
-   */
-  async retryFailedEmail(id: string): Promise<boolean> {
-    const scheduledEmail = this.scheduledEmails.get(id);
-    if (!scheduledEmail) {
-      return false;
-    }
-
-    if (scheduledEmail.status !== 'failed') {
-      return false; // Can only retry failed emails
-    }
-
-    scheduledEmail.status = 'pending';
-    scheduledEmail.attempts = 0;
-    scheduledEmail.lastError = undefined;
-    scheduledEmail.retryAt = undefined;
-    scheduledEmail.updatedAt = new Date();
-
-    // Process immediately
-    return await this.processEmail(id);
-  }
-
-  /**
-   * Get email statistics
-   */
-  getStatistics(): {
-    total: number;
-    pending: number;
-    processing: number;
-    sent: number;
-    failed: number;
-    cancelled: number;
-  } {
-    const emails = Array.from(this.scheduledEmails.values());
-
-    return {
-      total: emails.length,
-      pending: emails.filter(e => e.status === 'pending').length,
-      processing: emails.filter(e => e.status === 'processing').length,
-      sent: emails.filter(e => e.status === 'sent').length,
-      failed: emails.filter(e => e.status === 'failed').length,
-      cancelled: emails.filter(e => e.status === 'cancelled').length,
-    };
-  }
-
-  /**
-   * Check if an email should be sent now
-   */
-  private shouldSendNow(email: ScheduledEmail): boolean {
-    const now = new Date();
-
-    switch (email.triggerType) {
-      case 'immediate':
-        return true;
-
-      case 'scheduled':
-        return email.scheduledFor ? email.scheduledFor <= now : false;
-
-      case 'relative':
-        if (!email.relativeToDate || !email.relativeOffset) {
-          return false;
-        }
-        const triggerDate = new Date(email.relativeToDate.getTime() + email.relativeOffset);
-        return triggerDate <= now;
-
-      default:
-        return false;
-    }
-  }
-
-  /**
-   * Check if an email should be processed (including retries)
-   */
-  private shouldProcessEmail(email: ScheduledEmail): boolean {
-    if (email.status !== 'pending') {
-      return false;
-    }
-
-    if (this.processingQueue.has(email.id)) {
-      return false;
-    }
-
-    // Check if it's time for retry
-    if (email.retryAt && email.retryAt > new Date()) {
-      return false;
-    }
-
-    return this.shouldSendNow(email);
-  }
-
-  /**
-   * Generate a unique ID
-   */
-  private generateId(): string {
-    return `sch_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
-  }
-
-  /**
-   * Split array into chunks
-   */
-  private chunkArray<T>(array: T[], size: number): T[][] {
-    const chunks: T[][] = [];
-    for (let i = 0; i < array.length; i += size) {
-      chunks.push(array.slice(i, i + size));
-    }
-    return chunks;
-  }
-}