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

package/dist/index.js

@@ -1734,37 +1734,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 {
@@ -1772,41 +1785,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 (!psl.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();
@@ -1814,6 +1841,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,
@@ -1823,20 +1851,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 (!psl.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,
@@ -1864,6 +1899,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) => {
@@ -1872,6 +1908,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,
@@ -1886,6 +1923,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;
   }
 }
@@ -1918,7 +1956,7 @@ async function verifyEmailBatch(params) {
           commonDomains,
           cache
         });
-        if (result.valid) {
+        if (result.validFormat) {
           totalValid++;
         } else {
           totalInvalid++;
@@ -1928,7 +1966,7 @@ async function verifyEmailBatch(params) {
         totalErrors++;
         return {
           email,
-          result: createErrorDetailedResult(email)
+          result: createErrorResult(email)
         };
       }
     });
@@ -1948,18 +1986,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: exports.VerificationErrorCode.SMTP_CONNECTION_FAILED
     }
   };
 }
@@ -2029,26 +2067,25 @@ async function verifyEmail(params) {
   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 = exports.VerificationErrorCode.INVALID_FORMAT;
     if (result.metadata) {
       result.metadata.verificationTime = Date.now() - startTime;
+      result.metadata.error = exports.VerificationErrorCode.INVALID_FORMAT;
     }
     return result;
   }
-  result.format.valid = true;
+  result.validFormat = true;
   if (detectName2) {
     result.detectedName = detectNameFromEmail({
       email: emailAddress,
@@ -2058,64 +2095,67 @@ async function verifyEmail(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 = exports.VerificationErrorCode.INVALID_FORMAT;
     if (result.metadata) {
       result.metadata.verificationTime = Date.now() - startTime;
+      result.metadata.error = exports.VerificationErrorCode.INVALID_FORMAT;
     }
     return result;
   }
   if (!await isValidEmailDomain(domain, params.cache)) {
-    result.domain.error = exports.VerificationErrorCode.INVALID_DOMAIN;
     if (result.metadata) {
       result.metadata.verificationTime = Date.now() - startTime;
+      result.metadata.error = exports.VerificationErrorCode.INVALID_DOMAIN;
     }
     return result;
   }
   if (checkDisposable) {
-    result.disposable = await isDisposableEmail(emailAddress, params.cache);
-    if (result.disposable) {
-      result.valid = false;
-      result.domain.error = exports.VerificationErrorCode.DISPOSABLE_EMAIL;
+    result.isDisposable = await isDisposableEmail(emailAddress, params.cache);
+    if (result.isDisposable && result.metadata) {
+      result.metadata.error = exports.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 = exports.VerificationErrorCode.NO_MX_RECORDS;
+      result.validMx = mxRecords.length > 0;
+      if (!result.validMx && result.metadata) {
+        result.metadata.error = exports.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;
           }
@@ -2143,21 +2183,22 @@ async function verifyEmail(params) {
             retryAttempts: params.retryAttempts
           });
           await smtpCacheInstance.set(cacheKey, smtpResult);
-          result.smtp.valid = smtpResult;
+          result.validSmtp = smtpResult;
         }
-        if (result.smtp.valid === false) {
-          result.smtp.error = exports.VerificationErrorCode.MAILBOX_NOT_FOUND;
-        } else if (result.smtp.valid === null) {
-          result.smtp.error = exports.VerificationErrorCode.SMTP_CONNECTION_FAILED;
+        if (result.validSmtp === false && result.metadata) {
+          result.metadata.error = exports.VerificationErrorCode.MAILBOX_NOT_FOUND;
+        } else if (result.validSmtp === null && result.metadata) {
+          result.metadata.error = exports.VerificationErrorCode.SMTP_CONNECTION_FAILED;
         }
       }
     } catch (err) {
-      log("[verifyEmailDetailed] Failed to resolve MX records", err);
-      result.domain.valid = false;
-      result.domain.error = exports.VerificationErrorCode.NO_MX_RECORDS;
+      log("[verifyEmail] Failed to resolve MX records", err);
+      result.validMx = false;
+      if (result.metadata) {
+        result.metadata.error = exports.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;
   }