linkedin-secret-sauce 0.3.28 → 0.4.0

package/dist/utils/search-encoder.js

@@ -3,22 +3,32 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.stableStringify = stableStringify;
 exports.buildFilterSignature = buildFilterSignature;
 exports.buildLeadSearchQuery = buildLeadSearchQuery;
-// Stable stringify for cache keys: sorts object keys recursively.
+/**
+ * Creates a deterministic string representation of an object for use as cache keys.
+ * Sorts object keys recursively to ensure consistent output regardless of property order.
+ *
+ * @param obj - Any JSON-serializable value
+ * @returns Stable string representation suitable for cache key usage
+ */
 function stableStringify(obj) {
-    if (obj === null || typeof obj !== 'object')
+    if (obj === null || typeof obj !== "object")
         return JSON.stringify(obj);
     if (Array.isArray(obj))
-        return '[' + obj.map((v) => stableStringify(v)).join(',') + ']';
+        return "[" + obj.map((v) => stableStringify(v)).join(",") + "]";
     const rec = obj;
     const keys = Object.keys(rec).sort();
-    return '{' + keys.map((k) => JSON.stringify(k) + ':' + stableStringify(rec[k])).join(',') + '}';
+    return ("{" +
+        keys
+            .map((k) => JSON.stringify(k) + ":" + stableStringify(rec[k]))
+            .join(",") +
+        "}");
 }
 function buildFilterSignature(filters, rawQuery) {
     if (rawQuery)
-        return 'rq:' + String(rawQuery).trim();
+        return "rq:" + String(rawQuery).trim();
     if (!filters)
         return undefined;
-    return 'f:' + stableStringify(filters);
+    return "f:" + stableStringify(filters);
 }
 // Temporary minimal encoder: today we include only keywords in the query structure to
 // preserve existing behavior. Once facet ids are confirmed, extend this to encode filters
@@ -29,93 +39,135 @@ function encText(s) {
     return encodeURIComponent(String(s));
 }
 function list(values) {
-    return `List(${values.join(',')})`;
+    return `List(${values.join(",")})`;
 }
 function valObj(parts) {
-    return `(${parts.join(',')})`;
+    return `(${parts.join(",")})`;
 }
 function pushFilter(out, type, values) {
     if (!values.length)
         return;
     out.push(valObj([`type:${type}`, `values:${list(values)}`]));
 }
+/**
+ * Builds a Sales Navigator search query string from keywords and filters.
+ * Encodes the query in LinkedIn's proprietary format for the salesApiLeadSearch endpoint.
+ *
+ * @param keywords - Search keywords to include in the query
+ * @param filters - Optional SalesSearchFilters object with advanced criteria:
+ *   - role: seniority_ids, current_titles, past_titles, functions
+ *   - company: current, past, headcount, type
+ *   - personal: geography, industry_ids, profile_language, years_* ranges
+ * @returns Encoded query string ready for use in Sales Navigator API URL
+ *
+ * @example
+ * ```typescript
+ * // Simple keyword search
+ * const query = buildLeadSearchQuery('CEO');
+ * // Returns: "(keywords:CEO)"
+ *
+ * // With filters
+ * const query = buildLeadSearchQuery('', {
+ *   role: { seniority_ids: [9, 10] },
+ *   company: { headcount: { include: ['51-200', '201-500'] } }
+ * });
+ * ```
+ */
 function buildLeadSearchQuery(keywords, filters) {
-    const kw = (filters?.boolean?.keywords ?? keywords ?? '').toString();
-    const encodedKw = kw.replace(/\s+/g, '%20');
+    const kw = (filters?.boolean?.keywords ?? keywords ?? "").toString();
+    // Manually encode characters that encodeURIComponent doesn't handle properly in LinkedIn query context
+    const encodedKw = kw
+        .replace(/\(/g, "%28") // Encode (
+        .replace(/\)/g, "%29") // Encode )
+        .replace(/\[/g, "%5B") // Encode [
+        .replace(/\]/g, "%5D") // Encode ]
+        .replace(/\{/g, "%7B") // Encode {
+        .replace(/\}/g, "%7D") // Encode }
+        .replace(/&/g, "%26") // Encode &
+        .replace(/\+/g, "%2B") // Encode +
+        .replace(/=/g, "%3D") // Encode =
+        .replace(/\s+/g, "%20"); // Encode spaces
     const f = [];
     // SENIORITY_LEVEL
     if (filters?.role?.seniority_ids?.length) {
         const values = filters.role.seniority_ids.map((id) => valObj([`id:${id}`, `selectionType:INCLUDED`]));
-        pushFilter(f, 'SENIORITY_LEVEL', values);
+        pushFilter(f, "SENIORITY_LEVEL", values);
     }
     // CURRENT_TITLE / PAST_TITLE (supports id or text)
     function encodeTitles(arr) {
         if (!arr || !arr.length)
             return [];
         return arr.map((t) => {
-            if (typeof t === 'object') {
+            if (typeof t === "object") {
                 const parts = [];
                 if (t.id != null)
                     parts.push(`id:${t.id}`);
                 if (t.text)
                     parts.push(`text:${encText(t.text)}`);
-                parts.push('selectionType:INCLUDED');
+                parts.push("selectionType:INCLUDED");
                 return valObj(parts);
             }
             else {
                 // Heuristic: allow numeric strings to be treated as ids, otherwise text
                 const isNumeric = /^\d+$/.test(t);
-                const parts = [isNumeric ? `id:${t}` : `text:${encText(t)}`, 'selectionType:INCLUDED'];
+                const parts = [
+                    isNumeric ? `id:${t}` : `text:${encText(t)}`,
+                    "selectionType:INCLUDED",
+                ];
                 return valObj(parts);
             }
         });
     }
     const curTitles = encodeTitles(filters?.role?.current_titles?.include);
     if (curTitles.length)
-        pushFilter(f, 'CURRENT_TITLE', curTitles);
+        pushFilter(f, "CURRENT_TITLE", curTitles);
     const pastTitles = encodeTitles(filters?.role?.past_titles?.include);
     if (pastTitles.length)
-        pushFilter(f, 'PAST_TITLE', pastTitles);
+        pushFilter(f, "PAST_TITLE", pastTitles);
     // FUNCTION (ids as strings)
     if (filters?.role?.functions?.include?.length) {
-        const values = filters.role.functions.include.map((id) => valObj([`id:${id}`, 'selectionType:INCLUDED']));
-        pushFilter(f, 'FUNCTION', values);
+        const values = filters.role.functions.include.map((id) => valObj([`id:${id}`, "selectionType:INCLUDED"]));
+        pushFilter(f, "FUNCTION", values);
     }
     // INDUSTRY (numeric ids)
     if (filters?.personal?.industry_ids?.include?.length) {
-        const values = filters.personal.industry_ids.include.map((id) => valObj([`id:${id}`, 'selectionType:INCLUDED']));
-        pushFilter(f, 'INDUSTRY', values);
+        const values = filters.personal.industry_ids.include.map((id) => valObj([`id:${id}`, "selectionType:INCLUDED"]));
+        pushFilter(f, "INDUSTRY", values);
     }
     // PROFILE_LANGUAGE (ids like en, ar)
     if (filters?.personal?.profile_language?.include?.length) {
-        const values = filters.personal.profile_language.include.map((id) => valObj([`id:${id}`, 'selectionType:INCLUDED']));
-        pushFilter(f, 'PROFILE_LANGUAGE', values);
+        const values = filters.personal.profile_language.include.map((id) => valObj([`id:${id}`, "selectionType:INCLUDED"]));
+        pushFilter(f, "PROFILE_LANGUAGE", values);
     }
     // REGION (BING_GEO) — require id present
     if (filters?.personal?.geography?.include?.length) {
         const values = (filters.personal.geography.include || [])
             .filter((g) => g.id)
-            .map((g) => valObj([`id:${g.id}`, `text:${encText(g.value)}`, 'selectionType:INCLUDED']));
-        pushFilter(f, 'REGION', values);
+            .map((g) => valObj([
+            `id:${g.id}`,
+            `text:${encText(g.value)}`,
+            "selectionType:INCLUDED",
+        ]));
+        pushFilter(f, "REGION", values);
     }
     // COMPANY_HEADCOUNT — map common labels to A..I; accept raw letters too
     const HEADCOUNT_CODE = {
-        'Self-employed': 'A',
-        '1-10': 'B',
-        '11-50': 'C',
-        '51-200': 'D',
-        '201-500': 'E',
-        '501-1000': 'F',
-        '1001-5000': 'G',
-        '5001-10000': 'H',
-        '10000+': 'I',
+        "Self-employed": "A",
+        "1-10": "B",
+        "11-50": "C",
+        "51-200": "D",
+        "201-500": "E",
+        "501-1000": "F",
+        "1001-5000": "G",
+        "5001-10000": "H",
+        "10000+": "I",
     };
     if (filters?.company?.headcount?.include?.length) {
         const values = filters.company.headcount.include.map((label) => {
             const code = HEADCOUNT_CODE[label] ?? label; // allow passing A..I directly
-            return valObj([`id:${code}`, 'selectionType:INCLUDED']);
+            return valObj([`id:${code}`, "selectionType:INCLUDED"]);
         });
-        pushFilter(f, 'COMPANY_HEADCOUNT', values);
+        pushFilter(f, "COMPANY_HEADCOUNT", values);
     }
     // CURRENT_COMPANY — accept org URN (urn:li:organization:ID) or numeric ID (auto-converted to URN)
     function encodeCompanies(arr) {
@@ -135,41 +187,44 @@ function buildLeadSearchQuery(keywords, filters) {
                 // If not URN or numeric, assume it's already a URN (pass through)
                 urn = idStr;
             }
-            return valObj([`id:${encodeURIComponent(urn)}`, 'selectionType:INCLUDED']);
+            return valObj([
+                `id:${encodeURIComponent(urn)}`,
+                "selectionType:INCLUDED",
+            ]);
         });
     }
     const curCompanies = encodeCompanies(filters?.company?.current?.include);
     if (curCompanies.length)
-        pushFilter(f, 'CURRENT_COMPANY', curCompanies);
+        pushFilter(f, "CURRENT_COMPANY", curCompanies);
     // PAST_COMPANY — same logic as current
     const pastCompanies = encodeCompanies(filters?.company?.past?.include);
     if (pastCompanies.length)
-        pushFilter(f, 'PAST_COMPANY', pastCompanies);
+        pushFilter(f, "PAST_COMPANY", pastCompanies);
     // COMPANY_TYPE — map to C,P,N,D,G when known; allow raw codes
     const COMPANY_TYPE = {
-        PUBLIC: 'C',
-        PRIVATE: 'P',
-        NONPROFIT: 'N',
-        EDUCATIONAL: 'D',
-        GOVERNMENT: 'G',
+        PUBLIC: "C",
+        PRIVATE: "P",
+        NONPROFIT: "N",
+        EDUCATIONAL: "D",
+        GOVERNMENT: "G",
     };
     if (filters?.company?.type?.include?.length) {
         const values = filters.company.type.include.map((t) => {
             const code = COMPANY_TYPE[t] ?? t; // allow raw letter code
-            return valObj([`id:${code}`, 'selectionType:INCLUDED']);
+            return valObj([`id:${code}`, "selectionType:INCLUDED"]);
         });
-        pushFilter(f, 'COMPANY_TYPE', values);
+        pushFilter(f, "COMPANY_TYPE", values);
     }
     // YEARS_* via explicit bucket ids if provided (1..5)
     const yr = filters?.personal;
     if (yr?.years_at_company_ids?.length) {
-        pushFilter(f, 'YEARS_AT_CURRENT_COMPANY', yr.years_at_company_ids.map((id) => valObj([`id:${id}`, 'selectionType:INCLUDED'])));
+        pushFilter(f, "YEARS_AT_CURRENT_COMPANY", yr.years_at_company_ids.map((id) => valObj([`id:${id}`, "selectionType:INCLUDED"])));
     }
     if (yr?.years_in_current_role_ids?.length) {
-        pushFilter(f, 'YEARS_IN_CURRENT_POSITION', yr.years_in_current_role_ids.map((id) => valObj([`id:${id}`, 'selectionType:INCLUDED'])));
+        pushFilter(f, "YEARS_IN_CURRENT_POSITION", yr.years_in_current_role_ids.map((id) => valObj([`id:${id}`, "selectionType:INCLUDED"])));
     }
     if (yr?.years_experience_ids?.length) {
-        pushFilter(f, 'YEARS_OF_EXPERIENCE', yr.years_experience_ids.map((id) => valObj([`id:${id}`, 'selectionType:INCLUDED'])));
+        pushFilter(f, "YEARS_OF_EXPERIENCE", yr.years_experience_ids.map((id) => valObj([`id:${id}`, "selectionType:INCLUDED"])));
     }
     // Build query with minimal format for maximum compatibility
     // LinkedIn rejects spellCorrectionEnabled:true,keywords: with 400 errors
@@ -183,5 +238,5 @@ function buildLeadSearchQuery(keywords, filters) {
         parts.push(`filters:${list(f)}`);
     }
     // Return minimal format - no spellCorrectionEnabled wrapper
-    return parts.length > 0 ? `(${parts.join(',')})` : '()';
+    return parts.length > 0 ? `(${parts.join(",")})` : "()";
 }

package/dist/utils/sentry.d.ts

@@ -1,6 +1,6 @@
 export interface SentryClient {
     captureException(error: Error, context?: Record<string, unknown>): void;
-    captureMessage(message: string, level: 'error' | 'warning' | 'info', context?: Record<string, unknown>): void;
+    captureMessage(message: string, level: "error" | "warning" | "info", context?: Record<string, unknown>): void;
 }
 export declare function setSentryClient(client: SentryClient): void;
 export declare function reportToSentry(error: Error | string, context?: Record<string, unknown>): void;

package/dist/utils/sentry.js

@@ -6,42 +6,90 @@ exports.reportWarningToSentry = reportWarningToSentry;
 exports.reportCriticalError = reportCriticalError;
 const logger_1 = require("./logger");
 let sentryClient = null;
+// Deduplication: track recent error reports to prevent flooding Sentry
+const recentReports = new Map();
+const DEDUP_INTERVAL_MS = 60_000; // Only report same error once per minute
+const MAX_RECENT_REPORTS = 1000; // Prevent memory growth
+/**
+ * Generate a deduplication key for an error/message
+ */
+function getDedupKey(message, level) {
+    return `${level}:${message}`;
+}
+/**
+ * Check if we should report this error (deduplication)
+ * Returns true if we should report, false if deduplicated
+ */
+function shouldReport(key) {
+    const now = Date.now();
+    const lastReport = recentReports.get(key);
+    if (lastReport && now - lastReport < DEDUP_INTERVAL_MS) {
+        return false; // Skip - reported recently
+    }
+    // Cleanup old entries if map is too large
+    if (recentReports.size >= MAX_RECENT_REPORTS) {
+        const cutoff = now - DEDUP_INTERVAL_MS;
+        for (const [k, ts] of recentReports.entries()) {
+            if (ts < cutoff) {
+                recentReports.delete(k);
+            }
+        }
+    }
+    recentReports.set(key, now);
+    return true;
+}
 function setSentryClient(client) {
     sentryClient = client;
-    (0, logger_1.log)('info', 'sentry.configured', {});
+    (0, logger_1.log)("info", "sentry.configured", {});
 }
 function reportToSentry(error, context) {
     if (!sentryClient)
         return;
+    const message = typeof error === "string" ? error : error.message;
+    const key = getDedupKey(message, "error");
+    if (!shouldReport(key)) {
+        (0, logger_1.log)("debug", "sentry.deduplicated", { message });
+        return;
+    }
     try {
-        if (typeof error === 'string') {
-            sentryClient.captureMessage(error, 'error', context);
+        if (typeof error === "string") {
+            sentryClient.captureMessage(error, "error", context);
         }
         else {
             sentryClient.captureException(error, context);
         }
     }
     catch (err) {
-        (0, logger_1.log)('error', 'sentry.reportFailed', { error: err.message });
+        (0, logger_1.log)("error", "sentry.reportFailed", { error: err.message });
     }
 }
 function reportWarningToSentry(message, context) {
     if (!sentryClient)
         return;
+    const key = getDedupKey(message, "warning");
+    if (!shouldReport(key)) {
+        (0, logger_1.log)("debug", "sentry.deduplicated", { message });
+        return;
+    }
     try {
-        sentryClient.captureMessage(message, 'warning', context);
+        sentryClient.captureMessage(message, "warning", context);
     }
     catch (err) {
-        (0, logger_1.log)('error', 'sentry.warningFailed', { error: err.message });
+        (0, logger_1.log)("error", "sentry.warningFailed", { error: err.message });
     }
 }
 function reportCriticalError(message, context) {
     if (!sentryClient)
         return;
+    const key = getDedupKey(message, "critical");
+    if (!shouldReport(key)) {
+        (0, logger_1.log)("debug", "sentry.deduplicated", { message });
+        return;
+    }
     try {
-        sentryClient.captureMessage(message, 'error', context);
+        sentryClient.captureMessage(message, "error", context);
     }
     catch (err) {
-        (0, logger_1.log)('error', 'sentry.criticalFailed', { error: err.message });
+        (0, logger_1.log)("error", "sentry.criticalFailed", { error: err.message });
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "linkedin-secret-sauce",
-  "version": "0.3.28",
+  "version": "0.4.0",
   "description": "Private LinkedIn Sales Navigator client with automatic cookie management",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",