@bernierllc/sender-identity-verification 3.0.10 → 3.0.13
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/dist/SenderIdentityVerification.d.ts +107 -0
- package/dist/SenderIdentityVerification.js +989 -0
- package/dist/config.d.ts +34 -0
- package/dist/config.js +40 -0
- package/dist/errors.d.ts +39 -0
- package/dist/errors.js +56 -0
- package/dist/index.d.ts +7 -0
- package/dist/index.js +23 -0
- package/dist/manual-instructions.d.ts +9 -0
- package/dist/manual-instructions.js +54 -0
- package/dist/providers/MailgunProvider.d.ts +13 -0
- package/dist/providers/MailgunProvider.js +35 -0
- package/dist/providers/SESProvider.d.ts +12 -0
- package/dist/providers/SESProvider.js +47 -0
- package/dist/providers/SMTPProvider.d.ts +12 -0
- package/dist/providers/SMTPProvider.js +30 -0
- package/dist/providers/SendGridProvider.d.ts +19 -0
- package/dist/providers/SendGridProvider.js +99 -0
- package/dist/templates/verification-email.d.ts +9 -0
- package/dist/templates/verification-email.js +67 -0
- package/dist/types.d.ts +147 -0
- package/dist/types.js +36 -0
- package/dist/utils/domain-extractor.d.ts +4 -0
- package/dist/utils/domain-extractor.js +20 -0
- package/package.json +5 -5
|
@@ -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;
|