@push.rocks/smartmta 5.1.2 → 5.2.0

package/dist_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/mail/core/classes.emailvalidator.js

@@ -0,0 +1,184 @@
+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 {
+    validator;
+    dnsCache;
+    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/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/mail/core/classes.templatemanager.js

@@ -0,0 +1,240 @@
+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 {
+    templates = new Map();
+    defaultConfig;
+    constructor(defaultConfig) {
+        // 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/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/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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi90cy9tYWlsL2NvcmUvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsd0JBQXdCO0FBQ3hCLGNBQWMsb0JBQW9CLENBQUM7QUFDbkMsY0FBYyw2QkFBNkIsQ0FBQztBQUM1QyxjQUFjLDhCQUE4QixDQUFDO0FBQzdDLGNBQWMsNEJBQTRCLENBQUMifQ==