linkedin-secret-sauce 0.12.1 → 0.12.3

package/dist/enrichment/providers/ldd.js

@@ -10,87 +10,14 @@
  * while usernames can be changed by users at any time.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.extractNumericLinkedInId = extractNumericLinkedInId;
+exports.extractNumericLinkedInId = void 0;
 exports.createLddProvider = createLddProvider;
-const validation_1 = require("../utils/validation");
 const http_retry_1 = require("../utils/http-retry");
-/**
- * Extract numeric LinkedIn ID from various formats:
- * - Direct number: "307567"
- * - URN format: "urn:li:member:307567"
- * - Full URN: "urn:li:fs_salesProfile:(ACwAAAAEsW8B...,NAME_SEARCH,PJOV)"
- * - objectUrn: "urn:li:member:307567"
- *
- * Returns the numeric ID as a string, or null if not found.
- */
-function extractNumericLinkedInId(input) {
-    if (!input)
-        return null;
-    const trimmed = input.trim();
-    // Direct numeric ID
-    if (/^\d+$/.test(trimmed)) {
-        return trimmed;
-    }
-    // URN format: urn:li:member:307567
-    const memberMatch = trimmed.match(/urn:li:member:(\d+)/i);
-    if (memberMatch) {
-        return memberMatch[1];
-    }
-    // Sales profile URN with numeric ID
-    const salesMatch = trimmed.match(/urn:li:fs_salesProfile:\((\d+),/i);
-    if (salesMatch) {
-        return salesMatch[1];
-    }
-    return null;
-}
-/**
- * Extract LinkedIn username from candidate
- */
-function extractUsername(candidate) {
-    // Direct username
-    const directUsername = candidate.linkedinUsername || candidate.linkedin_username;
-    if (directUsername)
-        return directUsername;
-    // Extract from URL
-    const url = candidate.linkedinUrl || candidate.linkedin_url;
-    if (url) {
-        const extracted = (0, validation_1.extractLinkedInUsername)(url);
-        if (extracted)
-            return extracted;
-    }
-    return null;
-}
-/**
- * Extract numeric LinkedIn ID from candidate.
- * Checks multiple fields in order of preference:
- * 1. numericLinkedInId / numeric_linkedin_id (direct numeric ID)
- * 2. objectUrn / object_urn (URN format like "urn:li:member:307567")
- * 3. linkedinId / linkedin_id (may contain URN or numeric ID)
- */
-function extractNumericId(candidate) {
-    // Direct numeric ID field
-    const numericId = candidate.numericLinkedInId || candidate.numeric_linkedin_id;
-    if (numericId) {
-        const extracted = extractNumericLinkedInId(numericId);
-        if (extracted)
-            return extracted;
-    }
-    // objectUrn field (from Sales Navigator search results)
-    const objectUrn = candidate.objectUrn || candidate.object_urn;
-    if (objectUrn) {
-        const extracted = extractNumericLinkedInId(objectUrn);
-        if (extracted)
-            return extracted;
-    }
-    // linkedinId field (may contain URN or numeric ID)
-    const linkedinId = candidate.linkedinId || candidate.linkedin_id;
-    if (linkedinId) {
-        const extracted = extractNumericLinkedInId(linkedinId);
-        if (extracted)
-            return extracted;
-    }
-    return null;
-}
+const candidate_parser_1 = require("../utils/candidate-parser");
+const noop_provider_1 = require("../utils/noop-provider");
+// Re-export for backwards compatibility
+var candidate_parser_2 = require("../utils/candidate-parser");
+Object.defineProperty(exports, "extractNumericLinkedInId", { enumerable: true, get: function () { return candidate_parser_2.extractNumericLinkedInId; } });
 /**
  * Create the LDD provider function
  *
@@ -101,23 +28,19 @@ function extractNumericId(candidate) {
 function createLddProvider(config) {
     const { apiUrl, apiToken } = config;
     if (!apiUrl || !apiToken) {
-        // Return a no-op provider if not configured
-        const noopProvider = async () => null;
-        noopProvider.__name = "ldd";
-        return noopProvider;
+        return (0, noop_provider_1.createNoOpProvider)("ldd");
     }
     async function fetchEmail(candidate) {
+        const linkedin = (0, candidate_parser_1.extractLinkedIn)(candidate);
         // PRIORITY 1: Try numeric ID first (stable identifier)
-        const numericId = extractNumericId(candidate);
-        if (numericId) {
-            const result = await lookupByNumericId(numericId);
+        if (linkedin.numericId) {
+            const result = await lookupByNumericId(linkedin.numericId);
             if (result)
                 return result;
         }
         // PRIORITY 2: Fall back to username (less reliable)
-        const username = extractUsername(candidate);
-        if (username) {
-            const result = await lookupByUsername(username);
+        if (linkedin.username) {
+            const result = await lookupByUsername(linkedin.username);
             if (result)
                 return result;
         }
@@ -152,11 +75,11 @@ function createLddProvider(config) {
             return 75; // Unknown type
         const type = emailType.toLowerCase();
         // Professional/business emails - highest confidence
-        if (type === 'professional' || type === 'business' || type === 'work') {
+        if (type === "professional" || type === "business" || type === "work") {
             return 95;
         }
         // Personal emails - still valid but lower priority for B2B
-        if (type === 'personal' || type === 'private') {
+        if (type === "personal" || type === "private") {
             return 70;
         }
         // Other types (e.g., "other", "unknown")
@@ -167,15 +90,15 @@ function createLddProvider(config) {
      */
     function classifyEmailType(emailType) {
         if (!emailType)
-            return 'unknown';
+            return "unknown";
         const type = emailType.toLowerCase();
-        if (type === 'professional' || type === 'business' || type === 'work') {
-            return 'business';
+        if (type === "professional" || type === "business" || type === "work") {
+            return "business";
         }
-        if (type === 'personal' || type === 'private') {
-            return 'personal';
+        if (type === "personal" || type === "private") {
+            return "personal";
         }
-        return 'unknown';
+        return "unknown";
     }
     function parseResponse(data) {
         if (!data.success || !data.data) {

package/dist/enrichment/providers/smartprospect.js

@@ -18,6 +18,8 @@ exports.createSmartProspectProvider = createSmartProspectProvider;
 exports.createSmartProspectClient = createSmartProspectClient;
 const smartlead_auth_1 = require("../auth/smartlead-auth");
 const http_retry_1 = require("../utils/http-retry");
+const candidate_parser_1 = require("../utils/candidate-parser");
+const noop_provider_1 = require("../utils/noop-provider");
 const DEFAULT_API_URL = "https://prospect-api.smartlead.ai/api/search-email-leads";
 const DEFAULT_POLLING_CONFIG = {
     initialDelay: 500,
@@ -96,22 +98,6 @@ function calculateMatchScore(contact, searchName, company, title) {
     }
     return score;
 }
-/**
- * Extract name components from candidate
- */
-function extractNames(candidate) {
-    const firstName = candidate.firstName ||
-        candidate.first_name ||
-        candidate.first ||
-        candidate.name?.split(" ")?.[0] ||
-        "";
-    const lastName = candidate.lastName ||
-        candidate.last_name ||
-        candidate.last ||
-        candidate.name?.split(" ")?.slice(1).join(" ") ||
-        "";
-    return { firstName, lastName };
-}
 /**
  * Create the SmartProspect provider function
  *
@@ -125,10 +111,7 @@ function createSmartProspectProvider(config) {
     const hasDirectToken = !!apiToken;
     const hasCredentials = !!email && !!password;
     if (!hasDirectToken && !hasCredentials) {
-        // Return a no-op provider if not configured
-        const noopProvider = async () => null;
-        noopProvider.__name = "smartprospect";
-        return noopProvider;
+        return (0, noop_provider_1.createNoOpProvider)("smartprospect");
     }
     /**
      * Get the current auth token (either direct or via login)
@@ -241,7 +224,9 @@ function createSmartProspectProvider(config) {
                 await (0, http_retry_1.delay)(pollInterval);
             }
             catch (err) {
-                if (err instanceof Error && err.message.includes("401") && hasCredentials) {
+                if (err instanceof Error &&
+                    err.message.includes("401") &&
+                    hasCredentials) {
                     await handleAuthError();
                 }
                 await (0, http_retry_1.delay)(pollInterval);
@@ -372,23 +357,12 @@ function createSmartProspectProvider(config) {
         return confidence;
     }
     async function fetchEmail(candidate) {
-        const { firstName, lastName } = extractNames(candidate);
+        const { firstName, fullName } = (0, candidate_parser_1.extractName)(candidate);
         if (!firstName) {
             return null; // Minimum requirement
         }
-        const fullName = `${firstName} ${lastName}`.trim();
-        const company = candidate.company ||
-            candidate.currentCompany ||
-            candidate.organization ||
-            undefined;
-        const title = candidate.title ||
-            candidate.currentRole ||
-            candidate.current_role ||
-            undefined;
-        const domain = candidate.domain ||
-            candidate.companyDomain ||
-            candidate.company_domain ||
-            undefined;
+        const { company, domain } = (0, candidate_parser_1.extractCompany)(candidate);
+        const title = (0, candidate_parser_1.extractTitle)(candidate) ?? undefined;
         // Build search filters using correct API field names
         const filters = {
             name: [fullName],
@@ -410,7 +384,7 @@ function createSmartProspectProvider(config) {
         const scoredMatches = matches
             .map((contact) => ({
             contact,
-            score: calculateMatchScore(contact, fullName, company, title),
+            score: calculateMatchScore(contact, fullName, company ?? undefined, title),
         }))
             .filter((m) => m.score > 0) // Only include matches with some relevance
             .sort((a, b) => b.score - a.score);
@@ -547,20 +521,26 @@ function createSmartProspectClient(config) {
         if (filters.level?.length)
             payload.level = filters.level;
         // Company filters (note: API uses companyName and companyDomain)
-        if (filters.companyName?.length)
+        if (filters.companyName?.length) {
             payload.companyName = filters.companyName;
-        if (filters.companyDomain?.length)
+        }
+        if (filters.companyDomain?.length) {
             payload.companyDomain = filters.companyDomain;
+        }
         // Industry filters (note: API uses companyIndustry and companySubIndustry)
-        if (filters.companyIndustry?.length)
+        if (filters.companyIndustry?.length) {
             payload.companyIndustry = filters.companyIndustry;
-        if (filters.companySubIndustry?.length)
+        }
+        if (filters.companySubIndustry?.length) {
             payload.companySubIndustry = filters.companySubIndustry;
+        }
         // Company size filters
-        if (filters.companyHeadCount?.length)
+        if (filters.companyHeadCount?.length) {
             payload.companyHeadCount = filters.companyHeadCount;
-        if (filters.companyRevenue?.length)
+        }
+        if (filters.companyRevenue?.length) {
             payload.companyRevenue = filters.companyRevenue;
+        }
         // Location filters
         if (filters.country?.length)
             payload.country = filters.country;
@@ -826,11 +806,11 @@ function createSmartProspectClient(config) {
     async function getLocations(type, options = {}) {
         const { search: searchQuery, limit = 20, offset = 0 } = options;
         const params = new URLSearchParams();
-        params.set('limit', String(limit));
+        params.set("limit", String(limit));
         if (offset > 0)
-            params.set('offset', String(offset));
+            params.set("offset", String(offset));
         if (searchQuery)
-            params.set('search', searchQuery);
+            params.set("search", searchQuery);
         const makeRequest = async (token) => {
             return requestWithRetry(`${apiUrl}/${type}?${params.toString()}`, {
                 method: "GET",
@@ -870,19 +850,19 @@ function createSmartProspectClient(config) {
      * Lookup countries (for typeahead)
      */
     async function getCountries(options) {
-        return getLocations('countries', options);
+        return getLocations("countries", options);
     }
     /**
      * Lookup states (for typeahead)
      */
     async function getStates(options) {
-        return getLocations('states', options);
+        return getLocations("states", options);
     }
     /**
      * Lookup cities (for typeahead)
      */
     async function getCities(options) {
-        return getLocations('cities', options);
+        return getLocations("cities", options);
     }
     return {
         search,

package/dist/enrichment/providers/snovio.d.ts

@@ -12,7 +12,7 @@
  *
  * @see https://snov.io/api
  */
-import type { EnrichmentCandidate, ProviderResult, ProviderMultiResult, SnovioConfig, SnovioGetEmailsResponse, SnovioVerificationStatus } from '../types';
+import type { EnrichmentCandidate, ProviderResult, ProviderMultiResult, SnovioConfig, SnovioGetEmailsResponse, SnovioVerificationStatus } from "../types";
 /**
  * Create the Snov.io email finder provider
  *

package/dist/enrichment/providers/snovio.js

@@ -18,7 +18,8 @@ exports.createSnovioProvider = createSnovioProvider;
 exports.findEmailsWithSnovio = findEmailsWithSnovio;
 exports.verifyEmailWithSnovio = verifyEmailWithSnovio;
 exports.clearSnovioTokenCache = clearSnovioTokenCache;
-const DEFAULT_API_URL = 'https://api.snov.io';
+const noop_provider_1 = require("../utils/noop-provider");
+const DEFAULT_API_URL = "https://api.snov.io";
 const DEFAULT_TIMEOUT_MS = 30000;
 // Token cache
 let cachedAccessToken = null;
@@ -28,15 +29,15 @@ let tokenExpiresAt = 0;
  */
 function statusToConfidence(status) {
     switch (status) {
-        case 'valid':
+        case "valid":
             return 95; // High confidence - verified email
-        case 'catch_all':
+        case "catch_all":
             return 60; // Medium confidence - catch-all domain
-        case 'unverifiable':
+        case "unverifiable":
             return 40; // Low confidence - could not verify
-        case 'not_valid':
+        case "not_valid":
             return 0; // Invalid email
-        case 'unknown':
+        case "unknown":
         default:
             return 30;
     }
@@ -48,17 +49,17 @@ function extractNameAndDomain(candidate) {
     const firstName = candidate.firstName ||
         candidate.first_name ||
         candidate.first ||
-        candidate.name?.split(' ')?.[0] ||
-        '';
+        candidate.name?.split(" ")?.[0] ||
+        "";
     const lastName = candidate.lastName ||
         candidate.last_name ||
         candidate.last ||
-        candidate.name?.split(' ')?.slice(1).join(' ') ||
-        '';
+        candidate.name?.split(" ")?.slice(1).join(" ") ||
+        "";
     const domain = candidate.domain ||
         candidate.companyDomain ||
         candidate.company_domain ||
-        '';
+        "";
     if (!firstName || !domain) {
         return null;
     }
@@ -76,12 +77,12 @@ async function getAccessToken(userId, apiSecret, apiUrl, timeoutMs) {
     const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
     try {
         const response = await fetch(`${apiUrl}/v1/oauth/access_token`, {
-            method: 'POST',
+            method: "POST",
             headers: {
-                'Content-Type': 'application/json',
+                "Content-Type": "application/json",
             },
             body: JSON.stringify({
-                grant_type: 'client_credentials',
+                grant_type: "client_credentials",
                 client_id: userId,
                 client_secret: apiSecret,
             }),
@@ -90,7 +91,7 @@ async function getAccessToken(userId, apiSecret, apiUrl, timeoutMs) {
         if (!response.ok) {
             return null;
         }
-        const data = await response.json();
+        const data = (await response.json());
         // Cache token with 5 minute buffer
         cachedAccessToken = data.access_token;
         tokenExpiresAt = Date.now() + (data.expires_in - 300) * 1000;
@@ -117,24 +118,24 @@ async function findEmailsByName(firstName, lastName, domain, accessToken, apiUrl
             domain,
         });
         const response = await fetch(`${apiUrl}/v1/get-emails-from-names?${params}`, {
-            method: 'GET',
+            method: "GET",
             headers: {
-                'Accept': 'application/json',
+                Accept: "application/json",
             },
             signal: controller.signal,
         });
         if (!response.ok) {
             // Handle rate limiting
             if (response.status === 429) {
-                throw new Error('Rate limited by Snov.io API');
+                throw new Error("Rate limited by Snov.io API");
             }
             return null;
         }
-        const data = await response.json();
+        const data = (await response.json());
         return data;
     }
     catch (error) {
-        if (error instanceof Error && error.name === 'AbortError') {
+        if (error instanceof Error && error.name === "AbortError") {
             return null; // Timeout
         }
         throw error;
@@ -152,10 +153,7 @@ async function findEmailsByName(firstName, lastName, domain, accessToken, apiUrl
 function createSnovioProvider(config) {
     const { userId, apiSecret, apiUrl = DEFAULT_API_URL, timeoutMs = DEFAULT_TIMEOUT_MS, } = config;
     if (!userId || !apiSecret) {
-        // Return no-op provider if not configured
-        const noop = async () => null;
-        noop.__name = 'snovio';
-        return noop;
+        return (0, noop_provider_1.createNoOpProvider)("snovio");
     }
     async function findEmails(candidate) {
         const nameAndDomain = extractNameAndDomain(candidate);
@@ -175,12 +173,12 @@ function createSnovioProvider(config) {
         }
         // Convert to provider multi-result format
         const emails = result.data.emails
-            .filter((e) => e.email && e.emailStatus !== 'not_valid')
+            .filter((e) => e.email && e.emailStatus !== "not_valid")
             .map((e) => ({
             email: e.email,
-            verified: e.emailStatus === 'valid',
+            verified: e.emailStatus === "valid",
             confidence: statusToConfidence(e.emailStatus),
-            isCatchAll: e.emailStatus === 'catch_all',
+            isCatchAll: e.emailStatus === "catch_all",
             metadata: {
                 snovioStatus: e.emailStatus,
                 firstName: e.firstName,
@@ -199,7 +197,7 @@ function createSnovioProvider(config) {
         return { emails };
     }
     // Mark provider name for orchestrator
-    findEmails.__name = 'snovio';
+    findEmails.__name = "snovio";
     return findEmails;
 }
 /**
@@ -251,16 +249,16 @@ async function verifyEmailWithSnovio(email, config) {
             email,
         });
         const response = await fetch(`${apiUrl}/v1/email-verifier?${params}`, {
-            method: 'GET',
+            method: "GET",
             headers: {
-                'Accept': 'application/json',
+                Accept: "application/json",
             },
             signal: controller.signal,
         });
         if (!response.ok) {
             return null;
         }
-        const data = await response.json();
+        const data = (await response.json());
         if (!data.success || !data.data?.emails?.length) {
             return null;
         }

package/dist/enrichment/providers/trykitt.d.ts

@@ -0,0 +1,63 @@
+/**
+ * TryKitt.ai Email Finder Provider
+ *
+ * AI-powered email finding with enterprise identity server verification.
+ * FREE for individuals with unlimited searches.
+ *
+ * Features:
+ * - Email finding by name + domain
+ * - Enterprise identity server catch-all verification (more accurate than SMTP)
+ * - <0.1% bounce rate claimed
+ * - 2-5x faster than traditional SMTP verification
+ *
+ * API Endpoints:
+ * - POST /job/find-email - Find email by name + domain
+ * - POST /job/verify-email - Verify existing email
+ *
+ * Rate Limits (Free tier):
+ * - 2 requests/second
+ * - 120 requests/minute
+ * - Unlimited monthly quota
+ *
+ * @see https://trykitt.ai
+ */
+import type { EnrichmentCandidate, ProviderResult, TryKittConfig, TryKittFindEmailResponse } from "../types";
+/**
+ * Create the TryKitt.ai email finder provider
+ *
+ * This provider uses TryKitt's AI-powered email finding with enterprise
+ * identity server verification for catch-all domains.
+ */
+export declare function createTryKittProvider(config: TryKittConfig): (candidate: EnrichmentCandidate) => Promise<ProviderResult | null>;
+/**
+ * Standalone function to find email via TryKitt.ai
+ *
+ * @example
+ * ```typescript
+ * const result = await findEmailWithTryKitt('John Doe', 'example.com', {
+ *   apiKey: process.env.TRYKITT_API_KEY,
+ * });
+ * console.log(result?.email); // john.doe@example.com
+ * ```
+ */
+export declare function findEmailWithTryKitt(fullName: string, domain: string, config: TryKittConfig, linkedinUrl?: string): Promise<TryKittFindEmailResponse | null>;
+/**
+ * Verify an email address via TryKitt.ai
+ *
+ * @example
+ * ```typescript
+ * const result = await verifyEmailWithTryKitt('john@example.com', {
+ *   apiKey: process.env.TRYKITT_API_KEY,
+ * });
+ * console.log(result?.result?.valid); // true
+ * console.log(result?.result?.is_catchall); // false
+ * ```
+ */
+export declare function verifyEmailWithTryKitt(email: string, config: TryKittConfig): Promise<{
+    valid: boolean;
+    deliverable: boolean;
+    confidence: number;
+    isCatchAll: boolean;
+    isDisposable: boolean;
+    isRoleAccount: boolean;
+} | null>;