@bernierllc/sender-identity-verification 3.0.2 → 3.0.4

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