linkedin-secret-sauce 0.12.1 → 0.12.2

package/dist/utils/lru-cache.d.ts

@@ -0,0 +1,105 @@
+/**
+ * Simple LRU (Least Recently Used) Cache
+ *
+ * A memory-bounded cache that evicts the least recently used entries
+ * when the maximum size is exceeded. Prevents unbounded memory growth.
+ *
+ * Features:
+ * - O(1) get and set operations
+ * - Automatic eviction of stale entries
+ * - Optional TTL support
+ * - Size limit enforcement
+ */
+/**
+ * Cache entry with data and timestamp
+ */
+export interface CacheEntry<T> {
+    data: T;
+    ts: number;
+}
+/**
+ * LRU Cache implementation using Map's insertion order
+ *
+ * JavaScript Map maintains insertion order, so we can implement LRU
+ * by deleting and re-inserting on access (moving to end).
+ */
+export declare class LRUCache<T> {
+    private cache;
+    private readonly maxSize;
+    private readonly ttlMs;
+    /**
+     * Create a new LRU cache
+     *
+     * @param maxSize - Maximum number of entries to store (default: 1000)
+     * @param ttlMs - Optional TTL in milliseconds (default: null = no expiry)
+     */
+    constructor(maxSize?: number, ttlMs?: number | null);
+    /**
+     * Get a value from the cache
+     *
+     * @param key - Cache key
+     * @param ttlOverride - Optional TTL override in milliseconds (for dynamic TTL from config)
+     * @returns The cached value or null if not found/expired
+     */
+    get(key: string, ttlOverride?: number): T | null;
+    /**
+     * Set a value in the cache
+     *
+     * @param key - Cache key
+     * @param data - Value to cache
+     */
+    set(key: string, data: T): void;
+    /**
+     * Delete a key from the cache
+     *
+     * @param key - Cache key to delete
+     * @returns true if the key existed
+     */
+    delete(key: string): boolean;
+    /**
+     * Check if a key exists in the cache (without updating access time)
+     *
+     * @param key - Cache key
+     * @returns true if key exists and is not expired
+     */
+    has(key: string): boolean;
+    /**
+     * Clear all entries from the cache
+     */
+    clear(): void;
+    /**
+     * Get the current number of entries in the cache
+     */
+    get size(): number;
+    /**
+     * Get all keys in the cache (for debugging/testing)
+     */
+    keys(): IterableIterator<string>;
+    /**
+     * Prune expired entries (useful for periodic cleanup)
+     *
+     * @returns Number of entries removed
+     */
+    prune(): number;
+    /**
+     * Get cache statistics
+     */
+    stats(): {
+        size: number;
+        maxSize: number;
+        ttlMs: number | null;
+    };
+}
+/**
+ * Create a new LRU cache with the specified options
+ *
+ * @example
+ * ```typescript
+ * // Cache up to 500 profiles for 15 minutes
+ * const profileCache = createLRUCache<LinkedInProfile>(500, 15 * 60 * 1000);
+ *
+ * profileCache.set('johndoe', profile);
+ * const cached = profileCache.get('johndoe');
+ * ```
+ */
+export declare function createLRUCache<T>(maxSize?: number, ttlMs?: number | null): LRUCache<T>;

package/dist/utils/lru-cache.js

@@ -0,0 +1,175 @@
+"use strict";
+/**
+ * Simple LRU (Least Recently Used) Cache
+ *
+ * A memory-bounded cache that evicts the least recently used entries
+ * when the maximum size is exceeded. Prevents unbounded memory growth.
+ *
+ * Features:
+ * - O(1) get and set operations
+ * - Automatic eviction of stale entries
+ * - Optional TTL support
+ * - Size limit enforcement
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LRUCache = void 0;
+exports.createLRUCache = createLRUCache;
+/**
+ * LRU Cache implementation using Map's insertion order
+ *
+ * JavaScript Map maintains insertion order, so we can implement LRU
+ * by deleting and re-inserting on access (moving to end).
+ */
+class LRUCache {
+    cache;
+    maxSize;
+    ttlMs;
+    /**
+     * Create a new LRU cache
+     *
+     * @param maxSize - Maximum number of entries to store (default: 1000)
+     * @param ttlMs - Optional TTL in milliseconds (default: null = no expiry)
+     */
+    constructor(maxSize = 1000, ttlMs = null) {
+        this.cache = new Map();
+        this.maxSize = maxSize;
+        this.ttlMs = ttlMs;
+    }
+    /**
+     * Get a value from the cache
+     *
+     * @param key - Cache key
+     * @param ttlOverride - Optional TTL override in milliseconds (for dynamic TTL from config)
+     * @returns The cached value or null if not found/expired
+     */
+    get(key, ttlOverride) {
+        const entry = this.cache.get(key);
+        if (!entry) {
+            return null;
+        }
+        // Check TTL expiration (use override if provided, otherwise instance TTL)
+        const effectiveTtl = ttlOverride ?? this.ttlMs;
+        if (effectiveTtl !== null && Date.now() - entry.ts > effectiveTtl) {
+            this.cache.delete(key);
+            return null;
+        }
+        // Move to end (most recently used) by delete + set
+        this.cache.delete(key);
+        this.cache.set(key, entry);
+        return entry.data;
+    }
+    /**
+     * Set a value in the cache
+     *
+     * @param key - Cache key
+     * @param data - Value to cache
+     */
+    set(key, data) {
+        // If key exists, delete it first (will be re-added at end)
+        if (this.cache.has(key)) {
+            this.cache.delete(key);
+        }
+        // Evict oldest entries if at capacity
+        while (this.cache.size >= this.maxSize) {
+            const oldestKey = this.cache.keys().next().value;
+            if (oldestKey !== undefined) {
+                this.cache.delete(oldestKey);
+            }
+            else {
+                break;
+            }
+        }
+        // Add new entry
+        this.cache.set(key, { data, ts: Date.now() });
+    }
+    /**
+     * Delete a key from the cache
+     *
+     * @param key - Cache key to delete
+     * @returns true if the key existed
+     */
+    delete(key) {
+        return this.cache.delete(key);
+    }
+    /**
+     * Check if a key exists in the cache (without updating access time)
+     *
+     * @param key - Cache key
+     * @returns true if key exists and is not expired
+     */
+    has(key) {
+        const entry = this.cache.get(key);
+        if (!entry) {
+            return false;
+        }
+        // Check TTL expiration
+        if (this.ttlMs !== null && Date.now() - entry.ts > this.ttlMs) {
+            this.cache.delete(key);
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Clear all entries from the cache
+     */
+    clear() {
+        this.cache.clear();
+    }
+    /**
+     * Get the current number of entries in the cache
+     */
+    get size() {
+        return this.cache.size;
+    }
+    /**
+     * Get all keys in the cache (for debugging/testing)
+     */
+    keys() {
+        return this.cache.keys();
+    }
+    /**
+     * Prune expired entries (useful for periodic cleanup)
+     *
+     * @returns Number of entries removed
+     */
+    prune() {
+        if (this.ttlMs === null) {
+            return 0;
+        }
+        const now = Date.now();
+        let removed = 0;
+        for (const [key, entry] of this.cache) {
+            if (now - entry.ts > this.ttlMs) {
+                this.cache.delete(key);
+                removed++;
+            }
+        }
+        return removed;
+    }
+    /**
+     * Get cache statistics
+     */
+    stats() {
+        return {
+            size: this.cache.size,
+            maxSize: this.maxSize,
+            ttlMs: this.ttlMs,
+        };
+    }
+}
+exports.LRUCache = LRUCache;
+/**
+ * Create a new LRU cache with the specified options
+ *
+ * @example
+ * ```typescript
+ * // Cache up to 500 profiles for 15 minutes
+ * const profileCache = createLRUCache<LinkedInProfile>(500, 15 * 60 * 1000);
+ *
+ * profileCache.set('johndoe', profile);
+ * const cached = profileCache.get('johndoe');
+ * ```
+ */
+function createLRUCache(maxSize = 1000, ttlMs = null) {
+    return new LRUCache(maxSize, ttlMs);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "linkedin-secret-sauce",
-  "version": "0.12.1",
+  "version": "0.12.2",
   "description": "Private LinkedIn Sales Navigator client with automatic cookie management",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -10,30 +10,6 @@
   "publishConfig": {
     "registry": "https://registry.npmjs.org/"
   },
-  "scripts": {
-    "dev:playground": "pnpm -C apps/playground dev",
-    "search": "node scripts/rg-fast.mjs",
-    "rg:fast": "node scripts/rg-fast.mjs",
-    "build": "tsc -p tsconfig.json",
-    "typecheck": "tsc --noEmit",
-    "typecheck:playground": "pnpm -C apps/playground typecheck",
-    "typecheck:all": "pnpm typecheck && pnpm typecheck:playground",
-    "lint": "eslint \"src/**/*.ts\" --max-warnings=0",
-    "lint:playground": "eslint \"apps/playground/src/**/*.{ts,tsx}\" \"apps/playground/server/**/*.ts\" --max-warnings=0",
-    "lint:all": "eslint \"src/**/*.ts\" \"apps/playground/src/**/*.{ts,tsx}\" \"apps/playground/server/**/*.ts\" --max-warnings=0",
-    "lint:fix": "eslint \"src/**/*.ts\" \"apps/playground/src/**/*.{ts,tsx}\" \"apps/playground/server/**/*.ts\" --fix",
-    "check": "pnpm typecheck:all && pnpm lint:all",
-    "dev": "pnpm dev:playground",
-    "dev:watch": "tsc -w -p tsconfig.json",
-    "test": "vitest run",
-    "docs": "typedoc",
-    "docs:netlify": "rm -rf docs/api && typedoc && echo 'Build complete'",
-    "docs:watch": "typedoc --watch",
-    "prepublishOnly": "npm run build",
-    "release:patch": "npm version patch && git push --follow-tags",
-    "release:minor": "npm version minor && git push --follow-tags",
-    "release:major": "npm version major && git push --follow-tags"
-  },
   "keywords": [
     "linkedin",
     "sales-navigator",
@@ -66,5 +42,28 @@
     "typedoc-plugin-markdown": "^4.9.0",
     "typescript": "^5.9.3",
     "vitest": "^1.6.0"
+  },
+  "scripts": {
+    "dev:playground": "pnpm -C apps/playground dev",
+    "search": "node scripts/rg-fast.mjs",
+    "rg:fast": "node scripts/rg-fast.mjs",
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc --noEmit",
+    "typecheck:playground": "pnpm -C apps/playground typecheck",
+    "typecheck:all": "pnpm typecheck && pnpm typecheck:playground",
+    "lint": "eslint \"src/**/*.ts\" --max-warnings=0",
+    "lint:playground": "eslint \"apps/playground/src/**/*.{ts,tsx}\" \"apps/playground/server/**/*.ts\" --max-warnings=0",
+    "lint:all": "eslint \"src/**/*.ts\" \"apps/playground/src/**/*.{ts,tsx}\" \"apps/playground/server/**/*.ts\" --max-warnings=0",
+    "lint:fix": "eslint \"src/**/*.ts\" \"apps/playground/src/**/*.{ts,tsx}\" \"apps/playground/server/**/*.ts\" --fix",
+    "check": "pnpm typecheck:all && pnpm lint:all",
+    "dev": "pnpm dev:playground",
+    "dev:watch": "tsc -w -p tsconfig.json",
+    "test": "vitest run",
+    "docs": "typedoc",
+    "docs:netlify": "rm -rf docs/api && typedoc && echo 'Build complete'",
+    "docs:watch": "typedoc --watch",
+    "release:patch": "npm version patch && git push --follow-tags",
+    "release:minor": "npm version minor && git push --follow-tags",
+    "release:major": "npm version major && git push --follow-tags"
   }
-}
+}