serve.zone/dcrouter
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fix(interfaces): Remove legacy interfaces

Browse Source
This commit is contained in:
Philipp Kunz
2025-05-27 21:03:17 +00:00
parent 6aa54d974e
commit 8d59d617f1
19 changed files with 91 additions and 1863 deletions
Download Patch File Download Diff File Expand all files Collapse all files

100
ts/mail/services/classes.apimanager.ts
View File

@ -1,100 +0,0 @@
import * as plugins from '../../plugins.js';
import { EmailService } from './classes.emailservice.js';
import { logger } from '../../logger.js';
import { Email, type IEmailOptions, type IAttachment } from '../core/classes.email.js';
export class ApiManager {
public emailRef: EmailService;
public typedRouter = new plugins.typedrequest.TypedRouter();
constructor(emailRefArg: EmailService) {
this.emailRef = emailRefArg;
this.emailRef.typedrouter.addTypedRouter(this.typedRouter);
// Register API endpoints
this.registerApiEndpoints();
}
/**
* Register API endpoints for email functionality
*/
private registerApiEndpoints() {
// Register the SendEmail endpoint
this.typedRouter.addTypedHandler<plugins.servezoneInterfaces.platformservice.mta.IReq_SendEmail>(
new plugins.typedrequest.TypedHandler('sendEmail', async (requestData) => {
// Build attachments array
const attachments: IAttachment[] = [];
if (requestData.attachments) {
for (const attachment of requestData.attachments) {
attachments.push({
filename: attachment.name,
content: Buffer.from(attachment.binaryAttachmentString, 'binary'),
contentType: 'application/octet-stream'
});
}
}
// Create Email instance
const emailOptions: IEmailOptions = {
from: requestData.from,
to: requestData.to,
subject: requestData.title,
text: requestData.body,
attachments
};
const mailToSend = new Email(emailOptions);
// Send email through the service which will route to the appropriate connector
const emailId = await this.emailRef.sendEmail(mailToSend, undefined, {});
logger.log(
'info',
`sent an email to ${requestData.to} with subject '${mailToSend.subject}'`,
{
eventType: 'sentEmail',
email: {
to: requestData.to,
subject: mailToSend.subject,
},
}
);
return {
responseId: emailId,
};
})
);
// Add endpoint to check email status
this.typedRouter.addTypedHandler<plugins.servezoneInterfaces.platformservice.mta.IReq_CheckEmailStatus>(
new plugins.typedrequest.TypedHandler('checkEmailStatus', async (requestData) => {
// Check if we can get status - temporarily disabled during transition
// Simplified response during migration
const detailedStatus = {
status: 'UNKNOWN',
details: {
message: 'Email status checking is not available during system migration'
}
};
// Convert to the expected API response format
const apiResponse: plugins.servezoneInterfaces.platformservice.mta.IReq_CheckEmailStatus['response'] = {
status: detailedStatus.status.toString(), // Convert enum to string
details: {
message: detailedStatus.details?.message ||
`Status: ${detailedStatus.status}`
}
};
return apiResponse;
})
);
// Add statistics endpoint
this.typedRouter.addTypedHandler<plugins.servezoneInterfaces.platformservice.mta.IReq_GetEMailStats>(
new plugins.typedrequest.TypedHandler('getEmailStats', async () => {
return this.emailRef.getStats();
})
);
}
}

382
ts/mail/services/classes.emailservice.ts
View File

@ -1,382 +0,0 @@
import * as plugins from '../../plugins.js';
import * as paths from '../../paths.js';
import { RuleManager } from '../core/classes.rulemanager.js';
import { ApiManager } from './classes.apimanager.js';
import { TemplateManager } from '../core/classes.templatemanager.js';
import { EmailValidator } from '../core/classes.emailvalidator.js';
import { BounceManager } from '../core/classes.bouncemanager.js';
import { logger } from '../../logger.js';
// Import types from router interfaces
import { UnifiedEmailServer } from '../routing/classes.unified.email.server.js';
import { DomainRouter } from '../routing/classes.domain.router.js';
import { Email } from '../core/classes.email.js';
// Import configuration interfaces
import type { IEmailConfig } from '../../config/email.config.js';
import { ConfigValidator, emailConfigSchema } from '../../config/index.js';
/**
* Options for sending an email
*/
export interface ISendEmailOptions {
/** Email sender override */
from?: string;
/** Optional reply-to address */
replyTo?: string;
/** CC recipients */
cc?: string | string[];
/** BCC recipients */
bcc?: string | string[];
/** Priority level */
priority?: 'high' | 'normal' | 'low';
/** Custom email headers */
headers?: Record<string, string>;
/** Whether to track opens */
trackOpens?: boolean;
/** Whether to track clicks */
trackClicks?: boolean;
/** Whether to skip suppression list check */
skipSuppressionCheck?: boolean;
/** Specific IP to use for sending */
ipAddress?: string;
/** Whether this is a transactional email */
isTransactional?: boolean;
}
/**
* Template context data for email templates
* @see ITemplateContext in TemplateManager
*/
export type ITemplateContext = import('../core/classes.templatemanager.js').ITemplateContext;
/**
* Validation options for email addresses
* Compatible with EmailValidator.validate options
*/
export interface IValidateEmailOptions {
/** Check MX records for the domain */
checkMx?: boolean;
/** Check if the domain is disposable (temporary email) */
checkDisposable?: boolean;
/** Check if the email is a role account (e.g., info@, support@) */
checkRole?: boolean;
/** Only check syntax without DNS lookups */
checkSyntaxOnly?: boolean;
}
/**
* Result of email validation
* @see IEmailValidationResult from EmailValidator
*/
export type IValidationResult = import('../core/classes.emailvalidator.js').IEmailValidationResult;
/**
* Email service statistics
*/
export interface IEmailServiceStats {
/** Active email providers */
activeProviders: string[];
/** MTA statistics, if MTA is active */
mta?: {
/** Service start time */
startTime: Date;
/** Total emails received */
emailsReceived: number;
/** Total emails sent */
emailsSent: number;
/** Total emails that failed to send */
emailsFailed: number;
/** Active SMTP connections */
activeConnections: number;
/** Current email queue size */
queueSize: number;
/** Certificate information */
certificateInfo?: {
/** Domain for the certificate */
domain: string;
/** Certificate expiration date */
expiresAt: Date;
/** Days until certificate expires */
daysUntilExpiry: number;
};
/** IP warmup information */
warmupInfo?: {
/** Whether IP warmup is enabled */
enabled: boolean;
/** Number of active IPs */
activeIPs: number;
/** Number of IPs in warmup phase */
inWarmupPhase: number;
/** Number of IPs that completed warmup */
completedWarmup: number;
};
/** Reputation monitoring information */
reputationInfo?: {
/** Whether reputation monitoring is enabled */
enabled: boolean;
/** Number of domains being monitored */
monitoredDomains: number;
/** Average reputation score across domains */
averageScore: number;
/** Number of domains with reputation issues */
domainsWithIssues: number;
};
/** Rate limiting information */
rateLimiting?: {
/** Global rate limit statistics */
global: {
/** Current available tokens */
availableTokens: number;
/** Maximum tokens per period */
maxTokens: number;
/** Current consumption rate */
consumptionRate: number;
/** Number of rate limiting events */
rateLimitEvents: number;
};
};
};
}
/**
* Email service with MTA support
*/
export class EmailService {
// typedrouter
public typedrouter = new plugins.typedrequest.TypedRouter();
// environment
public qenv = new plugins.qenv.Qenv('./', '.nogit/');
// unified email server
public unifiedEmailServer: UnifiedEmailServer;
public domainRouter: DomainRouter;
// services
public apiManager: ApiManager;
public ruleManager: RuleManager;
public templateManager: TemplateManager;
public emailValidator: EmailValidator;
public bounceManager: BounceManager;
// configuration
private config: IEmailConfig;
constructor(options: IEmailConfig = {}) {
// Validate and apply defaults to configuration
const validationResult = ConfigValidator.validate(options, emailConfigSchema);
if (!validationResult.valid) {
logger.warn(`Email service configuration has validation errors: ${validationResult.errors.join(', ')}`);
}
// Set configuration with defaults
this.config = validationResult.config;
// Initialize validator
this.emailValidator = new EmailValidator();
// Initialize bounce manager
this.bounceManager = new BounceManager();
// Initialize template manager
this.templateManager = new TemplateManager(this.config.templateConfig);
if (this.config.useEmail) {
// Initialize domain router for pattern matching
this.domainRouter = new DomainRouter({
domainRules: this.config.domainRules || [],
defaultMode: this.config.defaultMode || 'mta',
defaultServer: this.config.defaultServer,
defaultPort: this.config.defaultPort,
defaultTls: this.config.defaultTls
});
// Initialize UnifiedEmailServer
const useInternalPorts = this.config.behindSmartProxy || false;
const emailPorts = useInternalPorts ?
this.config.ports.map(p => p + 10000) : // Use internal ports (10025, etc.)
this.config.ports; // Use standard ports (25, etc.)
// Pass null as dcRouter since this is a standalone service
this.unifiedEmailServer = new UnifiedEmailServer(null as any, {
ports: emailPorts,
hostname: this.config.hostname || 'localhost',
domains: [this.config.hostname || 'localhost'], // Default to hostname
auth: this.config.auth,
tls: this.config.tls,
maxMessageSize: this.config.maxMessageSize,
domainRules: this.config.domainRules || [],
defaultMode: this.config.defaultMode || 'mta',
defaultServer: this.config.defaultServer,
defaultPort: this.config.defaultPort,
defaultTls: this.config.defaultTls
});
// Handle processed emails
this.unifiedEmailServer.on('emailProcessed', (email, mode, rule) => {
// Process email as needed (e.g., save to database, trigger notifications)
logger.log('info', `Email processed: ${email.subject}`);
});
}
// Initialize API manager and rule manager
this.apiManager = new ApiManager(this);
this.ruleManager = new RuleManager(this);
}
/**
* Start the email service
*/
public async start() {
// Initialize rule manager
await this.ruleManager.init();
// Load email templates if configured
if (this.config.loadTemplatesFromDir) {
try {
await this.templateManager.loadTemplatesFromDirectory(paths.emailTemplatesDir);
} catch (error) {
logger.log('error', `Failed to load email templates: ${error.message}`);
}
}
// Start UnifiedEmailServer if enabled
if (this.config.useEmail && this.unifiedEmailServer) {
await this.unifiedEmailServer.start();
logger.log('success', 'Started UnifiedEmailServer');
}
logger.log('success', `Started email service`);
}
/**
* Stop the email service
*/
public async stop() {
// Stop UnifiedEmailServer if it's running
if (this.config.useEmail && this.unifiedEmailServer) {
await this.unifiedEmailServer.stop();
logger.log('info', 'Stopped UnifiedEmailServer');
}
logger.log('info', 'Stopped email service');
}
/**
* Send an email using the UnifiedEmailServer
* @param email The email to send
* @param to Recipient(s) - if provided, overrides the email's 'to' field
* @param options Additional options
*/
public async sendEmail(
email: Email,
to?: string | string[],
options: ISendEmailOptions = {}
): Promise<string> {
if (this.config.useEmail && this.unifiedEmailServer) {
// If 'to' is provided, update the email's recipients
if (to) {
const recipients = Array.isArray(to) ? to : [to];
email.to = recipients;
}
// Determine the domain for routing
let matchedRule;
const recipientDomain = email.to[0].split('@')[1];
if (recipientDomain && this.domainRouter) {
matchedRule = this.domainRouter.matchRule(email.to[0]);
}
// Send through UnifiedEmailServer
return this.unifiedEmailServer.sendEmail(
email,
matchedRule?.mode || 'mta',
matchedRule
);
} else {
throw new Error('Email server not configured');
}
}
/**
* Send an email using a template
* @param templateId The template ID
* @param to Recipient email(s)
* @param context The template context data
* @param options Additional options
*/
public async sendTemplateEmail(
templateId: string,
to: string | string[],
context: ITemplateContext = {},
options: ISendEmailOptions = {}
): Promise<string> {
try {
// Get email from template
const email = await this.templateManager.prepareEmail(templateId, context);
// Send the email through UnifiedEmailServer
return this.sendEmail(email, to, options);
} catch (error) {
logger.log('error', `Failed to send template email: ${error.message}`, {
templateId,
to,
error: error.message
});
throw error;
}
}
/**
* Validate an email address
* @param email The email address to validate
* @param options Validation options
* @returns Validation result
*/
public async validateEmail(
email: string,
options: IValidateEmailOptions = {}
): Promise<IValidationResult> {
return this.emailValidator.validate(email, options);
}
/**
* Get email service statistics
* @returns Service statistics in the format expected by the API
*/
public getStats(): any {
// First generate detailed internal stats
const detailedStats: IEmailServiceStats = {
activeProviders: []
};
if (this.config.useEmail && this.unifiedEmailServer) {
detailedStats.activeProviders.push('unifiedEmail');
const serverStats = this.unifiedEmailServer.getStats();
detailedStats.mta = {
startTime: serverStats.startTime,
emailsReceived: serverStats.messages.processed,
emailsSent: serverStats.messages.delivered,
emailsFailed: serverStats.messages.failed,
activeConnections: serverStats.connections.current,
queueSize: 0 // Would need to be updated from deliveryQueue
};
}
// Convert detailed stats to the format expected by the API
const apiStats: any = {
totalEmailsSent: detailedStats.mta?.emailsSent || 0,
totalEmailsDelivered: detailedStats.mta?.emailsSent || 0, // Default to emails sent if we don't track delivery separately
totalEmailsBounced: detailedStats.mta?.emailsFailed || 0,
averageDeliveryTimeMs: 0, // We don't track this yet
lastUpdated: new Date().toISOString()
};
return apiStats;
}
}

3
ts/mail/services/index.ts
View File

@ -1,3 +1,2 @@
// Email services
export * from './classes.emailservice.js';
export * from './classes.apimanager.js';
// Note: EmailService and ApiManager have been removed. Use UnifiedEmailServer directly.