@bernierllc/sender-identity-verification 1.3.1 → 1.4.0

package/dist/SenderIdentityVerification.js

@@ -6,34 +6,97 @@ 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.
 */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SenderIdentityVerification = void 0;
 const types_js_1 = require("./types.js");
-const SendGridProvider_js_1 = require("./providers/SendGridProvider.js");
-const MailgunProvider_js_1 = require("./providers/MailgunProvider.js");
-const SESProvider_js_1 = require("./providers/SESProvider.js");
-const SMTPProvider_js_1 = require("./providers/SMTPProvider.js");
 const verification_email_js_1 = require("./templates/verification-email.js");
 const domain_extractor_js_1 = require("./utils/domain-extractor.js");
+const manual_instructions_js_1 = require("./manual-instructions.js");
+const email_sender_manager_1 = require("@bernierllc/email-sender-manager");
 /**
- * Sender identity verification service
+ * Sender identity verification service.
+ *
+ * When configured with an `EmailSenderManager` (via config.senderManager) and
+ * provider plugins (via config.providerPlugins or registerProviderPlugin()),
+ * all persistence and provider API calls are delegated. Without those, the
+ * service falls back to the legacy in-memory store.
  */
 class SenderIdentityVerification {
     constructor(config) {
         this.config = config;
+        // Legacy in-memory store — used only when no senderManager is configured
         this.senders = new Map();
+        // Provider plugin registry (keyed by providerId)
+        this.providerPlugins = new Map();
         // Initialize domain verification from config if provided
         if (config.domainVerificationConfig?.instance) {
             this.domainVerification = config.domainVerificationConfig.instance;
         }
+        // Wire core sender manager if provided
+        if (config.senderManager) {
+            this.senderManager = config.senderManager;
+        }
+        // Register initial provider plugins
+        if (config.providerPlugins) {
+            for (const plugin of config.providerPlugins) {
+                this.providerPlugins.set(plugin.providerId, plugin);
+            }
+        }
+    }
+    /**
+     * Register a provider plugin at runtime.
+     */
+    registerProviderPlugin(plugin) {
+        this.providerPlugins.set(plugin.providerId, plugin);
+        this.logger?.info('Provider plugin registered', { providerId: plugin.providerId, name: plugin.name });
+    }
+    /**
+     * Get a registered provider plugin by providerId.
+     */
+    getProviderPlugin(providerId) {
+        return this.providerPlugins.get(providerId);
     }
     /**
      * Initialize service and register with NeverHub
      */
     async initialize() {
-        // Initialize dependencies (would import from actual packages)
-        // For now, we'll use stubs since we're missing dependencies
-        await this.loadSendersFromDatabase();
+        // Load from database if no senderManager (legacy path)
+        if (!this.senderManager) {
+            await this.loadSendersFromDatabase();
+        }
         this.logger?.info('Sender identity verification service initialized');
     }
     /**
@@ -50,7 +113,7 @@ class SenderIdentityVerification {
             }
             // 2. Extract domain
             const domain = (0, domain_extractor_js_1.extractDomain)(input.email);
-            // 3. Check if domain is verified (stub for missing dependency)
+            // 3. Check if domain is verified
             if (this.domainVerification) {
                 const domainStatus = await this.domainVerification.getDomainStatus(domain);
                 if (!domainStatus.isVerified) {
@@ -89,14 +152,51 @@ class SenderIdentityVerification {
             if (input.isDefault) {
                 await this.unsetOtherDefaults(input.provider);
             }
-            // 6. Persist to database
-            await this.saveSenderToDatabase(sender);
-            this.senders.set(sender.id, sender);
-            // 7. Send verification email (unless skipped)
-            if (!input.skipVerification) {
+            // 6. Persist — delegate to senderManager if available, else legacy
+            if (this.senderManager) {
+                const coreRequest = this.toCoreSenderRequest(input, sender);
+                const created = await this.senderManager.createSender(coreRequest);
+                sender.id = created.id;
+                sender.providerSenderId = created.providerSenderId;
+            }
+            else {
+                await this.saveSenderToDatabase(sender);
+                this.senders.set(sender.id, sender);
+            }
+            // 7. Delegate to provider plugin for API-level creation
+            const plugin = this.providerPlugins.get(input.provider);
+            if (plugin && (0, email_sender_manager_1.isManagedSenderProvider)(plugin) && !input.skipVerification) {
+                const providerResult = await plugin.createSender({
+                    fromEmail: input.email,
+                    fromName: input.name,
+                    replyToEmail: input.replyToEmail,
+                    replyToName: input.replyToName,
+                    providerFields: input.providerFields,
+                });
+                if (providerResult.success) {
+                    sender.providerSenderId = providerResult.providerSenderId;
+                    sender.providerMetadata = providerResult.metadata;
+                    // Persist the provider sender ID
+                    if (this.senderManager) {
+                        await this.senderManager.updateSender(sender.id, {
+                            providerSenderId: providerResult.providerSenderId,
+                            providerMetadata: providerResult.metadata,
+                            lastModifiedBy: input.createdBy || 'system',
+                        });
+                    }
+                }
+                else {
+                    this.logger?.warn('Provider creation failed, sender saved locally', {
+                        senderId: sender.id,
+                        error: providerResult.error?.message,
+                    });
+                }
+            }
+            // 8. Send verification email (unless skipped or provider handles it)
+            if (!input.skipVerification && !plugin) {
                 await this.sendVerificationEmail(sender);
             }
-            // 8. Publish event
+            // 9. Publish event
             if (this.neverhub) {
                 await this.neverhub.publishEvent({
                     type: 'sender-identity.created',
@@ -216,7 +316,7 @@ class SenderIdentityVerification {
                     errors: ['Account locked']
                 };
             }
-            // 5. Verify with provider
+            // 5. Verify with provider — use plugin system first, fall back to legacy
             const providerResult = await this.verifyWithProvider(sender);
             if (!providerResult.success) {
                 sender.status = types_js_1.SenderStatus.FAILED;
@@ -241,6 +341,17 @@ class SenderIdentityVerification {
             sender.validationErrors = undefined;
             sender.updatedAt = new Date();
             await this.saveSenderToDatabase(sender);
+            // Update core layer if available
+            if (this.senderManager) {
+                await this.senderManager.updateSender(sender.id, {
+                    isVerified: true,
+                    verificationStatus: 'verified',
+                    lastVerifiedAt: sender.verifiedAt,
+                    providerSenderId: sender.providerSenderId,
+                    providerMetadata: sender.providerMetadata,
+                    lastModifiedBy: 'system',
+                });
+            }
             // 7. Publish event
             if (this.neverhub) {
                 await this.neverhub.publishEvent({
@@ -274,37 +385,90 @@ class SenderIdentityVerification {
         }
     }
     /**
-     * Verify sender with email provider
+     * Verify sender with email provider.
+     *
+     * Uses the plugin registry first. If no plugin is registered for the
+     * provider, falls back to the legacy provider classes.
      */
     async verifyWithProvider(sender) {
+        // Try plugin-based verification
+        const plugin = this.providerPlugins.get(sender.provider);
+        if (plugin) {
+            if ((0, email_sender_manager_1.isVerifiableSenderProvider)(plugin) && sender.providerSenderId) {
+                const result = await plugin.checkVerificationStatus(sender.providerSenderId);
+                if (result.status === 'verified') {
+                    return {
+                        success: true,
+                        data: {
+                            providerId: result.providerSenderId,
+                            metadata: { verificationType: result.verificationType },
+                        },
+                    };
+                }
+                return {
+                    success: false,
+                    error: result.error?.message || `Verification status: ${result.status}`,
+                };
+            }
+            // Plugin exists but is not verifiable — validate only
+            const validation = await plugin.validateSender(sender.email);
+            if (validation.isVerified) {
+                return {
+                    success: true,
+                    data: { metadata: validation.metadata },
+                };
+            }
+            return { success: true, data: {} };
+        }
+        // Manual verification providers
+        if ((0, manual_instructions_js_1.isManualVerificationProvider)(sender.provider)) {
+            const instructions = (0, manual_instructions_js_1.getManualInstructions)(sender.provider);
+            return {
+                success: true,
+                data: {
+                    metadata: instructions ? { manualInstructions: instructions } : {},
+                },
+            };
+        }
+        // Legacy fallback — for backward compatibility when no plugins are registered
+        return this.legacyVerifyWithProvider(sender);
+    }
+    /**
+     * Legacy provider verification using inline provider classes.
+     * Preserved for backward compatibility when no plugins are configured.
+     */
+    async legacyVerifyWithProvider(sender) {
+        // Dynamic imports to avoid breaking if legacy providers are removed later
         switch (sender.provider) {
             case types_js_1.EmailProvider.SENDGRID:
                 if (this.config.sendgridApiKey) {
-                    const provider = new SendGridProvider_js_1.SendGridProvider(this.config.sendgridApiKey);
+                    const { SendGridProvider } = await Promise.resolve().then(() => __importStar(require('./providers/SendGridProvider.js')));
+                    const provider = new SendGridProvider(this.config.sendgridApiKey);
                     return provider.verifySender(sender);
                 }
                 return { success: false, error: 'SendGrid API key not configured' };
             case types_js_1.EmailProvider.MAILGUN:
                 if (this.config.mailgunApiKey) {
-                    const provider = new MailgunProvider_js_1.MailgunProvider(this.config.mailgunApiKey);
+                    const { MailgunProvider } = await Promise.resolve().then(() => __importStar(require('./providers/MailgunProvider.js')));
+                    const provider = new MailgunProvider(this.config.mailgunApiKey);
                     return provider.verifySender(sender);
                 }
-                return { success: true, data: {} }; // Mailgun doesn't require verification
+                return { success: true, data: {} };
             case types_js_1.EmailProvider.SES:
                 if (this.config.sesAccessKey && this.config.sesSecretKey && this.config.sesRegion) {
-                    const provider = new SESProvider_js_1.SESProvider(this.config.sesAccessKey, this.config.sesSecretKey, this.config.sesRegion);
+                    const { SESProvider } = await Promise.resolve().then(() => __importStar(require('./providers/SESProvider.js')));
+                    const provider = new SESProvider(this.config.sesAccessKey, this.config.sesSecretKey, this.config.sesRegion);
                     return provider.verifySender(sender);
                 }
                 return { success: false, error: 'SES credentials not configured' };
             case types_js_1.EmailProvider.SMTP: {
-                const provider = new SMTPProvider_js_1.SMTPProvider();
+                const { SMTPProvider } = await Promise.resolve().then(() => __importStar(require('./providers/SMTPProvider.js')));
+                const provider = new SMTPProvider();
                 return provider.verifySender(sender);
             }
             case types_js_1.EmailProvider.POSTMARK:
             case types_js_1.EmailProvider.MANDRILL:
             case types_js_1.EmailProvider.SMTP2GO:
-                // These providers handle sender verification through their own dashboards.
-                // Return success to allow the sender to be registered locally.
                 return { success: true, data: {} };
             default:
                 return {
@@ -317,6 +481,13 @@ class SenderIdentityVerification {
      * Get sender by ID
      */
     async getSender(senderId) {
+        if (this.senderManager) {
+            const config = await this.senderManager.getSender(senderId);
+            if (!config) {
+                return { success: false, error: `Sender not found: ${senderId}` };
+            }
+            return { success: true, data: this.coreConfigToIdentity(config) };
+        }
         const sender = this.senders.get(senderId);
         if (!sender) {
             return {
@@ -334,6 +505,21 @@ class SenderIdentityVerification {
      */
     async listSenders(options = {}) {
         try {
+            if (this.senderManager) {
+                const result = await this.senderManager.listSenders({
+                    provider: options.provider,
+                    isActive: options.isActive,
+                    domain: options.domain,
+                    offset: options.offset,
+                    limit: options.limit,
+                });
+                const identities = result.items.map((c) => this.coreConfigToIdentity(c));
+                // Apply status filter locally (core layer doesn't have SenderStatus enum)
+                const filtered = options.status
+                    ? identities.filter((s) => s.status === options.status)
+                    : identities;
+                return { success: true, data: filtered };
+            }
             let senders = Array.from(this.senders.values());
             // Filter by provider
             if (options.provider) {
@@ -374,13 +560,12 @@ class SenderIdentityVerification {
      */
     async updateSender(senderId, input) {
         try {
-            const sender = this.senders.get(senderId);
-            if (!sender) {
-                return {
-                    success: false,
-                    error: `Sender not found: ${senderId}`
-                };
+            // Fetch from appropriate store
+            const getResult = await this.getSender(senderId);
+            if (!getResult.success || !getResult.data) {
+                return { success: false, error: `Sender not found: ${senderId}` };
             }
+            const sender = getResult.data;
             // Update fields
             if (input.name !== undefined)
                 sender.name = input.name;
@@ -404,7 +589,32 @@ class SenderIdentityVerification {
                 sender.verifiedAt = undefined;
                 sender.lastValidated = undefined;
             }
-            await this.saveSenderToDatabase(sender);
+            // Persist
+            if (this.senderManager) {
+                await this.senderManager.updateSender(senderId, {
+                    name: input.name,
+                    fromName: input.name,
+                    replyToEmail: input.replyToEmail,
+                    replyToName: input.replyToName,
+                    isDefault: input.isDefault,
+                    isActive: input.isActive,
+                    lastModifiedBy: input.lastModifiedBy || 'system',
+                });
+            }
+            else {
+                await this.saveSenderToDatabase(sender);
+            }
+            // Delegate to provider plugin if available
+            const plugin = this.providerPlugins.get(sender.provider);
+            if (plugin && (0, email_sender_manager_1.isManagedSenderProvider)(plugin) && sender.providerSenderId) {
+                await plugin.updateSender({
+                    providerSenderId: sender.providerSenderId,
+                    fromName: input.name,
+                    replyToEmail: input.replyToEmail,
+                    replyToName: input.replyToName,
+                    providerFields: input.providerFields,
+                });
+            }
             // Publish event
             if (this.neverhub) {
                 await this.neverhub.publishEvent({
@@ -431,19 +641,27 @@ class SenderIdentityVerification {
      */
     async deleteSender(senderId) {
         try {
-            const sender = this.senders.get(senderId);
-            if (!sender) {
-                return {
-                    success: false,
-                    error: `Sender not found: ${senderId}`
-                };
+            const getResult = await this.getSender(senderId);
+            if (!getResult.success || !getResult.data) {
+                return { success: false, error: `Sender not found: ${senderId}` };
+            }
+            const sender = getResult.data;
+            // Delete from provider if plugin supports it
+            const plugin = this.providerPlugins.get(sender.provider);
+            if (plugin && (0, email_sender_manager_1.isManagedSenderProvider)(plugin) && sender.providerSenderId) {
+                await plugin.deleteSender(sender.providerSenderId);
+            }
+            // Persist deletion
+            if (this.senderManager) {
+                await this.senderManager.deleteSender(senderId);
+            }
+            else {
+                sender.deletedAt = new Date();
+                sender.isActive = false;
+                sender.updatedAt = new Date();
+                await this.saveSenderToDatabase(sender);
+                this.senders.delete(senderId);
             }
-            // Soft delete
-            sender.deletedAt = new Date();
-            sender.isActive = false;
-            sender.updatedAt = new Date();
-            await this.saveSenderToDatabase(sender);
-            this.senders.delete(senderId);
             // Publish event
             if (this.neverhub) {
                 await this.neverhub.publishEvent({
@@ -467,13 +685,11 @@ class SenderIdentityVerification {
      */
     async checkCompliance(senderId) {
         try {
-            const sender = this.senders.get(senderId);
-            if (!sender) {
-                return {
-                    success: false,
-                    error: `Sender not found: ${senderId}`
-                };
+            const getResult = await this.getSender(senderId);
+            if (!getResult.success || !getResult.data) {
+                return { success: false, error: `Sender not found: ${senderId}` };
             }
+            const sender = getResult.data;
             const errors = [];
             const warnings = [];
             // 1. Check email format
@@ -481,7 +697,7 @@ class SenderIdentityVerification {
             if (!emailFormat) {
                 errors.push('Invalid email format');
             }
-            // 2. Check domain verification (stub)
+            // 2. Check domain verification
             let domainVerified = true;
             let spfValid = true;
             let dkimValid = true;
@@ -500,12 +716,17 @@ class SenderIdentityVerification {
                     errors.push('DKIM record not configured or invalid');
                 }
             }
-            // 3. Provider-specific checks
-            if (sender.provider === types_js_1.EmailProvider.SENDGRID) {
-                if (!sender.providerSenderId) {
-                    warnings.push('SendGrid sender ID not set - may need re-verification');
+            // 3. Provider-specific checks via plugin
+            const plugin = this.providerPlugins.get(sender.provider);
+            if (plugin && (0, email_sender_manager_1.isVerifiableSenderProvider)(plugin) && sender.providerSenderId) {
+                const verificationResult = await plugin.checkVerificationStatus(sender.providerSenderId);
+                if (verificationResult.status !== 'verified') {
+                    warnings.push(`Provider verification status: ${verificationResult.status}`);
                 }
             }
+            else if (sender.provider === types_js_1.EmailProvider.SENDGRID && !sender.providerSenderId) {
+                warnings.push('SendGrid sender ID not set - may need re-verification');
+            }
             const isCompliant = errors.length === 0;
             const result = {
                 isCompliant,
@@ -539,6 +760,18 @@ class SenderIdentityVerification {
      * Get default sender for provider
      */
     async getDefaultSender(provider) {
+        if (this.senderManager) {
+            const result = await this.senderManager.listSenders({
+                provider,
+                isActive: true,
+                isVerified: true,
+            });
+            const defaultSender = result.items.find((s) => s.isDefault);
+            if (!defaultSender) {
+                return { success: false, error: `No default sender found for provider ${provider}` };
+            }
+            return { success: true, data: this.coreConfigToIdentity(defaultSender) };
+        }
         const senders = Array.from(this.senders.values());
         const defaultSender = senders.find(s => s.provider === provider &&
             s.isDefault &&
@@ -560,13 +793,11 @@ class SenderIdentityVerification {
      */
     async resendVerification(senderId) {
         try {
-            const sender = this.senders.get(senderId);
-            if (!sender) {
-                return {
-                    success: false,
-                    error: `Sender not found: ${senderId}`
-                };
+            const getResult = await this.getSender(senderId);
+            if (!getResult.success || !getResult.data) {
+                return { success: false, error: `Sender not found: ${senderId}` };
             }
+            const sender = getResult.data;
             if (sender.status === types_js_1.SenderStatus.VERIFIED) {
                 return {
                     success: false,
@@ -589,6 +820,14 @@ class SenderIdentityVerification {
                     };
                 }
             }
+            // If provider supports verification, use it
+            const plugin = this.providerPlugins.get(sender.provider);
+            if (plugin && (0, email_sender_manager_1.isVerifiableSenderProvider)(plugin) && sender.providerSenderId) {
+                const result = await plugin.initiateVerification(sender.providerSenderId);
+                if (result.success) {
+                    return { success: true };
+                }
+            }
             return this.sendVerificationEmail(sender);
         }
         catch (error) {
@@ -599,6 +838,35 @@ class SenderIdentityVerification {
             };
         }
     }
+    /**
+     * Check verification status for a sender using the provider plugin.
+     */
+    async checkVerificationStatus(senderId) {
+        const getResult = await this.getSender(senderId);
+        if (!getResult.success || !getResult.data) {
+            return { success: false, error: `Sender not found: ${senderId}` };
+        }
+        const sender = getResult.data;
+        const plugin = this.providerPlugins.get(sender.provider);
+        if (!plugin || !(0, email_sender_manager_1.isVerifiableSenderProvider)(plugin) || !sender.providerSenderId) {
+            return {
+                success: true,
+                data: {
+                    status: sender.status,
+                    verificationType: 'manual',
+                },
+            };
+        }
+        const result = await plugin.checkVerificationStatus(sender.providerSenderId);
+        return {
+            success: result.success,
+            data: {
+                status: result.status,
+                verificationType: result.verificationType,
+                dnsRecords: result.dnsRecords,
+            },
+        };
+    }
     // ============================================
     // Private Helper Methods
     // ============================================
@@ -622,12 +890,31 @@ class SenderIdentityVerification {
         return emailRegex.test(email);
     }
     async findSenderByEmail(email) {
+        if (this.senderManager) {
+            const result = await this.senderManager.listSenders({ limit: 1000 });
+            return result.items
+                .map((c) => this.coreConfigToIdentity(c))
+                .find((s) => s.email === email && !s.deletedAt);
+        }
         return Array.from(this.senders.values()).find(s => s.email === email && !s.deletedAt);
     }
     async findSenderByToken(token) {
+        // Token lookup is always in-memory (tokens live in the service layer)
         return Array.from(this.senders.values()).find(s => s.verificationToken === token);
     }
     async unsetOtherDefaults(provider) {
+        if (this.senderManager) {
+            const result = await this.senderManager.listSenders({ provider });
+            for (const sender of result.items) {
+                if (sender.isDefault) {
+                    await this.senderManager.updateSender(sender.id, {
+                        isDefault: false,
+                        lastModifiedBy: 'system',
+                    });
+                }
+            }
+            return;
+        }
         const senders = Array.from(this.senders.values())
             .filter(s => s.provider === provider && s.isDefault);
         for (const sender of senders) {
@@ -637,13 +924,57 @@ class SenderIdentityVerification {
         }
     }
     async loadSendersFromDatabase() {
-        // TODO: Implement database loading
+        // TODO: Implement database loading for legacy path
         // For now, no-op
     }
     async saveSenderToDatabase(sender) {
-        // TODO: Implement database persistence
+        // TODO: Implement database persistence for legacy path
         // For now, just update in-memory map
         this.senders.set(sender.id, sender);
     }
+    // ============================================
+    // Mapping helpers between service and core types
+    // ============================================
+    toCoreSenderRequest(input, sender) {
+        return {
+            name: input.name,
+            fromEmail: input.email,
+            fromName: input.name,
+            replyToEmail: input.replyToEmail,
+            replyToName: input.replyToName,
+            provider: input.provider,
+            allowedDomains: [sender.domain],
+            createdBy: input.createdBy || 'system',
+        };
+    }
+    coreConfigToIdentity(config) {
+        return {
+            id: config.id,
+            email: config.fromEmail,
+            name: config.fromName,
+            replyToEmail: config.replyToEmail,
+            replyToName: config.replyToName,
+            domain: config.domain,
+            provider: config.provider,
+            status: this.mapVerificationStatus(config.verificationStatus),
+            isDefault: config.isDefault,
+            isActive: config.isActive,
+            verificationAttempts: 0,
+            verifiedAt: config.lastVerifiedAt,
+            providerSenderId: config.providerSenderId,
+            providerMetadata: config.providerMetadata,
+            createdAt: config.createdAt,
+            updatedAt: config.updatedAt,
+        };
+    }
+    mapVerificationStatus(status) {
+        switch (status) {
+            case 'verified': return types_js_1.SenderStatus.VERIFIED;
+            case 'failed': return types_js_1.SenderStatus.FAILED;
+            case 'expired': return types_js_1.SenderStatus.EXPIRED;
+            case 'pending':
+            default: return types_js_1.SenderStatus.PENDING;
+        }
+    }
 }
 exports.SenderIdentityVerification = SenderIdentityVerification;

package/dist/config.d.ts

@@ -1,4 +1,5 @@
 import { IEmailDomainVerification } from './types.js';
+import type { EmailSenderManager, SenderProviderPlugin } from '@bernierllc/email-sender-manager';
 /**
  * Configuration for sender identity verification service
  */
@@ -10,6 +11,8 @@ export interface SenderIdentityConfig {
     domainVerificationConfig: {
         instance?: IEmailDomainVerification;
     };
+    senderManager?: EmailSenderManager;
+    providerPlugins?: SenderProviderPlugin[];
     retryConfig?: {
         maxRetries?: number;
         initialDelayMs?: number;

package/dist/config.js

@@ -24,6 +24,8 @@ function loadConfigFromEnv(overrides = {}) {
         databaseUrl: process.env.DATABASE_URL || overrides.databaseUrl,
         emailSenderConfig: overrides.emailSenderConfig || {},
         domainVerificationConfig: overrides.domainVerificationConfig || {},
+        senderManager: overrides.senderManager,
+        providerPlugins: overrides.providerPlugins,
         retryConfig: overrides.retryConfig
     };
     // Log configuration (without sensitive data)