@socketsecurity/lib 0.0.0 → 1.0.0

package/dist/cacache.d.ts

@@ -0,0 +1,86 @@
+export interface GetOptions {
+    integrity?: string | undefined;
+    size?: number | undefined;
+    memoize?: boolean | undefined;
+}
+export interface PutOptions {
+    integrity?: string | undefined;
+    size?: number | undefined;
+    // biome-ignore lint/suspicious/noExplicitAny: User-provided arbitrary metadata.
+    metadata?: any | undefined;
+    memoize?: boolean | undefined;
+}
+export interface CacheEntry {
+    data: Buffer;
+    integrity: string;
+    key: string;
+    // biome-ignore lint/suspicious/noExplicitAny: User-provided arbitrary metadata.
+    metadata?: any | undefined;
+    path: string;
+    size: number;
+    time: number;
+}
+export interface RemoveOptions {
+    /**
+     * Optional key prefix to filter removals.
+     * If provided, only keys starting with this prefix will be removed.
+     * Can include wildcards (*) for pattern matching.
+     *
+     * @example
+     * { prefix: 'socket-sdk' } // Simple prefix
+     * { prefix: 'socket-sdk:scans:abc*' } // With wildcard
+     */
+    prefix?: string | undefined;
+}
+/**
+ * Clear entries from the Socket shared cache.
+ *
+ * Supports wildcard patterns (*) in prefix for flexible matching.
+ * For simple prefixes without wildcards, uses efficient streaming.
+ * For wildcard patterns, iterates and matches each entry.
+ *
+ * @param options - Optional configuration for selective clearing
+ * @param options.prefix - Prefix or pattern to match (supports * wildcards)
+ * @returns Number of entries removed (only when prefix is specified)
+ *
+ * @example
+ * // Clear all entries
+ * await clear()
+ *
+ * @example
+ * // Clear entries with simple prefix
+ * const removed = await clear({ prefix: 'socket-sdk:scans' })
+ * console.log(`Removed ${removed} scan cache entries`)
+ *
+ * @example
+ * // Clear entries with wildcard pattern
+ * await clear({ prefix: 'socket-sdk:scans:abc*' })
+ * await clear({ prefix: 'socket-sdk:npm/lodash/*' })
+ */
+export declare function clear(options?: RemoveOptions | undefined): Promise<number | undefined>;
+/**
+ * Get data from the Socket shared cache by key.
+ * @throws {Error} When cache entry is not found.
+ * @throws {TypeError} If key contains wildcards (*)
+ */
+export declare function get(key: string, options?: GetOptions | undefined): Promise<CacheEntry>;
+/**
+ * Put data into the Socket shared cache with a key.
+ *
+ * @throws {TypeError} If key contains wildcards (*)
+ */
+export declare function put(key: string, data: string | Buffer, options?: PutOptions | undefined): Promise<any>;
+/**
+ * Remove an entry from the Socket shared cache by key.
+ *
+ * @throws {TypeError} If key contains wildcards (*)
+ */
+export declare function remove(key: string): Promise<unknown>;
+/**
+ * Get data from the Socket shared cache by key without throwing.
+ */
+export declare function safeGet(key: string, options?: GetOptions | undefined): Promise<CacheEntry | undefined>;
+/**
+ * Execute a callback with a temporary directory for cache operations.
+ */
+export declare function withTmp<T>(callback: (tmpDirPath: string) => Promise<T>): Promise<T>;

package/dist/cacache.js

@@ -0,0 +1,140 @@
+/* Socket Lib - Built with esbuild */
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var cacache_exports = {};
+__export(cacache_exports, {
+  clear: () => clear,
+  get: () => get,
+  put: () => put,
+  remove: () => remove,
+  safeGet: () => safeGet,
+  withTmp: () => withTmp
+});
+module.exports = __toCommonJS(cacache_exports);
+var import_paths = require("./paths");
+function getCacache() {
+  return require("../external/cacache");
+}
+function patternToRegex(pattern) {
+  const escaped = pattern.replaceAll(/[.+?^${}()|[\]\\]/g, "\\$&");
+  const regexPattern = escaped.replaceAll("*", ".*");
+  return new RegExp(`^${regexPattern}`);
+}
+function matchesPattern(key, pattern) {
+  if (!pattern.includes("*")) {
+    return key.startsWith(pattern);
+  }
+  const regex = patternToRegex(pattern);
+  return regex.test(key);
+}
+async function clear(options) {
+  const opts = { __proto__: null, ...options };
+  const cacache = getCacache();
+  const cacheDir = (0, import_paths.getSocketCacacheDir)();
+  if (!opts.prefix) {
+    try {
+      await cacache.rm.all(cacheDir);
+      return;
+    } catch (e) {
+      if (e?.code !== "ENOTEMPTY") {
+        throw e;
+      }
+      return;
+    }
+  }
+  const hasWildcard = opts.prefix.includes("*");
+  if (!hasWildcard) {
+    let removed2 = 0;
+    const stream2 = cacache.ls.stream(cacheDir);
+    for await (const entry of stream2) {
+      if (entry.key.startsWith(opts.prefix)) {
+        try {
+          await cacache.rm.entry(cacheDir, entry.key);
+          removed2++;
+        } catch {
+        }
+      }
+    }
+    return removed2;
+  }
+  let removed = 0;
+  const stream = cacache.ls.stream(cacheDir);
+  for await (const entry of stream) {
+    if (matchesPattern(entry.key, opts.prefix)) {
+      try {
+        await cacache.rm.entry(cacheDir, entry.key);
+        removed++;
+      } catch {
+      }
+    }
+  }
+  return removed;
+}
+async function get(key, options) {
+  if (key.includes("*")) {
+    throw new TypeError(
+      'Cache key cannot contain wildcards (*). Wildcards are only supported in clear({ prefix: "pattern*" }).'
+    );
+  }
+  const cacache = getCacache();
+  return await cacache.get((0, import_paths.getSocketCacacheDir)(), key, options);
+}
+async function put(key, data, options) {
+  if (key.includes("*")) {
+    throw new TypeError(
+      'Cache key cannot contain wildcards (*). Wildcards are only supported in clear({ prefix: "pattern*" }).'
+    );
+  }
+  const cacache = getCacache();
+  return await cacache.put((0, import_paths.getSocketCacacheDir)(), key, data, options);
+}
+async function remove(key) {
+  if (key.includes("*")) {
+    throw new TypeError(
+      'Cache key cannot contain wildcards (*). Use clear({ prefix: "pattern*" }) to remove multiple entries.'
+    );
+  }
+  const cacache = getCacache();
+  return await cacache.rm.entry((0, import_paths.getSocketCacacheDir)(), key);
+}
+async function safeGet(key, options) {
+  try {
+    return await get(key, options);
+  } catch {
+    return void 0;
+  }
+}
+async function withTmp(callback) {
+  const cacache = getCacache();
+  return await cacache.tmp.withTmp(
+    (0, import_paths.getSocketCacacheDir)(),
+    {},
+    // biome-ignore lint/suspicious/noExplicitAny: cacache types are incomplete.
+    callback
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  clear,
+  get,
+  put,
+  remove,
+  safeGet,
+  withTmp
+});
+//# sourceMappingURL=cacache.js.map

package/dist/cacache.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/cacache.ts"],
+  "sourcesContent": ["/** @fileoverview Cacache utilities for Socket ecosystem shared content-addressable cache. */\n\nimport { getSocketCacacheDir } from './paths'\n\nexport interface GetOptions {\n  integrity?: string | undefined\n  size?: number | undefined\n  memoize?: boolean | undefined\n}\n\nexport interface PutOptions {\n  integrity?: string | undefined\n  size?: number | undefined\n  // biome-ignore lint/suspicious/noExplicitAny: User-provided arbitrary metadata.\n  metadata?: any | undefined\n  memoize?: boolean | undefined\n}\n\nexport interface CacheEntry {\n  data: Buffer\n  integrity: string\n  key: string\n  // biome-ignore lint/suspicious/noExplicitAny: User-provided arbitrary metadata.\n  metadata?: any | undefined\n  path: string\n  size: number\n  time: number\n}\n\nexport interface RemoveOptions {\n  /**\n   * Optional key prefix to filter removals.\n   * If provided, only keys starting with this prefix will be removed.\n   * Can include wildcards (*) for pattern matching.\n   *\n   * @example\n   * { prefix: 'socket-sdk' } // Simple prefix\n   * { prefix: 'socket-sdk:scans:abc*' } // With wildcard\n   */\n  prefix?: string | undefined\n}\n\n/**\n * Get the cacache module for cache operations.\n */\nfunction getCacache() {\n  return /*@__PURE__*/ require('../external/cacache')\n}\n\n/**\n * Convert wildcard pattern to regex for matching.\n * Supports * as wildcard (matches any characters).\n */\nfunction patternToRegex(pattern: string): RegExp {\n  // Escape regex special characters except *\n  const escaped = pattern.replaceAll(/[.+?^${}()|[\\]\\\\]/g, '\\\\$&')\n  // Convert * to .* (match any characters)\n  const regexPattern = escaped.replaceAll('*', '.*')\n  return new RegExp(`^${regexPattern}`)\n}\n\n/**\n * Check if a key matches a pattern (with wildcard support).\n */\nfunction matchesPattern(key: string, pattern: string): boolean {\n  // If no wildcards, use simple prefix matching (faster)\n  if (!pattern.includes('*')) {\n    return key.startsWith(pattern)\n  }\n  // Use regex for wildcard patterns\n  const regex = patternToRegex(pattern)\n  return regex.test(key)\n}\n\n/**\n * Clear entries from the Socket shared cache.\n *\n * Supports wildcard patterns (*) in prefix for flexible matching.\n * For simple prefixes without wildcards, uses efficient streaming.\n * For wildcard patterns, iterates and matches each entry.\n *\n * @param options - Optional configuration for selective clearing\n * @param options.prefix - Prefix or pattern to match (supports * wildcards)\n * @returns Number of entries removed (only when prefix is specified)\n *\n * @example\n * // Clear all entries\n * await clear()\n *\n * @example\n * // Clear entries with simple prefix\n * const removed = await clear({ prefix: 'socket-sdk:scans' })\n * console.log(`Removed ${removed} scan cache entries`)\n *\n * @example\n * // Clear entries with wildcard pattern\n * await clear({ prefix: 'socket-sdk:scans:abc*' })\n * await clear({ prefix: 'socket-sdk:npm/lodash/*' })\n */\nexport async function clear(\n  options?: RemoveOptions | undefined,\n): Promise<number | undefined> {\n  const opts = { __proto__: null, ...options } as RemoveOptions\n  const cacache = getCacache()\n  const cacheDir = getSocketCacacheDir()\n\n  // If no prefix specified, clear everything.\n  if (!opts.prefix) {\n    try {\n      await cacache.rm.all(cacheDir)\n      return\n    } catch (e) {\n      // Ignore ENOTEMPTY errors - can occur when multiple processes\n      // are cleaning up concurrently (e.g., in CI test environments).\n      if ((e as NodeJS.ErrnoException)?.code !== 'ENOTEMPTY') {\n        throw e\n      }\n      return\n    }\n  }\n\n  const hasWildcard = opts.prefix.includes('*')\n\n  // For simple prefix (no wildcards), use faster iteration.\n  if (!hasWildcard) {\n    let removed = 0\n    const stream = cacache.ls.stream(cacheDir)\n\n    for await (const entry of stream) {\n      if (entry.key.startsWith(opts.prefix)) {\n        try {\n          await cacache.rm.entry(cacheDir, entry.key)\n          removed++\n        } catch {\n          // Ignore individual removal errors (e.g., already removed by another process).\n        }\n      }\n    }\n\n    return removed\n  }\n\n  // For wildcard patterns, need to match each entry.\n  let removed = 0\n  const stream = cacache.ls.stream(cacheDir)\n\n  for await (const entry of stream) {\n    if (matchesPattern(entry.key, opts.prefix)) {\n      try {\n        await cacache.rm.entry(cacheDir, entry.key)\n        removed++\n      } catch {\n        // Ignore individual removal errors.\n      }\n    }\n  }\n\n  return removed\n}\n\n/**\n * Get data from the Socket shared cache by key.\n * @throws {Error} When cache entry is not found.\n * @throws {TypeError} If key contains wildcards (*)\n */\nexport async function get(\n  key: string,\n  options?: GetOptions | undefined,\n): Promise<CacheEntry> {\n  if (key.includes('*')) {\n    throw new TypeError(\n      'Cache key cannot contain wildcards (*). Wildcards are only supported in clear({ prefix: \"pattern*\" }).',\n    )\n  }\n  // biome-ignore lint/suspicious/noExplicitAny: cacache types are incomplete.\n  const cacache = getCacache() as any\n  return await cacache.get(getSocketCacacheDir(), key, options)\n}\n\n/**\n * Put data into the Socket shared cache with a key.\n *\n * @throws {TypeError} If key contains wildcards (*)\n */\nexport async function put(\n  key: string,\n  data: string | Buffer,\n  options?: PutOptions | undefined,\n) {\n  if (key.includes('*')) {\n    throw new TypeError(\n      'Cache key cannot contain wildcards (*). Wildcards are only supported in clear({ prefix: \"pattern*\" }).',\n    )\n  }\n  const cacache = getCacache()\n  return await cacache.put(getSocketCacacheDir(), key, data, options)\n}\n\n/**\n * Remove an entry from the Socket shared cache by key.\n *\n * @throws {TypeError} If key contains wildcards (*)\n */\nexport async function remove(key: string): Promise<unknown> {\n  if (key.includes('*')) {\n    throw new TypeError(\n      'Cache key cannot contain wildcards (*). Use clear({ prefix: \"pattern*\" }) to remove multiple entries.',\n    )\n  }\n  // biome-ignore lint/suspicious/noExplicitAny: cacache types are incomplete.\n  const cacache = getCacache() as any\n  return await cacache.rm.entry(getSocketCacacheDir(), key)\n}\n\n/**\n * Get data from the Socket shared cache by key without throwing.\n */\nexport async function safeGet(\n  key: string,\n  options?: GetOptions | undefined,\n): Promise<CacheEntry | undefined> {\n  try {\n    return await get(key, options)\n  } catch {\n    return undefined\n  }\n}\n\n/**\n * Execute a callback with a temporary directory for cache operations.\n */\nexport async function withTmp<T>(\n  callback: (tmpDirPath: string) => Promise<T>,\n): Promise<T> {\n  const cacache = getCacache()\n  // The DefinitelyTyped types for cacache.tmp.withTmp are incorrect.\n  // It actually returns the callback's return value, not void.\n  return (await cacache.tmp.withTmp(\n    getSocketCacacheDir(),\n    {},\n    // biome-ignore lint/suspicious/noExplicitAny: cacache types are incomplete.\n    callback as any,\n  )) as T\n}\n"],
+  "mappings": "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",
+  "names": ["removed", "stream"]
+}

package/dist/cache-with-ttl.d.ts

@@ -0,0 +1,133 @@
+export interface TtlCacheOptions {
+    /**
+     * Time-to-live in milliseconds.
+     * @default 5 * 60 * 1000 (5 minutes)
+     */
+    ttl?: number | undefined;
+    /**
+     * Enable in-memory memoization for hot data.
+     * @default true
+     */
+    memoize?: boolean | undefined;
+    /**
+     * Custom cache key prefix.
+     * Must not contain wildcards (*).
+     * Use clear({ prefix: "pattern*" }) for wildcard matching instead.
+     *
+     * @default 'ttl-cache'
+     * @throws {TypeError} If prefix contains wildcards
+     *
+     * @example
+     * // Valid
+     * createTtlCache({ prefix: 'socket-sdk' })
+     * createTtlCache({ prefix: 'my-app:cache' })
+     *
+     * @example
+     * // Invalid - throws TypeError
+     * createTtlCache({ prefix: 'socket-*' })
+     */
+    prefix?: string | undefined;
+}
+export interface TtlCacheEntry<T> {
+    data: T;
+    expiresAt: number;
+}
+export interface ClearOptions {
+    /**
+     * Only clear in-memory memoization cache, not persistent cache.
+     * Useful for forcing a refresh of cached data without removing it from disk.
+     *
+     * @default false
+     */
+    memoOnly?: boolean | undefined;
+}
+export interface TtlCache {
+    /**
+     * Get cached data without fetching.
+     * Returns undefined if not found or expired.
+     *
+     * @param key - Cache key (must not contain wildcards)
+     * @throws {TypeError} If key contains wildcards (*)
+     */
+    get<T>(key: string): Promise<T | undefined>;
+    /**
+     * Get all cached entries matching a pattern.
+     * Supports wildcards (*) for flexible matching.
+     *
+     * @param pattern - Key pattern (supports * wildcards, or use '*' for all entries)
+     * @returns Map of matching entries (key -> value)
+     *
+     * @example
+     * // Get all organization entries
+     * const orgs = await cache.getAll<OrgData>('organizations:*')
+     * for (const [key, org] of orgs) {
+     *   console.log(`${key}: ${org.name}`)
+     * }
+     *
+     * @example
+     * // Get all entries with this cache's prefix
+     * const all = await cache.getAll<any>('*')
+     */
+    getAll<T>(pattern: string): Promise<Map<string, T>>;
+    /**
+     * Get cached data or fetch and cache if missing/expired.
+     *
+     * @param key - Cache key (must not contain wildcards)
+     */
+    getOrFetch<T>(key: string, fetcher: () => Promise<T>): Promise<T>;
+    /**
+     * Set cached data with TTL.
+     *
+     * @param key - Cache key (must not contain wildcards)
+     * @throws {TypeError} If key contains wildcards (*)
+     */
+    set<T>(key: string, data: T): Promise<void>;
+    /**
+     * Delete a specific cache entry.
+     *
+     * @param key - Cache key (must not contain wildcards)
+     * @throws {TypeError} If key contains wildcards (*)
+     */
+    delete(key: string): Promise<void>;
+    /**
+     * Delete all cache entries matching a pattern.
+     * Supports wildcards (*) for flexible matching.
+     *
+     * @param pattern - Key pattern (supports * wildcards, or omit to delete all)
+     * @returns Number of entries deleted
+     *
+     * @example
+     * // Delete all entries with this cache's prefix
+     * await cache.deleteAll()
+     *
+     * @example
+     * // Delete entries matching prefix
+     * await cache.deleteAll('organizations')
+     *
+     * @example
+     * // Delete entries with wildcard pattern
+     * await cache.deleteAll('scans:abc*')
+     * await cache.deleteAll('npm/lodash/*')
+     */
+    deleteAll(pattern?: string | undefined): Promise<number>;
+    /**
+     * Clear all cache entries (like Map.clear()).
+     * Optionally clear only in-memory cache.
+     *
+     * @param options - Optional configuration
+     * @param options.memoOnly - If true, only clears in-memory cache
+     *
+     * @example
+     * // Clear everything (memory + disk)
+     * await cache.clear()
+     *
+     * @example
+     * // Clear only in-memory cache (force refresh)
+     * await cache.clear({ memoOnly: true })
+     */
+    clear(options?: ClearOptions | undefined): Promise<void>;
+}
+/**
+ * Create a TTL-based cache instance.
+ */
+export declare function createTtlCache(options?: TtlCacheOptions): TtlCache;

package/dist/cache-with-ttl.js

@@ -0,0 +1,225 @@
+/* Socket Lib - Built with esbuild */
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var cache_with_ttl_exports = {};
+__export(cache_with_ttl_exports, {
+  createTtlCache: () => createTtlCache
+});
+module.exports = __toCommonJS(cache_with_ttl_exports);
+var cacache = __toESM(require("./cacache"));
+const DEFAULT_TTL_MS = 5 * 60 * 1e3;
+const DEFAULT_PREFIX = "ttl-cache";
+function createTtlCache(options) {
+  const opts = {
+    __proto__: null,
+    memoize: true,
+    prefix: DEFAULT_PREFIX,
+    ttl: DEFAULT_TTL_MS,
+    ...options
+  };
+  if (opts.prefix?.includes("*")) {
+    throw new TypeError(
+      'Cache prefix cannot contain wildcards (*). Use clear({ prefix: "pattern*" }) for wildcard matching.'
+    );
+  }
+  const memoCache = /* @__PURE__ */ new Map();
+  const ttl = opts.ttl ?? DEFAULT_TTL_MS;
+  function buildKey(key) {
+    return `${opts.prefix}:${key}`;
+  }
+  function isExpired(entry) {
+    return Date.now() > entry.expiresAt;
+  }
+  function createMatcher(pattern) {
+    const fullPattern = buildKey(pattern);
+    const hasWildcard = pattern.includes("*");
+    if (!hasWildcard) {
+      return (key) => key.startsWith(fullPattern);
+    }
+    const escaped = fullPattern.replaceAll(/[.+?^${}()|[\]\\]/g, "\\$&");
+    const regexPattern = escaped.replaceAll("*", ".*");
+    const regex = new RegExp(`^${regexPattern}`);
+    return (key) => regex.test(key);
+  }
+  async function get(key) {
+    if (key.includes("*")) {
+      throw new TypeError(
+        "Cache key cannot contain wildcards (*). Use getAll(pattern) to retrieve multiple entries."
+      );
+    }
+    const fullKey = buildKey(key);
+    if (opts.memoize) {
+      const memoEntry = memoCache.get(fullKey);
+      if (memoEntry && !isExpired(memoEntry)) {
+        return memoEntry.data;
+      }
+      if (memoEntry) {
+        memoCache.delete(fullKey);
+      }
+    }
+    const cacheEntry = await cacache.safeGet(fullKey);
+    if (cacheEntry) {
+      const entry = JSON.parse(
+        cacheEntry.data.toString("utf8")
+      );
+      if (!isExpired(entry)) {
+        if (opts.memoize) {
+          memoCache.set(fullKey, entry);
+        }
+        return entry.data;
+      }
+      await cacache.remove(fullKey);
+    }
+    return void 0;
+  }
+  async function getAll(pattern) {
+    const results = /* @__PURE__ */ new Map();
+    const matches = createMatcher(pattern);
+    if (opts.memoize) {
+      for (const [key, entry] of memoCache.entries()) {
+        if (!matches(key)) {
+          continue;
+        }
+        if (isExpired(entry)) {
+          memoCache.delete(key);
+          continue;
+        }
+        const originalKey = key.slice((opts.prefix?.length ?? 0) + 1);
+        results.set(originalKey, entry.data);
+      }
+    }
+    const cacheDir = (await import("./paths")).getSocketCacacheDir();
+    const cacacheModule = await import("./cacache");
+    const stream = cacacheModule.getCacache().ls.stream(cacheDir);
+    for await (const cacheEntry of stream) {
+      if (!cacheEntry.key.startsWith(`${opts.prefix}:`)) {
+        continue;
+      }
+      if (!matches(cacheEntry.key)) {
+        continue;
+      }
+      const originalKey = cacheEntry.key.slice((opts.prefix?.length ?? 0) + 1);
+      if (results.has(originalKey)) {
+        continue;
+      }
+      try {
+        const entry = await cacache.safeGet(cacheEntry.key);
+        if (!entry) {
+          continue;
+        }
+        const parsed = JSON.parse(
+          entry.data.toString("utf8")
+        );
+        if (isExpired(parsed)) {
+          await cacache.remove(cacheEntry.key);
+          continue;
+        }
+        results.set(originalKey, parsed.data);
+        if (opts.memoize) {
+          memoCache.set(cacheEntry.key, parsed);
+        }
+      } catch {
+      }
+    }
+    return results;
+  }
+  async function set(key, data) {
+    if (key.includes("*")) {
+      throw new TypeError(
+        'Cache key cannot contain wildcards (*). Wildcards are only supported in clear({ prefix: "pattern*" }).'
+      );
+    }
+    const fullKey = buildKey(key);
+    const entry = {
+      data,
+      expiresAt: Date.now() + ttl
+    };
+    if (opts.memoize) {
+      memoCache.set(fullKey, entry);
+    }
+    await cacache.put(fullKey, JSON.stringify(entry), {
+      metadata: { expiresAt: entry.expiresAt }
+    });
+  }
+  async function getOrFetch(key, fetcher) {
+    const cached = await get(key);
+    if (cached !== void 0) {
+      return cached;
+    }
+    const data = await fetcher();
+    await set(key, data);
+    return data;
+  }
+  async function deleteEntry(key) {
+    if (key.includes("*")) {
+      throw new TypeError(
+        "Cache key cannot contain wildcards (*). Use deleteAll(pattern) to remove multiple entries."
+      );
+    }
+    const fullKey = buildKey(key);
+    memoCache.delete(fullKey);
+    await cacache.remove(fullKey);
+  }
+  async function deleteAll(pattern) {
+    const fullPrefix = pattern ? `${opts.prefix}:${pattern}` : opts.prefix;
+    if (!pattern) {
+      memoCache.clear();
+    } else {
+      const matches = createMatcher(pattern);
+      for (const key of memoCache.keys()) {
+        if (matches(key)) {
+          memoCache.delete(key);
+        }
+      }
+    }
+    const removed = await cacache.clear({ prefix: fullPrefix });
+    return removed ?? 0;
+  }
+  async function clear(options2) {
+    const opts2 = { __proto__: null, ...options2 };
+    memoCache.clear();
+    if (opts2.memoOnly) {
+      return;
+    }
+    await deleteAll();
+  }
+  return {
+    clear,
+    delete: deleteEntry,
+    deleteAll,
+    get,
+    getAll,
+    getOrFetch,
+    set
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createTtlCache
+});
+//# sourceMappingURL=cache-with-ttl.js.map

package/dist/cache-with-ttl.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/cache-with-ttl.ts"],
+  "sourcesContent": ["/**\n * @fileoverview Generic TTL-based caching utility using cacache.\n *\n * Provides a simple interface for caching data with time-to-live (TTL) expiration.\n * Uses cacache for persistent storage with metadata for TTL tracking.\n *\n * Features:\n * - Automatic expiration based on TTL\n * - In-memory memoization for hot data\n * - Persistent storage across process restarts\n * - Type-safe with generics\n *\n * Usage:\n * ```ts\n * const cache = createTtlCache({ ttl: 5 * 60 * 1000 }) // 5 minutes\n * const data = await cache.getOrFetch('key', async () => fetchData())\n * ```\n */\n\nimport * as cacache from './cacache'\n\nexport interface TtlCacheOptions {\n  /**\n   * Time-to-live in milliseconds.\n   * @default 5 * 60 * 1000 (5 minutes)\n   */\n  ttl?: number | undefined\n  /**\n   * Enable in-memory memoization for hot data.\n   * @default true\n   */\n  memoize?: boolean | undefined\n  /**\n   * Custom cache key prefix.\n   * Must not contain wildcards (*).\n   * Use clear({ prefix: \"pattern*\" }) for wildcard matching instead.\n   *\n   * @default 'ttl-cache'\n   * @throws {TypeError} If prefix contains wildcards\n   *\n   * @example\n   * // Valid\n   * createTtlCache({ prefix: 'socket-sdk' })\n   * createTtlCache({ prefix: 'my-app:cache' })\n   *\n   * @example\n   * // Invalid - throws TypeError\n   * createTtlCache({ prefix: 'socket-*' })\n   */\n  prefix?: string | undefined\n}\n\nexport interface TtlCacheEntry<T> {\n  data: T\n  expiresAt: number\n}\n\nexport interface ClearOptions {\n  /**\n   * Only clear in-memory memoization cache, not persistent cache.\n   * Useful for forcing a refresh of cached data without removing it from disk.\n   *\n   * @default false\n   */\n  memoOnly?: boolean | undefined\n}\n\nexport interface TtlCache {\n  /**\n   * Get cached data without fetching.\n   * Returns undefined if not found or expired.\n   *\n   * @param key - Cache key (must not contain wildcards)\n   * @throws {TypeError} If key contains wildcards (*)\n   */\n  get<T>(key: string): Promise<T | undefined>\n  /**\n   * Get all cached entries matching a pattern.\n   * Supports wildcards (*) for flexible matching.\n   *\n   * @param pattern - Key pattern (supports * wildcards, or use '*' for all entries)\n   * @returns Map of matching entries (key -> value)\n   *\n   * @example\n   * // Get all organization entries\n   * const orgs = await cache.getAll<OrgData>('organizations:*')\n   * for (const [key, org] of orgs) {\n   *   console.log(`${key}: ${org.name}`)\n   * }\n   *\n   * @example\n   * // Get all entries with this cache's prefix\n   * const all = await cache.getAll<any>('*')\n   */\n  getAll<T>(pattern: string): Promise<Map<string, T>>\n  /**\n   * Get cached data or fetch and cache if missing/expired.\n   *\n   * @param key - Cache key (must not contain wildcards)\n   */\n  getOrFetch<T>(key: string, fetcher: () => Promise<T>): Promise<T>\n  /**\n   * Set cached data with TTL.\n   *\n   * @param key - Cache key (must not contain wildcards)\n   * @throws {TypeError} If key contains wildcards (*)\n   */\n  set<T>(key: string, data: T): Promise<void>\n  /**\n   * Delete a specific cache entry.\n   *\n   * @param key - Cache key (must not contain wildcards)\n   * @throws {TypeError} If key contains wildcards (*)\n   */\n  delete(key: string): Promise<void>\n  /**\n   * Delete all cache entries matching a pattern.\n   * Supports wildcards (*) for flexible matching.\n   *\n   * @param pattern - Key pattern (supports * wildcards, or omit to delete all)\n   * @returns Number of entries deleted\n   *\n   * @example\n   * // Delete all entries with this cache's prefix\n   * await cache.deleteAll()\n   *\n   * @example\n   * // Delete entries matching prefix\n   * await cache.deleteAll('organizations')\n   *\n   * @example\n   * // Delete entries with wildcard pattern\n   * await cache.deleteAll('scans:abc*')\n   * await cache.deleteAll('npm/lodash/*')\n   */\n  deleteAll(pattern?: string | undefined): Promise<number>\n  /**\n   * Clear all cache entries (like Map.clear()).\n   * Optionally clear only in-memory cache.\n   *\n   * @param options - Optional configuration\n   * @param options.memoOnly - If true, only clears in-memory cache\n   *\n   * @example\n   * // Clear everything (memory + disk)\n   * await cache.clear()\n   *\n   * @example\n   * // Clear only in-memory cache (force refresh)\n   * await cache.clear({ memoOnly: true })\n   */\n  clear(options?: ClearOptions | undefined): Promise<void>\n}\n\n// 5 minutes\nconst DEFAULT_TTL_MS = 5 * 60 * 1000\nconst DEFAULT_PREFIX = 'ttl-cache'\n\n/**\n * Create a TTL-based cache instance.\n */\nexport function createTtlCache(options?: TtlCacheOptions): TtlCache {\n  const opts = {\n    __proto__: null,\n    memoize: true,\n    prefix: DEFAULT_PREFIX,\n    ttl: DEFAULT_TTL_MS,\n    ...options,\n  } as Required<TtlCacheOptions>\n\n  // Validate prefix does not contain wildcards.\n  if (opts.prefix?.includes('*')) {\n    throw new TypeError(\n      'Cache prefix cannot contain wildcards (*). Use clear({ prefix: \"pattern*\" }) for wildcard matching.',\n    )\n  }\n\n  // In-memory cache for hot data\n  // biome-ignore lint/suspicious/noExplicitAny: Generic cache for any value type.\n  const memoCache = new Map<string, TtlCacheEntry<any>>()\n\n  // Ensure ttl is defined\n  const ttl = opts.ttl ?? DEFAULT_TTL_MS\n\n  /**\n   * Build full cache key with prefix.\n   */\n  function buildKey(key: string): string {\n    return `${opts.prefix}:${key}`\n  }\n\n  /**\n   * Check if entry is expired.\n   */\n  function isExpired(\n    // biome-ignore lint/suspicious/noExplicitAny: Generic check for any entry type.\n    entry: TtlCacheEntry<any>,\n  ): boolean {\n    return Date.now() > entry.expiresAt\n  }\n\n  /**\n   * Create a matcher function for a pattern (with wildcard support).\n   * Returns a function that tests if a key matches the pattern.\n   */\n  function createMatcher(pattern: string): (key: string) => boolean {\n    const fullPattern = buildKey(pattern)\n    const hasWildcard = pattern.includes('*')\n\n    if (!hasWildcard) {\n      // Simple prefix matching (fast path).\n      return (key: string) => key.startsWith(fullPattern)\n    }\n\n    // Wildcard matching with regex.\n    const escaped = fullPattern.replaceAll(/[.+?^${}()|[\\]\\\\]/g, '\\\\$&')\n    const regexPattern = escaped.replaceAll('*', '.*')\n    const regex = new RegExp(`^${regexPattern}`)\n    return (key: string) => regex.test(key)\n  }\n\n  /**\n   * Get cached data without fetching.\n   *\n   * @throws {TypeError} If key contains wildcards (*)\n   */\n  async function get<T>(key: string): Promise<T | undefined> {\n    if (key.includes('*')) {\n      throw new TypeError(\n        'Cache key cannot contain wildcards (*). Use getAll(pattern) to retrieve multiple entries.',\n      )\n    }\n\n    const fullKey = buildKey(key)\n\n    // Check in-memory cache first.\n    if (opts.memoize) {\n      const memoEntry = memoCache.get(fullKey)\n      if (memoEntry && !isExpired(memoEntry)) {\n        return memoEntry.data as T\n      }\n      // Remove expired memo entry.\n      if (memoEntry) {\n        memoCache.delete(fullKey)\n      }\n    }\n\n    // Check persistent cache.\n    const cacheEntry = await cacache.safeGet(fullKey)\n    if (cacheEntry) {\n      const entry = JSON.parse(\n        cacheEntry.data.toString('utf8'),\n      ) as TtlCacheEntry<T>\n      if (!isExpired(entry)) {\n        // Update in-memory cache.\n        if (opts.memoize) {\n          memoCache.set(fullKey, entry)\n        }\n        return entry.data\n      }\n      // Remove expired entry.\n      await cacache.remove(fullKey)\n    }\n\n    return undefined\n  }\n\n  /**\n   * Get all cached entries matching a pattern.\n   * Supports wildcards (*) for flexible matching.\n   */\n  async function getAll<T>(pattern: string): Promise<Map<string, T>> {\n    const results = new Map<string, T>()\n    const matches = createMatcher(pattern)\n\n    // Check in-memory cache first.\n    if (opts.memoize) {\n      for (const [key, entry] of memoCache.entries()) {\n        if (!matches(key)) {\n          continue\n        }\n\n        // Skip if expired.\n        if (isExpired(entry)) {\n          memoCache.delete(key)\n          continue\n        }\n\n        // Add to results (strip cache prefix from key).\n        const originalKey = key.slice((opts.prefix?.length ?? 0) + 1)\n        results.set(originalKey, entry.data as T)\n      }\n    }\n\n    // Check persistent cache for entries not in memory.\n    const cacheDir = (await import('./paths')).getSocketCacacheDir()\n    // biome-ignore lint/suspicious/noExplicitAny: cacache types are incomplete.\n    const cacacheModule = (await import('./cacache')) as any\n    const stream = cacacheModule.getCacache().ls.stream(cacheDir)\n\n    for await (const cacheEntry of stream) {\n      // Skip if doesn't match our cache prefix.\n      if (!cacheEntry.key.startsWith(`${opts.prefix}:`)) {\n        continue\n      }\n\n      // Skip if doesn't match pattern.\n      if (!matches(cacheEntry.key)) {\n        continue\n      }\n\n      // Skip if already in results (from memory).\n      const originalKey = cacheEntry.key.slice((opts.prefix?.length ?? 0) + 1)\n      if (results.has(originalKey)) {\n        continue\n      }\n\n      // Get entry from cache.\n      try {\n        const entry = await cacache.safeGet(cacheEntry.key)\n        if (!entry) {\n          continue\n        }\n\n        const parsed = JSON.parse(\n          entry.data.toString('utf8'),\n        ) as TtlCacheEntry<T>\n\n        // Skip if expired.\n        if (isExpired(parsed)) {\n          await cacache.remove(cacheEntry.key)\n          continue\n        }\n\n        // Add to results.\n        results.set(originalKey, parsed.data)\n\n        // Update in-memory cache.\n        if (opts.memoize) {\n          memoCache.set(cacheEntry.key, parsed)\n        }\n      } catch {\n        // Ignore parse errors or other issues.\n      }\n    }\n\n    return results\n  }\n\n  /**\n   * Set cached data with TTL.\n   *\n   * @throws {TypeError} If key contains wildcards (*)\n   */\n  async function set<T>(key: string, data: T): Promise<void> {\n    if (key.includes('*')) {\n      throw new TypeError(\n        'Cache key cannot contain wildcards (*). Wildcards are only supported in clear({ prefix: \"pattern*\" }).',\n      )\n    }\n\n    const fullKey = buildKey(key)\n    const entry: TtlCacheEntry<T> = {\n      data,\n      expiresAt: Date.now() + ttl,\n    }\n\n    // Update in-memory cache.\n    if (opts.memoize) {\n      memoCache.set(fullKey, entry)\n    }\n\n    // Update persistent cache.\n    await cacache.put(fullKey, JSON.stringify(entry), {\n      metadata: { expiresAt: entry.expiresAt },\n    })\n  }\n\n  /**\n   * Get cached data or fetch and cache if missing/expired.\n   */\n  async function getOrFetch<T>(\n    key: string,\n    fetcher: () => Promise<T>,\n  ): Promise<T> {\n    const cached = await get<T>(key)\n    if (cached !== undefined) {\n      return cached\n    }\n\n    const data = await fetcher()\n    await set(key, data)\n    return data\n  }\n\n  /**\n   * Delete a specific cache entry.\n   *\n   * @throws {TypeError} If key contains wildcards (*)\n   */\n  async function deleteEntry(key: string): Promise<void> {\n    if (key.includes('*')) {\n      throw new TypeError(\n        'Cache key cannot contain wildcards (*). Use deleteAll(pattern) to remove multiple entries.',\n      )\n    }\n\n    const fullKey = buildKey(key)\n    memoCache.delete(fullKey)\n    await cacache.remove(fullKey)\n  }\n\n  /**\n   * Delete all cache entries matching a pattern.\n   * Supports wildcards (*) in patterns.\n   * Delegates to cacache.clear() which handles pattern matching efficiently.\n   */\n  async function deleteAll(pattern?: string | undefined): Promise<number> {\n    // Build full prefix/pattern by combining cache prefix with optional pattern.\n    const fullPrefix = pattern ? `${opts.prefix}:${pattern}` : opts.prefix\n\n    // Delete matching in-memory entries.\n    if (!pattern) {\n      // Delete all in-memory entries for this cache.\n      memoCache.clear()\n    } else {\n      // Delete matching in-memory entries using shared matcher logic.\n      const matches = createMatcher(pattern)\n      for (const key of memoCache.keys()) {\n        if (matches(key)) {\n          memoCache.delete(key)\n        }\n      }\n    }\n\n    // Delete matching persistent cache entries.\n    // Delegate to cacache.clear() which handles wildcards efficiently.\n    const removed = await cacache.clear({ prefix: fullPrefix })\n    return (removed ?? 0) as number\n  }\n\n  /**\n   * Clear all cache entries (like Map.clear()).\n   * Optionally clear only in-memory cache.\n   */\n  async function clear(options?: ClearOptions | undefined): Promise<void> {\n    const opts = { __proto__: null, ...options } as ClearOptions\n\n    // Clear in-memory cache.\n    memoCache.clear()\n\n    // If memoOnly, stop here.\n    if (opts.memoOnly) {\n      return\n    }\n\n    // Clear persistent cache.\n    await deleteAll()\n  }\n\n  return {\n    clear,\n    delete: deleteEntry,\n    deleteAll,\n    get,\n    getAll,\n    getOrFetch,\n    set,\n  }\n}\n"],
+  "mappings": "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",
+  "names": ["options", "opts"]
+}