@emailcheck/email-validator-js 2.13.1-beta.3 → 2.13.1-beta.5

package/dist/dns.d.ts

@@ -1,2 +1,2 @@
-import type { ICache } from './cache-interface';
-export declare function resolveMxRecords(domain: string, cache?: ICache | null): Promise<string[]>;
+import type { IResolveMxParams } from './types';
+export declare function resolveMxRecords(params: IResolveMxParams): Promise<string[]>;

package/dist/index.d.ts

@@ -1,5 +1,6 @@
-import type { ICache } from './cache-interface';
-import { type IVerifyEmailParams, type VerificationResult } from './types';
+import { type IDisposableEmailParams, type IFreeEmailParams, type IVerifyEmailParams, type VerificationResult } from './types';
+export * from './adapters/lru-adapter';
+export * from './adapters/redis-adapter';
 export { verifyEmailBatch } from './batch';
 export { clearAllCaches } from './cache';
 export { COMMON_EMAIL_DOMAINS, defaultDomainSuggestionMethod, getDomainSimilarity, isCommonDomain, suggestDomain, suggestEmailDomain, } from './domain-suggester';
@@ -7,8 +8,8 @@ export { defaultNameDetectionMethod, detectName, detectNameFromEmail } from './n
 export * from './types';
 export { isValidEmail, isValidEmailDomain } from './validator';
 export { getDomainAge, getDomainRegistrationStatus } from './whois';
-export declare function isDisposableEmail(emailOrDomain: string, cache?: ICache | null): Promise<boolean>;
-export declare function isFreeEmail(emailOrDomain: string, cache?: ICache | null): Promise<boolean>;
+export declare function isDisposableEmail(params: IDisposableEmailParams): Promise<boolean>;
+export declare function isFreeEmail(params: IFreeEmailParams): Promise<boolean>;
 export declare const domainPorts: Record<string, number>;
 /**
  * Verify email address

package/dist/index.esm.js

@@ -96,12 +96,17 @@ function clearAllCaches() {
   whoisCache.clear();
 }
 
-async function resolveMxRecords(domain, cache) {
+async function resolveMxRecords(params) {
+  const { domain, cache, logger } = params;
+  const log = logger || (() => {
+  });
   const cacheStore = mxCacheStore(cache);
   const cached = await cacheStore.get(domain);
   if (cached !== null && cached !== void 0) {
+    log(`[resolveMxRecords] Cache hit for ${domain}: ${cached.length} MX records`);
     return cached;
   }
+  log(`[resolveMxRecords] Performing DNS MX lookup for ${domain}`);
   try {
     const records = await promises.resolveMx(domain);
     records.sort((a, b) => {
@@ -114,9 +119,12 @@ async function resolveMxRecords(domain, cache) {
       return 0;
     });
     const exchanges = records.map((record) => record.exchange);
+    log(`[resolveMxRecords] Found ${exchanges.length} MX records for ${domain}: [${exchanges.join(", ")}]`);
     await cacheStore.set(domain, exchanges);
+    log(`[resolveMxRecords] Cached ${exchanges.length} MX records for ${domain}`);
     return exchanges;
   } catch (error) {
+    log(`[resolveMxRecords] MX lookup failed for ${domain}, caching empty result`);
     await cacheStore.set(domain, []);
     throw error;
   }
@@ -1926,6 +1934,106 @@ async function getDomainRegistrationStatus(domain, timeout = 5e3, debug = false)
   }
 }
 
+class RedisAdapter {
+  constructor(redis, options = {}) {
+    this.redis = redis;
+    this.keyPrefix = options.keyPrefix || "email_validator:";
+    this.defaultTtlMs = options.defaultTtlMs || 36e5;
+    this.jsonSerializer = options.jsonSerializer || {
+      stringify: (value) => {
+        const processed = this.processDatesForSerialization(value);
+        return JSON.stringify(processed);
+      },
+      parse: (value) => JSON.parse(value, (key, v) => {
+        if (v && typeof v === "object" && v.__type === "Date") {
+          return new Date(v.value);
+        }
+        return v;
+      })
+    };
+  }
+  getKey(key) {
+    return `${this.keyPrefix}${key}`;
+  }
+  /**
+   * Recursively process an object to convert Date instances to a serializable format
+   */
+  processDatesForSerialization(obj) {
+    if (obj instanceof Date) {
+      return { __type: "Date", value: obj.toISOString() };
+    }
+    if (obj && typeof obj === "object") {
+      if (Array.isArray(obj)) {
+        return obj.map((item) => this.processDatesForSerialization(item));
+      }
+      const result = {};
+      for (const [key, value] of Object.entries(obj)) {
+        result[key] = this.processDatesForSerialization(value);
+      }
+      return result;
+    }
+    return obj;
+  }
+  async get(key) {
+    try {
+      const value = await this.redis.get(this.getKey(key));
+      if (value === null) {
+        return null;
+      }
+      return this.jsonSerializer.parse(value);
+    } catch (error) {
+      console.error("Redis get error:", error);
+      return null;
+    }
+  }
+  async set(key, value, ttlMs) {
+    try {
+      const serializedValue = this.jsonSerializer.stringify(value);
+      const ttl = ttlMs || this.defaultTtlMs;
+      const ttlSeconds = Math.ceil(ttl / 1e3);
+      await this.redis.set(this.getKey(key), serializedValue, "EX", ttlSeconds);
+    } catch (error) {
+      console.error("Redis set error:", error);
+    }
+  }
+  async delete(key) {
+    try {
+      const result = await this.redis.del(this.getKey(key));
+      return result > 0;
+    } catch (error) {
+      console.error("Redis delete error:", error);
+      return false;
+    }
+  }
+  async has(key) {
+    try {
+      const result = await this.redis.exists(this.getKey(key));
+      return result > 0;
+    } catch (error) {
+      console.error("Redis exists error:", error);
+      return false;
+    }
+  }
+  async clear() {
+    try {
+      await this.redis.flushdb();
+    } catch (error) {
+      console.error("Redis clear error:", error);
+    }
+  }
+  // size() is not applicable for Redis as it's a distributed store
+  size() {
+    return void 0;
+  }
+  /**
+   * Helper method to delete only keys with the configured prefix
+   * Requires Redis SCAN command which might not be available in all Redis clients
+   */
+  async clearPrefixed() {
+    console.warn("clearPrefixed not implemented. Use clear() to flush the entire database.");
+  }
+}
+
 async function verifyEmailBatch(params) {
   const { emailAddresses, concurrency = 5, timeout = 4e3, verifyMx = true, verifySmtp = false, checkDisposable = true, checkFree = true, detectName = false, nameDetectionMethod, suggestDomain = false, domainSuggestionMethod, commonDomains, skipMxForDisposable = false, skipDomainWhoisForDisposable = false, cache } = params;
   const startTime = Date.now();
@@ -2004,7 +2112,10 @@ function createErrorResult(email, _error) {
 
 let disposableEmailProviders;
 let freeEmailProviders;
-async function isDisposableEmail(emailOrDomain, cache) {
+async function isDisposableEmail(params) {
+  const { emailOrDomain, cache, logger } = params;
+  const log = logger || (() => {
+  });
   const parts = emailOrDomain.split("@");
   const emailDomain = parts.length > 1 ? parts[1] : parts[0];
   if (!emailDomain) {
@@ -2018,6 +2129,7 @@ async function isDisposableEmail(emailOrDomain, cache) {
     cached = null;
   }
   if (cached !== null && cached !== void 0) {
+    log(`[isDisposableEmail] Cache hit for ${emailDomain}: ${cached}`);
     return cached;
   }
   if (!disposableEmailProviders) {
@@ -2026,11 +2138,17 @@ async function isDisposableEmail(emailOrDomain, cache) {
   const result = disposableEmailProviders.has(emailDomain);
   try {
     await cacheStore.set(emailDomain, result);
+    log(`[isDisposableEmail] Cached result for ${emailDomain}: ${result}`);
   } catch (_error) {
+    log(`[isDisposableEmail] Cache write error for ${emailDomain}`);
   }
+  log(`[isDisposableEmail] Check result for ${emailDomain}: ${result}`);
   return result;
 }
-async function isFreeEmail(emailOrDomain, cache) {
+async function isFreeEmail(params) {
+  const { emailOrDomain, cache, logger } = params;
+  const log = logger || (() => {
+  });
   const parts = emailOrDomain.split("@");
   const emailDomain = parts.length > 1 ? parts[1] : parts[0];
   if (!emailDomain) {
@@ -2044,6 +2162,7 @@ async function isFreeEmail(emailOrDomain, cache) {
     cached = null;
   }
   if (cached !== null && cached !== void 0) {
+    log(`[isFreeEmail] Cache hit for ${emailDomain}: ${cached}`);
     return cached;
   }
   if (!freeEmailProviders) {
@@ -2052,8 +2171,11 @@ async function isFreeEmail(emailOrDomain, cache) {
   const result = freeEmailProviders.has(emailDomain);
   try {
     await cacheStore.set(emailDomain, result);
+    log(`[isFreeEmail] Cached result for ${emailDomain}: ${result}`);
   } catch (_error) {
+    log(`[isFreeEmail] Cache write error for ${emailDomain}`);
   }
+  log(`[isFreeEmail] Check result for ${emailDomain}: ${result}`);
   return result;
 }
 const domainPorts = {
@@ -2062,6 +2184,7 @@ const domainPorts = {
   "ovh.net": 465
 };
 async function verifyEmail(params) {
+  var _a;
   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, skipMxForDisposable = false, skipDomainWhoisForDisposable = false } = params;
   const startTime = Date.now();
   const log = debug ? console.debug : (..._args) => {
@@ -2119,36 +2242,56 @@ async function verifyEmail(params) {
     return result;
   }
   if (checkDisposable) {
-    result.isDisposable = await isDisposableEmail(emailAddress, params.cache);
+    log(`[verifyEmail] Checking if ${emailAddress} is disposable email`);
+    result.isDisposable = await isDisposableEmail({ emailOrDomain: emailAddress, cache: params.cache, logger: log });
+    log(`[verifyEmail] Disposable check result: ${result.isDisposable}`);
     if (result.isDisposable && result.metadata) {
       result.metadata.error = VerificationErrorCode.DISPOSABLE_EMAIL;
     }
   }
   if (checkFree) {
-    result.isFree = await isFreeEmail(emailAddress, params.cache);
+    log(`[verifyEmail] Checking if ${emailAddress} is free email provider`);
+    result.isFree = await isFreeEmail({ emailOrDomain: emailAddress, cache: params.cache, logger: log });
+    log(`[verifyEmail] Free email check result: ${result.isFree}`);
   }
   const shouldSkipMx = skipMxForDisposable && result.isDisposable;
   const shouldSkipDomainWhois = skipDomainWhoisForDisposable && result.isDisposable;
+  if (shouldSkipMx) {
+    log(`[verifyEmail] Skipping MX record check for disposable email: ${emailAddress}`);
+  }
+  if (shouldSkipDomainWhois) {
+    log(`[verifyEmail] Skipping domain WHOIS checks for disposable email: ${emailAddress}`);
+  }
   if (checkDomainAge && !shouldSkipDomainWhois) {
+    log(`[verifyEmail] Checking domain age for ${domain}`);
     try {
       result.domainAge = await getDomainAge(domain, whoisTimeout, debug);
+      log(`[verifyEmail] Domain age result:`, result.domainAge ? `${result.domainAge.ageInDays} days` : "null");
     } catch (err) {
       log("[verifyEmail] Failed to get domain age", err);
       result.domainAge = null;
     }
+  } else if (checkDomainAge && shouldSkipDomainWhois) {
+    log(`[verifyEmail] Domain age check skipped due to disposable email and skipDomainWhoisForDisposable=true`);
   }
   if (checkDomainRegistration && !shouldSkipDomainWhois) {
+    log(`[verifyEmail] Checking domain registration status for ${domain}`);
     try {
       result.domainRegistration = await getDomainRegistrationStatus(domain, whoisTimeout, debug);
+      log(`[verifyEmail] Domain registration result:`, ((_a = result.domainRegistration) === null || _a === void 0 ? void 0 : _a.isRegistered) ? "registered" : "not registered");
     } catch (err) {
       log("[verifyEmail] Failed to get domain registration status", err);
       result.domainRegistration = null;
     }
+  } else if (checkDomainRegistration && shouldSkipDomainWhois) {
+    log(`[verifyEmail] Domain registration check skipped due to disposable email and skipDomainWhoisForDisposable=true`);
   }
   if ((verifyMx || verifySmtp) && !shouldSkipMx) {
+    log(`[verifyEmail] Checking MX records for ${domain}`);
     try {
-      const mxRecords = await resolveMxRecords(domain, params.cache);
+      const mxRecords = await resolveMxRecords({ domain, cache: params.cache, logger: log });
       result.validMx = mxRecords.length > 0;
+      log(`[verifyEmail] MX records found: ${mxRecords.length}, valid: ${result.validMx}`);
       if (!result.validMx && result.metadata) {
         result.metadata.error = VerificationErrorCode.NO_MX_RECORDS;
       }
@@ -2158,6 +2301,7 @@ async function verifyEmail(params) {
         const cachedSmtp = await smtpCacheInstance.get(cacheKey);
         if (cachedSmtp !== null && cachedSmtp !== void 0) {
           result.validSmtp = cachedSmtp;
+          log(`[verifyEmail] SMTP result from cache: ${result.validSmtp} for ${emailAddress}`);
           if (result.metadata) {
             result.metadata.cached = true;
           }
@@ -2168,6 +2312,7 @@ async function verifyEmail(params) {
             });
           }
         } else {
+          log(`[verifyEmail] Performing SMTP verification for ${emailAddress}`);
           let domainPort = params.smtpPort;
           if (!domainPort) {
             const mxDomain = parse(mxRecords[0]);
@@ -2186,6 +2331,7 @@ async function verifyEmail(params) {
           });
           await smtpCacheInstance.set(cacheKey, smtpResult);
           result.validSmtp = smtpResult;
+          log(`[verifyEmail] SMTP verification result: ${result.validSmtp} for ${emailAddress} (cached for future use)`);
         }
         if (result.validSmtp === false && result.metadata) {
           result.metadata.error = VerificationErrorCode.MAILBOX_NOT_FOUND;
@@ -2200,6 +2346,8 @@ async function verifyEmail(params) {
         result.metadata.error = VerificationErrorCode.NO_MX_RECORDS;
       }
     }
+  } else if ((verifyMx || verifySmtp) && shouldSkipMx) {
+    log(`[verifyEmail] MX/SMTP checks skipped due to disposable email and skipMxForDisposable=true`);
   }
   if (result.metadata) {
     result.metadata.verificationTime = Date.now() - startTime;
@@ -2207,5 +2355,5 @@ async function verifyEmail(params) {
   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 };
+export { COMMON_EMAIL_DOMAINS, LRUAdapter, RedisAdapter, VerificationErrorCode, clearAllCaches, defaultDomainSuggestionMethod, defaultNameDetectionMethod, detectName, detectNameFromEmail, domainPorts, getDomainAge, getDomainRegistrationStatus, getDomainSimilarity, isCommonDomain, isDisposableEmail, isFreeEmail, isValidEmail, isValidEmailDomain, suggestDomain, suggestEmailDomain, verifyEmail, verifyEmailBatch };
 //# sourceMappingURL=index.esm.js.map