linkedin-secret-sauce 0.3.29 → 0.5.0

package/dist/enrichment/providers/construct.js

@@ -0,0 +1,107 @@
+"use strict";
+/**
+ * Email Construction Provider
+ *
+ * Generates email pattern candidates based on name + domain, then verifies via MX check.
+ * This is a FREE provider that doesn't require any API keys.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createConstructProvider = createConstructProvider;
+const mx_1 = require("../verification/mx");
+const personal_domains_1 = require("../utils/personal-domains");
+const validation_1 = require("../utils/validation");
+/**
+ * Build all email pattern candidates for a person
+ */
+function buildCandidates(input) {
+    const domain = String(input.domain || '').toLowerCase();
+    const first = (0, validation_1.cleanNamePart)(input.first || '');
+    const last = (0, validation_1.cleanNamePart)(input.last || '');
+    const fl = first ? first[0] : '';
+    const locals = [];
+    // Patterns with both first and last name
+    if (first && last) {
+        locals.push(`${first}.${last}`); // john.doe
+        locals.push(`${fl}.${last}`); // j.doe
+        locals.push(`${first}${last[0] ?? ''}`); // johnd
+        locals.push(`${fl}${last}`); // jdoe
+        locals.push(`${first}_${last}`); // john_doe
+        locals.push(`${last}.${first}`); // doe.john
+    }
+    // Single name patterns
+    if (first)
+        locals.push(first); // john
+    if (last)
+        locals.push(last); // doe
+    // Deduplicate while preserving order
+    const seen = new Set();
+    const emails = [];
+    for (const local of locals) {
+        if (!local)
+            continue;
+        const email = `${local}@${domain}`;
+        if (!seen.has(email)) {
+            seen.add(email);
+            emails.push(email);
+        }
+    }
+    return emails;
+}
+/**
+ * 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 { first: firstName, last: lastName };
+}
+/**
+ * Extract domain from candidate
+ */
+function extractDomain(candidate) {
+    return candidate.domain || candidate.companyDomain || candidate.company_domain || '';
+}
+/**
+ * Create the construct provider function
+ */
+function createConstructProvider(config) {
+    const maxAttempts = config?.maxAttempts ?? 8;
+    const timeoutMs = config?.timeoutMs ?? 5000;
+    async function fetchEmail(candidate) {
+        const { first, last } = extractNames(candidate);
+        const domain = extractDomain(candidate);
+        // Skip if missing required fields
+        if (!first || !domain) {
+            return null;
+        }
+        // Skip personal domains
+        if ((0, personal_domains_1.isPersonalDomain)(domain)) {
+            return null;
+        }
+        const candidates = buildCandidates({ first, last, domain });
+        const max = Math.min(candidates.length, maxAttempts);
+        for (let i = 0; i < max; i++) {
+            const email = candidates[i];
+            const verification = await (0, mx_1.verifyEmailMx)(email, { timeoutMs });
+            if (verification.valid === true && verification.confidence >= 50) {
+                return {
+                    email,
+                    verified: true,
+                    score: verification.confidence,
+                };
+            }
+        }
+        return null;
+    }
+    // Mark provider name for orchestrator
+    fetchEmail.__name = 'construct';
+    return fetchEmail;
+}

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

@@ -0,0 +1,16 @@
+/**
+ * Dropcontact Provider
+ *
+ * Dropcontact API for email finding.
+ * This is a placeholder implementation - full implementation would call the Dropcontact API.
+ */
+import type { EnrichmentCandidate, ProviderResult, DropcontactConfig } from '../types';
+/**
+ * Create the Dropcontact provider function
+ *
+ * Note: This is a placeholder. Full implementation would:
+ * 1. POST to https://api.dropcontact.io/batch with contacts
+ * 2. Poll for results
+ * 3. Return enriched email with verification status
+ */
+export declare function createDropcontactProvider(config: DropcontactConfig): (_candidate: EnrichmentCandidate) => Promise<ProviderResult | null>;

package/dist/enrichment/providers/dropcontact.js

@@ -0,0 +1,37 @@
+"use strict";
+/**
+ * Dropcontact Provider
+ *
+ * Dropcontact API for email finding.
+ * This is a placeholder implementation - full implementation would call the Dropcontact API.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDropcontactProvider = createDropcontactProvider;
+/**
+ * Create the Dropcontact provider function
+ *
+ * Note: This is a placeholder. Full implementation would:
+ * 1. POST to https://api.dropcontact.io/batch with contacts
+ * 2. Poll for results
+ * 3. Return enriched email with verification status
+ */
+function createDropcontactProvider(config) {
+    const { apiKey } = config;
+    if (!apiKey) {
+        // Return a no-op provider if not configured
+        const noopProvider = async () => null;
+        noopProvider.__name = 'dropcontact';
+        return noopProvider;
+    }
+    async function fetchEmail(_candidate) {
+        // TODO: Implement Dropcontact API integration
+        // API: POST https://api.dropcontact.io/batch
+        // Headers: X-Access-Token: {apiKey}
+        // Body: { data: [{ first_name, last_name, company, website }], siren: false, language: "en" }
+        // For now, return null (skip this provider)
+        return null;
+    }
+    // Mark provider name for orchestrator
+    fetchEmail.__name = 'dropcontact';
+    return fetchEmail;
+}

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

@@ -0,0 +1,11 @@
+/**
+ * Hunter.io Provider
+ *
+ * Hunter.io public API for email finding.
+ * Uses email-finder endpoint with name+domain, falls back to domain-search.
+ */
+import type { EnrichmentCandidate, ProviderResult, HunterConfig } from "../types";
+/**
+ * Create the Hunter provider function
+ */
+export declare function createHunterProvider(config: HunterConfig): (candidate: EnrichmentCandidate) => Promise<ProviderResult | null>;

package/dist/enrichment/providers/hunter.js

@@ -0,0 +1,162 @@
+"use strict";
+/**
+ * Hunter.io Provider
+ *
+ * Hunter.io public API for email finding.
+ * Uses email-finder endpoint with name+domain, falls back to domain-search.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createHunterProvider = createHunterProvider;
+const API_BASE = "https://api.hunter.io/v2";
+/**
+ * Delay helper for retry logic
+ */
+async function delay(ms) {
+    return new Promise((r) => setTimeout(r, ms));
+}
+/**
+ * Check if value is truthy
+ */
+function truthy(v) {
+    return v !== undefined && v !== null && String(v).length > 0;
+}
+/**
+ * Map Hunter verification status to boolean
+ */
+function mapVerified(status) {
+    if (!status)
+        return undefined;
+    const s = String(status).toLowerCase();
+    if (s === "valid" || s === "deliverable")
+        return true;
+    if (s === "invalid" || s === "undeliverable")
+        return false;
+    return undefined; // catch-all/unknown/webmail -> leave undefined
+}
+/**
+ * HTTP request with retry on 429 rate limit
+ */
+async function requestWithRetry(url, retries = 1, backoffMs = 200) {
+    let lastErr;
+    for (let i = 0; i <= retries; i++) {
+        try {
+            const res = await fetch(url);
+            // Retry on rate limit
+            if (res?.status === 429 && i < retries) {
+                await delay(backoffMs * Math.pow(2, i));
+                continue;
+            }
+            if (!res || res.status >= 400) {
+                lastErr = new Error(`hunter_http_${res?.status ?? "error"}`);
+                break;
+            }
+            const json = (await res.json());
+            return json;
+        }
+        catch (err) {
+            lastErr = err;
+            if (i < retries) {
+                await delay(backoffMs * Math.pow(2, i));
+                continue;
+            }
+        }
+    }
+    throw lastErr ?? new Error("hunter_http_error");
+}
+/**
+ * Extract name and domain from candidate
+ */
+function extractInputs(candidate) {
+    const name = candidate.name || candidate.fullName || candidate.full_name;
+    const first = candidate.first ||
+        candidate.first_name ||
+        candidate.firstName ||
+        name?.split?.(" ")?.[0];
+    const last = candidate.last ||
+        candidate.last_name ||
+        candidate.lastName ||
+        name?.split?.(" ")?.slice(1).join(" ") ||
+        undefined;
+    const domain = candidate.domain ||
+        candidate.companyDomain ||
+        candidate.company_domain ||
+        undefined;
+    return { first, last, domain };
+}
+/**
+ * Create the Hunter provider function
+ */
+function createHunterProvider(config) {
+    const { apiKey } = config;
+    if (!apiKey) {
+        // Return a no-op provider if not configured
+        const noopProvider = async () => null;
+        noopProvider.__name = "hunter";
+        return noopProvider;
+    }
+    async function fetchEmail(candidate) {
+        const { first, last, domain } = extractInputs(candidate);
+        let url = null;
+        // Use email-finder if we have name components
+        if (truthy(first) && truthy(last) && truthy(domain)) {
+            const qs = new URLSearchParams({
+                api_key: String(apiKey),
+                domain: String(domain),
+                first_name: String(first),
+                last_name: String(last),
+            });
+            url = `${API_BASE}/email-finder?${qs.toString()}`;
+        }
+        // Fall back to domain-search if only domain available
+        else if (truthy(domain)) {
+            const qs = new URLSearchParams({
+                api_key: String(apiKey),
+                domain: String(domain),
+                limit: "1",
+            });
+            url = `${API_BASE}/domain-search?${qs.toString()}`;
+        }
+        else {
+            return null; // Can't search without domain
+        }
+        try {
+            const json = await requestWithRetry(url, 1, 100);
+            // Parse email-finder response shape
+            const ef = (json && (json.data || json.result));
+            if (ef && (ef.email || ef.score !== undefined)) {
+                const email = ef.email ?? null;
+                const score = typeof ef.score === "number"
+                    ? ef.score
+                    : Number(ef.score ?? 0) || undefined;
+                const verified = mapVerified(ef?.verification?.status ?? ef?.status);
+                if (!email)
+                    return null;
+                return { email, verified, score };
+            }
+            // Parse domain-search response shape
+            const ds = (json &&
+                json.data &&
+                Array.isArray(json.data.emails)
+                ? json.data.emails
+                : null);
+            if (ds && ds.length > 0) {
+                const firstHit = ds[0];
+                const email = firstHit?.value || firstHit?.email || null;
+                const score = typeof firstHit?.confidence === "number"
+                    ? firstHit.confidence
+                    : Number(firstHit?.confidence ?? 0) || undefined;
+                const verified = mapVerified(firstHit?.verification?.status ?? firstHit?.status);
+                if (!email)
+                    return null;
+                return { email, verified, score };
+            }
+            return null;
+        }
+        catch {
+            return null;
+        }
+    }
+    // Mark provider name for orchestrator
+    fetchEmail.__name = "hunter";
+    return fetchEmail;
+}

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

@@ -0,0 +1,9 @@
+/**
+ * Email Enrichment Providers
+ */
+export { createConstructProvider } from './construct';
+export { createLddProvider } from './ldd';
+export { createSmartProspectProvider } from './smartprospect';
+export { createHunterProvider } from './hunter';
+export { createApolloProvider } from './apollo';
+export { createDropcontactProvider } from './dropcontact';

package/dist/enrichment/providers/index.js

@@ -0,0 +1,18 @@
+"use strict";
+/**
+ * Email Enrichment Providers
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDropcontactProvider = exports.createApolloProvider = exports.createHunterProvider = exports.createSmartProspectProvider = exports.createLddProvider = exports.createConstructProvider = void 0;
+var construct_1 = require("./construct");
+Object.defineProperty(exports, "createConstructProvider", { enumerable: true, get: function () { return construct_1.createConstructProvider; } });
+var ldd_1 = require("./ldd");
+Object.defineProperty(exports, "createLddProvider", { enumerable: true, get: function () { return ldd_1.createLddProvider; } });
+var smartprospect_1 = require("./smartprospect");
+Object.defineProperty(exports, "createSmartProspectProvider", { enumerable: true, get: function () { return smartprospect_1.createSmartProspectProvider; } });
+var hunter_1 = require("./hunter");
+Object.defineProperty(exports, "createHunterProvider", { enumerable: true, get: function () { return hunter_1.createHunterProvider; } });
+var apollo_1 = require("./apollo");
+Object.defineProperty(exports, "createApolloProvider", { enumerable: true, get: function () { return apollo_1.createApolloProvider; } });
+var dropcontact_1 = require("./dropcontact");
+Object.defineProperty(exports, "createDropcontactProvider", { enumerable: true, get: function () { return dropcontact_1.createDropcontactProvider; } });

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

@@ -0,0 +1,11 @@
+/**
+ * LinkedIn Data Dump (LDD) Provider
+ *
+ * YOUR private database of ~500M scraped LinkedIn profiles with emails.
+ * This is FREE and unlimited - it's your own service.
+ */
+import type { EnrichmentCandidate, ProviderResult, LddConfig } from "../types";
+/**
+ * Create the LDD provider function
+ */
+export declare function createLddProvider(config: LddConfig): (candidate: EnrichmentCandidate) => Promise<ProviderResult | null>;

package/dist/enrichment/providers/ldd.js

@@ -0,0 +1,110 @@
+"use strict";
+/**
+ * LinkedIn Data Dump (LDD) Provider
+ *
+ * YOUR private database of ~500M scraped LinkedIn profiles with emails.
+ * This is FREE and unlimited - it's your own service.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLddProvider = createLddProvider;
+const validation_1 = require("../utils/validation");
+/**
+ * Delay helper for retry logic
+ */
+async function delay(ms) {
+    return new Promise((r) => setTimeout(r, ms));
+}
+/**
+ * HTTP request with retry on 429 rate limit
+ */
+async function requestWithRetry(url, token, retries = 1, backoffMs = 200) {
+    let lastErr;
+    for (let i = 0; i <= retries; i++) {
+        try {
+            const res = await fetch(url, {
+                method: "GET",
+                headers: {
+                    Authorization: `Bearer ${token}`,
+                    "Content-Type": "application/json",
+                },
+            });
+            // Retry on rate limit
+            if (res?.status === 429 && i < retries) {
+                await delay(backoffMs * Math.pow(2, i));
+                continue;
+            }
+            return res;
+        }
+        catch (err) {
+            lastErr = err;
+            if (i < retries) {
+                await delay(backoffMs * Math.pow(2, i));
+                continue;
+            }
+        }
+    }
+    throw lastErr ?? new Error("ldd_http_error");
+}
+/**
+ * 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;
+}
+/**
+ * Create the LDD provider function
+ */
+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;
+    }
+    async function fetchEmail(candidate) {
+        const username = extractUsername(candidate);
+        if (!username) {
+            return null;
+        }
+        try {
+            const endpoint = `${apiUrl}/api/v1/profiles/by-username/${encodeURIComponent(username)}`;
+            const response = await requestWithRetry(endpoint, apiToken, 1, 100);
+            if (!response.ok) {
+                return null;
+            }
+            const data = (await response.json());
+            if (!data.success || !data.data) {
+                return null;
+            }
+            // Find first valid email
+            const emails = data.data.emails || [];
+            const validEmail = emails.find((e) => e.email_address && e.email_address.includes("@"));
+            if (!validEmail) {
+                return null;
+            }
+            return {
+                email: validEmail.email_address,
+                verified: true, // LDD data is pre-verified
+                score: 90, // High confidence from your own database
+            };
+        }
+        catch {
+            return null;
+        }
+    }
+    // Mark provider name for orchestrator
+    fetchEmail.__name = "ldd";
+    return fetchEmail;
+}

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

@@ -0,0 +1,11 @@
+/**
+ * SmartProspect/Smartlead Provider
+ *
+ * Smartlead's prospect database - a REVERSE-ENGINEERED private API.
+ * Two-phase process: search (free) then fetch (costs credits).
+ */
+import type { EnrichmentCandidate, ProviderResult, SmartProspectConfig } from '../types';
+/**
+ * Create the SmartProspect provider function
+ */
+export declare function createSmartProspectProvider(config: SmartProspectConfig): (candidate: EnrichmentCandidate) => Promise<ProviderResult | null>;