@getcodesentinel/codesentinel 1.17.2 → 1.17.3

package/dist/index.js

@@ -703,6 +703,14 @@ var DEFAULT_OPTIONS = {
   maxEntryBytes: 4 * 1024 * 1024,
   sweepIntervalWrites: 25
 };
+var DEFAULT_BUCKET = "default";
+var normalizeBucket = (value) => {
+  const trimmed = value.trim().toLowerCase();
+  if (trimmed.length === 0) {
+    return DEFAULT_BUCKET;
+  }
+  return trimmed.replace(/[^a-z0-9_-]/g, "_");
+};
 var FileCacheStore = class {
   constructor(directoryPath, options = DEFAULT_OPTIONS) {
     this.directoryPath = directoryPath;
@@ -712,13 +720,22 @@ var FileCacheStore = class {
   inFlightWrites = /* @__PURE__ */ new Map();
   writesSinceSweep = 0;
   sweepPromise = Promise.resolve();
+  bucketForKey(key) {
+    const configured = this.options.bucketForKey?.(key);
+    if (configured === void 0) {
+      return DEFAULT_BUCKET;
+    }
+    return normalizeBucket(configured);
+  }
   toEntryPath(key) {
+    const bucket = this.bucketForKey(key);
     const digest = createHash("sha256").update(key).digest("hex");
-    return join3(this.directoryPath, `${digest}.json`);
+    return join3(this.directoryPath, bucket, `${digest}.json`);
   }
   async writeEntry(key, entry) {
     const filePath = this.toEntryPath(key);
-    await mkdir(this.directoryPath, { recursive: true });
+    const bucketPath = join3(this.directoryPath, this.bucketForKey(key));
+    await mkdir(bucketPath, { recursive: true });
     const tempPath = `${filePath}.tmp`;
     const payload = {
       key,
@@ -745,34 +762,74 @@ var FileCacheStore = class {
     await this.sweepPromise;
   }
   async evictToSizeLimit() {
+    const nowMs = Date.now();
     let entries;
     try {
-      const dirEntries = await readdir(this.directoryPath, { withFileTypes: true });
+      const bucketEntries = await readdir(this.directoryPath, { withFileTypes: true });
+      const bucketNames = bucketEntries.filter((entry) => entry.isDirectory()).map((entry) => entry.name);
       entries = (await Promise.all(
-        dirEntries.filter((entry) => entry.isFile() && entry.name.endsWith(".json")).map(async (entry) => {
-          const path = join3(this.directoryPath, entry.name);
-          const info = await stat(path);
-          return { path, size: info.size, mtimeMs: info.mtimeMs };
+        bucketNames.map(async (bucket) => {
+          const bucketPath = join3(this.directoryPath, bucket);
+          const files = await readdir(bucketPath, { withFileTypes: true });
+          return await Promise.all(
+            files.filter((entry) => entry.isFile() && entry.name.endsWith(".json")).map(async (entry) => {
+              const path = join3(bucketPath, entry.name);
+              const info = await stat(path);
+              return {
+                path,
+                size: info.size,
+                mtimeMs: info.mtimeMs,
+                bucket
+              };
+            })
+          );
         })
-      )).filter((entry) => Number.isFinite(entry.size) && entry.size > 0);
+      )).flat().filter((entry) => Number.isFinite(entry.size) && entry.size > 0);
     } catch {
       return;
     }
+    if (this.options.maxAgeMsByBucket !== void 0) {
+      const retained = [];
+      let deletedAny2 = false;
+      for (const entry of entries) {
+        const maxAgeMs = this.options.maxAgeMsByBucket[entry.bucket];
+        const expired = typeof maxAgeMs === "number" && Number.isFinite(maxAgeMs) && nowMs - entry.mtimeMs > maxAgeMs;
+        if (!expired) {
+          retained.push(entry);
+          continue;
+        }
+        try {
+          await unlink(entry.path);
+          deletedAny2 = true;
+        } catch {
+          retained.push(entry);
+        }
+      }
+      entries = retained;
+      if (deletedAny2) {
+        this.byKey.clear();
+      }
+    }
     let totalBytes = entries.reduce((sum, entry) => sum + entry.size, 0);
     if (totalBytes <= this.options.maxBytes) {
       return;
     }
     entries.sort((a, b) => a.mtimeMs - b.mtimeMs);
+    let deletedAny = false;
     for (const entry of entries) {
       if (totalBytes <= this.options.maxBytes) {
         break;
       }
       try {
         await unlink(entry.path);
+        deletedAny = true;
         totalBytes -= entry.size;
       } catch {
       }
     }
+    if (deletedAny) {
+      this.byKey.clear();
+    }
   }
   async get(key) {
     if (this.byKey.has(key)) {
@@ -808,7 +865,7 @@ var FileCacheStore = class {
 };
 var SIX_HOURS_MS = 6 * 60 * 60 * 1e3;
 var ONE_DAY_MS = 24 * 60 * 60 * 1e3;
-var DEFAULT_MAX_BYTES = 100 * 1024 * 1024;
+var DEFAULT_MAX_BYTES = 20 * 1024 * 1024;
 var DEFAULT_MAX_ENTRY_BYTES = 4 * 1024 * 1024;
 var DEFAULT_SWEEP_INTERVAL_WRITES = 25;
 var cacheStoreSingleton;
@@ -835,6 +892,8 @@ var getNpmMetadataCacheStore = () => {
     return cacheStoreSingleton;
   }
   const path = join4(resolveCodesentinelCacheDir(process.env), "npm-metadata-v2");
+  const packumentTtlMs = getPackumentCacheTtlMs();
+  const downloadsTtlMs = getWeeklyDownloadsCacheTtlMs();
   cacheStoreSingleton = new FileCacheStore(path, {
     maxBytes: parsePositiveIntegerFromEnv(
       process.env["CODESENTINEL_CACHE_MAX_BYTES"],
@@ -847,7 +906,20 @@ var getNpmMetadataCacheStore = () => {
     sweepIntervalWrites: parsePositiveIntegerFromEnv(
       process.env["CODESENTINEL_CACHE_SWEEP_INTERVAL_WRITES"],
       DEFAULT_SWEEP_INTERVAL_WRITES
-    )
+    ),
+    bucketForKey: (key) => {
+      if (key.startsWith("npm:downloads:last-week:")) {
+        return "downloads";
+      }
+      if (key.startsWith("npm:packument:")) {
+        return "packument";
+      }
+      return "default";
+    },
+    maxAgeMsByBucket: {
+      downloads: downloadsTtlMs,
+      packument: packumentTtlMs
+    }
   });
   return cacheStoreSingleton;
 };