robust-email-validator
Version:
A comprehensive email validation library with format, DNS, and deliverability checking
133 lines • 5.04 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", { value: true });
exports.APIValidator = void 0;
class APIValidator {
constructor(provider, apiKey, timeout = 10000) {
this.provider = provider;
this.apiKey = apiKey;
this.timeout = timeout;
}
async validate(email) {
try {
switch (this.provider) {
case "zerobounce":
return await this.validateWithZeroBounce(email);
case "mailgun":
return await this.validateWithMailgun(email);
case "hunter":
return await this.validateWithHunter(email);
default:
throw new Error(`Unsupported API provider: ${this.provider}`);
}
}
catch (error) {
return {
isValid: false,
error: error instanceof Error ? error.message : "API validation failed",
};
}
}
async validateWithZeroBounce(email) {
const url = `https://api.zerobounce.net/v2/validate?api_key=${this.apiKey}&email=${encodeURIComponent(email)}`;
const controller = new AbortController();
const timeoutId = setTimeout(() => controller.abort(), this.timeout);
try {
const response = await fetch(url, { signal: controller.signal });
clearTimeout(timeoutId);
if (!response.ok) {
throw new Error(`ZeroBounce API error: ${response.status}`);
}
const data = (await response.json());
return {
isValid: data.status === "valid",
isDeliverable: data.status === "valid",
isDisposable: data.sub_status === "disposable_email",
isCatchAll: data.sub_status === "catch_all",
confidence: this.mapZeroBounceConfidence(data.status),
provider: "zerobounce",
};
}
finally {
clearTimeout(timeoutId);
}
}
async validateWithMailgun(email) {
const url = `https://api.mailgun.net/v4/address/validate`;
const controller = new AbortController();
const timeoutId = setTimeout(() => controller.abort(), this.timeout);
try {
const response = await fetch(url, {
method: "GET",
headers: {
Authorization: `Basic ${Buffer.from(`api:${this.apiKey}`).toString("base64")}`,
},
signal: controller.signal,
});
clearTimeout(timeoutId);
if (!response.ok) {
throw new Error(`Mailgun API error: ${response.status}`);
}
const data = (await response.json());
return {
isValid: data.is_valid,
isDeliverable: data.is_deliverable,
isDisposable: data.is_disposable_address,
confidence: data.confidence,
provider: "mailgun",
};
}
finally {
clearTimeout(timeoutId);
}
}
async validateWithHunter(email) {
const url = `https://api.hunter.io/v2/email-verifier?email=${encodeURIComponent(email)}&api_key=${this.apiKey}`;
const controller = new AbortController();
const timeoutId = setTimeout(() => controller.abort(), this.timeout);
try {
const response = await fetch(url, { signal: controller.signal });
clearTimeout(timeoutId);
if (!response.ok) {
throw new Error(`Hunter API error: ${response.status}`);
}
const data = (await response.json());
const result = data.data;
return {
isValid: result.status === "valid",
isDeliverable: result.status === "valid",
isDisposable: result.disposable,
confidence: result.confidence,
provider: "hunter",
};
}
finally {
clearTimeout(timeoutId);
}
}
mapZeroBounceConfidence(status) {
const confidenceMap = {
valid: 100,
invalid: 0,
"catch-all": 50,
unknown: 25,
spamtrap: 0,
abuse: 0,
do_not_mail: 0,
};
return confidenceMap[status] || 0;
}
async validateBatch(emails) {
// For batch processing, we'll validate emails sequentially to avoid rate limits
// In production, you might want to implement proper batch API calls where supported
const results = [];
for (const email of emails) {
const result = await this.validate(email);
results.push(result);
// Add a small delay to avoid rate limiting
await new Promise((resolve) => setTimeout(resolve, 100));
}
return results;
}
}
exports.APIValidator = APIValidator;
//# sourceMappingURL=api-validator.js.map