625 lines
20 KiB
TypeScript
625 lines
20 KiB
TypeScript
import * as plugins from '../../plugins.js';
|
|
import { EmailService } from '../services/classes.emailservice.js';
|
|
import { logger } from '../../logger.js';
|
|
|
|
// Import MTA classes
|
|
import { MtaService } from './classes.mta.js';
|
|
import { Email as MtaEmail } from '../core/classes.email.js';
|
|
import { DeliveryStatus } from './classes.emailsendjob.js';
|
|
|
|
// Re-export for use in index.ts
|
|
export { DeliveryStatus };
|
|
|
|
// Import Email types
|
|
export interface IEmailOptions {
|
|
from: string;
|
|
to: string[];
|
|
cc?: string[];
|
|
bcc?: string[];
|
|
subject: string;
|
|
text?: string;
|
|
html?: string;
|
|
attachments?: IAttachment[];
|
|
headers?: { [key: string]: string };
|
|
}
|
|
|
|
|
|
// Reuse the IAttachment interface
|
|
export interface IAttachment {
|
|
filename: string;
|
|
content: Buffer;
|
|
contentType: string;
|
|
contentId?: string;
|
|
encoding?: string;
|
|
}
|
|
|
|
/**
|
|
* Email status details
|
|
*/
|
|
export interface IEmailStatusDetails {
|
|
/** Number of delivery attempts */
|
|
attempts?: number;
|
|
/** Timestamp of last delivery attempt */
|
|
lastAttempt?: Date;
|
|
/** Timestamp of next scheduled attempt */
|
|
nextAttempt?: Date;
|
|
/** Error message if delivery failed */
|
|
error?: string;
|
|
/** Message explaining the status */
|
|
message?: string;
|
|
}
|
|
|
|
/**
|
|
* Email status response
|
|
*/
|
|
export interface IEmailStatusResponse {
|
|
/** Current status of the email */
|
|
status: DeliveryStatus | 'unknown' | 'error';
|
|
/** Additional status details */
|
|
details?: IEmailStatusDetails;
|
|
}
|
|
|
|
/**
|
|
* Options for sending an email via MTA
|
|
*/
|
|
export interface ISendEmailOptions {
|
|
/** Whether to use MIME format conversion */
|
|
useMimeFormat?: boolean;
|
|
/** Whether to track clicks */
|
|
trackClicks?: boolean;
|
|
/** Whether to track opens */
|
|
trackOpens?: boolean;
|
|
/** Message priority (1-5, where 1 is highest) */
|
|
priority?: number;
|
|
/** Message scheduling options */
|
|
schedule?: {
|
|
/** Time to send the email */
|
|
sendAt?: Date | string;
|
|
/** Time the message expires */
|
|
expireAt?: Date | string;
|
|
};
|
|
/** DKIM signing options */
|
|
dkim?: {
|
|
/** Whether to sign the message */
|
|
sign?: boolean;
|
|
/** Domain to use for signing */
|
|
domain?: string;
|
|
/** Key selector to use */
|
|
selector?: string;
|
|
};
|
|
/** Additional headers */
|
|
headers?: Record<string, string>;
|
|
/** Message tags for categorization */
|
|
tags?: string[];
|
|
}
|
|
|
|
export class MtaConnector {
|
|
public emailRef: EmailService;
|
|
private mtaService: MtaService;
|
|
|
|
constructor(emailRefArg: EmailService, mtaService?: MtaService) {
|
|
this.emailRef = emailRefArg;
|
|
this.mtaService = mtaService || this.emailRef.mtaService;
|
|
}
|
|
|
|
/**
|
|
* Send an email using the MTA service
|
|
* @param smartmail The email to send
|
|
* @param toAddresses Recipients (comma-separated or array)
|
|
* @param options Additional options
|
|
*/
|
|
|
|
/**
|
|
* Send an email using the MTA service
|
|
* @param smartmail The email to send
|
|
* @param toAddresses Recipients (comma-separated or array)
|
|
* @param options Additional options
|
|
*/
|
|
public async sendEmail(
|
|
smartmail: plugins.smartmail.Smartmail<any>,
|
|
toAddresses: string | string[],
|
|
options: ISendEmailOptions = {}
|
|
): Promise<string> {
|
|
// Check if recipients are on the suppression list
|
|
const recipients = Array.isArray(toAddresses)
|
|
? toAddresses
|
|
: toAddresses.split(',').map(addr => addr.trim());
|
|
|
|
// Filter out suppressed recipients
|
|
const validRecipients = [];
|
|
const suppressedRecipients = [];
|
|
|
|
for (const recipient of recipients) {
|
|
if (this.emailRef.bounceManager.isEmailSuppressed(recipient)) {
|
|
suppressedRecipients.push(recipient);
|
|
} else {
|
|
validRecipients.push(recipient);
|
|
}
|
|
}
|
|
|
|
// Log suppressed recipients
|
|
if (suppressedRecipients.length > 0) {
|
|
logger.log('warn', `Skipping ${suppressedRecipients.length} suppressed recipients`, {
|
|
suppressedRecipients
|
|
});
|
|
}
|
|
|
|
// If all recipients are suppressed, throw error
|
|
if (validRecipients.length === 0) {
|
|
throw new Error('All recipients are on the suppression list');
|
|
}
|
|
|
|
// Continue with valid recipients
|
|
try {
|
|
// Use filtered recipients - already an array, no need for toArray
|
|
|
|
// Add recipients to smartmail if they're not already added
|
|
if (!smartmail.options.to || smartmail.options.to.length === 0) {
|
|
for (const recipient of validRecipients) {
|
|
smartmail.addRecipient(recipient);
|
|
}
|
|
}
|
|
|
|
// Handle options
|
|
const emailOptions: Record<string, any> = { ...options };
|
|
|
|
// Check if we should use MIME format
|
|
const useMimeFormat = options.useMimeFormat !== false; // Default to true
|
|
|
|
if (useMimeFormat) {
|
|
// Use smartmail's MIME conversion for improved handling
|
|
try {
|
|
// Convert to MIME format
|
|
const mimeEmail = await smartmail.toMimeFormat(smartmail.options.creationObjectRef);
|
|
|
|
// Parse the MIME email to create an MTA Email
|
|
return this.sendMimeEmail(mimeEmail, validRecipients);
|
|
} catch (mimeError) {
|
|
logger.log('warn', `Failed to use MIME format, falling back to direct conversion: ${mimeError.message}`);
|
|
// Fall back to direct conversion
|
|
return this.sendDirectEmail(smartmail, validRecipients);
|
|
}
|
|
} else {
|
|
// Use direct conversion
|
|
return this.sendDirectEmail(smartmail, validRecipients);
|
|
}
|
|
} catch (error) {
|
|
logger.log('error', `Failed to send email via MTA: ${error.message}`, {
|
|
eventType: 'emailError',
|
|
provider: 'mta',
|
|
error: error.message
|
|
});
|
|
|
|
// Check if this is a bounce-related error
|
|
if (error.message.includes('550') || // Rejected
|
|
error.message.includes('551') || // User not local
|
|
error.message.includes('552') || // Mailbox full
|
|
error.message.includes('553') || // Bad mailbox name
|
|
error.message.includes('554') || // Transaction failed
|
|
error.message.includes('does not exist') ||
|
|
error.message.includes('unknown user') ||
|
|
error.message.includes('invalid recipient')) {
|
|
|
|
// Process as a bounce
|
|
for (const recipient of validRecipients) {
|
|
await this.emailRef.bounceManager.processSmtpFailure(
|
|
recipient,
|
|
error.message,
|
|
{
|
|
sender: smartmail.options.from,
|
|
statusCode: error.message.match(/\b([45]\d{2})\b/) ? error.message.match(/\b([45]\d{2})\b/)[1] : undefined
|
|
}
|
|
);
|
|
}
|
|
}
|
|
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Send a MIME-formatted email
|
|
* @param mimeEmail The MIME-formatted email content
|
|
* @param recipients The email recipients
|
|
*/
|
|
private async sendMimeEmail(mimeEmail: string, recipients: string[]): Promise<string> {
|
|
try {
|
|
// Parse the MIME email
|
|
const parsedEmail = await plugins.mailparser.simpleParser(mimeEmail);
|
|
|
|
// Extract necessary information for MTA Email
|
|
const mtaEmail = new MtaEmail({
|
|
from: parsedEmail.from?.text || '',
|
|
to: recipients,
|
|
subject: parsedEmail.subject || '',
|
|
text: parsedEmail.text || '',
|
|
html: parsedEmail.html || undefined,
|
|
attachments: parsedEmail.attachments?.map(attachment => ({
|
|
filename: attachment.filename || 'attachment',
|
|
content: attachment.content,
|
|
contentType: attachment.contentType || 'application/octet-stream',
|
|
contentId: attachment.contentId
|
|
})) || [],
|
|
headers: Object.fromEntries([...parsedEmail.headers].map(([key, value]) => [key, String(value)]))
|
|
});
|
|
|
|
// Send using MTA
|
|
const emailId = await this.mtaService.send(mtaEmail);
|
|
|
|
logger.log('info', `MIME email sent via MTA to ${recipients.join(', ')}`, {
|
|
eventType: 'sentEmail',
|
|
provider: 'mta',
|
|
emailId,
|
|
to: recipients
|
|
});
|
|
|
|
return emailId;
|
|
} catch (error) {
|
|
logger.log('error', `Failed to send MIME email: ${error.message}`);
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Send an email using direct conversion (fallback method)
|
|
* @param smartmail The Smartmail instance
|
|
* @param recipients The email recipients
|
|
*/
|
|
private async sendDirectEmail(
|
|
smartmail: plugins.smartmail.Smartmail<any>,
|
|
recipients: string[]
|
|
): Promise<string> {
|
|
// Map SmartMail attachments to MTA attachments with improved content type handling
|
|
const attachments: IAttachment[] = smartmail.attachments.map(attachment => {
|
|
// Try to determine content type from file extension if not explicitly set
|
|
let contentType = (attachment as any)?.contentType;
|
|
|
|
if (!contentType) {
|
|
const extension = attachment.parsedPath.ext.toLowerCase();
|
|
contentType = this.getContentTypeFromExtension(extension);
|
|
}
|
|
|
|
return {
|
|
filename: attachment.parsedPath.base,
|
|
content: Buffer.from(attachment.contentBuffer),
|
|
contentType: contentType || 'application/octet-stream',
|
|
// Add content ID for inline images if available
|
|
contentId: (attachment as any)?.contentId
|
|
};
|
|
});
|
|
|
|
// Create MTA Email
|
|
const mtaEmail = new MtaEmail({
|
|
from: smartmail.options.from,
|
|
to: recipients,
|
|
subject: smartmail.getSubject(),
|
|
text: smartmail.getBody(false), // Plain text version
|
|
html: smartmail.getBody(true), // HTML version
|
|
attachments
|
|
});
|
|
|
|
// Prepare arrays for CC and BCC recipients
|
|
let ccRecipients: string[] = [];
|
|
let bccRecipients: string[] = [];
|
|
|
|
// Add CC recipients if present
|
|
if (smartmail.options.cc?.length > 0) {
|
|
// Handle CC recipients - smartmail options may contain email objects
|
|
ccRecipients = smartmail.options.cc.map(r => {
|
|
if (typeof r === 'string') return r;
|
|
return typeof (r as any).address === 'string' ? (r as any).address :
|
|
typeof (r as any).email === 'string' ? (r as any).email : '';
|
|
});
|
|
mtaEmail.cc = ccRecipients;
|
|
}
|
|
|
|
// Add BCC recipients if present
|
|
if (smartmail.options.bcc?.length > 0) {
|
|
// Handle BCC recipients - smartmail options may contain email objects
|
|
bccRecipients = smartmail.options.bcc.map(r => {
|
|
if (typeof r === 'string') return r;
|
|
return typeof (r as any).address === 'string' ? (r as any).address :
|
|
typeof (r as any).email === 'string' ? (r as any).email : '';
|
|
});
|
|
mtaEmail.bcc = bccRecipients;
|
|
}
|
|
|
|
// Send using MTA
|
|
const emailId = await this.mtaService.send(mtaEmail);
|
|
|
|
logger.log('info', `Email sent via MTA to ${recipients.join(', ')}`, {
|
|
eventType: 'sentEmail',
|
|
provider: 'mta',
|
|
emailId,
|
|
to: recipients
|
|
});
|
|
|
|
return emailId;
|
|
}
|
|
|
|
/**
|
|
* Get content type from file extension
|
|
* @param extension The file extension (with or without dot)
|
|
* @returns The content type or undefined if unknown
|
|
*/
|
|
private getContentTypeFromExtension(extension: string): string | undefined {
|
|
// Remove dot if present
|
|
const ext = extension.startsWith('.') ? extension.substring(1) : extension;
|
|
|
|
// Common content types
|
|
const contentTypes: Record<string, string> = {
|
|
'pdf': 'application/pdf',
|
|
'jpg': 'image/jpeg',
|
|
'jpeg': 'image/jpeg',
|
|
'png': 'image/png',
|
|
'gif': 'image/gif',
|
|
'svg': 'image/svg+xml',
|
|
'webp': 'image/webp',
|
|
'txt': 'text/plain',
|
|
'html': 'text/html',
|
|
'csv': 'text/csv',
|
|
'json': 'application/json',
|
|
'xml': 'application/xml',
|
|
'zip': 'application/zip',
|
|
'doc': 'application/msword',
|
|
'docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
|
|
'xls': 'application/vnd.ms-excel',
|
|
'xlsx': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
|
|
'ppt': 'application/vnd.ms-powerpoint',
|
|
'pptx': 'application/vnd.openxmlformats-officedocument.presentationml.presentation'
|
|
};
|
|
|
|
return contentTypes[ext.toLowerCase()];
|
|
}
|
|
|
|
/**
|
|
* Retrieve and process an incoming email
|
|
* For MTA, this would handle an email already received by the SMTP server
|
|
* @param emailData The raw email data or identifier
|
|
* @param options Additional processing options
|
|
*/
|
|
public async receiveEmail(
|
|
emailData: string,
|
|
options: {
|
|
preserveHeaders?: boolean;
|
|
includeRawData?: boolean;
|
|
validateSender?: boolean;
|
|
} = {}
|
|
): Promise<plugins.smartmail.Smartmail<any>> {
|
|
try {
|
|
// In a real implementation, this would retrieve an email from the MTA storage
|
|
// For now, we can use a simplified approach:
|
|
|
|
// Parse the email (assuming emailData is a raw email or a file path)
|
|
const parsedEmail = await plugins.mailparser.simpleParser(emailData);
|
|
|
|
// Extract sender information
|
|
const sender = parsedEmail.from?.text || '';
|
|
let senderName = '';
|
|
let senderEmail = sender;
|
|
|
|
// Try to extract name and email from "Name <email>" format
|
|
const senderMatch = sender.match(/(.*?)\s*<([^>]+)>/);
|
|
if (senderMatch) {
|
|
senderName = senderMatch[1].trim();
|
|
senderEmail = senderMatch[2].trim();
|
|
}
|
|
|
|
// Extract recipients
|
|
const recipients = [];
|
|
if (parsedEmail.to) {
|
|
// Extract recipients safely
|
|
try {
|
|
// Handle AddressObject or AddressObject[]
|
|
if (parsedEmail.to && typeof parsedEmail.to === 'object' && 'value' in parsedEmail.to) {
|
|
const addressList = Array.isArray(parsedEmail.to.value)
|
|
? parsedEmail.to.value
|
|
: [parsedEmail.to.value];
|
|
|
|
for (const addr of addressList) {
|
|
if (addr && typeof addr === 'object' && 'address' in addr) {
|
|
recipients.push({
|
|
name: addr.name || '',
|
|
email: addr.address || ''
|
|
});
|
|
}
|
|
}
|
|
}
|
|
} catch (error) {
|
|
// If parsing fails, try to extract as string
|
|
let toStr = '';
|
|
if (parsedEmail.to && typeof parsedEmail.to === 'object' && 'text' in parsedEmail.to) {
|
|
toStr = String(parsedEmail.to.text || '');
|
|
}
|
|
if (toStr) {
|
|
recipients.push({
|
|
name: '',
|
|
email: toStr
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
// Create a more comprehensive creation object reference
|
|
const creationObjectRef: Record<string, any> = {
|
|
sender: {
|
|
name: senderName,
|
|
email: senderEmail
|
|
},
|
|
recipients: recipients,
|
|
subject: parsedEmail.subject || '',
|
|
date: parsedEmail.date || new Date(),
|
|
messageId: parsedEmail.messageId || '',
|
|
inReplyTo: parsedEmail.inReplyTo || null,
|
|
references: parsedEmail.references || []
|
|
};
|
|
|
|
// Include headers if requested
|
|
if (options.preserveHeaders) {
|
|
creationObjectRef.headers = parsedEmail.headers;
|
|
}
|
|
|
|
// Include raw data if requested
|
|
if (options.includeRawData) {
|
|
creationObjectRef.rawData = emailData;
|
|
}
|
|
|
|
// Create a Smartmail from the parsed email
|
|
const smartmail = new plugins.smartmail.Smartmail({
|
|
from: senderEmail,
|
|
subject: parsedEmail.subject || '',
|
|
body: parsedEmail.html || parsedEmail.text || '',
|
|
creationObjectRef
|
|
});
|
|
|
|
// Add recipients
|
|
if (recipients.length > 0) {
|
|
for (const recipient of recipients) {
|
|
smartmail.addRecipient(recipient.email);
|
|
}
|
|
}
|
|
|
|
// Add CC recipients if present
|
|
if (parsedEmail.cc) {
|
|
try {
|
|
// Extract CC recipients safely
|
|
if (parsedEmail.cc && typeof parsedEmail.cc === 'object' && 'value' in parsedEmail.cc) {
|
|
const ccList = Array.isArray(parsedEmail.cc.value)
|
|
? parsedEmail.cc.value
|
|
: [parsedEmail.cc.value];
|
|
|
|
for (const addr of ccList) {
|
|
if (addr && typeof addr === 'object' && 'address' in addr) {
|
|
smartmail.addRecipient(addr.address, 'cc');
|
|
}
|
|
}
|
|
}
|
|
} catch (error) {
|
|
// If parsing fails, try to extract as string
|
|
let ccStr = '';
|
|
if (parsedEmail.cc && typeof parsedEmail.cc === 'object' && 'text' in parsedEmail.cc) {
|
|
ccStr = String(parsedEmail.cc.text || '');
|
|
}
|
|
if (ccStr) {
|
|
smartmail.addRecipient(ccStr, 'cc');
|
|
}
|
|
}
|
|
}
|
|
|
|
// Add BCC recipients if present (usually not in received emails, but just in case)
|
|
if (parsedEmail.bcc) {
|
|
try {
|
|
// Extract BCC recipients safely
|
|
if (parsedEmail.bcc && typeof parsedEmail.bcc === 'object' && 'value' in parsedEmail.bcc) {
|
|
const bccList = Array.isArray(parsedEmail.bcc.value)
|
|
? parsedEmail.bcc.value
|
|
: [parsedEmail.bcc.value];
|
|
|
|
for (const addr of bccList) {
|
|
if (addr && typeof addr === 'object' && 'address' in addr) {
|
|
smartmail.addRecipient(addr.address, 'bcc');
|
|
}
|
|
}
|
|
}
|
|
} catch (error) {
|
|
// If parsing fails, try to extract as string
|
|
let bccStr = '';
|
|
if (parsedEmail.bcc && typeof parsedEmail.bcc === 'object' && 'text' in parsedEmail.bcc) {
|
|
bccStr = String(parsedEmail.bcc.text || '');
|
|
}
|
|
if (bccStr) {
|
|
smartmail.addRecipient(bccStr, 'bcc');
|
|
}
|
|
}
|
|
}
|
|
|
|
// Add attachments if present
|
|
if (parsedEmail.attachments && parsedEmail.attachments.length > 0) {
|
|
for (const attachment of parsedEmail.attachments) {
|
|
// Create smartfile with proper constructor options
|
|
const file = new plugins.smartfile.SmartFile({
|
|
path: attachment.filename || 'attachment',
|
|
contentBuffer: attachment.content,
|
|
base: ''
|
|
});
|
|
|
|
// Set content type and content ID for proper MIME handling
|
|
if (attachment.contentType) {
|
|
(file as any).contentType = attachment.contentType;
|
|
}
|
|
|
|
if (attachment.contentId) {
|
|
(file as any).contentId = attachment.contentId;
|
|
}
|
|
|
|
smartmail.addAttachment(file);
|
|
}
|
|
}
|
|
|
|
// Validate sender if requested
|
|
if (options.validateSender && this.emailRef.emailValidator) {
|
|
try {
|
|
const validationResult = await this.emailRef.emailValidator.validate(senderEmail, {
|
|
checkSyntaxOnly: true // Use syntax-only for performance
|
|
});
|
|
|
|
// Add validation info to the creation object
|
|
creationObjectRef.senderValidation = validationResult;
|
|
} catch (validationError) {
|
|
logger.log('warn', `Sender validation error: ${validationError.message}`);
|
|
}
|
|
}
|
|
|
|
return smartmail;
|
|
} catch (error) {
|
|
logger.log('error', `Failed to receive email via MTA: ${error.message}`, {
|
|
eventType: 'emailError',
|
|
provider: 'mta',
|
|
error: error.message
|
|
});
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Check the status of a sent email
|
|
* @param emailId The email ID to check
|
|
* @returns Current status and details
|
|
*/
|
|
public async checkEmailStatus(emailId: string): Promise<IEmailStatusResponse> {
|
|
try {
|
|
const status = this.mtaService.getEmailStatus(emailId);
|
|
|
|
if (!status) {
|
|
return {
|
|
status: 'unknown' as const,
|
|
details: { message: 'Email not found' }
|
|
};
|
|
}
|
|
|
|
return {
|
|
// Use type assertion to ensure this passes type check
|
|
status: status.status as DeliveryStatus,
|
|
details: {
|
|
attempts: status.attempts,
|
|
lastAttempt: status.lastAttempt,
|
|
nextAttempt: status.nextAttempt,
|
|
error: status.error?.message,
|
|
message: `Status: ${status.status}${status.error ? `, Error: ${status.error.message}` : ''}`
|
|
}
|
|
};
|
|
} catch (error) {
|
|
logger.log('error', `Failed to check email status: ${error.message}`, {
|
|
eventType: 'emailError',
|
|
provider: 'mta',
|
|
emailId,
|
|
error: error.message
|
|
});
|
|
|
|
return {
|
|
status: 'error' as const,
|
|
details: { message: error.message }
|
|
};
|
|
}
|
|
}
|
|
} |