@serve.zone/dcrouter 2.12.4

package/dist_ts/ts/mail/core/classes.emailvalidator.d.ts

@@ -0,0 +1,61 @@
+export interface IEmailValidationResult {
+    isValid: boolean;
+    hasMx: boolean;
+    hasSpamMarkings: boolean;
+    score: number;
+    details?: {
+        formatValid?: boolean;
+        mxRecords?: string[];
+        disposable?: boolean;
+        role?: boolean;
+        spamIndicators?: string[];
+        errorMessage?: string;
+    };
+}
+/**
+ * Advanced email validator class using smartmail's capabilities
+ */
+export declare class EmailValidator {
+    private validator;
+    private dnsCache;
+    constructor(options?: {
+        maxCacheSize?: number;
+        cacheTTL?: number;
+    });
+    /**
+     * Validates an email address using comprehensive checks
+     * @param email The email to validate
+     * @param options Validation options
+     * @returns Validation result with details
+     */
+    validate(email: string, options?: {
+        checkMx?: boolean;
+        checkDisposable?: boolean;
+        checkRole?: boolean;
+        checkSyntaxOnly?: boolean;
+    }): Promise<IEmailValidationResult>;
+    /**
+     * Gets MX records for a domain with caching
+     * @param domain Domain to check
+     * @returns Array of MX records
+     */
+    private getMxRecords;
+    /**
+     * Validates multiple email addresses in batch
+     * @param emails Array of emails to validate
+     * @param options Validation options
+     * @returns Object with email addresses as keys and validation results as values
+     */
+    validateBatch(emails: string[], options?: {
+        checkMx?: boolean;
+        checkDisposable?: boolean;
+        checkRole?: boolean;
+        checkSyntaxOnly?: boolean;
+    }): Promise<Record<string, IEmailValidationResult>>;
+    /**
+     * Quick check if an email format is valid (synchronous, no DNS checks)
+     * @param email Email to check
+     * @returns Boolean indicating if format is valid
+     */
+    isValidFormat(email: string): boolean;
+}

package/dist_ts/ts/mail/core/classes.emailvalidator.js

@@ -0,0 +1,182 @@
+import * as plugins from '../../plugins.js';
+import { logger } from '../../logger.js';
+import { LRUCache } from 'lru-cache';
+/**
+ * Advanced email validator class using smartmail's capabilities
+ */
+export class EmailValidator {
+    constructor(options) {
+        this.validator = new plugins.smartmail.EmailAddressValidator();
+        // Initialize LRU cache for DNS records
+        this.dnsCache = new LRUCache({
+            // Default to 1000 entries (reasonable for most applications)
+            max: options?.maxCacheSize || 1000,
+            // Default TTL of 1 hour (DNS records don't change frequently)
+            ttl: options?.cacheTTL || 60 * 60 * 1000,
+            // Optional cache monitoring
+            allowStale: false,
+            updateAgeOnGet: true,
+            // Add logging for cache events in production environments
+            disposeAfter: (value, key) => {
+                logger.log('debug', `DNS cache entry expired for domain: ${key}`);
+            },
+        });
+    }
+    /**
+     * Validates an email address using comprehensive checks
+     * @param email The email to validate
+     * @param options Validation options
+     * @returns Validation result with details
+     */
+    async validate(email, options = {}) {
+        try {
+            const result = {
+                isValid: false,
+                hasMx: false,
+                hasSpamMarkings: false,
+                score: 0,
+                details: {
+                    formatValid: false,
+                    spamIndicators: []
+                }
+            };
+            // Always check basic format
+            result.details.formatValid = this.validator.isValidEmailFormat(email);
+            if (!result.details.formatValid) {
+                result.details.errorMessage = 'Invalid email format';
+                return result;
+            }
+            // If syntax-only check is requested, return early
+            if (options.checkSyntaxOnly) {
+                result.isValid = true;
+                result.score = 0.5;
+                return result;
+            }
+            // Get domain for additional checks
+            const domain = email.split('@')[1];
+            // Check MX records
+            if (options.checkMx !== false) {
+                try {
+                    const mxRecords = await this.getMxRecords(domain);
+                    result.details.mxRecords = mxRecords;
+                    result.hasMx = mxRecords && mxRecords.length > 0;
+                    if (!result.hasMx) {
+                        result.details.spamIndicators.push('No MX records');
+                        result.details.errorMessage = 'Domain has no MX records';
+                    }
+                }
+                catch (error) {
+                    logger.log('error', `Error checking MX records: ${error.message}`);
+                    result.details.errorMessage = 'Unable to check MX records';
+                }
+            }
+            // Check if domain is disposable
+            if (options.checkDisposable !== false) {
+                result.details.disposable = await this.validator.isDisposableEmail(email);
+                if (result.details.disposable) {
+                    result.details.spamIndicators.push('Disposable email');
+                }
+            }
+            // Check if email is a role account
+            if (options.checkRole !== false) {
+                result.details.role = this.validator.isRoleAccount(email);
+                if (result.details.role) {
+                    result.details.spamIndicators.push('Role account');
+                }
+            }
+            // Calculate spam score and final validity
+            result.hasSpamMarkings = result.details.spamIndicators.length > 0;
+            // Calculate a score between 0-1 based on checks
+            let scoreFactors = 0;
+            let scoreTotal = 0;
+            // Format check (highest weight)
+            scoreFactors += 0.4;
+            if (result.details.formatValid)
+                scoreTotal += 0.4;
+            // MX check (high weight)
+            if (options.checkMx !== false) {
+                scoreFactors += 0.3;
+                if (result.hasMx)
+                    scoreTotal += 0.3;
+            }
+            // Disposable check (medium weight)
+            if (options.checkDisposable !== false) {
+                scoreFactors += 0.2;
+                if (!result.details.disposable)
+                    scoreTotal += 0.2;
+            }
+            // Role account check (low weight)
+            if (options.checkRole !== false) {
+                scoreFactors += 0.1;
+                if (!result.details.role)
+                    scoreTotal += 0.1;
+            }
+            // Normalize score based on factors actually checked
+            result.score = scoreFactors > 0 ? scoreTotal / scoreFactors : 0;
+            // Email is valid if score is above 0.7 (configurable threshold)
+            result.isValid = result.score >= 0.7;
+            return result;
+        }
+        catch (error) {
+            logger.log('error', `Email validation error: ${error.message}`);
+            return {
+                isValid: false,
+                hasMx: false,
+                hasSpamMarkings: true,
+                score: 0,
+                details: {
+                    formatValid: false,
+                    errorMessage: `Validation error: ${error.message}`,
+                    spamIndicators: ['Validation error']
+                }
+            };
+        }
+    }
+    /**
+     * Gets MX records for a domain with caching
+     * @param domain Domain to check
+     * @returns Array of MX records
+     */
+    async getMxRecords(domain) {
+        // Check cache first
+        const cachedRecords = this.dnsCache.get(domain);
+        if (cachedRecords) {
+            logger.log('debug', `Using cached MX records for domain: ${domain}`);
+            return cachedRecords;
+        }
+        try {
+            // Use smartmail's getMxRecords method
+            const records = await this.validator.getMxRecords(domain);
+            // Store in cache (TTL is handled by the LRU cache configuration)
+            this.dnsCache.set(domain, records);
+            logger.log('debug', `Cached MX records for domain: ${domain}`);
+            return records;
+        }
+        catch (error) {
+            logger.log('error', `Error fetching MX records for ${domain}: ${error.message}`);
+            return [];
+        }
+    }
+    /**
+     * Validates multiple email addresses in batch
+     * @param emails Array of emails to validate
+     * @param options Validation options
+     * @returns Object with email addresses as keys and validation results as values
+     */
+    async validateBatch(emails, options = {}) {
+        const results = {};
+        for (const email of emails) {
+            results[email] = await this.validate(email, options);
+        }
+        return results;
+    }
+    /**
+     * Quick check if an email format is valid (synchronous, no DNS checks)
+     * @param email Email to check
+     * @returns Boolean indicating if format is valid
+     */
+    isValidFormat(email) {
+        return this.validator.isValidEmailFormat(email);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/ts/mail/core/classes.templatemanager.d.ts

@@ -0,0 +1,95 @@
+import { Email } from './classes.email.js';
+/**
+ * Email template type definition
+ */
+export interface IEmailTemplate<T = any> {
+    id: string;
+    name: string;
+    description: string;
+    from: string;
+    subject: string;
+    bodyHtml: string;
+    bodyText?: string;
+    category?: string;
+    sampleData?: T;
+    attachments?: Array<{
+        name: string;
+        path: string;
+        contentType?: string;
+    }>;
+}
+/**
+ * Email template context - data used to render the template
+ */
+export interface ITemplateContext {
+    [key: string]: any;
+}
+/**
+ * Template category definitions
+ */
+export declare enum TemplateCategory {
+    NOTIFICATION = "notification",
+    TRANSACTIONAL = "transactional",
+    MARKETING = "marketing",
+    SYSTEM = "system"
+}
+/**
+ * Enhanced template manager using Email class for template rendering
+ */
+export declare class TemplateManager {
+    private templates;
+    private defaultConfig;
+    constructor(defaultConfig?: {
+        from?: string;
+        replyTo?: string;
+        footerHtml?: string;
+        footerText?: string;
+    });
+    /**
+     * Register built-in email templates
+     */
+    private registerBuiltinTemplates;
+    /**
+     * Register a new email template
+     * @param template The email template to register
+     */
+    registerTemplate<T = any>(template: IEmailTemplate<T>): void;
+    /**
+     * Get an email template by ID
+     * @param templateId The template ID
+     * @returns The template or undefined if not found
+     */
+    getTemplate<T = any>(templateId: string): IEmailTemplate<T> | undefined;
+    /**
+     * List all available templates
+     * @param category Optional category filter
+     * @returns Array of email templates
+     */
+    listTemplates(category?: TemplateCategory): IEmailTemplate[];
+    /**
+     * Create an Email instance from a template
+     * @param templateId The template ID
+     * @param context The template context data
+     * @returns A configured Email instance
+     */
+    createEmail<T = any>(templateId: string, context?: ITemplateContext): Promise<Email>;
+    /**
+     * Create and completely process an Email instance from a template
+     * @param templateId The template ID
+     * @param context The template context data
+     * @returns A complete, processed Email instance ready to send
+     */
+    prepareEmail<T = any>(templateId: string, context?: ITemplateContext): Promise<Email>;
+    /**
+     * Create a MIME-formatted email from a template
+     * @param templateId The template ID
+     * @param context The template context data
+     * @returns A MIME-formatted email string
+     */
+    createMimeEmail(templateId: string, context?: ITemplateContext): Promise<string>;
+    /**
+     * Load templates from a directory
+     * @param directory The directory containing template JSON files
+     */
+    loadTemplatesFromDirectory(directory: string): Promise<void>;
+}

package/dist_ts/ts/mail/core/classes.templatemanager.js

@@ -0,0 +1,239 @@
+import * as plugins from '../../plugins.js';
+import * as paths from '../../paths.js';
+import { logger } from '../../logger.js';
+import { Email } from './classes.email.js';
+/**
+ * Template category definitions
+ */
+export var TemplateCategory;
+(function (TemplateCategory) {
+    TemplateCategory["NOTIFICATION"] = "notification";
+    TemplateCategory["TRANSACTIONAL"] = "transactional";
+    TemplateCategory["MARKETING"] = "marketing";
+    TemplateCategory["SYSTEM"] = "system";
+})(TemplateCategory || (TemplateCategory = {}));
+/**
+ * Enhanced template manager using Email class for template rendering
+ */
+export class TemplateManager {
+    constructor(defaultConfig) {
+        this.templates = new Map();
+        // Set default configuration
+        this.defaultConfig = {
+            from: defaultConfig?.from || 'noreply@mail.lossless.com',
+            replyTo: defaultConfig?.replyTo,
+            footerHtml: defaultConfig?.footerHtml || '',
+            footerText: defaultConfig?.footerText || ''
+        };
+        // Initialize with built-in templates
+        this.registerBuiltinTemplates();
+    }
+    /**
+     * Register built-in email templates
+     */
+    registerBuiltinTemplates() {
+        // Welcome email
+        this.registerTemplate({
+            id: 'welcome',
+            name: 'Welcome Email',
+            description: 'Sent to users when they first sign up',
+            from: this.defaultConfig.from,
+            subject: 'Welcome to {{serviceName}}!',
+            category: TemplateCategory.TRANSACTIONAL,
+            bodyHtml: `
+        <h1>Welcome, {{firstName}}!</h1>
+        <p>Thank you for joining {{serviceName}}. We're excited to have you on board.</p>
+        <p>To get started, <a href="{{accountUrl}}">visit your account</a>.</p>
+      `,
+            bodyText: `Welcome, {{firstName}}!
+        
+        Thank you for joining {{serviceName}}. We're excited to have you on board.
+        
+        To get started, visit your account: {{accountUrl}}
+        `,
+            sampleData: {
+                firstName: 'John',
+                accountUrl: 'https://example.com/account'
+            }
+        });
+        // Password reset
+        this.registerTemplate({
+            id: 'password-reset',
+            name: 'Password Reset',
+            description: 'Sent when a user requests a password reset',
+            from: this.defaultConfig.from,
+            subject: 'Password Reset Request',
+            category: TemplateCategory.TRANSACTIONAL,
+            bodyHtml: `
+        <h2>Password Reset Request</h2>
+        <p>You recently requested to reset your password. Click the link below to reset it:</p>
+        <p><a href="{{resetUrl}}">Reset Password</a></p>
+        <p>This link will expire in {{expiryHours}} hours.</p>
+        <p>If you didn't request a password reset, please ignore this email.</p>
+      `,
+            sampleData: {
+                resetUrl: 'https://example.com/reset-password?token=abc123',
+                expiryHours: 24
+            }
+        });
+        // System notification
+        this.registerTemplate({
+            id: 'system-notification',
+            name: 'System Notification',
+            description: 'General system notification template',
+            from: this.defaultConfig.from,
+            subject: '{{subject}}',
+            category: TemplateCategory.SYSTEM,
+            bodyHtml: `
+        <h2>{{title}}</h2>
+        <div>{{message}}</div>
+      `,
+            sampleData: {
+                subject: 'Important System Notification',
+                title: 'System Maintenance',
+                message: 'The system will be undergoing maintenance on Saturday from 2-4am UTC.'
+            }
+        });
+    }
+    /**
+     * Register a new email template
+     * @param template The email template to register
+     */
+    registerTemplate(template) {
+        if (this.templates.has(template.id)) {
+            logger.log('warn', `Template with ID '${template.id}' already exists and will be overwritten`);
+        }
+        // Add footer to templates if configured
+        if (this.defaultConfig.footerHtml && template.bodyHtml) {
+            template.bodyHtml += this.defaultConfig.footerHtml;
+        }
+        if (this.defaultConfig.footerText && template.bodyText) {
+            template.bodyText += this.defaultConfig.footerText;
+        }
+        this.templates.set(template.id, template);
+        logger.log('info', `Registered email template: ${template.id}`);
+    }
+    /**
+     * Get an email template by ID
+     * @param templateId The template ID
+     * @returns The template or undefined if not found
+     */
+    getTemplate(templateId) {
+        return this.templates.get(templateId);
+    }
+    /**
+     * List all available templates
+     * @param category Optional category filter
+     * @returns Array of email templates
+     */
+    listTemplates(category) {
+        const templates = Array.from(this.templates.values());
+        if (category) {
+            return templates.filter(template => template.category === category);
+        }
+        return templates;
+    }
+    /**
+     * Create an Email instance from a template
+     * @param templateId The template ID
+     * @param context The template context data
+     * @returns A configured Email instance
+     */
+    async createEmail(templateId, context) {
+        const template = this.getTemplate(templateId);
+        if (!template) {
+            throw new Error(`Template with ID '${templateId}' not found`);
+        }
+        // Build attachments array for Email
+        const attachments = [];
+        if (template.attachments && template.attachments.length > 0) {
+            for (const attachment of template.attachments) {
+                try {
+                    const attachmentPath = plugins.path.isAbsolute(attachment.path)
+                        ? attachment.path
+                        : plugins.path.join(paths.MtaAttachmentsDir, attachment.path);
+                    // Read the file
+                    const fileBuffer = await plugins.fs.promises.readFile(attachmentPath);
+                    attachments.push({
+                        filename: attachment.name,
+                        content: fileBuffer,
+                        contentType: attachment.contentType || 'application/octet-stream'
+                    });
+                }
+                catch (error) {
+                    logger.log('error', `Failed to add attachment '${attachment.name}': ${error.message}`);
+                }
+            }
+        }
+        // Create Email instance with template content
+        const emailOptions = {
+            from: template.from || this.defaultConfig.from,
+            subject: template.subject,
+            text: template.bodyText || '',
+            html: template.bodyHtml,
+            // Note: 'to' is intentionally omitted for templates
+            attachments,
+            variables: context || {}
+        };
+        return new Email(emailOptions);
+    }
+    /**
+     * Create and completely process an Email instance from a template
+     * @param templateId The template ID
+     * @param context The template context data
+     * @returns A complete, processed Email instance ready to send
+     */
+    async prepareEmail(templateId, context = {}) {
+        const email = await this.createEmail(templateId, context);
+        // Email class processes variables when needed, no pre-compilation required
+        return email;
+    }
+    /**
+     * Create a MIME-formatted email from a template
+     * @param templateId The template ID
+     * @param context The template context data
+     * @returns A MIME-formatted email string
+     */
+    async createMimeEmail(templateId, context = {}) {
+        const email = await this.prepareEmail(templateId, context);
+        return email.toRFC822String(context);
+    }
+    /**
+     * Load templates from a directory
+     * @param directory The directory containing template JSON files
+     */
+    async loadTemplatesFromDirectory(directory) {
+        try {
+            // Ensure directory exists
+            if (!plugins.fs.existsSync(directory)) {
+                logger.log('error', `Template directory does not exist: ${directory}`);
+                return;
+            }
+            // Get all JSON files
+            const files = plugins.fs.readdirSync(directory)
+                .filter(file => file.endsWith('.json'));
+            for (const file of files) {
+                try {
+                    const filePath = plugins.path.join(directory, file);
+                    const content = plugins.fs.readFileSync(filePath, 'utf8');
+                    const template = JSON.parse(content);
+                    // Validate template
+                    if (!template.id || !template.subject || (!template.bodyHtml && !template.bodyText)) {
+                        logger.log('warn', `Invalid template in ${file}: missing required fields`);
+                        continue;
+                    }
+                    this.registerTemplate(template);
+                }
+                catch (error) {
+                    logger.log('error', `Error loading template from ${file}: ${error.message}`);
+                }
+            }
+            logger.log('info', `Loaded ${this.templates.size} email templates`);
+        }
+        catch (error) {
+            logger.log('error', `Failed to load templates from directory: ${error.message}`);
+            throw error;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/ts/mail/core/index.d.ts

@@ -0,0 +1,4 @@
+export * from './classes.email.js';
+export * from './classes.emailvalidator.js';
+export * from './classes.templatemanager.js';
+export * from './classes.bouncemanager.js';

package/dist_ts/ts/mail/core/index.js

@@ -0,0 +1,6 @@
+// Core email components
+export * from './classes.email.js';
+export * from './classes.emailvalidator.js';
+export * from './classes.templatemanager.js';
+export * from './classes.bouncemanager.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi90cy9tYWlsL2NvcmUvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsd0JBQXdCO0FBQ3hCLGNBQWMsb0JBQW9CLENBQUM7QUFDbkMsY0FBYyw2QkFBNkIsQ0FBQztBQUM1QyxjQUFjLDhCQUE4QixDQUFDO0FBQzdDLGNBQWMsNEJBQTRCLENBQUMifQ==