@bernierllc/email-manager 0.1.1 → 0.1.4

package/dist/enhanced-email-manager.js

@@ -0,0 +1,866 @@
+/*
+Copyright (c) 2025 Bernier LLC
+
+This file is licensed to the client under a limited-use license.
+The client may use and modify this code *only within the scope of the project it was delivered for*.
+Redistribution or use in other products or commercial offerings is not permitted without written consent from Bernier LLC.
+*/
+import { EmailManager } from './email-manager.js';
+import { v4 as uuidv4 } from 'uuid';
+/**
+ * EnhancedEmailManager - Extended email management with template service,
+ * sender management, and variable validation integration.
+ *
+ * This class extends EmailManager to provide:
+ * - Advanced template management
+ * - Sender configuration and selection
+ * - Template variable validation
+ * - System bootstrap and health monitoring
+ *
+ * Note: This implementation provides built-in functionality that can be
+ * replaced with external services when available.
+ */
+export class EnhancedEmailManager extends EmailManager {
+    constructor(config) {
+        super(config);
+        this.templateStore = new Map();
+        this.senderStore = new Map();
+        this.variableContexts = new Map();
+        this.initialized = false;
+        this.enhancedConfig = config;
+    }
+    // ======================
+    // Enhanced Email Sending
+    // ======================
+    /**
+     * Send a templated email with variable validation and smart sender selection
+     */
+    async sendEnhancedTemplatedEmail(templateId, templateData, recipients, options = {}) {
+        const results = [];
+        try {
+            // 1. Get template from internal store
+            const template = this.templateStore.get(templateId);
+            if (!template) {
+                throw new Error(`Template not found: ${templateId}`);
+            }
+            // 2. Validate template variables if enabled
+            if (options.validateVariables && template.context) {
+                const validation = await this.validateTemplateData(template.context, templateData);
+                if (!validation.isValid && options.strictMode) {
+                    return [{
+                            success: false,
+                            provider: 'none',
+                            sentAt: new Date(),
+                            errors: validation.errors.map(e => ({
+                                code: 'VALIDATION_ERROR',
+                                message: e.message
+                            }))
+                        }];
+                }
+            }
+            // 3. Send to all recipients
+            for (const recipient of recipients) {
+                // Select best sender for this recipient
+                let sender = options.senderOverride;
+                if (!sender && options.selectBestSender) {
+                    const selectedSender = await this.selectBestSender(recipient.email, options.preferredProvider, { allowUnverified: false });
+                    sender = selectedSender || undefined;
+                }
+                // Create email data
+                const emailData = {
+                    to: recipient.email,
+                    subject: this.renderSimpleTemplate(template.subject, templateData),
+                    html: this.renderSimpleTemplate(template.htmlContent, templateData),
+                    text: template.textContent ? this.renderSimpleTemplate(template.textContent, templateData) : undefined,
+                    templateId,
+                    metadata: {
+                        templateVersion: template.version,
+                        senderId: sender?.id,
+                        context: template.context,
+                        recipientMetadata: recipient.metadata
+                    }
+                };
+                // Send email
+                const result = await this.sendEmail(emailData);
+                results.push(result);
+            }
+            return results;
+        }
+        catch (error) {
+            return [{
+                    success: false,
+                    provider: 'none',
+                    sentAt: new Date(),
+                    errors: [{
+                            code: 'ENHANCED_SEND_ERROR',
+                            message: error instanceof Error ? error.message : 'Unknown error occurred'
+                        }]
+                }];
+        }
+    }
+    /**
+     * Send email with variable validation
+     */
+    async sendWithVariableValidation(email, context, _options) {
+        if (context && email.templateContext) {
+            const validation = await this.validateTemplateData(context, email.templateContext);
+            if (!validation.isValid) {
+                return {
+                    success: false,
+                    provider: 'none',
+                    sentAt: new Date(),
+                    errors: validation.errors.map(e => ({
+                        code: 'VALIDATION_ERROR',
+                        message: e.message
+                    }))
+                };
+            }
+        }
+        return await this.sendEmail(email);
+    }
+    // ======================
+    // Template Management
+    // ======================
+    /**
+     * Create a template with validation
+     */
+    async createEnhancedTemplate(template) {
+        try {
+            // Validate template if context is provided
+            if (template.context) {
+                const validation = await this.validateEnhancedTemplate(template.htmlContent, template.context);
+                if (!validation.isValid) {
+                    return {
+                        success: false,
+                        errors: validation.errors.map(e => e.message)
+                    };
+                }
+            }
+            const id = uuidv4();
+            const now = new Date();
+            const internalTemplate = {
+                id,
+                name: template.name,
+                subject: template.subject,
+                htmlContent: template.htmlContent,
+                textContent: template.textContent,
+                context: template.context,
+                category: template.category,
+                version: '1.0.0',
+                isActive: true,
+                createdAt: now,
+                updatedAt: now
+            };
+            this.templateStore.set(id, internalTemplate);
+            return { success: true, templateId: id };
+        }
+        catch (error) {
+            return {
+                success: false,
+                errors: [error instanceof Error ? error.message : 'Failed to create template']
+            };
+        }
+    }
+    /**
+     * Get a template by ID from enhanced store
+     */
+    async getEnhancedTemplate(templateId) {
+        return this.templateStore.get(templateId) || null;
+    }
+    /**
+     * List all enhanced templates
+     */
+    async listEnhancedTemplates() {
+        const items = Array.from(this.templateStore.values());
+        return { items, total: items.length };
+    }
+    /**
+     * Sync a template to providers (placeholder for future integration)
+     */
+    async syncTemplate(templateId, providerId) {
+        const template = this.templateStore.get(templateId);
+        if (!template) {
+            return {
+                success: false,
+                action: 'failed',
+                localTemplateId: templateId,
+                error: 'Template not found'
+            };
+        }
+        // Placeholder - would integrate with actual provider plugins
+        return {
+            success: true,
+            action: providerId ? 'updated' : 'synced_all',
+            localTemplateId: templateId,
+            providerId,
+            metadata: { note: 'Sync placeholder - integrate with provider plugins' }
+        };
+    }
+    /**
+     * Validate a template against a variable context
+     */
+    async validateEnhancedTemplate(templateContent, context) {
+        const variableContext = this.variableContexts.get(context);
+        if (!variableContext) {
+            return {
+                isValid: true,
+                errors: [],
+                warnings: [],
+                info: [`No variable context '${context}' registered, validation skipped`]
+            };
+        }
+        // Extract variables from template (simple Handlebars-style extraction)
+        const variablePattern = /\{\{\s*([a-zA-Z_][a-zA-Z0-9_.]*)\s*\}\}/g;
+        const usedVariables = [];
+        let match;
+        while ((match = variablePattern.exec(templateContent)) !== null) {
+            usedVariables.push(match[1]);
+        }
+        // Check for required variables
+        const errors = [];
+        const definedPaths = variableContext.variables.map(v => v.path);
+        for (const variable of usedVariables) {
+            if (!definedPaths.includes(variable) && !this.isNestedPath(variable, definedPaths)) {
+                errors.push({
+                    message: `Undefined variable: ${variable}`,
+                    path: variable
+                });
+            }
+        }
+        return {
+            isValid: errors.length === 0,
+            errors,
+            warnings: []
+        };
+    }
+    /**
+     * Sync all templates to providers
+     */
+    async syncAllTemplates() {
+        const templates = Array.from(this.templateStore.values());
+        const results = [];
+        for (const template of templates) {
+            const result = await this.syncTemplate(template.id);
+            results.push(result);
+        }
+        const synced = results.filter(r => r.success).length;
+        return {
+            success: synced > 0,
+            total: results.length,
+            synced,
+            failed: results.length - synced,
+            results
+        };
+    }
+    // ======================
+    // Sender Management
+    // ======================
+    /**
+     * Create a new sender configuration
+     */
+    async createSender(sender) {
+        try {
+            // Validate email format
+            if (!this.validateEmail(sender.fromEmail)) {
+                throw new Error(`Invalid email format: ${sender.fromEmail}`);
+            }
+            const id = uuidv4();
+            const now = new Date();
+            const internalSender = {
+                id,
+                name: sender.name,
+                fromEmail: sender.fromEmail,
+                fromName: sender.fromName,
+                replyToEmail: sender.replyToEmail,
+                provider: sender.provider,
+                priority: sender.priority ?? 100,
+                isDefault: sender.isDefault ?? false,
+                isActive: true,
+                isVerified: sender.isVerified ?? false,
+                verificationStatus: sender.verificationStatus ?? 'pending',
+                createdAt: now,
+                updatedAt: now
+            };
+            this.senderStore.set(id, internalSender);
+            return this.mapToEnhancedSender(internalSender);
+        }
+        catch (error) {
+            console.error('Failed to create sender:', error);
+            return null;
+        }
+    }
+    /**
+     * Get a sender by ID
+     */
+    async getSender(senderId) {
+        const sender = this.senderStore.get(senderId);
+        return sender ? this.mapToEnhancedSender(sender) : null;
+    }
+    /**
+     * List all senders
+     */
+    async listSenders() {
+        const items = Array.from(this.senderStore.values()).map(s => this.mapToEnhancedSender(s));
+        return { items, total: items.length };
+    }
+    /**
+     * Select the best sender for an email
+     */
+    async selectBestSender(fromEmail, provider, options = {}) {
+        const senders = Array.from(this.senderStore.values())
+            .filter(s => s.isActive)
+            .filter(s => !options.excludeIds?.includes(s.id))
+            .filter(s => options.allowUnverified || s.isVerified)
+            .filter(s => !provider || s.provider === provider);
+        if (senders.length === 0) {
+            return null;
+        }
+        // Strategy selection
+        let selected;
+        const strategy = options.strategy || 'domain_match';
+        if (strategy === 'domain_match') {
+            // Try to match domain
+            const domain = this.extractDomain(fromEmail);
+            selected = senders.find(s => this.extractDomain(s.fromEmail) === domain);
+        }
+        // Fallback to priority-based selection
+        if (!selected) {
+            senders.sort((a, b) => a.priority - b.priority);
+            selected = senders[0];
+        }
+        return selected ? this.mapToEnhancedSender(selected) : null;
+    }
+    /**
+     * Validate a sender configuration
+     */
+    async validateSender(senderId) {
+        const sender = this.senderStore.get(senderId);
+        if (!sender) {
+            return {
+                isValid: false,
+                errors: [{ field: 'id', message: `Sender not found: ${senderId}` }],
+                warnings: []
+            };
+        }
+        const errors = [];
+        const warnings = [];
+        // Basic validation
+        if (!sender.fromEmail) {
+            errors.push({ field: 'fromEmail', message: 'From email is required' });
+        }
+        else if (!this.validateEmail(sender.fromEmail)) {
+            errors.push({ field: 'fromEmail', message: 'Invalid email format' });
+        }
+        if (!sender.fromName) {
+            warnings.push({ field: 'fromName', message: 'From name is recommended' });
+        }
+        if (!sender.isVerified) {
+            warnings.push({ field: 'isVerified', message: 'Sender is not verified' });
+        }
+        return {
+            isValid: errors.length === 0,
+            errors,
+            warnings,
+            metadata: {
+                lastValidated: new Date(),
+                validatedBy: 'email-manager',
+                checks: ['basic', 'email-format', 'verification-status']
+            }
+        };
+    }
+    // ======================
+    // Variable Management
+    // ======================
+    /**
+     * Register a variable context
+     */
+    async registerVariableContext(name, contextDef) {
+        this.variableContexts.set(name, {
+            name,
+            description: contextDef.description,
+            variables: contextDef.variables
+        });
+    }
+    /**
+     * Get a variable context
+     */
+    async getVariableContext(name) {
+        return this.variableContexts.get(name) || null;
+    }
+    /**
+     * Get variable suggestions for a context
+     */
+    async getVariableSuggestions(context, prefix) {
+        const variableContext = this.variableContexts.get(context);
+        if (!variableContext) {
+            return [];
+        }
+        let variables = variableContext.variables;
+        if (prefix) {
+            variables = variables.filter(v => v.path.startsWith(prefix));
+        }
+        return variables.map((v, index) => ({
+            path: v.path,
+            type: v.type,
+            description: v.description,
+            required: v.required ?? false,
+            score: 100 - index // Simple scoring based on order
+        }));
+    }
+    /**
+     * Validate template data against a context
+     */
+    async validateTemplateData(context, data) {
+        const variableContext = this.variableContexts.get(context);
+        if (!variableContext) {
+            return {
+                isValid: true,
+                errors: [],
+                warnings: [],
+                info: [`Variable context '${context}' not registered`]
+            };
+        }
+        const errors = [];
+        // Check required variables
+        for (const variable of variableContext.variables) {
+            if (variable.required) {
+                const value = this.getNestedValue(data, variable.path);
+                if (value === undefined) {
+                    errors.push({
+                        message: `Required variable missing: ${variable.path}`,
+                        path: variable.path
+                    });
+                }
+            }
+        }
+        return {
+            isValid: errors.length === 0,
+            errors,
+            warnings: []
+        };
+    }
+    // ======================
+    // System Operations
+    // ======================
+    /**
+     * Bootstrap the email manager system
+     */
+    async bootstrap() {
+        const result = {
+            success: true,
+            components: {},
+            errors: [],
+            warnings: []
+        };
+        try {
+            // 1. Bootstrap senders
+            if (this.enhancedConfig.bootstrap?.senders?.enabled) {
+                const senderResult = await this.bootstrapSenders();
+                result.components.senders = senderResult;
+                if (!senderResult.success) {
+                    result.errors.push(...senderResult.errors);
+                }
+            }
+            // 2. Bootstrap variable contexts
+            if (this.enhancedConfig.bootstrap?.variables?.enabled) {
+                const variableResult = await this.bootstrapVariableContexts();
+                result.components.variables = variableResult;
+                if (!variableResult.success) {
+                    result.errors.push(...variableResult.errors);
+                }
+            }
+            // 3. Bootstrap templates
+            if (this.enhancedConfig.bootstrap?.templates?.enabled) {
+                const templateResult = await this.bootstrapTemplates();
+                result.components.templates = templateResult;
+                if (!templateResult.success) {
+                    result.errors.push(...templateResult.errors);
+                }
+            }
+            // 4. Bootstrap providers
+            if (this.enhancedConfig.bootstrap?.providers?.enabled) {
+                const providerResult = await this.bootstrapProviders();
+                result.components.providers = providerResult;
+                if (!providerResult.success) {
+                    result.warnings.push(...providerResult.errors);
+                }
+            }
+            // 5. Final health check
+            const health = await this.getSystemHealth();
+            if (health.overall.status === 'unhealthy') {
+                result.warnings.push('System health check indicates issues after bootstrap');
+            }
+            this.initialized = true;
+            return result;
+        }
+        catch (error) {
+            result.success = false;
+            result.errors.push(`Bootstrap failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            return result;
+        }
+    }
+    /**
+     * Get comprehensive system health report
+     */
+    async getSystemHealth() {
+        const emailStats = await this.getEmailDeliveryStats();
+        const templateStats = await this.getTemplateSystemStats();
+        const senderStats = await this.getSenderSystemStats();
+        const providerStats = await this.getProviderHealthStats();
+        const overallHealth = this.calculateOverallHealth([
+            emailStats,
+            templateStats,
+            senderStats,
+            providerStats
+        ]);
+        return {
+            overall: overallHealth,
+            timestamp: new Date(),
+            components: {
+                email: emailStats,
+                templates: templateStats,
+                senders: senderStats,
+                providers: providerStats
+            },
+            recommendations: this.generateHealthRecommendations({
+                emailStats,
+                templateStats,
+                senderStats,
+                providerHealth: providerStats
+            })
+        };
+    }
+    // ======================
+    // Private Helper Methods
+    // ======================
+    async bootstrapSenders() {
+        const result = {
+            success: true,
+            created: [],
+            updated: [],
+            errors: []
+        };
+        const defaultSenders = this.enhancedConfig.bootstrap?.senders?.defaultSenders || [];
+        for (const senderDef of defaultSenders) {
+            try {
+                const created = await this.createSender(senderDef);
+                if (created) {
+                    result.created.push(created.id);
+                }
+            }
+            catch (error) {
+                result.errors.push(`Failed to bootstrap sender "${senderDef.name}": ${error instanceof Error ? error.message : 'Unknown error'}`);
+                result.success = false;
+            }
+        }
+        return result;
+    }
+    async bootstrapVariableContexts() {
+        const result = {
+            success: true,
+            created: [],
+            updated: [],
+            errors: []
+        };
+        const contexts = this.enhancedConfig.bootstrap?.variables?.contexts || [];
+        for (const contextDef of contexts) {
+            try {
+                await this.registerVariableContext(contextDef.name, contextDef);
+                result.created.push(contextDef.name);
+            }
+            catch (error) {
+                result.errors.push(`Failed to bootstrap context "${contextDef.name}": ${error instanceof Error ? error.message : 'Unknown error'}`);
+                result.success = false;
+            }
+        }
+        return result;
+    }
+    async bootstrapTemplates() {
+        const result = {
+            success: true,
+            created: [],
+            updated: [],
+            errors: []
+        };
+        const defaultTemplates = this.enhancedConfig.bootstrap?.templates?.defaultTemplates || [];
+        for (const templateDef of defaultTemplates) {
+            try {
+                const createResult = await this.createEnhancedTemplate(templateDef);
+                if (createResult.success && createResult.templateId) {
+                    result.created.push(createResult.templateId);
+                    // Sync to providers if enabled
+                    if (this.enhancedConfig.bootstrap?.templates?.syncToProviders) {
+                        await this.syncTemplate(createResult.templateId);
+                    }
+                }
+                else {
+                    result.errors.push(...(createResult.errors || []));
+                }
+            }
+            catch (error) {
+                result.errors.push(`Failed to bootstrap template "${templateDef.name}": ${error instanceof Error ? error.message : 'Unknown error'}`);
+                result.success = false;
+            }
+        }
+        return result;
+    }
+    async bootstrapProviders() {
+        const result = {
+            success: true,
+            created: [],
+            updated: [],
+            errors: []
+        };
+        // Test provider connections if enabled
+        if (this.enhancedConfig.bootstrap?.providers?.testConnections) {
+            const providers = await this.listProviders();
+            for (const provider of providers.providers) {
+                try {
+                    const testResult = await this.testConnection(provider.id);
+                    if (testResult.success) {
+                        result.updated.push(provider.id);
+                    }
+                    else {
+                        result.errors.push(`Provider "${provider.name}" connection test failed: ${testResult.message}`);
+                    }
+                }
+                catch (error) {
+                    result.errors.push(`Provider "${provider.name}" test error: ${error instanceof Error ? error.message : 'Unknown error'}`);
+                }
+            }
+        }
+        return result;
+    }
+    async getEmailDeliveryStats() {
+        const summary = await this.getAnalyticsSummary(7);
+        const bounceRate = summary.bounceRate || 0;
+        const issues = [];
+        if (bounceRate > 5) {
+            issues.push({
+                severity: 'warning',
+                message: 'High bounce rate detected',
+                details: `Current bounce rate: ${bounceRate.toFixed(2)}%`
+            });
+        }
+        return {
+            status: bounceRate > 10 ? 'unhealthy' : bounceRate > 5 ? 'degraded' : 'healthy',
+            score: Math.max(0, 100 - bounceRate * 10),
+            metrics: {
+                totalSent: summary.totalSent || 0,
+                totalDelivered: summary.totalDelivered || 0,
+                bounceRate,
+                deliveryRate: summary.deliveryRate || 100
+            },
+            issues
+        };
+    }
+    async getTemplateSystemStats() {
+        const templates = Array.from(this.templateStore.values());
+        const activeTemplates = templates.filter(t => t.isActive);
+        return {
+            status: 'healthy',
+            score: 100,
+            metrics: {
+                totalTemplates: templates.length,
+                activeTemplates: activeTemplates.length
+            },
+            issues: []
+        };
+    }
+    async getSenderSystemStats() {
+        const senders = Array.from(this.senderStore.values());
+        const activeSenders = senders.filter(s => s.isActive);
+        const verifiedSenders = activeSenders.filter(s => s.isVerified);
+        const defaultSenders = senders.filter(s => s.isDefault);
+        const issues = [];
+        if (senders.length > 0 && defaultSenders.length === 0) {
+            issues.push({
+                severity: 'error',
+                message: 'No default sender configured'
+            });
+        }
+        const verificationRate = activeSenders.length > 0 ?
+            (verifiedSenders.length / activeSenders.length) * 100 : 100;
+        if (verificationRate < 50 && activeSenders.length > 0) {
+            issues.push({
+                severity: 'warning',
+                message: 'Low sender verification rate',
+                details: `Only ${Math.round(verificationRate)}% of active senders are verified`
+            });
+        }
+        return {
+            status: issues.some(i => i.severity === 'error') ? 'unhealthy' :
+                issues.length > 0 ? 'degraded' : 'healthy',
+            score: Math.max(0, 100 - issues.length * 20),
+            metrics: {
+                totalSenders: senders.length,
+                activeSenders: activeSenders.length,
+                verifiedSenders: verifiedSenders.length,
+                defaultSenders: defaultSenders.length,
+                verificationRate: Math.round(verificationRate)
+            },
+            issues
+        };
+    }
+    async getProviderHealthStats() {
+        const providers = await this.listProviders();
+        const activeProviders = providers.providers.filter(p => p.isActive);
+        const issues = [];
+        if (activeProviders.length === 0) {
+            issues.push({
+                severity: 'error',
+                message: 'No active email providers configured'
+            });
+        }
+        return {
+            status: activeProviders.length === 0 ? 'unhealthy' : 'healthy',
+            score: activeProviders.length > 0 ? 100 : 0,
+            metrics: {
+                totalProviders: providers.providers.length,
+                activeProviders: activeProviders.length
+            },
+            issues
+        };
+    }
+    calculateOverallHealth(components) {
+        const avgScore = components.reduce((sum, c) => sum + c.score, 0) / components.length;
+        const hasUnhealthy = components.some(c => c.status === 'unhealthy');
+        const hasDegraded = components.some(c => c.status === 'degraded');
+        return {
+            status: hasUnhealthy ? 'unhealthy' : hasDegraded ? 'degraded' : 'healthy',
+            score: Math.round(avgScore),
+            metrics: {
+                componentsHealthy: components.filter(c => c.status === 'healthy').length,
+                componentsDegraded: components.filter(c => c.status === 'degraded').length,
+                componentsUnhealthy: components.filter(c => c.status === 'unhealthy').length
+            },
+            issues: components.flatMap(c => c.issues)
+        };
+    }
+    generateHealthRecommendations(stats) {
+        const recommendations = [];
+        // Email delivery recommendations
+        if (stats.emailStats.metrics.bounceRate > 5) {
+            recommendations.push({
+                priority: 'high',
+                category: 'delivery',
+                title: 'High Bounce Rate Detected',
+                description: 'Consider reviewing sender reputation and email list quality',
+                action: 'Review and clean email lists, check sender verification status'
+            });
+        }
+        // Sender verification recommendations
+        if (stats.senderStats.metrics.verificationRate < 80) {
+            recommendations.push({
+                priority: 'medium',
+                category: 'senders',
+                title: 'Low Sender Verification Rate',
+                description: 'Improve email deliverability by verifying more senders',
+                action: 'Complete sender verification process with email providers'
+            });
+        }
+        // Provider health recommendations
+        if (stats.providerHealth.metrics.activeProviders === 0) {
+            recommendations.push({
+                priority: 'high',
+                category: 'providers',
+                title: 'No Active Providers',
+                description: 'Email sending will fail without active providers',
+                action: 'Configure and activate at least one email provider'
+            });
+        }
+        return recommendations;
+    }
+    renderSimpleTemplate(template, data) {
+        let result = template;
+        const flattenObject = (obj, prefix = '') => {
+            const flattened = {};
+            for (const [key, value] of Object.entries(obj)) {
+                const path = prefix ? `${prefix}.${key}` : key;
+                if (value !== null && typeof value === 'object' && !Array.isArray(value)) {
+                    Object.assign(flattened, flattenObject(value, path));
+                }
+                else {
+                    flattened[path] = String(value ?? '');
+                }
+            }
+            return flattened;
+        };
+        const flatData = flattenObject(data);
+        for (const [key, value] of Object.entries(flatData)) {
+            const patterns = [
+                new RegExp(`\\{\\{\\s*${key.replace(/\./g, '\\.')}\\s*\\}\\}`, 'g')
+            ];
+            for (const pattern of patterns) {
+                result = result.replace(pattern, value);
+            }
+        }
+        return result;
+    }
+    mapToEnhancedSender(sender) {
+        return {
+            id: sender.id,
+            name: sender.name,
+            fromEmail: sender.fromEmail,
+            fromName: sender.fromName,
+            replyToEmail: sender.replyToEmail,
+            provider: sender.provider,
+            priority: sender.priority,
+            isDefault: sender.isDefault,
+            isActive: sender.isActive,
+            isVerified: sender.isVerified,
+            verificationStatus: sender.verificationStatus,
+            createdAt: sender.createdAt,
+            updatedAt: sender.updatedAt
+        };
+    }
+    extractDomain(email) {
+        const parts = email.split('@');
+        return parts.length > 1 ? parts[1].toLowerCase() : '';
+    }
+    isNestedPath(path, definedPaths) {
+        // Check if the path is a child of any defined paths
+        for (const defined of definedPaths) {
+            if (path.startsWith(defined + '.')) {
+                return true;
+            }
+        }
+        return false;
+    }
+    getNestedValue(obj, path) {
+        const parts = path.split('.');
+        let current = obj;
+        for (const part of parts) {
+            if (current === null || current === undefined || typeof current !== 'object') {
+                return undefined;
+            }
+            current = current[part];
+        }
+        return current;
+    }
+    /**
+     * Check if the enhanced manager is initialized
+     */
+    isInitialized() {
+        return this.initialized;
+    }
+    /**
+     * Get template store size
+     */
+    getTemplateCount() {
+        return this.templateStore.size;
+    }
+    /**
+     * Get sender store size
+     */
+    getSenderCount() {
+        return this.senderStore.size;
+    }
+    /**
+     * Get variable context count
+     */
+    getVariableContextCount() {
+        return this.variableContexts.size;
+    }
+}
+//# sourceMappingURL=enhanced-email-manager.js.map