@socketsecurity/lib 6.0.2 → 6.0.4

package/dist/cache/ttl/store.js

@@ -1,293 +1,237 @@
 "use strict";
-/* Socket Lib - Built with esbuild */
-"use strict";
-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 store_exports = {};
-__export(store_exports, {
-  createTtlCache: () => createTtlCache
-});
-module.exports = __toCommonJS(store_exports);
-var import_clear = require("../../cacache/clear");
-var import_read = require("../../cacache/read");
-var import_write = require("../../cacache/write");
-var import_date = require("../../primordials/date");
-var import_error = require("../../primordials/error");
-var import_json = require("../../primordials/json");
-var import_map_set = require("../../primordials/map-set");
-var import_math = require("../../primordials/math");
-var import_regexp = require("../../primordials/regexp");
-var import_string = require("../../primordials/string");
-const DEFAULT_TTL_MS = 5 * 60 * 1e3;
+/* Socket Lib - Built with rolldown */
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_primordials_error = require('../../primordials/error.js');
+const require_primordials_string = require('../../primordials/string.js');
+const require_primordials_math = require('../../primordials/math.js');
+const require_primordials_regexp = require('../../primordials/regexp.js');
+const require_primordials_map_set = require('../../primordials/map-set.js');
+const require_primordials_date = require('../../primordials/date.js');
+const require_primordials_json = require('../../primordials/json.js');
+const require_cacache_clear = require('../../cacache/clear.js');
+const require_cacache_read = require('../../cacache/read.js');
+const require_cacache_write = require('../../cacache/write.js');
+
+//#region src/cache/ttl/store.ts
+/**
+* @file `createTtlCache` — generic TTL-based cache built on top of cacache
+*   (persistent) plus an in-memory LRU memo layer. Two-tier caching: hot data
+*   lives in `memoCache` (Map<string, TtlCacheEntry>) capped at `memoMaxSize`
+*   entries with LRU eviction via Map insertion-order semantics. Persistent
+*   storage uses cacache so cached values survive process restarts. Key
+*   features:
+*
+*   - Per-key namespacing via `prefix` so multiple caches share one cacache
+*     directory without conflicting.
+*   - `getOrFetch` deduplicates concurrent requests for the same key
+*     (thundering-herd protection via `inflightRequests` map).
+*   - Wildcard support for `getAll` / `deleteAll` (single-key methods throw on
+*     `*`).
+*   - Clock-skew detection: entries with suspiciously-far-future `expiresAt` are
+*     treated as expired.
+*/
+const DEFAULT_TTL_MS = 300 * 1e3;
 const DEFAULT_PREFIX = "ttl-cache";
 const DEFAULT_MEMO_MAX_SIZE = 1e3;
+/**
+* Create a TTL-based cache instance.
+*
+* @example
+*   ;```typescript
+*   const cache = createTtlCache({ ttl: 60_000, prefix: 'my-app' })
+*   await cache.set('key', { value: 42 })
+*   const data = await cache.get('key') // { value: 42 }
+*   ```
+*/
 function createTtlCache(options) {
-  const opts = {
-    __proto__: null,
-    memoize: true,
-    memoMaxSize: DEFAULT_MEMO_MAX_SIZE,
-    prefix: DEFAULT_PREFIX,
-    ttl: DEFAULT_TTL_MS,
-    ...options
-  };
-  if (opts.prefix?.includes("*")) {
-    throw new import_error.TypeErrorCtor(
-      'Cache prefix cannot contain wildcards (*). Use clear({ prefix: "pattern*" }) for wildcard matching.'
-    );
-  }
-  const memoCache = new import_map_set.MapCtor();
-  const memoMaxSize = (0, import_math.MathMax)(1, opts.memoMaxSize ?? DEFAULT_MEMO_MAX_SIZE);
-  function memoSet(fullKey, entry) {
-    if (memoCache.has(fullKey)) {
-      memoCache.delete(fullKey);
-    } else if (memoCache.size >= memoMaxSize) {
-      const oldest = memoCache.keys().next().value;
-      if (oldest !== void 0) {
-        memoCache.delete(oldest);
-      }
-    }
-    memoCache.set(fullKey, entry);
-  }
-  const ttl = opts.ttl ?? DEFAULT_TTL_MS;
-  function buildKey(key) {
-    return `${opts.prefix}:${key}`;
-  }
-  function isExpired(entry) {
-    const now = (0, import_date.DateNow)();
-    const maxFutureMs = 1e4;
-    if (entry.expiresAt > now + ttl + maxFutureMs) {
-      return true;
-    }
-    return now > entry.expiresAt;
-  }
-  function createMatcher(pattern) {
-    const fullPattern = buildKey(pattern);
-    const hasWildcard = pattern.includes("*");
-    if (!hasWildcard) {
-      return (key) => (0, import_string.StringPrototypeStartsWith)(key, fullPattern);
-    }
-    const escaped = (0, import_string.StringPrototypeReplaceAll)(
-      fullPattern,
-      /[.+?^${}()|[\]\\]/g,
-      "\\$&"
-    );
-    const regexPattern = (0, import_string.StringPrototypeReplaceAll)(escaped, "*", ".*");
-    const regex = new import_regexp.RegExpCtor(`^${regexPattern}$`);
-    return (key) => (0, import_regexp.RegExpPrototypeTest)(regex, key);
-  }
-  async function get(key) {
-    if ((0, import_string.StringPrototypeIncludes)(key, "*")) {
-      throw new import_error.TypeErrorCtor(
-        "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)) {
-        memoSet(fullKey, memoEntry);
-        return memoEntry.data;
-      }
-      if (memoEntry) {
-        memoCache.delete(fullKey);
-      }
-    }
-    const cacheEntry = await (0, import_read.safeGet)(fullKey);
-    if (cacheEntry) {
-      let entry;
-      try {
-        entry = (0, import_json.JSONParse)(cacheEntry.data.toString("utf8"));
-      } catch {
-        try {
-          await (0, import_write.remove)(fullKey);
-        } catch {
-        }
-        return void 0;
-      }
-      if (!isExpired(entry)) {
-        if (opts.memoize) {
-          memoSet(fullKey, entry);
-        }
-        return entry.data;
-      }
-      try {
-        await (0, import_write.remove)(fullKey);
-      } catch {
-      }
-    }
-    return void 0;
-  }
-  async function getAll(pattern) {
-    const results = new import_map_set.MapCtor();
-    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 = opts.prefix ? (0, import_string.StringPrototypeSlice)(key, opts.prefix.length + 1) : key;
-        results.set(originalKey, entry.data);
-      }
-    }
-    const cacheDir = (await import("../../paths/socket")).getSocketCacacheDir();
-    const cacacheModule = await import("../../cacache/_internal");
-    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 = opts.prefix ? cacheEntry.key.slice(opts.prefix.length + 1) : cacheEntry.key;
-      if (results.has(originalKey)) {
-        continue;
-      }
-      try {
-        const entry = await (0, import_read.safeGet)(cacheEntry.key);
-        if (!entry) {
-          continue;
-        }
-        const parsed = (0, import_json.JSONParse)(
-          entry.data.toString("utf8")
-        );
-        if (isExpired(parsed)) {
-          await (0, import_write.remove)(cacheEntry.key);
-          continue;
-        }
-        results.set(originalKey, parsed.data);
-        if (opts.memoize) {
-          memoSet(cacheEntry.key, parsed);
-        }
-      } catch {
-      }
-    }
-    return results;
-  }
-  async function set(key, data) {
-    if ((0, import_string.StringPrototypeIncludes)(key, "*")) {
-      throw new import_error.TypeErrorCtor(
-        'Cache key cannot contain wildcards (*). Wildcards are only supported in clear({ prefix: "pattern*" }).'
-      );
-    }
-    const fullKey = buildKey(key);
-    const entry = {
-      data,
-      expiresAt: (0, import_date.DateNow)() + ttl
-    };
-    if (opts.memoize) {
-      memoSet(fullKey, entry);
-    }
-    try {
-      await (0, import_write.put)(fullKey, (0, import_json.JSONStringify)(entry), {
-        metadata: { expiresAt: entry.expiresAt }
-      });
-    } catch {
-    }
-  }
-  const inflightRequests = new import_map_set.MapCtor();
-  async function getOrFetch(key, fetcher) {
-    const fullKey = buildKey(key);
-    const preexisting = inflightRequests.get(fullKey);
-    if (preexisting) {
-      return await preexisting;
-    }
-    const cached = await get(key);
-    if (cached !== void 0) {
-      return cached;
-    }
-    const rechecked = inflightRequests.get(fullKey);
-    if (rechecked) {
-      return await rechecked;
-    }
-    const promise = (async () => {
-      try {
-        const data = await fetcher();
-        await set(key, data);
-        return data;
-      } finally {
-        inflightRequests.delete(fullKey);
-      }
-    })();
-    inflightRequests.set(fullKey, promise);
-    return await promise;
-  }
-  async function deleteEntry(key) {
-    if ((0, import_string.StringPrototypeIncludes)(key, "*")) {
-      throw new import_error.TypeErrorCtor(
-        "Cache key cannot contain wildcards (*). Use deleteAll(pattern) to remove multiple entries."
-      );
-    }
-    const fullKey = buildKey(key);
-    memoCache.delete(fullKey);
-    try {
-      await (0, import_write.remove)(fullKey);
-    } catch {
-    }
-  }
-  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 (0, import_clear.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
-  };
+	const opts = {
+		__proto__: null,
+		memoize: true,
+		memoMaxSize: DEFAULT_MEMO_MAX_SIZE,
+		prefix: DEFAULT_PREFIX,
+		ttl: DEFAULT_TTL_MS,
+		...options
+	};
+	if (opts.prefix?.includes("*")) throw new require_primordials_error.TypeErrorCtor("Cache prefix cannot contain wildcards (*). Use clear({ prefix: \"pattern*\" }) for wildcard matching.");
+	const memoCache = new require_primordials_map_set.MapCtor();
+	const memoMaxSize = require_primordials_math.MathMax(1, opts.memoMaxSize ?? DEFAULT_MEMO_MAX_SIZE);
+	function memoSet(fullKey, entry) {
+		/* c8 ignore start */
+		if (memoCache.has(fullKey)) memoCache.delete(fullKey);
+		else if (memoCache.size >= memoMaxSize) {
+			const oldest = memoCache.keys().next().value;
+			if (oldest !== void 0) memoCache.delete(oldest);
+		}
+		/* c8 ignore stop */
+		memoCache.set(fullKey, entry);
+	}
+	/* c8 ignore next */
+	const ttl = opts.ttl ?? DEFAULT_TTL_MS;
+	/**
+	* Build full cache key with prefix.
+	*/
+	function buildKey(key) {
+		return `${opts.prefix}:${key}`;
+	}
+	/**
+	* Check if entry is expired. Also detects clock skew by treating suspiciously
+	* far-future expiresAt as expired.
+	*/
+	function isExpired(entry) {
+		const now = require_primordials_date.DateNow();
+		if (entry.expiresAt > now + ttl + 1e4) return true;
+		return now > entry.expiresAt;
+	}
+	/**
+	* Create a matcher function for a pattern (with wildcard support). Returns a
+	* function that tests if a key matches the pattern.
+	*/
+	function createMatcher(pattern) {
+		const fullPattern = buildKey(pattern);
+		if (!pattern.includes("*")) return (key) => require_primordials_string.StringPrototypeStartsWith(key, fullPattern);
+		const regex = new require_primordials_regexp.RegExpCtor(`^${require_primordials_string.StringPrototypeReplaceAll(require_primordials_string.StringPrototypeReplaceAll(fullPattern, /[.+?^${}()|[\]\\]/g, "\\$&"), "*", ".*")}$`);
+		return (key) => require_primordials_regexp.RegExpPrototypeTest(regex, key);
+	}
+	async function get(key) {
+		if (require_primordials_string.StringPrototypeIncludes(key, "*")) throw new require_primordials_error.TypeErrorCtor("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)) {
+				memoSet(fullKey, memoEntry);
+				return memoEntry.data;
+			}
+			if (memoEntry) memoCache.delete(fullKey);
+		}
+		const cacheEntry = await require_cacache_read.safeGet(fullKey);
+		if (cacheEntry) {
+			let entry;
+			try {
+				entry = require_primordials_json.JSONParse(cacheEntry.data.toString("utf8"));
+			} catch {
+				try {
+					await require_cacache_write.remove(fullKey);
+				} catch {}
+				return;
+			}
+			if (!isExpired(entry)) {
+				if (opts.memoize) memoSet(fullKey, entry);
+				return entry.data;
+			}
+			/* c8 ignore start */
+			try {
+				await require_cacache_write.remove(fullKey);
+			} catch {}
+		}
+	}
+	async function getAll(pattern) {
+		const results = new require_primordials_map_set.MapCtor();
+		const matches = createMatcher(pattern);
+		/* c8 ignore start */
+		if (opts.memoize) for (const [key, entry] of memoCache.entries()) {
+			if (!matches(key)) continue;
+			if (isExpired(entry)) {
+				memoCache.delete(key);
+				continue;
+			}
+			const originalKey = opts.prefix ? require_primordials_string.StringPrototypeSlice(key, opts.prefix.length + 1) : key;
+			results.set(originalKey, entry.data);
+		}
+		/* c8 ignore stop */
+		const cacheDir = (await Promise.resolve().then(() => require("../../paths/socket.js"))).getSocketCacacheDir();
+		const stream = (await Promise.resolve().then(() => require("../../cacache/_internal.js"))).getCacache().ls.stream(cacheDir);
+		for await (const cacheEntry of stream) {
+			if (!cacheEntry.key.startsWith(`${opts.prefix}:`)) continue;
+			if (!matches(cacheEntry.key)) continue;
+			const originalKey = opts.prefix ? cacheEntry.key.slice(opts.prefix.length + 1) : cacheEntry.key;
+			if (results.has(originalKey)) continue;
+			try {
+				const entry = await require_cacache_read.safeGet(cacheEntry.key);
+				if (!entry) continue;
+				const parsed = require_primordials_json.JSONParse(entry.data.toString("utf8"));
+				if (isExpired(parsed)) {
+					await require_cacache_write.remove(cacheEntry.key);
+					continue;
+				}
+				results.set(originalKey, parsed.data);
+				if (opts.memoize) memoSet(cacheEntry.key, parsed);
+			} catch {}
+		}
+		return results;
+	}
+	async function set(key, data) {
+		if (require_primordials_string.StringPrototypeIncludes(key, "*")) throw new require_primordials_error.TypeErrorCtor("Cache key cannot contain wildcards (*). Wildcards are only supported in clear({ prefix: \"pattern*\" }).");
+		const fullKey = buildKey(key);
+		const entry = {
+			data,
+			expiresAt: require_primordials_date.DateNow() + ttl
+		};
+		if (opts.memoize) memoSet(fullKey, entry);
+		try {
+			await require_cacache_write.put(fullKey, require_primordials_json.JSONStringify(entry), { metadata: { expiresAt: entry.expiresAt } });
+		} catch {}
+	}
+	const inflightRequests = new require_primordials_map_set.MapCtor();
+	async function getOrFetch(key, fetcher) {
+		const fullKey = buildKey(key);
+		/* c8 ignore start */
+		const preexisting = inflightRequests.get(fullKey);
+		if (preexisting) return await preexisting;
+		/* c8 ignore stop */
+		const cached = await get(key);
+		if (cached !== void 0) return cached;
+		/* c8 ignore start */
+		const rechecked = inflightRequests.get(fullKey);
+		if (rechecked) return await rechecked;
+		/* c8 ignore stop */
+		const promise = (async () => {
+			try {
+				const data = await fetcher();
+				await set(key, data);
+				return data;
+			} finally {
+				inflightRequests.delete(fullKey);
+			}
+		})();
+		inflightRequests.set(fullKey, promise);
+		return await promise;
+	}
+	async function deleteEntry(key) {
+		if (require_primordials_string.StringPrototypeIncludes(key, "*")) throw new require_primordials_error.TypeErrorCtor("Cache key cannot contain wildcards (*). Use deleteAll(pattern) to remove multiple entries.");
+		const fullKey = buildKey(key);
+		memoCache.delete(fullKey);
+		try {
+			await require_cacache_write.remove(fullKey);
+		} catch {}
+	}
+	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);
+		}
+		return await require_cacache_clear.clear({ prefix: fullPrefix }) ?? 0;
+	}
+	async function clear$1(options) {
+		const opts = {
+			__proto__: null,
+			...options
+		};
+		memoCache.clear();
+		if (opts.memoOnly) return;
+		await deleteAll();
+	}
+	return {
+		clear: clear$1,
+		delete: deleteEntry,
+		deleteAll,
+		get,
+		getAll,
+		getOrFetch,
+		set
+	};
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  createTtlCache
-});
+
+//#endregion
+exports.createTtlCache = createTtlCache;

package/dist/cache/ttl/types.js

@@ -1,18 +1,2 @@
 "use strict";
-/* Socket Lib - Built with esbuild */
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-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 types_exports = {};
-module.exports = __toCommonJS(types_exports);
+/* Socket Lib - Built with rolldown */