@b9g/cache-redis 0.1.2 → 0.1.3

package/src/index.d.ts

@@ -3,13 +3,55 @@
  *
  * Provides Redis-backed caching with HTTP-aware storage and retrieval
  */
-export { RedisCache, type RedisCacheOptions } from "./redis-cache.js";
-export { createRedisFactory } from "./factory.js";
-import { RedisCache, type RedisCacheOptions } from "./redis-cache.js";
+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;
+}
 /**
- * Platform adapter factory function
- * Creates a RedisCache instance with the given configuration
+ * Redis-backed cache implementation
+ * Stores HTTP responses with proper serialization and TTL support
  */
-export declare function createCache(config?: RedisCacheOptions & {
-    name?: string;
-}): RedisCache;
+export declare class RedisCache extends Cache {
+    #private;
+    constructor(name: string, options?: RedisCacheOptions);
+    /**
+     * 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;
+    }>;
+    /**
+     * Dispose of Redis client connection
+     * Call this during graceful shutdown to properly close Redis connections
+     */
+    dispose(): Promise<void>;
+}

package/src/index.js

@@ -1,14 +1,242 @@
 /// <reference types="./index.d.ts" />
 // src/index.ts
-import { RedisCache } from "./redis-cache.js";
-import { createRedisFactory } from "./factory.js";
-import { RedisCache as RedisCache2 } from "./redis-cache.js";
-function createCache(config = {}) {
-  const name = config.name || "default";
-  return new RedisCache2(name, config);
-}
+import { Cache, generateCacheKey } from "@b9g/cache";
+import { createClient } from "redis";
+import { getLogger } from "@logtape/logtape";
+var logger = getLogger(["cache-redis"]);
+var RedisCache = class extends Cache {
+  #client;
+  #prefix;
+  #defaultTTL;
+  #maxEntrySize;
+  #connected;
+  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.#connected = false;
+    this.#client.on("error", (err) => {
+      logger.error("Redis error", { error: err });
+    });
+    this.#client.on("connect", () => {
+      logger.info("Connected to Redis", { cache: name });
+      this.#connected = true;
+    });
+    this.#client.on("disconnect", () => {
+      logger.warn("Disconnected from Redis", { 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: btoa(String.fromCharCode(...new Uint8Array(body))),
+      cachedAt: Date.now(),
+      TTL: this.#defaultTTL
+    };
+  }
+  /**
+   * Deserialize cache entry to Response
+   */
+  #deserializeResponse(entry) {
+    const body = Uint8Array.from(atob(entry.body), (c) => c.charCodeAt(0));
+    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) {
+      logger.error("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) {
+      logger.error("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) {
+      logger.error("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) {
+      logger.error("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 += 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 });
+      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
+   */
+  async dispose() {
+    if (this.#connected || this.#client.isReady) {
+      try {
+        await this.#client.quit();
+        logger.info("Redis connection closed", { prefix: this.#prefix });
+      } catch (error) {
+        logger.error("Error closing Redis connection", { error });
+        try {
+          await this.#client.disconnect();
+        } catch (disconnectError) {
+          logger.error("Error forcing Redis disconnect", {
+            error: disconnectError
+          });
+        }
+      }
+    }
+  }
+};
 export {
-  RedisCache,
-  createCache,
-  createRedisFactory
+  RedisCache
 };

package/src/factory.cjs

@@ -1,34 +0,0 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/factory.ts
-var factory_exports = {};
-__export(factory_exports, {
-  createRedisFactory: () => createRedisFactory
-});
-module.exports = __toCommonJS(factory_exports);
-var import_redis_cache = require("./redis-cache.cjs");
-function createRedisFactory(options = {}) {
-  return (name) => {
-    return new import_redis_cache.RedisCache(name, options);
-  };
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  createRedisFactory
-});

package/src/factory.d.ts

@@ -1,19 +0,0 @@
-import { type CacheFactory } from "@b9g/cache";
-import { type RedisCacheOptions } from "./redis-cache.js";
-/**
- * Create a Redis cache factory for use with CustomCacheStorage
- *
- * Example usage:
- * ```typescript
- * import {CustomCacheStorage} from "@b9g/cache";
- * import {createRedisFactory} from "@b9g/cache-redis";
- *
- * const cacheStorage = new CustomCacheStorage(createRedisFactory({
- *   redis: { url: "redis://localhost:6379" },
- *   defaultTTL: 3600 // 1 hour
- * }));
- *
- * const cache = await cacheStorage.open("my-cache");
- * ```
- */
-export declare function createRedisFactory(options?: RedisCacheOptions): CacheFactory;

package/src/factory.js

@@ -1,11 +0,0 @@
-/// <reference types="./factory.d.ts" />
-// src/factory.ts
-import { RedisCache } from "./redis-cache.js";
-function createRedisFactory(options = {}) {
-  return (name) => {
-    return new RedisCache(name, options);
-  };
-}
-export {
-  createRedisFactory
-};