@b9g/cache-redis 0.1.4 → 0.2.0-beta.1

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.4",
-  "description": "Redis cache adapter for Shovel cache system",
+  "version": "0.2.0-beta.1",
+  "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.4"
+    "@b9g/cache": "^0.2.0-beta.0"
   },
   "type": "module",
   "types": "src/index.d.ts",
@@ -32,23 +31,19 @@
     "README.md",
     "src/"
   ],
-  "main": "src/index.cjs",
   "module": "src/index.js",
   "exports": {
     ".": {
       "types": "./src/index.d.ts",
-      "import": "./src/index.js",
-      "require": "./src/index.cjs"
+      "import": "./src/index.js"
     },
     "./index": {
       "types": "./src/index.d.ts",
-      "import": "./src/index.js",
-      "require": "./src/index.cjs"
+      "import": "./src/index.js"
     },
     "./index.js": {
       "types": "./src/index.d.ts",
-      "import": "./src/index.js",
-      "require": "./src/index.cjs"
+      "import": "./src/index.js"
     },
     "./package.json": "./package.json"
   }

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,22 @@
 import { Cache, generateCacheKey } from "@b9g/cache";
 import { createClient } from "redis";
 import { getLogger } from "@logtape/logtape";
-var logger = getLogger(["cache-redis"]);
+var logger = getLogger(["shovel", "cache"]);
+function uint8ArrayToBase64(bytes) {
+  let binary = "";
+  for (let i = 0; i < bytes.length; i++) {
+    binary += String.fromCharCode(bytes[i]);
+  }
+  return btoa(binary);
+}
+function base64ToUint8Array(base64) {
+  const binary = atob(base64);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) {
+    bytes[i] = binary.charCodeAt(i);
+  }
+  return bytes;
+}
 var RedisCache = class extends Cache {
   #client;
   #prefix;
@@ -33,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();
     }
   }
@@ -47,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) {
@@ -59,26 +74,61 @@ 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: btoa(String.fromCharCode(...new Uint8Array(body))),
+      body: uint8ArrayToBase64(new Uint8Array(body)),
       cachedAt: Date.now(),
-      TTL: this.#defaultTTL
+      TTL: ttl,
+      requestHeaders
     };
   }
   /**
    * Deserialize cache entry to Response
    */
   #deserializeResponse(entry) {
-    const body = Uint8Array.from(atob(entry.body), (c) => c.charCodeAt(0));
+    const body = base64ToUint8Array(entry.body);
     return new Response(body, {
       status: entry.status,
       statusText: entry.statusText,
       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
    */
@@ -98,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 });
@@ -111,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);
@@ -160,11 +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 {
+        } catch (err) {
+          if (!(err instanceof TypeError)) throw err;
         }
       }
       return requests;
@@ -173,48 +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 {
-        }
-      }
-      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
@@ -229,7 +244,9 @@ var RedisCache = class extends Cache {
         try {
           await this.#client.disconnect();
         } catch (disconnectError) {
-          logger.error("Error forcing Redis disconnect: {error}", { error: disconnectError });
+          logger.error("Error forcing Redis disconnect: {error}", {
+            error: disconnectError
+          });
         }
       }
     }