@keq-request/cache 5.0.0-alpha.21 → 5.0.0-alpha.23

package/dist/index.mjs

@@ -3,45 +3,21 @@ var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { en
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 
 // src/cache.ts
+import * as R2 from "ramda";
+
+// src/request-cache-handler/request-cache-handler.ts
 import * as R from "ramda";
+
+// src/exceptions/cache-exception.ts
 import { Exception } from "keq";
-function cache(opts) {
-  const storage = opts.storage;
-  const rules = (opts == null ? void 0 : opts.rules) || [];
-  return async function cache2(ctx, next) {
-    if (ctx.options.cache === false) {
-      await next();
-      return;
-    }
-    let cOpt = ctx.options.cache;
-    const rule = rules.find((rule2) => {
-      if (rule2.pattern === void 0 || rule2.pattern === true) return true;
-      if (typeof rule2.pattern === "function") return rule2.pattern(ctx);
-      return rule2.pattern.test(ctx.request.__url__.href);
-    });
-    if (rule) cOpt = R.mergeRight(rule, cOpt || {});
-    if (!cOpt || R.isEmpty(cOpt)) {
-      await next();
-      return;
-    }
-    let key = ctx.locationId;
-    if (cOpt.key) {
-      if (typeof cOpt.key === "function") key = cOpt.key(ctx);
-      else key = cOpt.key;
-    } else if (opts == null ? void 0 : opts.keyFactory) {
-      key = opts.keyFactory(ctx);
-    }
-    if (!key) throw new Exception("Cache key is required");
-    const strategy = cOpt.strategy;
-    const opt = {
-      key,
-      storage,
-      ttl: cOpt.ttl,
-      exclude: cOpt.exclude
-    };
-    await strategy(opt)(ctx, next);
-  };
-}
+var CacheException = class extends Exception {
+  constructor(message) {
+    super("[@keq-request/cache] ".concat(message));
+  }
+};
+
+// src/cache-entry/cache-entry.ts
+import { createProxyResponse } from "keq";
 
 // src/utils/get-response-bytes.ts
 async function getResponseBytes(response) {
@@ -53,6 +29,124 @@ async function getResponseBytes(response) {
   return arrayBuffer.byteLength;
 }
 
+// src/constants/max-expired-at.ts
+var MAX_EXPIRED_AT = /* @__PURE__ */ new Date(864e13);
+
+// src/constants/eviction.enum.ts
+var Eviction = /* @__PURE__ */ ((Eviction2) => {
+  Eviction2["LRU"] = "lru";
+  Eviction2["LFU"] = "lfu";
+  Eviction2["RANDOM"] = "random";
+  Eviction2["TTL"] = "ttl";
+  return Eviction2;
+})(Eviction || {});
+
+// src/constants/size.enum.ts
+var Size = /* @__PURE__ */ ((Size2) => {
+  Size2[Size2["B"] = 1] = "B";
+  Size2[Size2["KB"] = 1024] = "KB";
+  Size2[Size2["MB"] = 1048576] = "MB";
+  Size2[Size2["GB"] = 1073741824] = "GB";
+  return Size2;
+})(Size || {});
+
+// src/strategies/cache-first.ts
+var cacheFirst = async function cacheFirst2(handler, context, next) {
+  const [cacheKey, cacheValue] = await handler.getCache(context);
+  if (cacheValue) {
+    context.emitter.emit("cache:hit", { key: cacheKey, response: cacheValue.response, context });
+    context.res = cacheValue.response;
+    return;
+  }
+  context.emitter.emit("cache:miss", { key: cacheKey, context });
+  await next();
+  const [, entry] = await handler.setCache(context);
+  if (entry) {
+    context.emitter.emit("cache:update", {
+      key: entry.key,
+      oldResponse: void 0,
+      newResponse: entry.response,
+      context
+    });
+  }
+};
+
+// src/strategies/network-first.ts
+var networkFirst = async function networkFirst2(handler, context, next) {
+  try {
+    await next();
+    const [, cache2] = await handler.getCache(context);
+    const [, entry] = await handler.setCache(context);
+    if (entry) {
+      context.emitter.emit("cache:update", {
+        key: entry.key,
+        oldResponse: cache2 == null ? void 0 : cache2.response,
+        newResponse: entry.response,
+        context
+      });
+    }
+  } catch (err) {
+    const [key, cache2] = await handler.getCache(context);
+    if (!cache2) {
+      context.emitter.emit("cache:miss", { key, context });
+      throw err;
+    }
+    context.emitter.emit("cache:hit", { key, response: cache2.response, context });
+    context.res = cache2.response;
+  }
+};
+
+// src/strategies/network-only.ts
+var networkOnly = async function(handler, context, next) {
+  await next();
+};
+
+// src/strategies/stale-while-revalidate.ts
+var staleWhileRevalidate = async function(handler, context, next) {
+  const [key, cache2] = await handler.getCache(context);
+  if (cache2) {
+    context.emitter.emit("cache:hit", { key, response: cache2.response, context });
+    const orchestrator = context.orchestration.fork();
+    context.res = cache2.response;
+    setTimeout(async () => {
+      try {
+        await orchestrator.execute();
+        const context2 = orchestrator.context;
+        const [, entry] = await handler.setCache(context2);
+        if (entry) {
+          context2.emitter.emit("cache:update", {
+            key,
+            oldResponse: cache2.response,
+            newResponse: entry.response,
+            context: context2
+          });
+        }
+      } catch (err) {
+      }
+    }, 1);
+  } else {
+    context.emitter.emit("cache:miss", { key, context });
+    await next();
+    const [, entry] = await handler.setCache(context);
+    if (entry) {
+      context.emitter.emit("cache:update", {
+        key,
+        oldResponse: void 0,
+        newResponse: entry.response,
+        context
+      });
+    }
+  }
+};
+
+// src/constants/strategy.enum.ts
+var Strategy = {
+  STALE_WHILE_REVALIDATE: staleWhileRevalidate,
+  NETWORK_FIRST: networkFirst,
+  NETWORK_ONLY: networkOnly,
+  CACHE_FIRST: cacheFirst
+};
+
 // src/cache-entry/cache-entry.ts
 var CacheEntry = class _CacheEntry {
   constructor(options) {
@@ -66,13 +160,13 @@ var CacheEntry = class _CacheEntry {
     __publicField(this, "expiredAt");
     var _a;
     this.key = options.key;
-    this.response = options.response;
+    this.response = createProxyResponse(options.response);
     this.size = options.size;
-    this.expiredAt = (_a = options.expiredAt) != null ? _a : /* @__PURE__ */ new Date(864e13);
+    this.expiredAt = (_a = options.expiredAt) != null ? _a : MAX_EXPIRED_AT;
   }
   static async build(options) {
     var _a;
-    const expiredAt = "expiredAt" in options ? options.expiredAt : "ttl" in options && typeof options.ttl === "number" && options.ttl > 0 ? new Date(Date.now() + options.ttl * 1e3) : /* @__PURE__ */ new Date(864e13);
+    const expiredAt = "expiredAt" in options ? options.expiredAt : "ttl" in options && typeof options.ttl === "number" && options.ttl > 0 ? new Date(Date.now() + options.ttl * 1e3) : MAX_EXPIRED_AT;
     const response = options.response.clone();
     return new _CacheEntry({
       key: options.key,
@@ -98,164 +192,106 @@ var CacheEntry = class _CacheEntry {
   }
 };
 
-// src/strategies/utils/cache-context.ts
-async function cacheContext(opts, context) {
-  if (!context.response) return;
-  if (opts.exclude && await opts.exclude(context.response)) return;
-  const key = opts.key;
-  const storage = opts.storage;
-  const entry = await CacheEntry.build({
-    key,
-    response: context.response,
-    ttl: opts.ttl
-  });
-  storage.set(entry);
-  return entry;
-}
+// src/request-cache-handler/request-cache-handler.ts
+var RequestCacheHandler = class {
+  constructor(storage, options) {
+    this.storage = storage;
+    this.options = options;
+  }
+  /**
+   * Get cache key for request
+   */
+  getRequestCacheKey(context) {
+    const options = this.options;
+    if (typeof options.key === "string") return options.key;
+    else if (typeof options.key === "function") return options.key(context);
+    else if (R.isNil(options.key) && context.locationId) return context.locationId;
+    else throw new CacheException("Cannot resolve cache key");
+  }
+  /**
+   * Get cache from storage
+   */
+  async getCache(context) {
+    const key = this.getRequestCacheKey(context);
+    return [key, await this.storage.get(key)];
+  }
+  /**
+   * Store response that in context to storage
+   */
+  async setCache(context) {
+    const options = this.options;
+    const key = this.getRequestCacheKey(context);
+    if (!context.response) return [key, void 0];
+    if (options.exclude && await options.exclude(context.response)) return [key, void 0];
+    const entry = await CacheEntry.build({
+      key,
+      response: context.response,
+      ttl: options.ttl
+    });
+    void this.storage.set(entry);
+    return [key, entry];
+  }
+};
 
-// src/strategies/cache-first.ts
-var cacheFirst = function(opts) {
-  const { storage, key } = opts;
-  return async function(context, next) {
-    const cache2 = await storage.get(key);
-    if (cache2) {
-      context.emitter.emit("cache:hit", { key, response: cache2.response, context });
-      context.res = cache2.response;
+// src/cache.ts
+function cache(options) {
+  const storage = options.storage;
+  const rules = (options == null ? void 0 : options.rules) || [];
+  return async function cache2(ctx, next) {
+    if (ctx.options.cache === false) {
+      await next();
       return;
     }
-    context.emitter.emit("cache:miss", { key, context });
-    await next();
-    const entry = await cacheContext(opts, context);
-    if (entry) {
-      context.emitter.emit("cache:update", {
-        key,
-        oldResponse: void 0,
-        newResponse: entry.response,
-        context
-      });
-    }
-  };
-};
-
-// src/strategies/network-first.ts
-var networkFirst = function(opts) {
-  const { key, storage } = opts;
-  return async function(context, next) {
-    try {
+    let requestCacheOptions = ctx.options.cache;
+    const rule = rules.find((rule2) => {
+      if (rule2.pattern === void 0 || rule2.pattern === true) return true;
+      if (typeof rule2.pattern === "function") return rule2.pattern(ctx);
+      return rule2.pattern.test(ctx.request.__url__.href);
+    });
+    if (rule) requestCacheOptions = R2.mergeRight(rule, requestCacheOptions || {});
+    if (!requestCacheOptions || R2.isEmpty(requestCacheOptions)) {
       await next();
-      const cache2 = await storage.get(key);
-      const entry = await cacheContext(opts, context);
-      if (entry) {
-        context.emitter.emit("cache:update", {
-          key,
-          oldResponse: cache2 == null ? void 0 : cache2.response,
-          newResponse: entry.response,
-          context
-        });
-      }
-    } catch (err) {
-      const cache2 = await storage.get(key);
-      if (!cache2) {
-        context.emitter.emit("cache:miss", { key, context });
-        throw err;
-      }
-      context.emitter.emit("cache:hit", { key, response: cache2.response, context });
-      context.res = cache2.response;
+      return;
     }
-  };
-};
-
-// src/strategies/network-only.ts
-var networkOnly = function(opts) {
-  return async function(ctx, next) {
-    await next();
-  };
-};
-
-// src/strategies/stale-while-revalidate.ts
-var staleWhileRevalidate = function(opts) {
-  const { key, storage } = opts;
-  return async function(context, next) {
-    const cache2 = await storage.get(key);
-    if (cache2) {
-      context.emitter.emit("cache:hit", { key, response: cache2.response, context });
-      const orchestrator = context.orchestration.fork();
-      context.res = cache2.response;
-      setTimeout(async () => {
-        try {
-          await orchestrator.execute();
-          const context2 = orchestrator.context;
-          const entry = await cacheContext(opts, context2);
-          if (entry) {
-            context2.emitter.emit("cache:update", {
-              key,
-              oldResponse: cache2.response,
-              newResponse: entry.response,
-              context: context2
-            });
-          }
-        } catch (err) {
-        }
-      }, 1);
-    } else {
-      context.emitter.emit("cache:miss", { key, context });
+    if (!requestCacheOptions.key) requestCacheOptions.key = options.keyFactory;
+    if (!ctx.locationId && !requestCacheOptions.key) {
+      console.warn("[@keq/cache] Warning: Cannot resolve Cache Key. Cache is skipped.");
       await next();
-      const entry = await cacheContext(opts, context);
-      if (entry) {
-        context.emitter.emit("cache:update", {
-          key,
-          oldResponse: void 0,
-          newResponse: entry.response,
-          context
-        });
-      }
+      return;
     }
+    const handler = new RequestCacheHandler(storage, requestCacheOptions);
+    const strategy = requestCacheOptions.strategy;
+    await strategy(handler, ctx, next);
   };
-};
-
-// src/constants/strategy.enum.ts
-var Strategy = {
-  STALE_WHILE_REVALIDATE: staleWhileRevalidate,
-  NETWORK_FIRST: networkFirst,
-  NETWORK_ONLY: networkOnly,
-  CACHE_FIRST: cacheFirst
-};
-
-// src/constants/eviction.enum.ts
-var Eviction = /* @__PURE__ */ ((Eviction2) => {
-  Eviction2["LRU"] = "lru";
-  Eviction2["LFU"] = "lfu";
-  Eviction2["RANDOM"] = "random";
-  Eviction2["TTL"] = "ttl";
-  return Eviction2;
-})(Eviction || {});
-
-// src/constants/size.enum.ts
-var Size = /* @__PURE__ */ ((Size2) => {
-  Size2[Size2["B"] = 1] = "B";
-  Size2[Size2["KB"] = 1024] = "KB";
-  Size2[Size2["MB"] = 1048576] = "MB";
-  Size2[Size2["GB"] = 1073741824] = "GB";
-  return Size2;
-})(Size || {});
+}
 
 // src/storage/memory-storage/ttl-memory-storage.ts
 import dayjs2 from "dayjs";
-import * as R3 from "ramda";
+import * as R4 from "ramda";
 
 // src/storage/memory-storage/base-memory-storage.ts
 import dayjs from "dayjs";
-import * as R2 from "ramda";
-
-// src/utils/debug.ts
-function debug(...args) {
-  console.debug("[@keq-cache] [DEBUG] ", ...args);
-}
+import * as R3 from "ramda";
 
 // src/storage/keq-cache-storage.ts
 var KeqCacheStorage = class {
 };
 
+// src/utils/logger.ts
+var Logger = class {
+  static debug(...args) {
+    console.debug("[@keq-cache] [DEBUG] ", ...args);
+  }
+  static error(...args) {
+    console.error("[@keq-cache] [ERROR] ", ...args);
+  }
+};
+
+// src/utils/random.ts
+function random(min, max) {
+  return Math.floor(Math.random() * (max - min)) + min;
+}
+
 // src/storage/internal-storage/internal-storage.ts
 var InternalStorage = class extends KeqCacheStorage {
   constructor(options) {
@@ -270,7 +306,7 @@ var InternalStorage = class extends KeqCacheStorage {
     __publicField(this, "__onCacheEvict__");
     __publicField(this, "__onCacheExpired__");
     if ((options == null ? void 0 : options.size) && (typeof (options == null ? void 0 : options.size) !== "number" || options.size <= 0)) {
-      throw TypeError("Invalid size: ".concat(String(options == null ? void 0 : options.size)));
+      throw new CacheException("Invalid size: ".concat(String(options == null ? void 0 : options.size)));
     }
     this.__size__ = (_a = options == null ? void 0 : options.size) != null ? _a : Infinity;
     this.__debug__ = !!(options == null ? void 0 : options.debug);
@@ -283,12 +319,38 @@ var InternalStorage = class extends KeqCacheStorage {
   debug(fn) {
     if (this.__debug__) {
       fn((...args) => {
-        debug("[Storage(".concat(this.__id__, ")]"), ...args);
+        Logger.debug("[Storage(".concat(this.__id__, ")]"), ...args);
       });
     }
   }
 };
 
+// src/storage/memory-storage/utils/humanize-size.ts
+function humanizeSize(size) {
+  if (size < 1024) return "".concat(size, " B");
+  if (size < 1024 * 1024) return "".concat((size / 1024).toFixed(2), " KB");
+  if (size < 1024 * 1024 * 1024) return "".concat((size / (1024 * 1024)).toFixed(2), " MB");
+  return "".concat((size / (1024 * 1024 * 1024)).toFixed(2), " GB");
+}
+
+// src/storage/memory-storage/utils/serialize-response-body.ts
+async function serializeResponseBody(response) {
+  var _a;
+  const contentType = (_a = response.headers.get("content-type")) != null ? _a : "";
+  try {
+    if (contentType.includes("application/json")) {
+      const json = await response.json();
+      return JSON.stringify(json);
+    }
+    if (contentType.includes("text/") || contentType.includes("application/xml") || contentType.includes("application/javascript")) {
+      return await response.text();
+    }
+    return "[Binary or unsupported content]";
+  } catch {
+    return "[Unable to serialize]";
+  }
+}
+
 // src/storage/memory-storage/base-memory-storage.ts
 var BaseMemoryStorage = class extends InternalStorage {
   constructor() {
@@ -299,7 +361,7 @@ var BaseMemoryStorage = class extends InternalStorage {
     __publicField(this, "lastEvictExpiredTime", dayjs());
   }
   get size() {
-    const used = R2.sum(R2.pluck("size", [...this.storage.values()]));
+    const used = R3.sum(R3.pluck("size", [...this.storage.values()]));
     const free = this.__size__ > used ? this.__size__ - used : 0;
     return {
       used,
@@ -342,23 +404,6 @@ var BaseMemoryStorage = class extends InternalStorage {
   remove(key) {
     this.__remove__([key]);
   }
-  /**
-   * Print all cache entries
-   */
-  print() {
-    const entries = Array.from(this.storage.entries()).map(([key, entry]) => {
-      var _a;
-      return {
-        key,
-        size: entry.size,
-        expiredAt: entry.expiredAt ? dayjs(entry.expiredAt).format("YYYY-MM-DD HH:mm:ss") : "N/A",
-        visitCount: (_a = this.visitCountRecords.get(key)) != null ? _a : 0,
-        lastVisit: this.visitTimeRecords.get(key) ? dayjs(this.visitTimeRecords.get(key)).format("YYYY-MM-DD HH:mm:ss") : "N/A"
-      };
-    });
-    console.table(entries);
-    console.log("Total: ".concat(entries.length, " entries, Used: ").concat(this.size.used, ", Free: ").concat(this.size.free));
-  }
   /**
    * @zh 清除过期的缓存
    */
@@ -386,6 +431,33 @@ var BaseMemoryStorage = class extends InternalStorage {
     const size = this.size;
     return size.free >= expectSize;
   }
+  /**
+   * @en Print all cached data using console.table for debugging
+   * @zh 使用 console.table 打印所有缓存数据，用于调试
+   */
+  async print() {
+    if (this.storage.size === 0) {
+      console.log("MemoryStorage is empty");
+      return;
+    }
+    const entries = await Promise.all(
+      [...this.storage.entries()].map(async ([key, entry]) => {
+        var _a, _b, _c;
+        const body = await serializeResponseBody(entry.response.clone());
+        return {
+          key,
+          size: humanizeSize(entry.size),
+          "Expired Time": entry.expiredAt.getTime() >= MAX_EXPIRED_AT.getTime() ? "-" : entry.expiredAt.toISOString(),
+          "Visit Count": (_a = this.visitCountRecords.get(key)) != null ? _a : 0,
+          "Last Visit Time": (_c = (_b = this.visitTimeRecords.get(key)) == null ? void 0 : _b.toISOString()) != null ? _c : "-",
+          "Response Status": entry.response.status,
+          "Response URL": entry.response.url,
+          "Response Body": body
+        };
+      })
+    );
+    console.table(entries);
+  }
 };
 
 // src/storage/memory-storage/ttl-memory-storage.ts
@@ -423,7 +495,7 @@ var TTLMemoryStorage = class extends BaseMemoryStorage {
       const bExpiredAt = dayjs2(b.expiredAt);
       return aExpiredAt.isBefore(bExpiredAt) ? 1 : -1;
     });
-    if (R3.sum(R3.pluck("size", entries)) < deficitSize) {
+    if (R4.sum(R4.pluck("size", entries)) < deficitSize) {
       this.debug((log) => log("Storage Size Not Enough: ", this.size.free, " < ", deficitSize));
       return false;
     }
@@ -439,11 +511,6 @@ var TTLMemoryStorage = class extends BaseMemoryStorage {
   }
 };
 
-// src/utils/random.ts
-function random(min, max) {
-  return Math.floor(Math.random() * (max - min)) + min;
-}
-
 // src/storage/memory-storage/random-memory-storage.ts
 var RandomMemoryStorage = class extends BaseMemoryStorage {
   constructor(options) {
@@ -614,15 +681,18 @@ var MemoryStorage = class extends KeqCacheStorage {
   remove(key) {
     return this.storage.remove(key);
   }
+  async print() {
+    return this.storage.print();
+  }
 };
 
 // src/storage/indexed-db-storage/random-indexed-db-storage.ts
-import * as R5 from "ramda";
+import * as R6 from "ramda";
 
 // src/storage/indexed-db-storage/base-indexed-db-storage.ts
-import * as R4 from "ramda";
-import { openDB } from "idb";
+import * as R5 from "ramda";
 import dayjs4 from "dayjs";
+import { openDB } from "idb";
 
 // src/storage/indexed-db-storage/constants/default-table-name.ts
 var DEFAULT_TABLE_NAME = "keq_cache_indexed_db_storage";
@@ -633,9 +703,9 @@ var BaseIndexedDBStorage = class extends InternalStorage {
     super(options);
     __publicField(this, "tableName", DEFAULT_TABLE_NAME);
     __publicField(this, "db");
-    __publicField(this, "lastEvictExpiredTime", dayjs4());
+    __publicField(this, "lastEvictExpiredTime", dayjs4(0));
     if ((options == null ? void 0 : options.tableName) === DEFAULT_TABLE_NAME) {
-      throw new TypeError('[keq-cache] IndexedDBStorage name cannot be "'.concat(DEFAULT_TABLE_NAME, '"'));
+      throw new CacheException('IndexedDBStorage name cannot be "'.concat(DEFAULT_TABLE_NAME, '"'));
     }
     this.tableName = (options == null ? void 0 : options.tableName) || DEFAULT_TABLE_NAME;
   }
@@ -659,13 +729,13 @@ var BaseIndexedDBStorage = class extends InternalStorage {
         }
       },
       blocked() {
-        console.error("IndexedDB Table ".concat(tableName, " is blocked"));
+        Logger.error("[@keq-request/cache] IndexedDB Table ".concat(tableName, " is blocked"));
       },
       blocking() {
-        console.error("IndexedDB Table ".concat(tableName, " is blocking"));
+        Logger.error("[@keq-request/cache] IndexedDB Table ".concat(tableName, " is blocking"));
       },
       terminated() {
-        console.error("IndexedDB Table ".concat(tableName, " is terminated"));
+        Logger.error("[@keq-request/cache] IndexedDB Table ".concat(tableName, " is terminated"));
       }
     });
     this.db = db;
@@ -674,7 +744,7 @@ var BaseIndexedDBStorage = class extends InternalStorage {
   async getSize() {
     const db = await this.openDB();
     const items = await db.getAll("metadata");
-    const used = R4.sum(items.map((entry) => entry.size));
+    const used = R5.sum(items.map((entry) => entry.size));
     const free = this.__size__ - used;
     return { used, free };
   }
@@ -750,7 +820,7 @@ var BaseIndexedDBStorage = class extends InternalStorage {
   }
   async __remove__(tx, keys) {
     await Promise.all(
-      R4.unnest(
+      R5.unnest(
         keys.map((key) => [
           tx.objectStore("metadata").delete(key),
           tx.objectStore("response").delete(key),
@@ -776,15 +846,15 @@ var BaseIndexedDBStorage = class extends InternalStorage {
     var _a;
     const now = dayjs4();
     if (now.diff(this.lastEvictExpiredTime, "second") < 1) return;
+    this.lastEvictExpiredTime = now;
     try {
-      const now2 = dayjs4();
       const db = await this.openDB();
       const tx = db.transaction(["metadata", "response", "visits"], "readwrite");
       const metadataStore = tx.objectStore("metadata");
-      let cursor = await metadataStore.index("expiredAt").openCursor(IDBKeyRange.upperBound(now2.valueOf()));
+      let cursor = await metadataStore.index("expiredAt").openCursor(IDBKeyRange.upperBound(now.toDate()));
       const expiredKeys = [];
       while (cursor) {
-        if (dayjs4(cursor.value.expiredAt).isBefore(now2)) {
+        if (dayjs4(cursor.value.expiredAt).isBefore(now)) {
           expiredKeys.push(cursor.value.key);
           cursor = await cursor.continue();
         } else {
@@ -831,7 +901,7 @@ var RandomIndexedDBStorage = class extends BaseIndexedDBStorage {
     const tx = db.transaction(["metadata", "response", "visits"], "readwrite");
     const metadataStore = tx.objectStore("metadata");
     const metadatas = await metadataStore.getAll();
-    const totalSize = R5.sum(metadatas.map((m) => m.size));
+    const totalSize = R6.sum(metadatas.map((m) => m.size));
     if (totalSize < deficitSize) {
       this.debug((log) => log("Storage Size Not Enough, deficit size: ".concat(deficitSize - totalSize)));
       tx.abort();
@@ -1034,7 +1104,7 @@ var IndexedDBStorage = class extends KeqCacheStorage {
     } else if (eviction === "ttl" /* TTL */) {
       this.storage = new TTLIndexedDBStorage(options);
     } else {
-      throw TypeError("Not Supported Eviction: ".concat(String(options == null ? void 0 : options.eviction)));
+      throw new CacheException("Not Supported Eviction: ".concat(String(options == null ? void 0 : options.eviction)));
     }
   }
   set(entry) {
@@ -1084,7 +1154,7 @@ var MultiTierStorage = class extends KeqCacheStorage {
    * @zh 并发写入所有层的缓存
    */
   async set(entry) {
-    const promises = this.storages.map((storage) => storage.set(entry));
+    const promises = this.storages.map(async (storage) => storage.set(entry));
     await Promise.all(promises);
   }
   /**
@@ -1092,7 +1162,7 @@ var MultiTierStorage = class extends KeqCacheStorage {
    * @zh 从所有层删除缓存条目
    */
   async remove(key) {
-    const promises = this.storages.map((storage) => storage.remove(key));
+    const promises = this.storages.map(async (storage) => storage.remove(key));
     await Promise.all(promises);
   }
   /**
@@ -1104,7 +1174,7 @@ var MultiTierStorage = class extends KeqCacheStorage {
     if (lowerTierStorages.length === 0) {
       return;
     }
-    const promises = lowerTierStorages.map((storage) => storage.set(entry.clone()));
+    const promises = lowerTierStorages.map(async (storage) => storage.set(entry.clone()));
     try {
       await Promise.all(promises);
     } catch (error) {
@@ -1124,10 +1194,11 @@ var TierStorage = class extends MultiTierStorage {
   }
 };
 export {
-  KeqCacheStorage as CacheStorage,
   Eviction,
   IndexedDBStorage,
+  KeqCacheStorage,
   MemoryStorage,
+  MultiTierStorage,
   Size,
   Strategy,
   TierStorage,