Use deno for checks

Author: ascorbic

.vscode/settings.json

@@ -1,6 +1,8 @@
 {
 	"typescript.tsdk": "node_modules/typescript/lib",
-	"deno.enablePaths": ["packages/cache-handlers/test/deno"],
+	"deno.enablePaths": [
+		"packages/cache-handlers/"
+	],
 	"deno.config": "./deno.json",
 	"deno.suggest.imports.hosts": {
 		"https://deno.land": true,

deno.lock

@@ -61,12 +61,7 @@ export async function invalidateByTag(
 	// Clean up tag metadata after successful deletion
 	if (metadataResponse && metadata[validatedTag]) {
 		delete metadata[validatedTag];
-		await cache.put(
-			METADATA_KEY,
-			new Response(JSON.stringify(metadata), {
-				headers: { "Content-Type": "application/json" },
-			}),
-		);
+		await cache.put(METADATA_KEY, Response.json(metadata));
 	}
 
 	return deletedCount;
@@ -161,12 +156,7 @@ export async function invalidateByPath(
 			}
 		}
 
-		await cache.put(
-			METADATA_KEY,
-			new Response(JSON.stringify(updatedMetadata), {
-				headers: { "Content-Type": "application/json" },
-			}),
-		);
+		await cache.put(METADATA_KEY, Response.json(updatedMetadata));
 	}
 
 	return deletedCount;
@@ -336,10 +326,75 @@ export async function getCacheStats(
 export async function regenerateCacheStats(
 	options: InvalidationOptions = {},
 ): Promise<{ totalEntries: number; entriesByTag: Record<string, number> }> {
-	// In Deno, we can't enumerate cache keys, so this function cannot work
-	// without the ability to list all cache entries. Return empty stats.
-	console.warn(
-		"regenerateCacheStats: Cannot enumerate cache keys in Deno environment",
-	);
-	return { totalEntries: 0, entriesByTag: {} };
+	const cache = await getCache(options);
+	interface CacheWithKeys extends Cache {
+		keys(): Promise<Request[]>;
+	}
+	if (!("keys" in cache)) {
+		console.warn(
+			"regenerateCacheStats: cache.keys() not supported in this runtime; returning empty stats",
+		);
+		return { totalEntries: 0, entriesByTag: {} };
+	}
+
+	let requests: Request[] = [];
+	try {
+		requests = await (cache as unknown as CacheWithKeys).keys();
+	} catch (err) {
+		console.warn("regenerateCacheStats: failed to enumerate cache keys", err);
+		return { totalEntries: 0, entriesByTag: {} };
+	}
+
+	const metadata: Record<string, string[]> = {};
+	const uniqueKeys = new Set<string>();
+
+	for (const req of requests) {
+		const url = req.url;
+		if (url === METADATA_KEY) {
+			continue; // skip old metadata entry
+		}
+		uniqueKeys.add(url);
+
+		let response: Response | undefined;
+		try {
+			response = await cache.match(req) as Response | undefined;
+		} catch {
+			continue;
+		}
+		if (!response) {
+			continue;
+		}
+		const tagHeader = response.headers.get("cache-tag");
+		if (!tagHeader) {
+			continue; // cannot reconstruct tags if they were stripped
+		}
+		const tags = parseCacheTags(tagHeader);
+		for (const tag of tags) {
+			if (!metadata[tag]) {
+				metadata[tag] = [];
+			}
+			metadata[tag].push(url);
+		}
+	}
+
+	// Write rebuilt metadata (best-effort)
+	try {
+		await cache.put(METADATA_KEY, Response.json(metadata));
+	} catch (err) {
+		console.warn(
+			"regenerateCacheStats: failed to persist rebuilt metadata",
+			err,
+		);
+	}
+
+	const entriesByTag: Record<string, number> = {};
+	for (const tag in metadata) {
+		const list = metadata[tag];
+		if (!Array.isArray(list)) {
+			continue;
+		}
+		entriesByTag[tag] = list.length;
+	}
+
+	return { totalEntries: uniqueKeys.size, entriesByTag };
 }

packages/cache-handlers/src/invalidation.ts

@@ -238,6 +238,6 @@ export async function cleanupVaryMetadata(
 
 			return cleanedMetadata;
 		},
-		{} as Record<string, any>,
+		{} as const,
 	);
 }

packages/cache-handlers/src/metadata.ts

@@ -19,9 +19,11 @@ export async function readFromCache(
 	const getCacheKey = config.getCacheKey || defaultGetCacheKey;
 	const cache = await getCache(config);
 	const varyMetadataResponse = await cache.match(VARY_METADATA_KEY);
+	// deno-lint-ignore no-explicit-any
 	let varyMetadata: Record<string, any> = {};
 	varyMetadata = await safeJsonParse(
 		varyMetadataResponse?.clone() || null,
+		// deno-lint-ignore no-explicit-any
 		{} as Record<string, any>,
 		"vary metadata parsing in cache handler",
 	);

packages/cache-handlers/src/read.ts

@@ -575,6 +575,7 @@ export function validateCacheTag(tag: string): string {
 	}
 
 	// Remove ALL control characters (0-31) and DEL (127) except space (32)
+	// deno-lint-ignore no-control-regex
 	const sanitized = tag.replace(/[\x00-\x1F\x7F]/g, "").trim();
 
 	if (sanitized.length === 0) {

packages/cache-handlers/src/utils.ts

@@ -5,8 +5,8 @@ import {
 	generateETag,
 	parseETag,
 	validateConditionalRequest,
-} from "../../src/conditional.js";
-import { createCacheHandler } from "../../src/handlers.js";
+} from "../../src/conditional.ts";
+import { createCacheHandler } from "../../src/handlers.ts";
 
 describe("Conditional Requests - Node.js with undici", () => {
 	describe("ETag utilities", () => {

packages/cache-handlers/test/node/conditional.test.ts

@@ -1,6 +1,6 @@
 import { beforeEach, describe, expect, test } from "vitest";
 import { caches, Request, Response } from "undici";
-import { createCacheHandler } from "../../src/index.js";
+import { createCacheHandler } from "../../src/index.ts";
 
 describe("Unified Cache Handler - Node.js with undici", () => {
 	beforeEach(async () => {

packages/cache-handlers/test/node/factory.test.ts

@@ -1,6 +1,6 @@
 import { beforeEach, describe, expect, test } from "vitest";
 import { caches, Request, Response } from "undici";
-import { createCacheHandler } from "../../src/handlers.js";
+import { createCacheHandler } from "../../src/handlers.ts";
 
 describe("Cache Handler - Node.js with undici", () => {
 	beforeEach(async () => {

packages/cache-handlers/test/node/handlers.test.ts

@@ -1,9 +1,10 @@
 // Setup global web APIs using undici's implementations
+// @ts-ignore The undici types are wrong
 import { caches, install } from "undici";
 
 // Make undici's implementations available globally to match the Web API
 if (!globalThis.caches) {
-	globalThis.caches = caches as unknown as CacheStorage;
+	globalThis.caches = caches as CacheStorage;
 }
 
 install();