robust-email-validator
Version:
A comprehensive email validation library with format, DNS, and deliverability checking
163 lines • 7.09 kB
JavaScript
;
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
var desc = Object.getOwnPropertyDescriptor(m, k);
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
desc = { enumerable: true, get: function() { return m[k]; } };
}
Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
o[k2] = m[k];
}));
var __exportStar = (this && this.__exportStar) || function(m, exports) {
for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.APIValidator = exports.DNSValidator = exports.FormatValidator = exports.EmailValidator = void 0;
const format_validator_1 = require("./validators/format-validator");
const dns_validator_1 = require("./validators/dns-validator");
const api_validator_1 = require("./validators/api-validator");
class EmailValidator {
constructor(options = {}) {
this.options = {
checkFormat: true,
checkDNS: false,
checkMX: false,
checkDeliverability: false,
apiProvider: "zerobounce",
apiKey: "",
timeout: 5000,
...options,
};
// Validate configuration
if (this.options.checkDeliverability && !this.options.apiKey) {
throw new Error("API key is required for deliverability checking");
}
// Replace the window check with proper typing
if ((this.options.checkDNS || this.options.checkMX) &&
typeof globalThis !== "undefined" &&
typeof globalThis.window !== "undefined") {
console.warn("DNS/MX validation is not supported in browser environments");
this.options.checkDNS = false;
this.options.checkMX = false;
}
}
async validate(email) {
const result = {
email,
isValid: true,
errors: [],
warnings: [],
details: {},
};
try {
// 1. Format validation
if (this.options.checkFormat) {
const formatResult = format_validator_1.FormatValidator.validate(email);
result.details.format = formatResult;
if (!formatResult.isValid) {
result.isValid = false;
result.errors.push(formatResult.error || "Invalid email format");
return result; // No point in continuing if format is invalid
}
}
// Extract domain for DNS checks
const domain = email.split("@")[1];
// 2. DNS validation
if (this.options.checkDNS || this.options.checkMX) {
const dnsResult = await dns_validator_1.DNSValidator.validate(domain, this.options.timeout);
result.details.dns = dnsResult;
if (!dnsResult.isValid) {
result.isValid = false;
result.errors.push(dnsResult.error || "Domain does not exist or cannot receive emails");
}
else {
if (this.options.checkMX && !dnsResult.hasMXRecord) {
result.warnings.push("Domain has no MX records but may still receive emails");
}
}
}
// 3. Deliverability validation
if (this.options.checkDeliverability && this.options.apiKey) {
const apiValidator = new api_validator_1.APIValidator(this.options.apiProvider, this.options.apiKey, this.options.timeout);
const deliverabilityResult = await apiValidator.validate(email);
result.details.deliverability = deliverabilityResult;
if (!deliverabilityResult.isValid) {
result.isValid = false;
result.errors.push(deliverabilityResult.error || "Email is not deliverable");
}
else {
if (deliverabilityResult.isDisposable) {
result.warnings.push("Email appears to be from a disposable email service");
}
if (deliverabilityResult.isCatchAll) {
result.warnings.push("Domain appears to be a catch-all domain");
}
}
}
}
catch (error) {
result.isValid = false;
result.errors.push(error instanceof Error ? error.message : "Validation failed");
}
return result;
}
async validateBatch(emails) {
const results = [];
let processed = 0;
let failed = 0;
for (const email of emails) {
try {
const result = await this.validate(email);
results.push(result);
processed++;
}
catch (error) {
results.push({
email,
isValid: false,
errors: [error instanceof Error ? error.message : "Validation failed"],
warnings: [],
details: {},
});
failed++;
}
}
const valid = results.filter((r) => r.isValid).length;
const invalid = results.filter((r) => !r.isValid).length;
return {
results,
summary: {
total: emails.length,
valid,
invalid,
processed,
failed,
},
};
}
// Convenience methods for quick validation
static async isValid(email, options) {
const validator = new EmailValidator(options);
const result = await validator.validate(email);
return result.isValid;
}
static validateFormat(email, strict = false) {
return format_validator_1.FormatValidator.validate(email, strict).isValid;
}
static async validateDomain(domain, timeout = 5000) {
const result = await dns_validator_1.DNSValidator.validate(domain, timeout);
return result.isValid;
}
}
exports.EmailValidator = EmailValidator;
// Export everything for easy importing
__exportStar(require("./types"), exports);
var format_validator_2 = require("./validators/format-validator");
Object.defineProperty(exports, "FormatValidator", { enumerable: true, get: function () { return format_validator_2.FormatValidator; } });
var dns_validator_2 = require("./validators/dns-validator");
Object.defineProperty(exports, "DNSValidator", { enumerable: true, get: function () { return dns_validator_2.DNSValidator; } });
var api_validator_2 = require("./validators/api-validator");
Object.defineProperty(exports, "APIValidator", { enumerable: true, get: function () { return api_validator_2.APIValidator; } });
//# sourceMappingURL=email-validator.js.map