Transactional Email Deliverability Crisis

// Password Reset with Email Validation
async function sendPasswordReset(userEmail) {
  // Step 1: Validate email before attempting send
  const validation = await emailCheckClient.validate({
    email: userEmail,
    validateMX: true,
    checkDisposable: false, // User may have registered with temp email
    checkSMTP: true,
    timeout: 3000
  });

  // Step 2: Handle validation results
  if (validation.result === 'undeliverable') {
    // Log for security monitoring but return generic message
    await securityLog.logPasswordResetAttempt({
      email: userEmail,
      reason: 'undeliverable',
      timestamp: Date.now()
    });

    return {
      success: false,
      message: 'If the email exists, a reset link has been sent.'
    };
  }

  // Step 3: Generate secure reset token
  const resetToken = crypto.randomBytes(32).toString('hex');
  const expiry = Date.now() + 3600000; // 1 hour

  // Step 4: Store token securely
  await db.passwordResets.create({
    email: userEmail,
    token: hash(resetToken),
    expires: expiry
  });

  // Step 5: Send email with retry logic
  try {
    await emailService.send({
      to: userEmail,
      template: 'password-reset',
      data: {
        resetUrl: `https://example.com/reset?${resetToken}`,
        expiry: '1 hour'
      }
    });

    return {
      success: true,
      message: 'If the email exists, a reset link has been sent.'
    };
  } catch (error) {
    // Implement retry logic or fallback
    await handleEmailFailure(userEmail, 'password-reset', error);
  }
}

// 2FA Code Delivery with Validation
async function sendTwoFactorCode(userEmail) {
  // Step 1: Rapid validation for time-sensitive delivery
  const validation = await emailCheckClient.validate({
    email: userEmail,
    fastValidation: true, // Skip deeper checks for speed
    timeout: 1500
  });

  // Step 2: Generate short-lived code
  const code = generateSecureCode(6);
  const expiry = Date.now() + 300000; // 5 minutes

  // Step 3: Store with rate limiting
  await rateLimiter.check(userEmail, '2fa', {
    maxAttempts: 3,
    windowMs: 300000 // 5 minutes
  });

  await db.twoFactorCodes.create({
    email: userEmail,
    code: hash(code),
    expires: expiry
  });

  // Step 4: Prioritized sending
  const priority = 'urgent'; // Higher priority queue

  try {
    await emailService.send({
      to: userEmail,
      template: '2fa-code',
      priority: priority,
      data: {
        code: code,
        expiry: '5 minutes'
      }
    });

    // Step 5: Track delivery for monitoring
    await metrics.track('2fa_sent', {
      email: userEmail,
      timestamp: Date.now(),
      validationStatus: validation.result
    });

    return { success: true };
  } catch (error) {
    // Implement SMS fallback with security considerations
    if (error.type === 'bounce' || error.type === 'timeout') {
      return await fallbackToSMS(userEmail, code);
    }
    throw error;
  }
}

// Order Confirmation with Pre-Send Validation
async function sendOrderConfirmation(order) {
  const { customerEmail, orderId, items, total } = order;

  // Step 1: Validate before generating confirmation
  const validation = await emailCheckClient.validate({
    email: customerEmail,
    checkSMTP: true,
    validateMX: true,
    timeout: 5000 // Longer timeout for important emails
  });

  // Step 2: Handle validation issues gracefully
  if (validation.result === 'undeliverable') {
    // Flag order for manual review
    await orderService.flagForReview(orderId, {
      reason: 'email_undeliverable',
      validationDetails: validation
    });

    // Notify internal team
    await alertService.send({
      team: 'customer-support',
      message: `Order ${orderId} placed with invalid email: ${customerEmail}`,
      priority: 'high'
    });

    // Attempt to contact via alternative channel if available
    if (order.customerPhone) {
      await sendSMSConfirmation(order);
    }

    return {
      sent: false,
      requiresManualFollowUp: true
    };
  }

  // Step 3: Send confirmation with tracking
  const trackingId = generateTrackingId();

  await emailService.send({
    to: customerEmail,
    template: 'order-confirmation',
    trackingId: trackingId,
    data: {
      orderId: orderId,
      items: items,
      total: total,
      estimatedDelivery: calculateDeliveryDate()
    }
  });

  // Step 4: Monitor for engagement
  await monitoring.track('order_confirmation_sent', {
    orderId: orderId,
    email: customerEmail,
    trackingId: trackingId,
    validationStatus: validation.result
  });

  return { sent: true, trackingId: trackingId };
}