@emailcheck/email-validator-js 2.13.1-beta.0 → 2.13.1-beta.2

package/dist/index.esm.js

@@ -1732,37 +1732,50 @@ const WHOIS_SERVERS = {
   ar: "whois.nic.ar",
   cl: "whois.nic.cl"
 };
-function queryWhoisServer(domain, server, timeout = 5e3) {
+function queryWhoisServer(domain, server, timeout = 5e3, debug = false) {
+  const log = debug ? console.debug : (..._args) => {
+  };
   return new Promise((resolve, reject) => {
     const client = new net.Socket();
     let data = "";
+    log(`[whois] querying ${server} for domain ${domain}`);
     const timer = setTimeout(() => {
+      log(`[whois] timeout after ${timeout}ms for ${domain} at ${server}`);
       client.destroy();
       reject(new Error("WHOIS query timeout"));
     }, timeout);
     client.connect(43, server, () => {
+      log(`[whois] connected to ${server}, sending query for ${domain}`);
       client.write(`${domain}\r
 `);
     });
     client.on("data", (chunk) => {
-      data += chunk.toString();
+      const chunkStr = chunk.toString();
+      data += chunkStr;
+      log(`[whois] received ${chunkStr.length} bytes from ${server}`);
     });
     client.on("close", () => {
       clearTimeout(timer);
+      log(`[whois] connection closed, received total ${data.length} bytes from ${server}`);
       resolve(data);
     });
     client.on("error", (err) => {
       clearTimeout(timer);
+      log(`[whois] error querying ${server}: ${err.message}`);
       reject(err);
     });
   });
 }
-async function getWhoisData(domain, timeout = 5e3) {
+async function getWhoisData(domain, timeout = 5e3, debug = false) {
   var _a;
+  const log = debug ? console.debug : (..._args) => {
+  };
   const cacheKey = `whois:${domain}`;
   const cache = whoisCacheStore();
+  log(`[whois] getting WHOIS data for ${domain}`);
   const cached = await cache.get(cacheKey);
   if (cached !== null && cached !== void 0) {
+    log(`[whois] using cached data for ${domain}`);
     return cached;
   }
   try {
@@ -1770,41 +1783,55 @@ async function getWhoisData(domain, timeout = 5e3) {
     if (!tld) {
       throw new Error("Invalid domain");
     }
+    log(`[whois] extracted TLD: ${tld} for domain: ${domain}`);
     const whoisServer = WHOIS_SERVERS[tld];
     if (!whoisServer) {
+      log(`[whois] no specific server for TLD ${tld}, trying IANA`);
       const defaultServer = "whois.iana.org";
-      const ianaResponse = await queryWhoisServer(domain, defaultServer, timeout);
+      const ianaResponse = await queryWhoisServer(domain, defaultServer, timeout, debug);
       const referMatch = ianaResponse.match(/refer:\s+(\S+)/i);
       if (referMatch === null || referMatch === void 0 ? void 0 : referMatch[1]) {
         const referredServer = referMatch[1];
-        const whoisResponse2 = await queryWhoisServer(domain, referredServer, timeout);
+        log(`[whois] IANA referred to ${referredServer} for ${domain}`);
+        const whoisResponse2 = await queryWhoisServer(domain, referredServer, timeout, debug);
         const whoisData3 = parseWhoisData({ rawData: whoisResponse2, domain });
         await cache.set(cacheKey, whoisData3);
+        log(`[whois] successfully retrieved and cached WHOIS data from referred server for ${domain}`);
         return whoisData3;
       }
       const whoisData2 = parseWhoisData({ rawData: ianaResponse, domain });
       await cache.set(cacheKey, whoisData2);
+      log(`[whois] successfully retrieved and cached WHOIS data from IANA for ${domain}`);
       return whoisData2;
     }
-    const whoisResponse = await queryWhoisServer(domain, whoisServer, timeout);
+    log(`[whois] using WHOIS server ${whoisServer} for TLD ${tld}`);
+    const whoisResponse = await queryWhoisServer(domain, whoisServer, timeout, debug);
     const whoisData = parseWhoisData({ rawData: whoisResponse, domain });
     await cache.set(cacheKey, whoisData);
+    log(`[whois] successfully retrieved and cached WHOIS data for ${domain}`);
     return whoisData;
   } catch (_error) {
+    log(`[whois] failed to get WHOIS data for ${domain}: ${_error instanceof Error ? _error.message : "Unknown error"}`);
     return null;
   }
 }
-async function getDomainAge(domain, timeout = 5e3) {
+async function getDomainAge(domain, timeout = 5e3, debug = false) {
+  const log = debug ? console.debug : (..._args) => {
+  };
   try {
     const cleanDomain = domain.replace(/^https?:\/\//, "").split("/")[0].split("@").pop();
     if (!cleanDomain) {
+      log(`[whois] invalid domain format: ${domain}`);
       return null;
     }
+    log(`[whois] checking domain age for ${cleanDomain}`);
     if (!isValid(cleanDomain)) {
+      log(`[whois] domain validation failed: ${cleanDomain}`);
       return null;
     }
-    const whoisData = await getWhoisData(cleanDomain, timeout);
+    const whoisData = await getWhoisData(cleanDomain, timeout, debug);
     if (!whoisData || !whoisData.creationDate) {
+      log(`[whois] no creation date found for ${cleanDomain}`);
       return null;
     }
     const now = /* @__PURE__ */ new Date();
@@ -1812,6 +1839,7 @@ async function getDomainAge(domain, timeout = 5e3) {
     const ageInMilliseconds = now.getTime() - creationDate.getTime();
     const ageInDays = Math.floor(ageInMilliseconds / (1e3 * 60 * 60 * 24));
     const ageInYears = ageInDays / 365.25;
+    log(`[whois] calculated age for ${cleanDomain}: ${ageInDays} days (${ageInYears.toFixed(2)} years)`);
     return {
       domain: cleanDomain,
       creationDate,
@@ -1821,20 +1849,27 @@ async function getDomainAge(domain, timeout = 5e3) {
       updatedDate: whoisData.updatedDate ? new Date(whoisData.updatedDate) : null
     };
   } catch (_error) {
+    log(`[whois] error getting domain age for ${domain}: ${_error instanceof Error ? _error.message : "Unknown error"}`);
     return null;
   }
 }
-async function getDomainRegistrationStatus(domain, timeout = 5e3) {
+async function getDomainRegistrationStatus(domain, timeout = 5e3, debug = false) {
+  const log = debug ? console.debug : (..._args) => {
+  };
   try {
     const cleanDomain = domain.replace(/^https?:\/\//, "").split("/")[0].split("@").pop();
     if (!cleanDomain) {
+      log(`[whois] invalid domain format: ${domain}`);
       return null;
     }
+    log(`[whois] checking domain registration status for ${cleanDomain}`);
     if (!isValid(cleanDomain)) {
+      log(`[whois] domain validation failed: ${cleanDomain}`);
       return null;
     }
-    const whoisData = await getWhoisData(cleanDomain, timeout);
+    const whoisData = await getWhoisData(cleanDomain, timeout, debug);
     if (!whoisData || whoisData.isAvailable) {
+      log(`[whois] domain ${cleanDomain} is available or not registered`);
       return {
         domain: cleanDomain,
         isRegistered: false,
@@ -1862,6 +1897,7 @@ async function getDomainRegistrationStatus(domain, timeout = 5e3) {
       if (!isExpired) {
         daysUntilExpiration = Math.floor((expirationTime - currentTime) / (1e3 * 60 * 60 * 24));
       }
+      log(`[whois] domain ${cleanDomain} expires in ${daysUntilExpiration} days`);
     }
     const statusList = whoisData.status || [];
     const formattedStatusList = statusList.map((s) => {
@@ -1870,6 +1906,7 @@ async function getDomainRegistrationStatus(domain, timeout = 5e3) {
     });
     const isPendingDelete = formattedStatusList.some((s) => s.toLowerCase().includes("pendingdelete") || s.toLowerCase().includes("redemption"));
     const isLocked = formattedStatusList.some((s) => s.toLowerCase().includes("clienttransferprohibited") || s.toLowerCase().includes("servertransferprohibited"));
+    log(`[whois] domain ${cleanDomain} - registered: ${isRegistered}, expired: ${isExpired}, locked: ${isLocked}, pending delete: ${isPendingDelete}`);
     return {
       domain: cleanDomain,
       isRegistered,
@@ -1884,6 +1921,7 @@ async function getDomainRegistrationStatus(domain, timeout = 5e3) {
       isLocked
     };
   } catch (_error) {
+    log(`[whois] error getting domain registration status for ${domain}: ${_error instanceof Error ? _error.message : "Unknown error"}`);
     return null;
   }
 }
@@ -1902,7 +1940,7 @@ async function verifyEmailBatch(params) {
   for (const batch of batches) {
     const batchPromises = batch.map(async (email) => {
       try {
-        const result = await verifyEmailDetailed({
+        const result = await verifyEmail({
           emailAddress: email,
           timeout,
           verifyMx,
@@ -1916,7 +1954,7 @@ async function verifyEmailBatch(params) {
           commonDomains,
           cache
         });
-        if (result.valid) {
+        if (result.validFormat) {
           totalValid++;
         } else {
           totalInvalid++;
@@ -1926,7 +1964,7 @@ async function verifyEmailBatch(params) {
         totalErrors++;
         return {
           email,
-          result: createErrorDetailedResult(email)
+          result: createErrorResult(email)
         };
       }
     });
@@ -1946,18 +1984,18 @@ async function verifyEmailBatch(params) {
     }
   };
 }
-function createErrorDetailedResult(email, _error) {
+function createErrorResult(email, _error) {
   return {
-    valid: false,
     email,
-    format: { valid: false },
-    domain: { valid: null },
-    smtp: { valid: null },
-    disposable: false,
-    freeProvider: false,
+    validFormat: false,
+    validMx: null,
+    validSmtp: null,
+    isDisposable: false,
+    isFree: false,
     metadata: {
       verificationTime: 0,
-      cached: false
+      cached: false,
+      error: VerificationErrorCode.SMTP_CONNECTION_FAILED
     }
   };
 }
@@ -2022,129 +2060,30 @@ const domainPorts = {
   "ovh.net": 465
 };
 async function verifyEmail(params) {
-  const { emailAddress, timeout = 4e3, verifyMx = false, verifySmtp = false, debug = false, detectName: detectName2 = false, nameDetectionMethod, suggestDomain: suggestDomain2 = false, domainSuggestionMethod, commonDomains, checkDomainAge = false, checkDomainRegistration = false, whoisTimeout = 5e3 } = params;
-  const result = { validFormat: false, validMx: null, validSmtp: null };
-  const log = debug ? console.debug : (..._args) => {
-  };
-  let mxRecords;
-  if (!isValidEmail(emailAddress)) {
-    log("[verifyEmail] Failed on wellFormed check");
-    return result;
-  }
-  const [local, domain] = emailAddress.split("@");
-  if (!domain || !local) {
-    log("[verifyEmail] Failed on wellFormed check");
-    return result;
-  }
-  result.validFormat = true;
-  if (detectName2) {
-    result.detectedName = detectNameFromEmail({
-      email: emailAddress,
-      customMethod: nameDetectionMethod
-    });
-  }
-  if (suggestDomain2) {
-    const [, emailDomain] = emailAddress.split("@");
-    if (emailDomain) {
-      result.domainSuggestion = domainSuggestionMethod ? domainSuggestionMethod(emailDomain) : await suggestEmailDomain(emailAddress, commonDomains);
-    }
-  }
-  if (checkDomainAge) {
-    try {
-      result.domainAge = await getDomainAge(domain, whoisTimeout);
-    } catch (err) {
-      log("[verifyEmail] Failed to get domain age", err);
-      result.domainAge = null;
-    }
-  }
-  if (checkDomainRegistration) {
-    try {
-      result.domainRegistration = await getDomainRegistrationStatus(domain, whoisTimeout);
-    } catch (err) {
-      log("[verifyEmail] Failed to get domain registration status", err);
-      result.domainRegistration = null;
-    }
-  }
-  if (!verifyMx && !verifySmtp)
-    return result;
-  try {
-    mxRecords = await resolveMxRecords(domain, params.cache);
-    log("[verifyEmail] Found MX records", mxRecords);
-  } catch (err) {
-    log("[verifyEmail] Failed to resolve MX records", err);
-    mxRecords = [];
-  }
-  if (verifyMx || verifySmtp) {
-    result.validMx = mxRecords && mxRecords.length > 0;
-  }
-  if (verifySmtp && !(mxRecords === null || mxRecords === void 0 ? void 0 : mxRecords.length)) {
-    result.validSmtp = false;
-  }
-  if (verifySmtp && (mxRecords === null || mxRecords === void 0 ? void 0 : mxRecords.length) > 0) {
-    const cacheKey = `${emailAddress}:smtp`;
-    const smtpCacheInstance = smtpCacheStore(params.cache);
-    const cachedSmtp = await smtpCacheInstance.get(cacheKey);
-    if (cachedSmtp !== null && cachedSmtp !== void 0) {
-      result.validSmtp = cachedSmtp;
-      if (detectName2 && !result.detectedName) {
-        result.detectedName = detectNameFromEmail({
-          email: emailAddress,
-          customMethod: nameDetectionMethod
-        });
-      }
-      return result;
-    }
-    let domainPort = params.smtpPort;
-    if (!domainPort) {
-      const mxDomain = parse(mxRecords[0]);
-      if ("domain" in mxDomain && mxDomain.domain) {
-        domainPort = domainPorts[mxDomain.domain];
-        log(`[verifyEmail] Found mxDomain ${mxDomain.domain} with port ${domainPort}`);
-      }
-      if ("error" in mxDomain) {
-        log(`[verifyEmail] Failed to parse mxDomain ${mxDomain.error}`);
-      }
-    }
-    const smtpResult = await verifyMailboxSMTP({
-      local,
-      domain,
-      mxRecords,
-      timeout,
-      debug,
-      port: domainPort,
-      retryAttempts: params.retryAttempts
-    });
-    await smtpCacheInstance.set(cacheKey, smtpResult);
-    result.validSmtp = smtpResult;
-  }
-  return result;
-}
-async function verifyEmailDetailed(params) {
   const { emailAddress, timeout = 4e3, verifyMx = true, verifySmtp = false, debug = false, checkDisposable = true, checkFree = true, detectName: detectName2 = false, nameDetectionMethod, suggestDomain: suggestDomain2 = true, domainSuggestionMethod, commonDomains, checkDomainAge = false, checkDomainRegistration = false, whoisTimeout = 5e3 } = params;
   const startTime = Date.now();
   const log = debug ? console.debug : (..._args) => {
   };
   const result = {
-    valid: false,
     email: emailAddress,
-    format: { valid: false },
-    domain: { valid: null },
-    smtp: { valid: null },
-    disposable: false,
-    freeProvider: false,
+    validFormat: false,
+    validMx: null,
+    validSmtp: null,
+    isDisposable: false,
+    isFree: false,
     metadata: {
       verificationTime: 0,
       cached: false
     }
   };
   if (!isValidEmail(emailAddress)) {
-    result.format.error = VerificationErrorCode.INVALID_FORMAT;
     if (result.metadata) {
       result.metadata.verificationTime = Date.now() - startTime;
+      result.metadata.error = VerificationErrorCode.INVALID_FORMAT;
     }
     return result;
   }
-  result.format.valid = true;
+  result.validFormat = true;
   if (detectName2) {
     result.detectedName = detectNameFromEmail({
       email: emailAddress,
@@ -2154,64 +2093,67 @@ async function verifyEmailDetailed(params) {
   if (suggestDomain2) {
     const [, emailDomain] = emailAddress.split("@");
     if (emailDomain) {
-      result.domainSuggestion = domainSuggestionMethod ? domainSuggestionMethod(emailDomain) : await suggestEmailDomain(emailAddress, commonDomains);
+      const suggestion = domainSuggestionMethod ? domainSuggestionMethod(emailDomain) : await suggestEmailDomain(emailAddress, commonDomains);
+      if (suggestion) {
+        result.domainSuggestion = suggestion;
+      } else {
+        result.domainSuggestion = null;
+      }
     }
   }
   const [local, domain] = emailAddress.split("@");
   if (!domain || !local) {
-    result.format.error = VerificationErrorCode.INVALID_FORMAT;
     if (result.metadata) {
       result.metadata.verificationTime = Date.now() - startTime;
+      result.metadata.error = VerificationErrorCode.INVALID_FORMAT;
     }
     return result;
   }
   if (!await isValidEmailDomain(domain, params.cache)) {
-    result.domain.error = VerificationErrorCode.INVALID_DOMAIN;
     if (result.metadata) {
       result.metadata.verificationTime = Date.now() - startTime;
+      result.metadata.error = VerificationErrorCode.INVALID_DOMAIN;
     }
     return result;
   }
   if (checkDisposable) {
-    result.disposable = await isDisposableEmail(emailAddress, params.cache);
-    if (result.disposable) {
-      result.valid = false;
-      result.domain.error = VerificationErrorCode.DISPOSABLE_EMAIL;
+    result.isDisposable = await isDisposableEmail(emailAddress, params.cache);
+    if (result.isDisposable && result.metadata) {
+      result.metadata.error = VerificationErrorCode.DISPOSABLE_EMAIL;
     }
   }
   if (checkFree) {
-    result.freeProvider = await isFreeEmail(emailAddress, params.cache);
+    result.isFree = await isFreeEmail(emailAddress, params.cache);
   }
   if (checkDomainAge) {
     try {
-      result.domainAge = await getDomainAge(domain, whoisTimeout);
+      result.domainAge = await getDomainAge(domain, whoisTimeout, debug);
     } catch (err) {
-      log("[verifyEmailDetailed] Failed to get domain age", err);
+      log("[verifyEmail] Failed to get domain age", err);
       result.domainAge = null;
     }
   }
   if (checkDomainRegistration) {
     try {
-      result.domainRegistration = await getDomainRegistrationStatus(domain, whoisTimeout);
+      result.domainRegistration = await getDomainRegistrationStatus(domain, whoisTimeout, debug);
     } catch (err) {
-      log("[verifyEmailDetailed] Failed to get domain registration status", err);
+      log("[verifyEmail] Failed to get domain registration status", err);
       result.domainRegistration = null;
     }
   }
   if (verifyMx || verifySmtp) {
     try {
       const mxRecords = await resolveMxRecords(domain, params.cache);
-      result.domain.mxRecords = mxRecords;
-      result.domain.valid = mxRecords.length > 0;
-      if (!result.domain.valid) {
-        result.domain.error = VerificationErrorCode.NO_MX_RECORDS;
+      result.validMx = mxRecords.length > 0;
+      if (!result.validMx && result.metadata) {
+        result.metadata.error = VerificationErrorCode.NO_MX_RECORDS;
       }
       if (verifySmtp && mxRecords.length > 0) {
         const cacheKey = `${emailAddress}:smtp`;
         const smtpCacheInstance = smtpCacheStore(params.cache);
         const cachedSmtp = await smtpCacheInstance.get(cacheKey);
         if (cachedSmtp !== null && cachedSmtp !== void 0) {
-          result.smtp.valid = cachedSmtp;
+          result.validSmtp = cachedSmtp;
           if (result.metadata) {
             result.metadata.cached = true;
           }
@@ -2239,26 +2181,27 @@ async function verifyEmailDetailed(params) {
             retryAttempts: params.retryAttempts
           });
           await smtpCacheInstance.set(cacheKey, smtpResult);
-          result.smtp.valid = smtpResult;
+          result.validSmtp = smtpResult;
         }
-        if (result.smtp.valid === false) {
-          result.smtp.error = VerificationErrorCode.MAILBOX_NOT_FOUND;
-        } else if (result.smtp.valid === null) {
-          result.smtp.error = VerificationErrorCode.SMTP_CONNECTION_FAILED;
+        if (result.validSmtp === false && result.metadata) {
+          result.metadata.error = VerificationErrorCode.MAILBOX_NOT_FOUND;
+        } else if (result.validSmtp === null && result.metadata) {
+          result.metadata.error = VerificationErrorCode.SMTP_CONNECTION_FAILED;
         }
       }
     } catch (err) {
-      log("[verifyEmailDetailed] Failed to resolve MX records", err);
-      result.domain.valid = false;
-      result.domain.error = VerificationErrorCode.NO_MX_RECORDS;
+      log("[verifyEmail] Failed to resolve MX records", err);
+      result.validMx = false;
+      if (result.metadata) {
+        result.metadata.error = VerificationErrorCode.NO_MX_RECORDS;
+      }
     }
   }
-  result.valid = result.format.valid && result.domain.valid !== false && result.smtp.valid !== false && !result.disposable;
   if (result.metadata) {
     result.metadata.verificationTime = Date.now() - startTime;
   }
   return result;
 }
 
-export { COMMON_EMAIL_DOMAINS, VerificationErrorCode, clearAllCaches, defaultDomainSuggestionMethod, defaultNameDetectionMethod, detectName, detectNameFromEmail, domainPorts, getDomainAge, getDomainRegistrationStatus, getDomainSimilarity, isCommonDomain, isDisposableEmail, isFreeEmail, isValidEmail, isValidEmailDomain, suggestDomain, suggestEmailDomain, verifyEmail, verifyEmailBatch, verifyEmailDetailed };
+export { COMMON_EMAIL_DOMAINS, VerificationErrorCode, clearAllCaches, defaultDomainSuggestionMethod, defaultNameDetectionMethod, detectName, detectNameFromEmail, domainPorts, getDomainAge, getDomainRegistrationStatus, getDomainSimilarity, isCommonDomain, isDisposableEmail, isFreeEmail, isValidEmail, isValidEmailDomain, suggestDomain, suggestEmailDomain, verifyEmail, verifyEmailBatch };
 //# sourceMappingURL=index.esm.js.map