Update tests and types

Author: ascorbic

deno.lock

@@ -174,7 +174,6 @@ console.log(stats.totalEntries, stats.entriesByTag);
 | `cacheName`                                 | Named cache to open (default `cache-primitives-default`) |
 | `cache`                                     | Provide a `Cache` instance directly                      |
 | `handler`                                   | Function invoked on misses / background revalidation     |
-| `revalidationHandler`                       | Alternate function used only for background refresh      |
 | `defaultTtl`                                | Fallback TTL (seconds) when no cache headers present     |
 | `maxTtl`                                    | Upper bound to clamp any TTL (seconds)                   |
 | `getCacheKey`                               | Custom key generator `(request) => string`               |

packages/cache-handlers/README.md

@@ -1,11 +1,9 @@
 import type {
-	CacheConfig,
 	CacheHandle,
 	CacheHandleOptions,
 	CreateCacheHandlerOptions,
 	HandlerFunction,
 } from "./types.ts";
-import { defaultGetCacheKey } from "./utils.ts";
 import { readFromCache } from "./read.ts";
 import { writeToCache } from "./write.ts";
 
@@ -14,7 +12,6 @@ export function createCacheHandler(
 	options: CreateCacheHandlerOptions = {},
 ): CacheHandle {
 	const baseHandler: HandlerFunction | undefined = options.handler;
-	const getCacheKey = options.getCacheKey || defaultGetCacheKey;
 
 	const handle: CacheHandle = async (
 		request: Request,

packages/cache-handlers/src/handlers.ts

@@ -29,6 +29,5 @@ export type {
 	HandlerInfo,
 	HandlerMode,
 	InvalidationOptions,
-	RevalidationHandler,
 	SWRPolicy,
 } from "./types.ts";

packages/cache-handlers/src/index.ts

@@ -3,6 +3,15 @@
  */
 
 import { getErrorHandler, safeJsonParse } from "./errors.ts";
+import type { CacheVary } from "./types.ts";
+
+// Strongly typed metadata entry for Vary data (LRU tracking via timestamp)
+interface VaryEntry {
+	// Arbitrary vary data structure (headers/cookies/query lists etc.)
+	// Use unknown to avoid any; callers narrow as needed
+	[key: string]: unknown;
+	timestamp: number; // LRU timestamp (ms)
+}
 
 const METADATA_LOCK_PREFIX = "https://cache-internal/lock-";
 const METADATA_LOCK_TIMEOUT = 5000; // 5 seconds
@@ -46,12 +55,7 @@ export async function atomicMetadataUpdate<T>(
 				const updatedData = updateFn(currentData);
 
 				// Write back updated metadata
-				await cache.put(
-					metadataKey,
-					new Response(JSON.stringify(updatedData), {
-						headers: { "Content-Type": "application/json" },
-					}),
-				);
+				await cache.put(metadataKey, Response.json(updatedData));
 
 				return; // Success
 			} finally {
@@ -106,12 +110,7 @@ async function tryAcquireLock(cache: Cache, lockKey: string): Promise<boolean> {
 			pid: Math.random().toString(36).substring(2), // Simple process identifier
 		};
 
-		await cache.put(
-			lockKey,
-			new Response(JSON.stringify(lockData), {
-				headers: { "Content-Type": "application/json" },
-			}),
-		);
+		await cache.put(lockKey, Response.json(lockData));
 
 		return true;
 	} catch (error) {
@@ -180,37 +179,37 @@ export async function updateVaryMetadata(
 	cache: Cache,
 	metadataKey: string,
 	requestUrl: string,
-	varyData: any,
+	varyData: CacheVary,
 	maxEntries = 1000,
 ): Promise<void> {
 	await atomicMetadataUpdate(
 		cache,
 		metadataKey,
-		(metadata: Record<string, any>) => {
+		(metadata: Record<string, VaryEntry>) => {
 			// Add timestamp for LRU cleanup
-			metadata[requestUrl] = {
+			const entry: VaryEntry = {
 				...varyData,
 				timestamp: Date.now(),
 			};
+			metadata[requestUrl] = entry;
 
 			// Implement LRU cleanup if we exceed maxEntries
-			const entries = Object.entries(metadata);
+			const entries: Array<[string, VaryEntry]> = Object.entries(
+				metadata,
+			) as Array<[string, VaryEntry]>;
 			if (entries.length > maxEntries) {
-				// Sort by timestamp (oldest first) and remove oldest entries
-				entries.sort(([, a], [, b]) => (a.timestamp || 0) - (b.timestamp || 0));
+				// Sort by timestamp (oldest first) and keep newest maxEntries
+				entries.sort(([, a], [, b]) => a.timestamp - b.timestamp);
 				const toKeep = entries.slice(-maxEntries);
-
-				// Rebuild metadata with only the entries to keep
-				const cleanedMetadata: Record<string, any> = {};
-				for (const [key, value] of toKeep) {
-					cleanedMetadata[key] = value;
+				const cleanedMetadata: Record<string, VaryEntry> = {};
+				for (const [k, v] of toKeep) {
+					cleanedMetadata[k] = v;
 				}
 				return cleanedMetadata;
 			}
-
 			return metadata;
 		},
-		{} as Record<string, any>,
+		{} as Record<string, VaryEntry>,
 	);
 }
 
@@ -225,19 +224,18 @@ export async function cleanupVaryMetadata(
 	await atomicMetadataUpdate(
 		cache,
 		metadataKey,
-		(metadata: Record<string, any>) => {
+		(metadata: Record<string, VaryEntry>) => {
 			const now = Date.now();
-			const cleanedMetadata: Record<string, any> = {};
-
-			for (const [key, value] of Object.entries(metadata)) {
-				const timestamp = value.timestamp || 0;
-				if (now - timestamp < maxAge) {
-					cleanedMetadata[key] = value;
+			const cleanedMetadata: Record<string, VaryEntry> = {};
+			for (
+				const [k, v] of Object.entries(metadata) as Array<[string, VaryEntry]>
+			) {
+				if (now - v.timestamp < maxAge) {
+					cleanedMetadata[k] = v;
 				}
 			}
-
 			return cleanedMetadata;
 		},
-		{} as const,
+		{} as Record<string, VaryEntry>,
 	);
 }

packages/cache-handlers/src/metadata.ts

@@ -19,16 +19,31 @@ 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> = {};
+	interface VaryEntry {
+		timestamp?: number;
+		headers?: unknown;
+		cookies?: unknown;
+		query?: unknown;
+	}
+	function isStringArray(value: unknown): value is string[] {
+		return Array.isArray(value) && value.every((v) => typeof v === "string");
+	}
+	let varyMetadata: Record<string, VaryEntry> = {};
 	varyMetadata = await safeJsonParse(
 		varyMetadataResponse?.clone() || null,
-		// deno-lint-ignore no-explicit-any
-		{} as Record<string, any>,
+		{} as Record<string, VaryEntry>,
 		"vary metadata parsing in cache handler",
 	);
-	const vary = varyMetadata[request.url];
-	const cacheKey = await getCacheKey(request, vary);
+	const vary = varyMetadata[request.url] as VaryEntry | undefined;
+	// Only pass vary data if present; defaultGetCacheKey expects CacheVary shape
+	const varyArg = vary
+		? {
+			headers: isStringArray(vary.headers) ? vary.headers : [],
+			cookies: isStringArray(vary.cookies) ? vary.cookies : [],
+			query: isStringArray(vary.query) ? vary.query : [],
+		}
+		: undefined;
+	const cacheKey = await getCacheKey(request, varyArg);
 	const cacheRequest = new Request(cacheKey);
 	let cachedResponse: Response | null = (await cache.match(cacheKey)) ?? null;
 	let needsBackgroundRevalidation = false;

packages/cache-handlers/src/read.ts

@@ -85,20 +85,13 @@ export interface CacheConfig {
 	 */
 	maxTtl?: number;
 
-	/**
-	 * Revalidation handler for stale-while-revalidate support.
-	 * Called when cached content is stale but within the SWR window.
-	 * If not provided, revalidation will be skipped.
-	 */
-	revalidationHandler?: RevalidationHandler;
-
 	/**
 	 * WaitUntil handler for background tasks (like revalidation).
 	 * Similar to Cloudflare Workers' ctx.waitUntil().
 	 * Allows the platform to keep processes alive for background work.
 	 * If not provided, queueMicrotask will be used as fallback.
 	 */
-	waitUntil?: (promise: Promise<any>) => void;
+	waitUntil?: (promise: Promise<unknown>) => void;
 }
 
 /**
@@ -264,21 +257,6 @@ export interface ParsedCacheHeaders {
 	shouldGenerateETag?: boolean;
 }
 
-/**
- * Revalidation handler function for stale-while-revalidate support.
- * Called when content needs to be revalidated in the background.
- *
- * @example
- * ```typescript
- * const revalidateHandler: RevalidationHandler = async (request) => fetch(request.url);
- * ```
- */
-export interface RevalidationHandler {
-	(request: Request): Promise<Response>;
-}
-
-// --- Higher-level handler API ---
-
 /**
  * Render / handling mode information passed to user handler.
  * - miss: cache miss foreground render
@@ -298,7 +276,7 @@ export interface HandlerInfo {
 export type HandlerFunction = (
 	request: Request,
 	info: HandlerInfo,
-) => Promise<Response>;
+) => Promise<Response> | Response;
 
 /**
  * SWR policy (reserved for future strategies).
@@ -323,12 +301,12 @@ export interface CreateCacheHandlerOptions extends CacheConfig {
 	/**
 	 * Background scheduler analogous to waitUntil.
 	 */
-	runInBackground?: (p: Promise<any>) => void;
+	runInBackground?: (p: Promise<unknown>) => void;
 }
 
 export interface CacheHandleFunctionOptions {
 	handler?: HandlerFunction;
-	runInBackground?: (p: Promise<any>) => void;
+	runInBackground?: (p: Promise<unknown>) => void;
 	swr?: SWRPolicy;
 }
 /**