@b9g/cache-redis 0.1.0

package/src/redis-cache.d.ts

@@ -0,0 +1,71 @@
+import { Cache, type CacheQueryOptions } from "@b9g/cache";
+import { type RedisClientOptions } from "redis";
+export interface RedisCacheOptions {
+    /** Redis connection options */
+    redis?: RedisClientOptions;
+    /** Cache name prefix for Redis keys */
+    prefix?: string;
+    /** Default TTL in seconds (0 = no expiration) */
+    defaultTTL?: number;
+    /** Maximum cache entry size in bytes */
+    maxEntrySize?: number;
+}
+/**
+ * Redis-backed cache implementation
+ * Stores HTTP responses with proper serialization and TTL support
+ */
+export declare class RedisCache extends Cache {
+    private client;
+    private prefix;
+    private defaultTTL;
+    private maxEntrySize;
+    private connected;
+    constructor(name: string, options?: RedisCacheOptions);
+    /**
+     * Ensure Redis client is connected
+     */
+    private ensureConnected;
+    /**
+     * Generate Redis key for cache entry
+     */
+    private getRedisKey;
+    /**
+     * Serialize Response to cache entry
+     */
+    private serializeResponse;
+    /**
+     * Deserialize cache entry to Response
+     */
+    private deserializeResponse;
+    /**
+     * Returns a Promise that resolves to the response associated with the first matching request
+     */
+    match(request: Request, options?: CacheQueryOptions): Promise<Response | undefined>;
+    /**
+     * Puts a request/response pair into the cache
+     */
+    put(request: Request, response: Response): Promise<void>;
+    /**
+     * Finds the cache entry whose key is the request, and if found, deletes it and returns true
+     */
+    delete(request: Request, options?: CacheQueryOptions): Promise<boolean>;
+    /**
+     * 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;
+    }>;
+    /**
+     * Cleanup method for implementations that need resource disposal
+     */
+    dispose(): Promise<void>;
+}

package/src/redis-cache.js

@@ -0,0 +1,228 @@
+/// <reference types="./redis-cache.d.ts" />
+// src/redis-cache.ts
+import { Cache, generateCacheKey } from "@b9g/cache";
+import { createClient } from "redis";
+var RedisCache = class extends Cache {
+  client;
+  prefix;
+  defaultTTL;
+  maxEntrySize;
+  connected = false;
+  constructor(name, options = {}) {
+    super();
+    this.client = createClient(options.redis || {});
+    this.prefix = options.prefix ? `${options.prefix}:${name}` : `cache:${name}`;
+    this.defaultTTL = options.defaultTTL || 0;
+    this.maxEntrySize = options.maxEntrySize || 10 * 1024 * 1024;
+    this.client.on("error", (err) => {
+      console.error("[RedisCache] Redis error:", err);
+    });
+    this.client.on("connect", () => {
+      console.info(`[RedisCache] Connected to Redis for cache: ${name}`);
+      this.connected = true;
+    });
+    this.client.on("disconnect", () => {
+      console.warn(`[RedisCache] Disconnected from Redis for cache: ${name}`);
+      this.connected = false;
+    });
+  }
+  /**
+   * Ensure Redis client is connected
+   */
+  async ensureConnected() {
+    if (!this.connected && !this.client.isReady) {
+      await this.client.connect();
+    }
+  }
+  /**
+   * Generate Redis key for cache entry
+   */
+  getRedisKey(request, options) {
+    const cacheKey = generateCacheKey(request, options);
+    return `${this.prefix}:${cacheKey}`;
+  }
+  /**
+   * Serialize Response to cache entry
+   */
+  async serializeResponse(response) {
+    const cloned = response.clone();
+    const body = await cloned.arrayBuffer();
+    if (body.byteLength > this.maxEntrySize) {
+      throw new Error(`Response body too large: ${body.byteLength} bytes (max: ${this.maxEntrySize})`);
+    }
+    const headers = {};
+    response.headers.forEach((value, key) => {
+      headers[key] = value;
+    });
+    return {
+      status: response.status,
+      statusText: response.statusText,
+      headers,
+      body: Buffer.from(body).toString("base64"),
+      cachedAt: Date.now(),
+      ttl: this.defaultTTL
+    };
+  }
+  /**
+   * Deserialize cache entry to Response
+   */
+  deserializeResponse(entry) {
+    const body = Buffer.from(entry.body, "base64");
+    return new Response(body, {
+      status: entry.status,
+      statusText: entry.statusText,
+      headers: entry.headers
+    });
+  }
+  /**
+   * Returns a Promise that resolves to the response associated with the first matching request
+   */
+  async match(request, options) {
+    try {
+      await this.ensureConnected();
+      const key = this.getRedisKey(request, options);
+      const cached = await this.client.get(key);
+      if (!cached) {
+        return void 0;
+      }
+      const entry = JSON.parse(cached);
+      if (entry.ttl > 0) {
+        const ageInSeconds = (Date.now() - entry.cachedAt) / 1e3;
+        if (ageInSeconds > entry.ttl) {
+          await this.client.del(key);
+          return void 0;
+        }
+      }
+      return this.deserializeResponse(entry);
+    } catch (error) {
+      console.error("[RedisCache] Failed to match:", error);
+      return void 0;
+    }
+  }
+  /**
+   * Puts a request/response pair into the cache
+   */
+  async put(request, response) {
+    try {
+      await this.ensureConnected();
+      const key = this.getRedisKey(request);
+      const entry = await this.serializeResponse(response);
+      const serialized = JSON.stringify(entry);
+      if (entry.ttl > 0) {
+        await this.client.setEx(key, entry.ttl, serialized);
+      } else {
+        await this.client.set(key, serialized);
+      }
+    } catch (error) {
+      console.error("[RedisCache] Failed to put:", error);
+      throw error;
+    }
+  }
+  /**
+   * Finds the cache entry whose key is the request, and if found, deletes it and returns true
+   */
+  async delete(request, options) {
+    try {
+      await this.ensureConnected();
+      const key = this.getRedisKey(request, options);
+      const result = await this.client.del(key);
+      return result > 0;
+    } catch (error) {
+      console.error("[RedisCache] Failed to delete:", error);
+      return false;
+    }
+  }
+  /**
+   * Returns a Promise that resolves to an array of cache keys (Request objects)
+   */
+  async keys(request, options) {
+    try {
+      await this.ensureConnected();
+      if (request) {
+        const key = this.getRedisKey(request, options);
+        const exists = await this.client.exists(key);
+        return exists ? [request] : [];
+      }
+      const pattern = `${this.prefix}:*`;
+      const keys = [];
+      for await (const key of this.client.scanIterator({
+        MATCH: pattern,
+        COUNT: 100
+      })) {
+        keys.push(key);
+      }
+      const requests = [];
+      for (const key of keys) {
+        try {
+          const cacheKey = key.replace(`${this.prefix}:`, "");
+          const [method, url] = cacheKey.split(":", 2);
+          if (method && url) {
+            requests.push(new Request(url, { method }));
+          }
+        } catch {
+        }
+      }
+      return requests;
+    } catch (error) {
+      console.error("[RedisCache] Failed to get keys:", error);
+      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 += Buffer.byteLength(value, "utf8");
+          }
+        } catch {
+        }
+      }
+      return {
+        connected: this.connected,
+        keyCount,
+        totalSize,
+        prefix: this.prefix,
+        defaultTTL: this.defaultTTL,
+        maxEntrySize: this.maxEntrySize
+      };
+    } catch (error) {
+      console.error("[RedisCache] Failed to get stats:", error);
+      return {
+        connected: false,
+        keyCount: 0,
+        totalSize: 0,
+        prefix: this.prefix,
+        defaultTTL: this.defaultTTL,
+        maxEntrySize: this.maxEntrySize
+      };
+    }
+  }
+  /**
+   * Cleanup method for implementations that need resource disposal
+   */
+  async dispose() {
+    try {
+      if (this.client.isReady) {
+        await this.client.disconnect();
+      }
+    } catch (error) {
+      console.error("[RedisCache] Failed to dispose:", error);
+    }
+  }
+};
+export {
+  RedisCache
+};