@b9g/cache-redis 0.1.5 → 0.2.0

package/README.md

@@ -5,7 +5,8 @@ Redis cache adapter for Shovel's universal cache system.
 ## Features
 
 - **HTTP-aware caching**: Stores complete HTTP responses with headers and status codes
-- **TTL support**: Configurable time-to-live for cache entries
+- **TTL support**: Respects `Cache-Control: max-age` headers, with configurable default TTL
+- **Vary header support**: Full HTTP content negotiation with Vary header checking
 - **Size limits**: Configurable maximum entry size to prevent memory issues
 - **Connection pooling**: Uses the official Redis client with connection management
 - **Error resilience**: Graceful handling of Redis connection issues
@@ -44,11 +45,10 @@ const cached = await cache.match(request);
 ### Direct Cache Usage
 
 ```typescript
-import {createCache} from "@b9g/cache-redis";
+import {RedisCache} from "@b9g/cache-redis";
 
 // Create a single Redis cache instance
-const cache = createCache({
-  name: "my-cache",
+const cache = new RedisCache("my-cache", {
   redis: {
     url: process.env.REDIS_URL || "redis://localhost:6379",
     password: process.env.REDIS_PASSWORD
@@ -157,23 +157,6 @@ The Redis cache gracefully handles connection issues:
 - Connection errors are logged but don't crash the application
 - Automatic reconnection when Redis becomes available
 
-## Cache Statistics
-
-Get insights into cache performance:
-
-```typescript
-const cache = new RedisCache("my-cache");
-const stats = await cache.getStats();
-
-console.log({
-  connected: stats.connected,
-  keyCount: stats.keyCount,
-  totalSize: stats.totalSize,
-  prefix: stats.prefix
-});
-```
-
-
 ## Exports
 
 ### Classes

package/package.json

@@ -1,13 +1,12 @@
 {
   "name": "@b9g/cache-redis",
-  "version": "0.1.5",
-  "description": "Redis cache adapter for Shovel cache system",
+  "version": "0.2.0",
+  "description": "Redis cache implementation for Shovel cache system",
   "keywords": [
     "cache",
     "redis",
-    "shovel",
-    "metaframework",
-    "cache-adapter"
+    "service-workers",
+    "shovel"
   ],
   "author": "Shovel Team",
   "license": "MIT",
@@ -24,7 +23,7 @@
     "@b9g/libuild": "^0.1.18"
   },
   "peerDependencies": {
-    "@b9g/cache": "^0.1.5"
+    "@b9g/cache": "^0.2.0"
   },
   "type": "module",
   "types": "src/index.d.ts",

package/src/index.d.ts

@@ -38,17 +38,6 @@ export declare class RedisCache extends Cache {
      * Returns a Promise that resolves to an array of cache keys (Request objects)
      */
     keys(request?: Request, options?: CacheQueryOptions): Promise<Request[]>;
-    /**
-     * Get cache statistics
-     */
-    getStats(): Promise<{
-        connected: boolean;
-        keyCount: number;
-        totalSize: number;
-        prefix: string;
-        defaultTTL: number;
-        maxEntrySize: number;
-    }>;
     /**
      * Dispose of Redis client connection
      * Call this during graceful shutdown to properly close Redis connections

package/src/index.js

@@ -3,7 +3,7 @@
 import { Cache, generateCacheKey } from "@b9g/cache";
 import { createClient } from "redis";
 import { getLogger } from "@logtape/logtape";
-var logger = getLogger(["platform"]);
+var logger = getLogger(["shovel", "cache"]);
 function uint8ArrayToBase64(bytes) {
   let binary = "";
   for (let i = 0; i < bytes.length; i++) {
@@ -48,7 +48,7 @@ var RedisCache = class extends Cache {
    * Ensure Redis client is connected
    */
   async #ensureConnected() {
-    if (!this.#connected && !this.#client.isReady) {
+    if (!this.#client.isOpen && !this.#client.isReady) {
       await this.#client.connect();
     }
   }
@@ -62,7 +62,7 @@ var RedisCache = class extends Cache {
   /**
    * Serialize Response to cache entry
    */
-  async #serializeResponse(response) {
+  async #serializeResponse(request, response) {
     const cloned = response.clone();
     const body = await cloned.arrayBuffer();
     if (body.byteLength > this.#maxEntrySize) {
@@ -74,13 +74,26 @@ var RedisCache = class extends Cache {
     response.headers.forEach((value, key) => {
       headers[key] = value;
     });
+    const requestHeaders = {};
+    request.headers.forEach((value, key) => {
+      requestHeaders[key] = value;
+    });
+    let ttl = this.#defaultTTL;
+    const cacheControl = response.headers.get("cache-control");
+    if (cacheControl) {
+      const maxAgeMatch = cacheControl.match(/max-age=(\d+)/);
+      if (maxAgeMatch) {
+        ttl = parseInt(maxAgeMatch[1], 10);
+      }
+    }
     return {
       status: response.status,
       statusText: response.statusText,
       headers,
       body: uint8ArrayToBase64(new Uint8Array(body)),
       cachedAt: Date.now(),
-      TTL: this.#defaultTTL
+      TTL: ttl,
+      requestHeaders
     };
   }
   /**
@@ -94,6 +107,28 @@ var RedisCache = class extends Cache {
       headers: entry.headers
     });
   }
+  /**
+   * Check if a request matches the Vary header of a cached entry
+   * Returns true if the request matches or if there's no Vary header
+   */
+  #matchesVary(request, entry) {
+    const varyHeader = entry.headers["vary"] || entry.headers["Vary"];
+    if (!varyHeader) {
+      return true;
+    }
+    if (varyHeader === "*") {
+      return false;
+    }
+    const varyHeaders = varyHeader.split(",").map((h) => h.trim().toLowerCase());
+    for (const headerName of varyHeaders) {
+      const requestValue = request.headers.get(headerName);
+      const cachedValue = entry.requestHeaders[headerName] || null;
+      if (requestValue !== cachedValue) {
+        return false;
+      }
+    }
+    return true;
+  }
   /**
    * Returns a Promise that resolves to the response associated with the first matching request
    */
@@ -113,6 +148,9 @@ var RedisCache = class extends Cache {
           return void 0;
         }
       }
+      if (!options?.ignoreVary && !this.#matchesVary(request, entry)) {
+        return void 0;
+      }
       return this.#deserializeResponse(entry);
     } catch (error) {
       logger.error("Failed to match: {error}", { error });
@@ -126,7 +164,7 @@ var RedisCache = class extends Cache {
     try {
       await this.#ensureConnected();
       const key = this.#getRedisKey(request);
-      const entry = await this.#serializeResponse(response);
+      const entry = await this.#serializeResponse(request, response);
       const serialized = JSON.stringify(entry);
       if (entry.TTL > 0) {
         await this.#client.setEx(key, entry.TTL, serialized);
@@ -175,13 +213,15 @@ var RedisCache = class extends Cache {
       for (const key of keys) {
         try {
           const cacheKey = key.replace(`${this.#prefix}:`, "");
-          const [method, url] = cacheKey.split(":", 2);
+          const colonIndex = cacheKey.indexOf(":");
+          if (colonIndex === -1) continue;
+          const method = cacheKey.substring(0, colonIndex);
+          const url = cacheKey.substring(colonIndex + 1);
           if (method && url) {
             requests.push(new Request(url, { method }));
           }
         } catch (err) {
-          if (!(err instanceof TypeError))
-            throw err;
+          if (!(err instanceof TypeError)) throw err;
         }
       }
       return requests;
@@ -190,49 +230,6 @@ var RedisCache = class extends Cache {
       return [];
     }
   }
-  /**
-   * Get cache statistics
-   */
-  async getStats() {
-    try {
-      await this.#ensureConnected();
-      const pattern = `${this.#prefix}:*`;
-      let keyCount = 0;
-      let totalSize = 0;
-      for await (const key of this.#client.scanIterator({
-        MATCH: pattern,
-        COUNT: 100
-      })) {
-        keyCount++;
-        try {
-          const value = await this.#client.get(key);
-          if (value) {
-            totalSize += new TextEncoder().encode(value).length;
-          }
-        } catch (err) {
-          logger.debug("Error reading key {key}: {error}", { key, error: err });
-        }
-      }
-      return {
-        connected: this.#connected,
-        keyCount,
-        totalSize,
-        prefix: this.#prefix,
-        defaultTTL: this.#defaultTTL,
-        maxEntrySize: this.#maxEntrySize
-      };
-    } catch (error) {
-      logger.error("Failed to get stats: {error}", { error });
-      return {
-        connected: false,
-        keyCount: 0,
-        totalSize: 0,
-        prefix: this.#prefix,
-        defaultTTL: this.#defaultTTL,
-        maxEntrySize: this.#maxEntrySize
-      };
-    }
-  }
   /**
    * Dispose of Redis client connection
    * Call this during graceful shutdown to properly close Redis connections