@bernierllc/sender-identity-verification 3.0.10 → 3.0.11

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -0,0 +1,989 @@
1
+ "use strict";
2
+ /*
3
+ Copyright (c) 2025 Bernier LLC
4
+
5
+ This file is licensed to the client under a limited-use license.
6
+ The client may use and modify this code *only within the scope of the project it was delivered for*.
7
+ Redistribution or use in other products or commercial offerings is not permitted without written consent from Bernier LLC.
8
+ */
9
+ var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
10
+ if (k2 === undefined) k2 = k;
11
+ var desc = Object.getOwnPropertyDescriptor(m, k);
12
+ if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
13
+ desc = { enumerable: true, get: function() { return m[k]; } };
14
+ }
15
+ Object.defineProperty(o, k2, desc);
16
+ }) : (function(o, m, k, k2) {
17
+ if (k2 === undefined) k2 = k;
18
+ o[k2] = m[k];
19
+ }));
20
+ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
21
+ Object.defineProperty(o, "default", { enumerable: true, value: v });
22
+ }) : function(o, v) {
23
+ o["default"] = v;
24
+ });
25
+ var __importStar = (this && this.__importStar) || (function () {
26
+ var ownKeys = function(o) {
27
+ ownKeys = Object.getOwnPropertyNames || function (o) {
28
+ var ar = [];
29
+ for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
30
+ return ar;
31
+ };
32
+ return ownKeys(o);
33
+ };
34
+ return function (mod) {
35
+ if (mod && mod.__esModule) return mod;
36
+ var result = {};
37
+ if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
38
+ __setModuleDefault(result, mod);
39
+ return result;
40
+ };
41
+ })();
42
+ Object.defineProperty(exports, "__esModule", { value: true });
43
+ exports.SenderIdentityVerification = void 0;
44
+ const types_js_1 = require("./types.js");
45
+ const verification_email_js_1 = require("./templates/verification-email.js");
46
+ const domain_extractor_js_1 = require("./utils/domain-extractor.js");
47
+ const manual_instructions_js_1 = require("./manual-instructions.js");
48
+ const email_sender_manager_1 = require("@bernierllc/email-sender-manager");
49
+ /**
50
+ * Sender identity verification service.
51
+ *
52
+ * When configured with an `EmailSenderManager` (via config.senderManager) and
53
+ * provider plugins (via config.providerPlugins or registerProviderPlugin()),
54
+ * all persistence and provider API calls are delegated. Without those, the
55
+ * service falls back to the legacy in-memory store.
56
+ */
57
+ class SenderIdentityVerification {
58
+ config;
59
+ // Legacy in-memory store — used only when no senderManager is configured
60
+ senders = new Map();
61
+ // Provider plugin registry (keyed by providerId)
62
+ providerPlugins = new Map();
63
+ // Core persistence layer (optional, new path)
64
+ senderManager;
65
+ emailSender;
66
+ domainVerification;
67
+ cryptoUtils;
68
+ logger;
69
+ emailValidator;
70
+ neverhub;
71
+ constructor(config) {
72
+ this.config = config;
73
+ // Initialize domain verification from config if provided
74
+ if (config.domainVerificationConfig?.instance) {
75
+ this.domainVerification = config.domainVerificationConfig.instance;
76
+ }
77
+ // Wire core sender manager if provided
78
+ if (config.senderManager) {
79
+ this.senderManager = config.senderManager;
80
+ }
81
+ // Register initial provider plugins
82
+ if (config.providerPlugins) {
83
+ for (const plugin of config.providerPlugins) {
84
+ this.providerPlugins.set(plugin.providerId, plugin);
85
+ }
86
+ }
87
+ }
88
+ /**
89
+ * Register a provider plugin at runtime.
90
+ */
91
+ registerProviderPlugin(plugin) {
92
+ this.providerPlugins.set(plugin.providerId, plugin);
93
+ this.logger?.info('Provider plugin registered', { providerId: plugin.providerId, name: plugin.name });
94
+ }
95
+ /**
96
+ * Get a registered provider plugin by providerId.
97
+ */
98
+ getProviderPlugin(providerId) {
99
+ return this.providerPlugins.get(providerId);
100
+ }
101
+ /**
102
+ * Initialize service and register with NeverHub
103
+ */
104
+ async initialize() {
105
+ // Load from database if no senderManager (legacy path)
106
+ if (!this.senderManager) {
107
+ await this.loadSendersFromDatabase();
108
+ }
109
+ this.logger?.info('Sender identity verification service initialized');
110
+ }
111
+ /**
112
+ * Create a new sender identity
113
+ */
114
+ async createSender(input) {
115
+ try {
116
+ // 1. Validate email format
117
+ if (!this.isValidEmail(input.email)) {
118
+ return {
119
+ success: false,
120
+ error: 'Invalid email format'
121
+ };
122
+ }
123
+ // 2. Extract domain
124
+ const domain = (0, domain_extractor_js_1.extractDomain)(input.email);
125
+ // 3. Check if domain is verified
126
+ if (this.domainVerification) {
127
+ const domainStatus = await this.domainVerification.getDomainStatus(domain);
128
+ if (!domainStatus.isVerified) {
129
+ return {
130
+ success: false,
131
+ error: `Domain ${domain} is not verified. Please verify the domain first.`,
132
+ errors: [`Domain verification required`]
133
+ };
134
+ }
135
+ }
136
+ // 4. Check for duplicate sender
137
+ const existing = await this.findSenderByEmail(input.email);
138
+ if (existing) {
139
+ return {
140
+ success: false,
141
+ error: `Sender with email ${input.email} already exists (ID: ${existing.id})`
142
+ };
143
+ }
144
+ // 5. Create sender record
145
+ const sender = {
146
+ id: this.generateSenderId(),
147
+ email: input.email,
148
+ name: input.name,
149
+ replyToEmail: input.replyToEmail || input.email,
150
+ replyToName: input.replyToName || input.name,
151
+ domain,
152
+ provider: input.provider,
153
+ status: input.skipVerification ? types_js_1.SenderStatus.VERIFIED : types_js_1.SenderStatus.PENDING,
154
+ isDefault: input.isDefault || false,
155
+ isActive: true,
156
+ verificationAttempts: 0,
157
+ createdAt: new Date(),
158
+ updatedAt: new Date(),
159
+ };
160
+ // If setting as default, unset other defaults for this provider
161
+ if (input.isDefault) {
162
+ await this.unsetOtherDefaults(input.provider);
163
+ }
164
+ // 6. Persist — delegate to senderManager if available, else legacy
165
+ if (this.senderManager) {
166
+ const coreRequest = this.toCoreSenderRequest(input, sender);
167
+ const created = await this.senderManager.createSender(coreRequest);
168
+ sender.id = created.id;
169
+ sender.providerSenderId = created.providerSenderId;
170
+ }
171
+ else {
172
+ await this.saveSenderToDatabase(sender);
173
+ this.senders.set(sender.id, sender);
174
+ }
175
+ // 7. Delegate to provider plugin for API-level creation
176
+ const plugin = this.providerPlugins.get(input.provider);
177
+ if (plugin && (0, email_sender_manager_1.isManagedSenderProvider)(plugin) && !input.skipVerification) {
178
+ const providerResult = await plugin.createSender({
179
+ fromEmail: input.email,
180
+ fromName: input.name,
181
+ replyToEmail: input.replyToEmail,
182
+ replyToName: input.replyToName,
183
+ providerFields: input.providerFields,
184
+ });
185
+ if (providerResult.success) {
186
+ sender.providerSenderId = providerResult.providerSenderId;
187
+ sender.providerMetadata = providerResult.metadata;
188
+ // Persist the provider sender ID
189
+ if (this.senderManager) {
190
+ await this.senderManager.updateSender(sender.id, {
191
+ providerSenderId: providerResult.providerSenderId,
192
+ providerMetadata: providerResult.metadata,
193
+ lastModifiedBy: input.createdBy || 'system',
194
+ });
195
+ }
196
+ }
197
+ else {
198
+ this.logger?.warn('Provider creation failed, sender saved locally', {
199
+ senderId: sender.id,
200
+ error: providerResult.error?.message,
201
+ });
202
+ }
203
+ }
204
+ // 8. Send verification email (unless skipped or provider handles it)
205
+ if (!input.skipVerification && !plugin) {
206
+ await this.sendVerificationEmail(sender);
207
+ }
208
+ // 9. Publish event
209
+ if (this.neverhub) {
210
+ await this.neverhub.publishEvent({
211
+ type: 'sender-identity.created',
212
+ data: { senderId: sender.id, email: sender.email, provider: sender.provider }
213
+ });
214
+ }
215
+ this.logger?.info('Sender identity created', { senderId: sender.id, email: sender.email });
216
+ return {
217
+ success: true,
218
+ data: sender
219
+ };
220
+ }
221
+ catch (error) {
222
+ this.logger?.error('Failed to create sender identity', { error, input });
223
+ return {
224
+ success: false,
225
+ error: error instanceof Error ? error.message : 'Unknown error creating sender'
226
+ };
227
+ }
228
+ }
229
+ /**
230
+ * Send verification email to sender
231
+ */
232
+ async sendVerificationEmail(sender) {
233
+ try {
234
+ // 1. Generate verification token
235
+ const token = this.cryptoUtils?.generateSecureToken(32) || this.fallbackGenerateToken(32);
236
+ const expiresAt = new Date(Date.now() + 24 * 60 * 60 * 1000); // 24 hours
237
+ // 2. Update sender record
238
+ sender.verificationToken = token;
239
+ sender.verificationSentAt = new Date();
240
+ sender.verificationExpiresAt = expiresAt;
241
+ sender.status = types_js_1.SenderStatus.VERIFICATION_SENT;
242
+ sender.verificationAttempts++;
243
+ sender.updatedAt = new Date();
244
+ await this.saveSenderToDatabase(sender);
245
+ // 3. Build verification URL
246
+ const verificationUrl = `${this.config.verificationBaseUrl}/verify-sender?token=${token}`;
247
+ // 4. Send verification email
248
+ if (this.emailSender) {
249
+ const emailResult = await this.emailSender.sendEmail({
250
+ to: sender.email,
251
+ subject: 'Verify your sender email address',
252
+ html: (0, verification_email_js_1.buildVerificationEmailHtml)(sender, verificationUrl),
253
+ text: (0, verification_email_js_1.buildVerificationEmailText)(sender, verificationUrl),
254
+ from: this.config.verificationFromEmail,
255
+ fromName: this.config.verificationFromName,
256
+ });
257
+ if (!emailResult.success) {
258
+ throw new Error(`Failed to send verification email: ${emailResult.error}`);
259
+ }
260
+ }
261
+ // 5. Publish event
262
+ if (this.neverhub) {
263
+ await this.neverhub.publishEvent({
264
+ type: 'sender-identity.verification-sent',
265
+ data: { senderId: sender.id, email: sender.email, expiresAt }
266
+ });
267
+ }
268
+ this.logger?.info('Verification email sent', { senderId: sender.id, email: sender.email });
269
+ return { success: true };
270
+ }
271
+ catch (error) {
272
+ this.logger?.error('Failed to send verification email', { error, senderId: sender.id });
273
+ return {
274
+ success: false,
275
+ error: error instanceof Error ? error.message : 'Failed to send verification email'
276
+ };
277
+ }
278
+ }
279
+ /**
280
+ * Verify sender email with token
281
+ */
282
+ async verifySender(token) {
283
+ try {
284
+ // 1. Find sender by token
285
+ const sender = await this.findSenderByToken(token);
286
+ if (!sender) {
287
+ return {
288
+ success: false,
289
+ senderId: '',
290
+ status: types_js_1.SenderStatus.FAILED,
291
+ message: 'Invalid verification token',
292
+ errors: ['Token not found or already used']
293
+ };
294
+ }
295
+ // 2. Check if already verified
296
+ if (sender.status === types_js_1.SenderStatus.VERIFIED) {
297
+ return {
298
+ success: true,
299
+ senderId: sender.id,
300
+ status: sender.status,
301
+ message: 'Sender already verified',
302
+ verifiedAt: sender.verifiedAt
303
+ };
304
+ }
305
+ // 3. Check if token expired
306
+ if (sender.verificationExpiresAt && sender.verificationExpiresAt < new Date()) {
307
+ sender.status = types_js_1.SenderStatus.EXPIRED;
308
+ sender.updatedAt = new Date();
309
+ await this.saveSenderToDatabase(sender);
310
+ return {
311
+ success: false,
312
+ senderId: sender.id,
313
+ status: types_js_1.SenderStatus.EXPIRED,
314
+ message: 'Verification token expired. Please request a new verification email.',
315
+ errors: ['Token expired']
316
+ };
317
+ }
318
+ // 4. Check if locked
319
+ if (sender.status === types_js_1.SenderStatus.LOCKED) {
320
+ return {
321
+ success: false,
322
+ senderId: sender.id,
323
+ status: types_js_1.SenderStatus.LOCKED,
324
+ message: 'Sender locked due to too many failed verification attempts',
325
+ errors: ['Account locked']
326
+ };
327
+ }
328
+ // 5. Verify with provider — use plugin system first, fall back to legacy
329
+ const providerResult = await this.verifyWithProvider(sender);
330
+ if (!providerResult.success) {
331
+ sender.status = types_js_1.SenderStatus.FAILED;
332
+ sender.validationErrors = providerResult.errors || [providerResult.error || 'Provider verification failed'];
333
+ sender.updatedAt = new Date();
334
+ await this.saveSenderToDatabase(sender);
335
+ return {
336
+ success: false,
337
+ senderId: sender.id,
338
+ status: types_js_1.SenderStatus.FAILED,
339
+ message: 'Provider verification failed',
340
+ errors: sender.validationErrors
341
+ };
342
+ }
343
+ // 6. Mark as verified
344
+ sender.status = types_js_1.SenderStatus.VERIFIED;
345
+ sender.verifiedAt = new Date();
346
+ sender.verificationToken = undefined;
347
+ sender.providerSenderId = providerResult.data?.providerId;
348
+ sender.providerMetadata = providerResult.data?.metadata;
349
+ sender.lastValidated = new Date();
350
+ sender.validationErrors = undefined;
351
+ sender.updatedAt = new Date();
352
+ await this.saveSenderToDatabase(sender);
353
+ // Update core layer if available
354
+ if (this.senderManager) {
355
+ await this.senderManager.updateSender(sender.id, {
356
+ isVerified: true,
357
+ verificationStatus: 'verified',
358
+ lastVerifiedAt: sender.verifiedAt,
359
+ providerSenderId: sender.providerSenderId,
360
+ providerMetadata: sender.providerMetadata,
361
+ lastModifiedBy: 'system',
362
+ });
363
+ }
364
+ // 7. Publish event
365
+ if (this.neverhub) {
366
+ await this.neverhub.publishEvent({
367
+ type: 'sender-identity.verified',
368
+ data: {
369
+ senderId: sender.id,
370
+ email: sender.email,
371
+ provider: sender.provider,
372
+ verifiedAt: sender.verifiedAt
373
+ }
374
+ });
375
+ }
376
+ this.logger?.info('Sender verified successfully', { senderId: sender.id, email: sender.email });
377
+ return {
378
+ success: true,
379
+ senderId: sender.id,
380
+ status: sender.status,
381
+ message: 'Sender verified successfully',
382
+ verifiedAt: sender.verifiedAt
383
+ };
384
+ }
385
+ catch (error) {
386
+ this.logger?.error('Failed to verify sender', { error, token });
387
+ return {
388
+ success: false,
389
+ senderId: '',
390
+ status: types_js_1.SenderStatus.FAILED,
391
+ message: error instanceof Error ? error.message : 'Verification failed',
392
+ errors: [error instanceof Error ? error.message : 'Unknown error']
393
+ };
394
+ }
395
+ }
396
+ /**
397
+ * Verify sender with email provider.
398
+ *
399
+ * Uses the plugin registry first. If no plugin is registered for the
400
+ * provider, falls back to the legacy provider classes.
401
+ */
402
+ async verifyWithProvider(sender) {
403
+ // Try plugin-based verification
404
+ const plugin = this.providerPlugins.get(sender.provider);
405
+ if (plugin) {
406
+ if ((0, email_sender_manager_1.isVerifiableSenderProvider)(plugin) && sender.providerSenderId) {
407
+ const result = await plugin.checkVerificationStatus(sender.providerSenderId);
408
+ if (result.status === 'verified') {
409
+ return {
410
+ success: true,
411
+ data: {
412
+ providerId: result.providerSenderId,
413
+ metadata: { verificationType: result.verificationType },
414
+ },
415
+ };
416
+ }
417
+ return {
418
+ success: false,
419
+ error: result.error?.message || `Verification status: ${result.status}`,
420
+ };
421
+ }
422
+ // Plugin exists but is not verifiable — validate only
423
+ const validation = await plugin.validateSender(sender.email);
424
+ if (validation.isVerified) {
425
+ return {
426
+ success: true,
427
+ data: { metadata: validation.metadata },
428
+ };
429
+ }
430
+ return { success: true, data: {} };
431
+ }
432
+ // Manual verification providers
433
+ if ((0, manual_instructions_js_1.isManualVerificationProvider)(sender.provider)) {
434
+ const instructions = (0, manual_instructions_js_1.getManualInstructions)(sender.provider);
435
+ return {
436
+ success: true,
437
+ data: {
438
+ metadata: instructions ? { manualInstructions: instructions } : {},
439
+ },
440
+ };
441
+ }
442
+ // Legacy fallback — for backward compatibility when no plugins are registered
443
+ return this.legacyVerifyWithProvider(sender);
444
+ }
445
+ /**
446
+ * Legacy provider verification using inline provider classes.
447
+ * Preserved for backward compatibility when no plugins are configured.
448
+ */
449
+ async legacyVerifyWithProvider(sender) {
450
+ // Dynamic imports to avoid breaking if legacy providers are removed later
451
+ switch (sender.provider) {
452
+ case types_js_1.EmailProvider.SENDGRID:
453
+ if (this.config.sendgridApiKey) {
454
+ const { SendGridProvider } = await Promise.resolve().then(() => __importStar(require('./providers/SendGridProvider.js')));
455
+ const provider = new SendGridProvider(this.config.sendgridApiKey);
456
+ return provider.verifySender(sender);
457
+ }
458
+ return { success: false, error: 'SendGrid API key not configured' };
459
+ case types_js_1.EmailProvider.MAILGUN:
460
+ if (this.config.mailgunApiKey) {
461
+ const { MailgunProvider } = await Promise.resolve().then(() => __importStar(require('./providers/MailgunProvider.js')));
462
+ const provider = new MailgunProvider(this.config.mailgunApiKey);
463
+ return provider.verifySender(sender);
464
+ }
465
+ return { success: true, data: {} };
466
+ case types_js_1.EmailProvider.SES:
467
+ if (this.config.sesAccessKey && this.config.sesSecretKey && this.config.sesRegion) {
468
+ const { SESProvider } = await Promise.resolve().then(() => __importStar(require('./providers/SESProvider.js')));
469
+ const provider = new SESProvider(this.config.sesAccessKey, this.config.sesSecretKey, this.config.sesRegion);
470
+ return provider.verifySender(sender);
471
+ }
472
+ return { success: false, error: 'SES credentials not configured' };
473
+ case types_js_1.EmailProvider.SMTP: {
474
+ const { SMTPProvider } = await Promise.resolve().then(() => __importStar(require('./providers/SMTPProvider.js')));
475
+ const provider = new SMTPProvider();
476
+ return provider.verifySender(sender);
477
+ }
478
+ case types_js_1.EmailProvider.POSTMARK:
479
+ case types_js_1.EmailProvider.MANDRILL:
480
+ case types_js_1.EmailProvider.SMTP2GO:
481
+ return { success: true, data: {} };
482
+ default:
483
+ return {
484
+ success: false,
485
+ error: `Unsupported provider: ${sender.provider}`
486
+ };
487
+ }
488
+ }
489
+ /**
490
+ * Get sender by ID
491
+ */
492
+ async getSender(senderId) {
493
+ if (this.senderManager) {
494
+ const config = await this.senderManager.getSender(senderId);
495
+ if (!config) {
496
+ return { success: false, error: `Sender not found: ${senderId}` };
497
+ }
498
+ return { success: true, data: this.coreConfigToIdentity(config) };
499
+ }
500
+ const sender = this.senders.get(senderId);
501
+ if (!sender) {
502
+ return {
503
+ success: false,
504
+ error: `Sender not found: ${senderId}`
505
+ };
506
+ }
507
+ return {
508
+ success: true,
509
+ data: sender
510
+ };
511
+ }
512
+ /**
513
+ * List senders
514
+ */
515
+ async listSenders(options = {}) {
516
+ try {
517
+ if (this.senderManager) {
518
+ const result = await this.senderManager.listSenders({
519
+ provider: options.provider,
520
+ isActive: options.isActive,
521
+ domain: options.domain,
522
+ offset: options.offset,
523
+ limit: options.limit,
524
+ });
525
+ const identities = result.items.map((c) => this.coreConfigToIdentity(c));
526
+ // Apply status filter locally (core layer doesn't have SenderStatus enum)
527
+ const filtered = options.status
528
+ ? identities.filter((s) => s.status === options.status)
529
+ : identities;
530
+ return { success: true, data: filtered };
531
+ }
532
+ let senders = Array.from(this.senders.values());
533
+ // Filter by provider
534
+ if (options.provider) {
535
+ senders = senders.filter(s => s.provider === options.provider);
536
+ }
537
+ // Filter by status
538
+ if (options.status) {
539
+ senders = senders.filter(s => s.status === options.status);
540
+ }
541
+ // Filter by active
542
+ if (options.isActive !== undefined) {
543
+ senders = senders.filter(s => s.isActive === options.isActive);
544
+ }
545
+ // Filter by domain
546
+ if (options.domain) {
547
+ senders = senders.filter(s => s.domain === options.domain);
548
+ }
549
+ // Sort by created date (newest first)
550
+ senders.sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
551
+ // Pagination
552
+ const limit = options.limit || 50;
553
+ const offset = options.offset || 0;
554
+ senders = senders.slice(offset, offset + limit);
555
+ return {
556
+ success: true,
557
+ data: senders
558
+ };
559
+ }
560
+ catch (error) {
561
+ return {
562
+ success: false,
563
+ error: error instanceof Error ? error.message : 'Failed to list senders'
564
+ };
565
+ }
566
+ }
567
+ /**
568
+ * Update sender
569
+ */
570
+ async updateSender(senderId, input) {
571
+ try {
572
+ // Fetch from appropriate store
573
+ const getResult = await this.getSender(senderId);
574
+ if (!getResult.success || !getResult.data) {
575
+ return { success: false, error: `Sender not found: ${senderId}` };
576
+ }
577
+ const sender = getResult.data;
578
+ // Update fields
579
+ if (input.name !== undefined)
580
+ sender.name = input.name;
581
+ if (input.replyToEmail !== undefined)
582
+ sender.replyToEmail = input.replyToEmail;
583
+ if (input.replyToName !== undefined)
584
+ sender.replyToName = input.replyToName;
585
+ if (input.isDefault !== undefined) {
586
+ // If setting as default, unset other defaults
587
+ if (input.isDefault) {
588
+ await this.unsetOtherDefaults(sender.provider);
589
+ }
590
+ sender.isDefault = input.isDefault;
591
+ }
592
+ if (input.isActive !== undefined)
593
+ sender.isActive = input.isActive;
594
+ sender.updatedAt = new Date();
595
+ // If changing email-related fields, require re-verification
596
+ if (input.replyToEmail && input.replyToEmail !== sender.email) {
597
+ sender.status = types_js_1.SenderStatus.PENDING;
598
+ sender.verifiedAt = undefined;
599
+ sender.lastValidated = undefined;
600
+ }
601
+ // Persist
602
+ if (this.senderManager) {
603
+ await this.senderManager.updateSender(senderId, {
604
+ name: input.name,
605
+ fromName: input.name,
606
+ replyToEmail: input.replyToEmail,
607
+ replyToName: input.replyToName,
608
+ isDefault: input.isDefault,
609
+ isActive: input.isActive,
610
+ lastModifiedBy: input.lastModifiedBy || 'system',
611
+ });
612
+ }
613
+ else {
614
+ await this.saveSenderToDatabase(sender);
615
+ }
616
+ // Delegate to provider plugin if available
617
+ const plugin = this.providerPlugins.get(sender.provider);
618
+ if (plugin && (0, email_sender_manager_1.isManagedSenderProvider)(plugin) && sender.providerSenderId) {
619
+ await plugin.updateSender({
620
+ providerSenderId: sender.providerSenderId,
621
+ fromName: input.name,
622
+ replyToEmail: input.replyToEmail,
623
+ replyToName: input.replyToName,
624
+ providerFields: input.providerFields,
625
+ });
626
+ }
627
+ // Publish event
628
+ if (this.neverhub) {
629
+ await this.neverhub.publishEvent({
630
+ type: 'sender-identity.updated',
631
+ data: { senderId: sender.id, updates: input }
632
+ });
633
+ }
634
+ this.logger?.info('Sender updated', { senderId, updates: input });
635
+ return {
636
+ success: true,
637
+ data: sender
638
+ };
639
+ }
640
+ catch (error) {
641
+ this.logger?.error('Failed to update sender', { error, senderId, input });
642
+ return {
643
+ success: false,
644
+ error: error instanceof Error ? error.message : 'Failed to update sender'
645
+ };
646
+ }
647
+ }
648
+ /**
649
+ * Delete sender
650
+ */
651
+ async deleteSender(senderId) {
652
+ try {
653
+ const getResult = await this.getSender(senderId);
654
+ if (!getResult.success || !getResult.data) {
655
+ return { success: false, error: `Sender not found: ${senderId}` };
656
+ }
657
+ const sender = getResult.data;
658
+ // Delete from provider if plugin supports it
659
+ const plugin = this.providerPlugins.get(sender.provider);
660
+ if (plugin && (0, email_sender_manager_1.isManagedSenderProvider)(plugin) && sender.providerSenderId) {
661
+ await plugin.deleteSender(sender.providerSenderId);
662
+ }
663
+ // Persist deletion
664
+ if (this.senderManager) {
665
+ await this.senderManager.deleteSender(senderId);
666
+ }
667
+ else {
668
+ sender.deletedAt = new Date();
669
+ sender.isActive = false;
670
+ sender.updatedAt = new Date();
671
+ await this.saveSenderToDatabase(sender);
672
+ this.senders.delete(senderId);
673
+ }
674
+ // Publish event
675
+ if (this.neverhub) {
676
+ await this.neverhub.publishEvent({
677
+ type: 'sender-identity.deleted',
678
+ data: { senderId, email: sender.email }
679
+ });
680
+ }
681
+ this.logger?.info('Sender deleted', { senderId, email: sender.email });
682
+ return { success: true };
683
+ }
684
+ catch (error) {
685
+ this.logger?.error('Failed to delete sender', { error, senderId });
686
+ return {
687
+ success: false,
688
+ error: error instanceof Error ? error.message : 'Failed to delete sender'
689
+ };
690
+ }
691
+ }
692
+ /**
693
+ * Check provider compliance for sender
694
+ */
695
+ async checkCompliance(senderId) {
696
+ try {
697
+ const getResult = await this.getSender(senderId);
698
+ if (!getResult.success || !getResult.data) {
699
+ return { success: false, error: `Sender not found: ${senderId}` };
700
+ }
701
+ const sender = getResult.data;
702
+ const errors = [];
703
+ const warnings = [];
704
+ // 1. Check email format
705
+ const emailFormat = this.isValidEmail(sender.email);
706
+ if (!emailFormat) {
707
+ errors.push('Invalid email format');
708
+ }
709
+ // 2. Check domain verification
710
+ let domainVerified = true;
711
+ let spfValid = true;
712
+ let dkimValid = true;
713
+ if (this.domainVerification) {
714
+ const domainStatus = await this.domainVerification.getDomainStatus(sender.domain);
715
+ domainVerified = domainStatus.isVerified;
716
+ spfValid = domainStatus.dnsRecords?.spf?.isValid || false;
717
+ dkimValid = domainStatus.dnsRecords?.dkim?.isValid || false;
718
+ if (!domainVerified) {
719
+ errors.push(`Domain ${sender.domain} is not verified`);
720
+ }
721
+ if (!spfValid) {
722
+ errors.push('SPF record not configured or invalid');
723
+ }
724
+ if (!dkimValid) {
725
+ errors.push('DKIM record not configured or invalid');
726
+ }
727
+ }
728
+ // 3. Provider-specific checks via plugin
729
+ const plugin = this.providerPlugins.get(sender.provider);
730
+ if (plugin && (0, email_sender_manager_1.isVerifiableSenderProvider)(plugin) && sender.providerSenderId) {
731
+ const verificationResult = await plugin.checkVerificationStatus(sender.providerSenderId);
732
+ if (verificationResult.status !== 'verified') {
733
+ warnings.push(`Provider verification status: ${verificationResult.status}`);
734
+ }
735
+ }
736
+ else if (sender.provider === types_js_1.EmailProvider.SENDGRID && !sender.providerSenderId) {
737
+ warnings.push('SendGrid sender ID not set - may need re-verification');
738
+ }
739
+ const isCompliant = errors.length === 0;
740
+ const result = {
741
+ isCompliant,
742
+ checks: {
743
+ domainVerified,
744
+ spfValid,
745
+ dkimValid,
746
+ emailFormat
747
+ },
748
+ errors,
749
+ warnings
750
+ };
751
+ // Update sender validation
752
+ sender.lastValidated = new Date();
753
+ sender.validationErrors = errors.length > 0 ? errors : undefined;
754
+ await this.saveSenderToDatabase(sender);
755
+ return {
756
+ success: true,
757
+ data: result
758
+ };
759
+ }
760
+ catch (error) {
761
+ this.logger?.error('Failed to check compliance', { error, senderId });
762
+ return {
763
+ success: false,
764
+ error: error instanceof Error ? error.message : 'Failed to check compliance'
765
+ };
766
+ }
767
+ }
768
+ /**
769
+ * Get default sender for provider
770
+ */
771
+ async getDefaultSender(provider) {
772
+ if (this.senderManager) {
773
+ const result = await this.senderManager.listSenders({
774
+ provider,
775
+ isActive: true,
776
+ isVerified: true,
777
+ });
778
+ const defaultSender = result.items.find((s) => s.isDefault);
779
+ if (!defaultSender) {
780
+ return { success: false, error: `No default sender found for provider ${provider}` };
781
+ }
782
+ return { success: true, data: this.coreConfigToIdentity(defaultSender) };
783
+ }
784
+ const senders = Array.from(this.senders.values());
785
+ const defaultSender = senders.find(s => s.provider === provider &&
786
+ s.isDefault &&
787
+ s.status === types_js_1.SenderStatus.VERIFIED &&
788
+ s.isActive);
789
+ if (!defaultSender) {
790
+ return {
791
+ success: false,
792
+ error: `No default sender found for provider ${provider}`
793
+ };
794
+ }
795
+ return {
796
+ success: true,
797
+ data: defaultSender
798
+ };
799
+ }
800
+ /**
801
+ * Resend verification email
802
+ */
803
+ async resendVerification(senderId) {
804
+ try {
805
+ const getResult = await this.getSender(senderId);
806
+ if (!getResult.success || !getResult.data) {
807
+ return { success: false, error: `Sender not found: ${senderId}` };
808
+ }
809
+ const sender = getResult.data;
810
+ if (sender.status === types_js_1.SenderStatus.VERIFIED) {
811
+ return {
812
+ success: false,
813
+ error: 'Sender already verified'
814
+ };
815
+ }
816
+ if (sender.status === types_js_1.SenderStatus.LOCKED) {
817
+ return {
818
+ success: false,
819
+ error: 'Sender locked due to too many attempts'
820
+ };
821
+ }
822
+ // Check rate limiting (max 3 emails per hour)
823
+ if (sender.verificationSentAt) {
824
+ const hourAgo = new Date(Date.now() - 60 * 60 * 1000);
825
+ if (sender.verificationSentAt > hourAgo && sender.verificationAttempts >= 3) {
826
+ return {
827
+ success: false,
828
+ error: 'Too many verification emails sent. Please try again later.'
829
+ };
830
+ }
831
+ }
832
+ // If provider supports verification, use it
833
+ const plugin = this.providerPlugins.get(sender.provider);
834
+ if (plugin && (0, email_sender_manager_1.isVerifiableSenderProvider)(plugin) && sender.providerSenderId) {
835
+ const result = await plugin.initiateVerification(sender.providerSenderId);
836
+ if (result.success) {
837
+ return { success: true };
838
+ }
839
+ }
840
+ return this.sendVerificationEmail(sender);
841
+ }
842
+ catch (error) {
843
+ this.logger?.error('Failed to resend verification', { error, senderId });
844
+ return {
845
+ success: false,
846
+ error: error instanceof Error ? error.message : 'Failed to resend verification'
847
+ };
848
+ }
849
+ }
850
+ /**
851
+ * Check verification status for a sender using the provider plugin.
852
+ */
853
+ async checkVerificationStatus(senderId) {
854
+ const getResult = await this.getSender(senderId);
855
+ if (!getResult.success || !getResult.data) {
856
+ return { success: false, error: `Sender not found: ${senderId}` };
857
+ }
858
+ const sender = getResult.data;
859
+ const plugin = this.providerPlugins.get(sender.provider);
860
+ if (!plugin || !(0, email_sender_manager_1.isVerifiableSenderProvider)(plugin) || !sender.providerSenderId) {
861
+ return {
862
+ success: true,
863
+ data: {
864
+ status: sender.status,
865
+ verificationType: 'manual',
866
+ },
867
+ };
868
+ }
869
+ const result = await plugin.checkVerificationStatus(sender.providerSenderId);
870
+ return {
871
+ success: result.success,
872
+ data: {
873
+ status: result.status,
874
+ verificationType: result.verificationType,
875
+ dnsRecords: result.dnsRecords,
876
+ },
877
+ };
878
+ }
879
+ // ============================================
880
+ // Private Helper Methods
881
+ // ============================================
882
+ generateSenderId() {
883
+ return this.cryptoUtils?.generateSecureToken(16) || this.fallbackGenerateToken(16);
884
+ }
885
+ fallbackGenerateToken(length) {
886
+ const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
887
+ let result = '';
888
+ for (let i = 0; i < length; i++) {
889
+ result += chars.charAt(Math.floor(Math.random() * chars.length));
890
+ }
891
+ return result;
892
+ }
893
+ isValidEmail(email) {
894
+ if (this.emailValidator) {
895
+ return this.emailValidator.validate(email).isValid;
896
+ }
897
+ // Fallback basic validation
898
+ const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
899
+ return emailRegex.test(email);
900
+ }
901
+ async findSenderByEmail(email) {
902
+ if (this.senderManager) {
903
+ const result = await this.senderManager.listSenders({ limit: 1000 });
904
+ return result.items
905
+ .map((c) => this.coreConfigToIdentity(c))
906
+ .find((s) => s.email === email && !s.deletedAt);
907
+ }
908
+ return Array.from(this.senders.values()).find(s => s.email === email && !s.deletedAt);
909
+ }
910
+ async findSenderByToken(token) {
911
+ // Token lookup is always in-memory (tokens live in the service layer)
912
+ return Array.from(this.senders.values()).find(s => s.verificationToken === token);
913
+ }
914
+ async unsetOtherDefaults(provider) {
915
+ if (this.senderManager) {
916
+ const result = await this.senderManager.listSenders({ provider });
917
+ for (const sender of result.items) {
918
+ if (sender.isDefault) {
919
+ await this.senderManager.updateSender(sender.id, {
920
+ isDefault: false,
921
+ lastModifiedBy: 'system',
922
+ });
923
+ }
924
+ }
925
+ return;
926
+ }
927
+ const senders = Array.from(this.senders.values())
928
+ .filter(s => s.provider === provider && s.isDefault);
929
+ for (const sender of senders) {
930
+ sender.isDefault = false;
931
+ sender.updatedAt = new Date();
932
+ await this.saveSenderToDatabase(sender);
933
+ }
934
+ }
935
+ async loadSendersFromDatabase() {
936
+ // TODO: Implement database loading for legacy path
937
+ // For now, no-op
938
+ }
939
+ async saveSenderToDatabase(sender) {
940
+ // TODO: Implement database persistence for legacy path
941
+ // For now, just update in-memory map
942
+ this.senders.set(sender.id, sender);
943
+ }
944
+ // ============================================
945
+ // Mapping helpers between service and core types
946
+ // ============================================
947
+ toCoreSenderRequest(input, sender) {
948
+ return {
949
+ name: input.name,
950
+ fromEmail: input.email,
951
+ fromName: input.name,
952
+ replyToEmail: input.replyToEmail,
953
+ replyToName: input.replyToName,
954
+ provider: input.provider,
955
+ allowedDomains: [sender.domain],
956
+ createdBy: input.createdBy || 'system',
957
+ };
958
+ }
959
+ coreConfigToIdentity(config) {
960
+ return {
961
+ id: config.id,
962
+ email: config.fromEmail,
963
+ name: config.fromName,
964
+ replyToEmail: config.replyToEmail,
965
+ replyToName: config.replyToName,
966
+ domain: config.domain,
967
+ provider: config.provider,
968
+ status: this.mapVerificationStatus(config.verificationStatus),
969
+ isDefault: config.isDefault,
970
+ isActive: config.isActive,
971
+ verificationAttempts: 0,
972
+ verifiedAt: config.lastVerifiedAt,
973
+ providerSenderId: config.providerSenderId,
974
+ providerMetadata: config.providerMetadata,
975
+ createdAt: config.createdAt,
976
+ updatedAt: config.updatedAt,
977
+ };
978
+ }
979
+ mapVerificationStatus(status) {
980
+ switch (status) {
981
+ case 'verified': return types_js_1.SenderStatus.VERIFIED;
982
+ case 'failed': return types_js_1.SenderStatus.FAILED;
983
+ case 'expired': return types_js_1.SenderStatus.EXPIRED;
984
+ case 'pending':
985
+ default: return types_js_1.SenderStatus.PENDING;
986
+ }
987
+ }
988
+ }
989
+ exports.SenderIdentityVerification = SenderIdentityVerification;