@bernierllc/sender-identity-verification 3.0.3 → 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.
- package/{src/utils/domain-extractor.ts → LICENSE} +0 -13
- package/package.json +13 -8
- package/.env.test +0 -8
- package/.eslintrc.js +0 -30
- package/CHANGELOG.md +0 -222
- package/__tests__/SenderIdentityVerification.test.ts +0 -461
- package/__tests__/__mocks__/fetch-mock.ts +0 -156
- package/__tests__/additional-coverage.test.ts +0 -129
- package/__tests__/additional-error-coverage.test.ts +0 -483
- package/__tests__/branch-coverage.test.ts +0 -509
- package/__tests__/config.test.ts +0 -126
- package/__tests__/error-handling.test.ts +0 -336
- package/__tests__/final-branch-coverage.test.ts +0 -372
- package/__tests__/integration.real-api.test.ts +0 -295
- package/__tests__/providers.test.ts +0 -331
- package/__tests__/service-coverage.test.ts +0 -412
- package/jest.config.cjs +0 -34
- package/src/SenderIdentityVerification.ts +0 -1140
- package/src/config.ts +0 -90
- package/src/errors.ts +0 -90
- package/src/global.d.ts +0 -24
- package/src/index.ts +0 -33
- package/src/manual-instructions.ts +0 -61
- package/src/providers/MailgunProvider.ts +0 -35
- package/src/providers/SESProvider.ts +0 -51
- package/src/providers/SMTPProvider.ts +0 -29
- package/src/providers/SendGridProvider.ts +0 -108
- package/src/templates/verification-email.ts +0 -67
- package/src/types.ts +0 -171
- package/tsconfig.json +0 -22
|
@@ -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
|
-
}
|