valid-email-checker 1.0.0

package/src/validators/formatValidator.js

@@ -0,0 +1,257 @@
+/**
+ * Email Format Validator
+ * Validates email addresses according to RFC 5322 standards
+ */
+
+// RFC 5322 compliant email regex (simplified but comprehensive)
+const EMAIL_REGEX = /^(?:[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*|"(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21\x23-\x5b\x5d-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])*")@(?:(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?|\[(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?|[a-z0-9-]*[a-z0-9]:(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21-\x5a\x53-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])+)\])$/i;
+
+// Simple but effective email regex for common use cases
+const SIMPLE_EMAIL_REGEX = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+
+// Valid TLD list (common ones)
+const VALID_TLDS = new Set([
+  'com', 'org', 'net', 'edu', 'gov', 'mil', 'int',
+  'co', 'io', 'ai', 'app', 'dev', 'tech', 'online', 'site', 'web',
+  'info', 'biz', 'name', 'pro', 'museum', 'coop', 'aero',
+  'uk', 'us', 'ca', 'au', 'de', 'fr', 'jp', 'cn', 'in', 'br', 'ru',
+  'es', 'it', 'nl', 'se', 'no', 'fi', 'dk', 'pl', 'cz', 'at', 'ch',
+  'be', 'ie', 'nz', 'sg', 'hk', 'kr', 'tw', 'th', 'my', 'ph', 'id',
+  'vn', 'za', 'eg', 'ng', 'ke', 'mx', 'ar', 'cl', 'co', 'pe', 've',
+  'xyz', 'club', 'shop', 'blog', 'news', 'live', 'store', 'email',
+  'me', 'tv', 'cc', 'ws', 'bz', 'fm', 'am', 'ly', 'to', 'gg', 'gl'
+]);
+
+/**
+ * Validates email format
+ * @param {string} email - Email address to validate
+ * @param {object} options - Validation options
+ * @returns {object} Validation result
+ */
+function validateEmail(email, options = {}) {
+  const {
+    strict = false,
+    allowPlusAddressing = true,
+    checkTld = true,
+    maxLength = 254,
+    minLocalLength = 1,
+    maxLocalLength = 64
+  } = options;
+
+  const result = {
+    valid: false,
+    email: email,
+    normalized: null,
+    local: null,
+    domain: null,
+    errors: []
+  };
+
+  // Basic checks
+  if (!email || typeof email !== 'string') {
+    result.errors.push('Email is required and must be a string');
+    return result;
+  }
+
+  // Trim and normalize
+  const normalizedEmail = email.trim().toLowerCase();
+  result.normalized = normalizedEmail;
+
+  // Length checks
+  if (normalizedEmail.length > maxLength) {
+    result.errors.push(`Email exceeds maximum length of ${maxLength} characters`);
+    return result;
+  }
+
+  if (normalizedEmail.length === 0) {
+    result.errors.push('Email cannot be empty');
+    return result;
+  }
+
+  // Split into local and domain parts
+  const atIndex = normalizedEmail.lastIndexOf('@');
+  if (atIndex === -1) {
+    result.errors.push('Email must contain @ symbol');
+    return result;
+  }
+
+  const local = normalizedEmail.substring(0, atIndex);
+  const domain = normalizedEmail.substring(atIndex + 1);
+
+  result.local = local;
+  result.domain = domain;
+
+  // Local part validation
+  if (local.length < minLocalLength) {
+    result.errors.push(`Local part must be at least ${minLocalLength} character(s)`);
+  }
+
+  if (local.length > maxLocalLength) {
+    result.errors.push(`Local part exceeds maximum length of ${maxLocalLength} characters`);
+  }
+
+  // Check plus addressing
+  if (!allowPlusAddressing && local.includes('+')) {
+    result.errors.push('Plus addressing is not allowed');
+  }
+
+  // Check for consecutive dots in local part
+  if (local.includes('..')) {
+    result.errors.push('Local part cannot contain consecutive dots');
+  }
+
+  // Check if local starts or ends with dot
+  if (local.startsWith('.') || local.endsWith('.')) {
+    result.errors.push('Local part cannot start or end with a dot');
+  }
+
+  // Domain validation
+  if (!domain || domain.length === 0) {
+    result.errors.push('Domain is required');
+  } else {
+    // Check for valid domain format
+    if (domain.includes('..')) {
+      result.errors.push('Domain cannot contain consecutive dots');
+    }
+
+    if (domain.startsWith('.') || domain.endsWith('.')) {
+      result.errors.push('Domain cannot start or end with a dot');
+    }
+
+    if (domain.startsWith('-') || domain.endsWith('-')) {
+      result.errors.push('Domain cannot start or end with a hyphen');
+    }
+
+    // Extract TLD
+    const domainParts = domain.split('.');
+    if (domainParts.length < 2) {
+      result.errors.push('Domain must have at least two parts');
+    } else {
+      const tld = domainParts[domainParts.length - 1];
+      result.tld = tld;
+
+      if (checkTld && tld.length < 2) {
+        result.errors.push('TLD must be at least 2 characters');
+      }
+
+      // Check if TLD contains only letters
+      if (!/^[a-z]+$/i.test(tld)) {
+        result.errors.push('TLD must contain only letters');
+      }
+    }
+  }
+
+  // Regex validation
+  const regex = strict ? EMAIL_REGEX : SIMPLE_EMAIL_REGEX;
+  if (!regex.test(normalizedEmail)) {
+    result.errors.push('Email format is invalid');
+  }
+
+  // Set valid flag
+  result.valid = result.errors.length === 0;
+
+  return result;
+}
+
+/**
+ * Quick validation - returns boolean only
+ * @param {string} email - Email address to validate
+ * @returns {boolean} True if valid
+ */
+function isValidEmail(email) {
+  return validateEmail(email).valid;
+}
+
+/**
+ * Normalize email address
+ * @param {string} email - Email to normalize
+ * @param {object} options - Normalization options
+ * @returns {string} Normalized email
+ */
+function normalizeEmail(email, options = {}) {
+  const {
+    lowercase = true,
+    removePlusAddressing = false,
+    removeDotsFromGmail = false
+  } = options;
+
+  if (!email || typeof email !== 'string') {
+    return null;
+  }
+
+  let normalized = email.trim();
+  
+  if (lowercase) {
+    normalized = normalized.toLowerCase();
+  }
+
+  const atIndex = normalized.lastIndexOf('@');
+  if (atIndex === -1) {
+    return normalized;
+  }
+
+  let local = normalized.substring(0, atIndex);
+  const domain = normalized.substring(atIndex + 1);
+
+  // Remove plus addressing
+  if (removePlusAddressing) {
+    const plusIndex = local.indexOf('+');
+    if (plusIndex !== -1) {
+      local = local.substring(0, plusIndex);
+    }
+  }
+
+  // Remove dots from Gmail local part (Gmail ignores dots)
+  if (removeDotsFromGmail && (domain === 'gmail.com' || domain === 'googlemail.com')) {
+    local = local.replace(/\./g, '');
+  }
+
+  return `${local}@${domain}`;
+}
+
+/**
+ * Extract domain from email
+ * @param {string} email - Email address
+ * @returns {string|null} Domain or null
+ */
+function extractDomain(email) {
+  if (!email || typeof email !== 'string') {
+    return null;
+  }
+
+  const atIndex = email.lastIndexOf('@');
+  if (atIndex === -1) {
+    return null;
+  }
+
+  return email.substring(atIndex + 1).toLowerCase();
+}
+
+/**
+ * Extract local part from email
+ * @param {string} email - Email address
+ * @returns {string|null} Local part or null
+ */
+function extractLocal(email) {
+  if (!email || typeof email !== 'string') {
+    return null;
+  }
+
+  const atIndex = email.lastIndexOf('@');
+  if (atIndex === -1) {
+    return null;
+  }
+
+  return email.substring(0, atIndex).toLowerCase();
+}
+
+module.exports = {
+  validateEmail,
+  isValidEmail,
+  normalizeEmail,
+  extractDomain,
+  extractLocal,
+  EMAIL_REGEX,
+  SIMPLE_EMAIL_REGEX,
+  VALID_TLDS
+};

package/src/validators/mxValidator.js

@@ -0,0 +1,143 @@
+/**
+ * MX Record Validator
+ * Validates email domains using DNS MX record lookups
+ */
+
+const dns = require('dns');
+const { promisify } = require('util');
+
+const resolveMx = promisify(dns.resolveMx);
+const resolve = promisify(dns.resolve);
+
+/**
+ * Check if domain has valid MX records
+ * @param {string} domain - Domain to check
+ * @param {object} options - Options
+ * @returns {Promise<object>} Result with MX records info
+ */
+async function checkMxRecords(domain, options = {}) {
+  const { timeout = 5000 } = options;
+
+  const result = {
+    hasMxRecords: false,
+    domain: domain,
+    mxRecords: [],
+    error: null
+  };
+
+  if (!domain || typeof domain !== 'string') {
+    result.error = 'Invalid domain provided';
+    return result;
+  }
+
+  try {
+    // Create a promise that rejects after timeout
+    const timeoutPromise = new Promise((_, reject) => {
+      setTimeout(() => reject(new Error('DNS lookup timeout')), timeout);
+    });
+
+    // Race between MX lookup and timeout
+    const mxRecords = await Promise.race([
+      resolveMx(domain),
+      timeoutPromise
+    ]);
+
+    if (mxRecords && mxRecords.length > 0) {
+      result.hasMxRecords = true;
+      result.mxRecords = mxRecords
+        .sort((a, b) => a.priority - b.priority)
+        .map(record => ({
+          exchange: record.exchange,
+          priority: record.priority
+        }));
+    }
+  } catch (error) {
+    // MX lookup failed, try A record as fallback
+    try {
+      const aRecords = await Promise.race([
+        resolve(domain, 'A'),
+        new Promise((_, reject) => {
+          setTimeout(() => reject(new Error('DNS lookup timeout')), timeout);
+        })
+      ]);
+
+      if (aRecords && aRecords.length > 0) {
+        result.hasMxRecords = true;
+        result.mxRecords = [{ exchange: domain, priority: 0, type: 'A' }];
+        result.fallbackToA = true;
+      }
+    } catch (aError) {
+      result.error = `DNS lookup failed: ${error.code || error.message}`;
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Validate email with MX record check
+ * @param {string} email - Email to validate
+ * @param {object} options - Options
+ * @returns {Promise<object>} Validation result
+ */
+async function validateEmailMx(email, options = {}) {
+  const { extractDomain } = require('./formatValidator');
+  
+  const result = {
+    valid: false,
+    email: email,
+    domain: null,
+    hasMxRecords: false,
+    mxRecords: [],
+    error: null
+  };
+
+  const domain = extractDomain(email);
+  if (!domain) {
+    result.error = 'Could not extract domain from email';
+    return result;
+  }
+
+  result.domain = domain;
+
+  const mxResult = await checkMxRecords(domain, options);
+  
+  result.hasMxRecords = mxResult.hasMxRecords;
+  result.mxRecords = mxResult.mxRecords;
+  result.error = mxResult.error;
+  result.valid = mxResult.hasMxRecords;
+  result.fallbackToA = mxResult.fallbackToA;
+
+  return result;
+}
+
+/**
+ * Batch check MX records for multiple domains
+ * @param {string[]} domains - Domains to check
+ * @param {object} options - Options
+ * @returns {Promise<object>} Results mapped by domain
+ */
+async function batchCheckMxRecords(domains, options = {}) {
+  const { concurrency = 5 } = options;
+  const results = {};
+
+  // Process in batches to avoid overwhelming DNS
+  for (let i = 0; i < domains.length; i += concurrency) {
+    const batch = domains.slice(i, i + concurrency);
+    const batchResults = await Promise.all(
+      batch.map(domain => checkMxRecords(domain, options))
+    );
+    
+    batch.forEach((domain, index) => {
+      results[domain] = batchResults[index];
+    });
+  }
+
+  return results;
+}
+
+module.exports = {
+  checkMxRecords,
+  validateEmailMx,
+  batchCheckMxRecords
+};