@modern-js/runtime-utils 2.68.1 → 2.68.2

package/dist/esm-node/universal/cache.js

@@ -13,50 +13,6 @@ const CacheTime = {
   WEEK: 7 * 24 * 60 * 60 * 1e3,
   MONTH: 30 * 24 * 60 * 60 * 1e3
 };
-const isServer = typeof window === "undefined";
-const requestCacheMap = /* @__PURE__ */ new WeakMap();
-let lruCache;
-let cacheConfig = {
-  maxSize: CacheSize.GB
-};
-const tagKeyMap = /* @__PURE__ */ new Map();
-function addTagKeyRelation(tag, key) {
-  let keys = tagKeyMap.get(tag);
-  if (!keys) {
-    keys = /* @__PURE__ */ new Set();
-    tagKeyMap.set(tag, keys);
-  }
-  keys.add(key);
-}
-function configureCache(config) {
-  cacheConfig = {
-    ...cacheConfig,
-    ...config
-  };
-}
-function getLRUCache() {
-  if (!lruCache) {
-    var _cacheConfig_maxSize;
-    lruCache = new LRUCache({
-      maxSize: (_cacheConfig_maxSize = cacheConfig.maxSize) !== null && _cacheConfig_maxSize !== void 0 ? _cacheConfig_maxSize : CacheSize.GB,
-      sizeCalculation: (value) => {
-        if (!value.size) {
-          return 1;
-        }
-        let size = 0;
-        for (const [k, item] of value.entries()) {
-          size += k.length * 2;
-          size += estimateObjectSize(item.data);
-          size += 8;
-        }
-        return size;
-      },
-      updateAgeOnGet: true,
-      updateAgeOnHas: true
-    });
-  }
-  return lruCache;
-}
 function estimateObjectSize(data) {
   const type = typeof data;
   if (type === "number")
@@ -84,6 +40,67 @@ function estimateObjectSize(data) {
   }
   return 1;
 }
+class MemoryContainer {
+  async get(key) {
+    return this.lru.get(key);
+  }
+  async set(key, value, options) {
+    if (options === null || options === void 0 ? void 0 : options.ttl) {
+      this.lru.set(key, value, {
+        ttl: options.ttl * 1e3
+      });
+    } else {
+      this.lru.set(key, value);
+    }
+  }
+  async has(key) {
+    return this.lru.has(key);
+  }
+  async delete(key) {
+    return this.lru.delete(key);
+  }
+  async clear() {
+    this.lru.clear();
+  }
+  constructor(options) {
+    var _options_maxSize;
+    this.lru = new LRUCache({
+      maxSize: (_options_maxSize = options === null || options === void 0 ? void 0 : options.maxSize) !== null && _options_maxSize !== void 0 ? _options_maxSize : CacheSize.GB,
+      sizeCalculation: estimateObjectSize,
+      updateAgeOnGet: true,
+      updateAgeOnHas: true
+    });
+  }
+}
+const isServer = typeof window === "undefined";
+const requestCacheMap = /* @__PURE__ */ new WeakMap();
+const TAG_PREFIX = "tag:";
+const CACHE_PREFIX = "modernjs_cache:";
+const ongoingRevalidations = /* @__PURE__ */ new Map();
+let storage;
+let cacheConfig = {
+  maxSize: CacheSize.GB
+};
+function getStorage() {
+  if (storage) {
+    return storage;
+  }
+  if (cacheConfig.container) {
+    storage = cacheConfig.container;
+  } else {
+    storage = new MemoryContainer({
+      maxSize: cacheConfig.maxSize
+    });
+  }
+  return storage;
+}
+function configureCache(config) {
+  cacheConfig = {
+    ...cacheConfig,
+    ...config
+  };
+  storage = void 0;
+}
 function generateKey(args) {
   return JSON.stringify(args, (_, value) => {
     if (value && typeof value === "object" && !Array.isArray(value)) {
@@ -95,24 +112,22 @@ function generateKey(args) {
     return value;
   });
 }
+function generateStableFunctionId(fn) {
+  const fnString = fn.toString();
+  let hash = 0;
+  for (let i = 0; i < fnString.length; i++) {
+    const char = fnString.charCodeAt(i);
+    hash = (hash << 5) - hash + char;
+    hash = hash & hash;
+  }
+  return `fn_${fn.name || "anonymous"}_${Math.abs(hash).toString(36)}`;
+}
 function cache(fn, options) {
-  const { tag = "default", maxAge = CacheTime.MINUTE * 5, revalidate = 0, customKey, onCache, getKey } = options || {};
-  const store = getLRUCache();
-  const tags = Array.isArray(tag) ? tag : [
-    tag
-  ];
-  const getCacheKey = (args, generatedKey) => {
-    return customKey ? customKey({
-      params: args,
-      fn,
-      generatedKey
-    }) : fn;
-  };
   return async (...args) => {
     if (isServer && typeof options === "undefined") {
       var _storage_useContext;
-      const storage = getAsyncLocalStorage();
-      const request = storage === null || storage === void 0 ? void 0 : (_storage_useContext = storage.useContext()) === null || _storage_useContext === void 0 ? void 0 : _storage_useContext.request;
+      const storage2 = getAsyncLocalStorage();
+      const request = storage2 === null || storage2 === void 0 ? void 0 : (_storage_useContext = storage2.useContext()) === null || _storage_useContext === void 0 ? void 0 : _storage_useContext.request;
       if (request) {
         let shouldDisableCaching = false;
         if (cacheConfig.unstable_shouldDisable) {
@@ -148,123 +163,231 @@ function cache(fn, options) {
         }
       }
     } else if (typeof options !== "undefined") {
-      const genKey = getKey ? getKey(...args) : generateKey(args);
-      const now = Date.now();
-      const cacheKey = getCacheKey(args, genKey);
-      const finalKey = typeof cacheKey === "function" ? genKey : cacheKey;
-      tags.forEach((t) => addTagKeyRelation(t, cacheKey));
-      let cacheStore = store.get(cacheKey);
-      if (!cacheStore) {
-        cacheStore = /* @__PURE__ */ new Map();
-      }
-      const storeKey = customKey && typeof cacheKey === "symbol" ? "symbol-key" : genKey;
-      let shouldDisableCaching = false;
-      if (isServer && cacheConfig.unstable_shouldDisable) {
-        var _storage_useContext1;
-        const storage = getAsyncLocalStorage();
-        const request = storage === null || storage === void 0 ? void 0 : (_storage_useContext1 = storage.useContext()) === null || _storage_useContext1 === void 0 ? void 0 : _storage_useContext1.request;
-        if (request) {
-          shouldDisableCaching = await cacheConfig.unstable_shouldDisable({
-            request
+      try {
+        const { tag, maxAge = CacheTime.MINUTE * 5, revalidate = 0, customKey, onCache, getKey, unstable_shouldCache } = options;
+        let missReason;
+        const currentStorage = getStorage();
+        const now = Date.now();
+        const tags = tag ? Array.isArray(tag) ? tag : [
+          tag
+        ] : [];
+        const genKey = getKey ? getKey(...args) : generateKey(args);
+        let finalKey;
+        if (customKey) {
+          finalKey = customKey({
+            params: args,
+            fn,
+            generatedKey: genKey
           });
+        } else {
+          const functionId = generateStableFunctionId(fn);
+          finalKey = `${functionId}:${genKey}`;
         }
-      }
-      const cached = cacheStore.get(storeKey);
-      if (cached && !shouldDisableCaching) {
-        const age = now - cached.timestamp;
-        if (age < maxAge) {
-          if (onCache) {
-            onCache({
-              status: "hit",
-              key: finalKey,
-              params: args,
-              result: cached.data
+        const storageKey = `${CACHE_PREFIX}${finalKey}`;
+        let shouldDisableCaching = false;
+        if (isServer && cacheConfig.unstable_shouldDisable) {
+          var _asyncStorage_useContext;
+          const asyncStorage = getAsyncLocalStorage();
+          const request = asyncStorage === null || asyncStorage === void 0 ? void 0 : (_asyncStorage_useContext = asyncStorage.useContext()) === null || _asyncStorage_useContext === void 0 ? void 0 : _asyncStorage_useContext.request;
+          if (request) {
+            shouldDisableCaching = await cacheConfig.unstable_shouldDisable({
+              request
             });
           }
-          return cached.data;
         }
-        if (revalidate > 0 && age < maxAge + revalidate) {
-          if (onCache) {
-            onCache({
-              status: "stale",
-              key: finalKey,
-              params: args,
-              result: cached.data
-            });
-          }
-          if (!cached.isRevalidating) {
-            cached.isRevalidating = true;
-            Promise.resolve().then(async () => {
-              try {
-                const newData = await fn(...args);
-                cacheStore.set(storeKey, {
-                  data: newData,
-                  timestamp: Date.now(),
-                  isRevalidating: false
+        if (!shouldDisableCaching) {
+          const cached = await currentStorage.get(storageKey);
+          if (cached) {
+            try {
+              const cacheItem = cached;
+              const age = now - cacheItem.timestamp;
+              if (age < maxAge) {
+                onCache === null || onCache === void 0 ? void 0 : onCache({
+                  status: "hit",
+                  key: finalKey,
+                  params: args,
+                  result: cacheItem.data
+                });
+                return cacheItem.data;
+              }
+              if (revalidate > 0 && age < maxAge + revalidate) {
+                onCache === null || onCache === void 0 ? void 0 : onCache({
+                  status: "stale",
+                  key: finalKey,
+                  params: args,
+                  result: cacheItem.data
                 });
-                store.set(cacheKey, cacheStore);
-              } catch (error) {
-                cached.isRevalidating = false;
-                if (isServer) {
-                  var _storage_useContext_monitors, _storage_useContext2;
-                  const storage = getAsyncLocalStorage();
-                  storage === null || storage === void 0 ? void 0 : (_storage_useContext2 = storage.useContext()) === null || _storage_useContext2 === void 0 ? void 0 : (_storage_useContext_monitors = _storage_useContext2.monitors) === null || _storage_useContext_monitors === void 0 ? void 0 : _storage_useContext_monitors.error(error.message);
-                } else {
-                  console.error("Background revalidation failed:", error);
+                if (!ongoingRevalidations.has(storageKey)) {
+                  const revalidationPromise = (async () => {
+                    try {
+                      const newData = await fn(...args);
+                      let shouldCache = true;
+                      if (unstable_shouldCache) {
+                        shouldCache = await unstable_shouldCache({
+                          params: args,
+                          result: newData
+                        });
+                      }
+                      if (shouldCache) {
+                        await setCacheItem(currentStorage, storageKey, newData, tags, maxAge, revalidate);
+                      }
+                    } catch (error) {
+                      if (isServer) {
+                        var _asyncStorage_useContext_monitors, _asyncStorage_useContext2;
+                        const asyncStorage = getAsyncLocalStorage();
+                        asyncStorage === null || asyncStorage === void 0 ? void 0 : (_asyncStorage_useContext2 = asyncStorage.useContext()) === null || _asyncStorage_useContext2 === void 0 ? void 0 : (_asyncStorage_useContext_monitors = _asyncStorage_useContext2.monitors) === null || _asyncStorage_useContext_monitors === void 0 ? void 0 : _asyncStorage_useContext_monitors.error(error.message);
+                      } else {
+                        console.error("Background revalidation failed:", error);
+                      }
+                    } finally {
+                      ongoingRevalidations.delete(storageKey);
+                    }
+                  })();
+                  ongoingRevalidations.set(storageKey, revalidationPromise);
                 }
+                return cacheItem.data;
               }
+              missReason = 3;
+            } catch (error) {
+              console.warn("Failed to parse cached data:", error);
+              missReason = 4;
+            }
+          } else {
+            missReason = 2;
+          }
+        } else {
+          missReason = 1;
+        }
+        const data = await fn(...args);
+        if (!shouldDisableCaching) {
+          let shouldCache = true;
+          if (unstable_shouldCache) {
+            shouldCache = await unstable_shouldCache({
+              params: args,
+              result: data
             });
           }
-          return cached.data;
+          if (shouldCache) {
+            await setCacheItem(currentStorage, storageKey, data, tags, maxAge, revalidate);
+          }
         }
-      }
-      const data = await fn(...args);
-      if (!shouldDisableCaching) {
-        cacheStore.set(storeKey, {
-          data,
-          timestamp: now,
-          isRevalidating: false
-        });
-        store.set(cacheKey, cacheStore);
-      }
-      if (onCache) {
-        onCache({
+        onCache === null || onCache === void 0 ? void 0 : onCache({
           status: "miss",
           key: finalKey,
           params: args,
-          result: data
+          result: data,
+          reason: missReason
         });
+        return data;
+      } catch (error) {
+        console.warn("Cache operation failed, falling back to direct execution:", error);
+        const data = await fn(...args);
+        const { onCache } = options;
+        try {
+          onCache === null || onCache === void 0 ? void 0 : onCache({
+            status: "miss",
+            key: "cache_failed",
+            params: args,
+            result: data,
+            reason: 5
+          });
+        } catch (callbackError) {
+          console.warn("Failed to call onCache callback:", callbackError);
+        }
+        return data;
       }
-      return data;
     } else {
       console.warn("The cache function will not work because it runs on the browser and there are no options are provided.");
       return fn(...args);
     }
   };
 }
+async function setCacheItem(storage2, storageKey, data, tags, maxAge, revalidate) {
+  const newItem = {
+    data,
+    timestamp: Date.now(),
+    tags: tags.length > 0 ? tags : void 0
+  };
+  const ttl = (maxAge + revalidate) / 1e3;
+  await storage2.set(storageKey, newItem, {
+    ttl: ttl > 0 ? ttl : void 0
+  });
+  await updateTagRelationships(storage2, storageKey, tags);
+}
+async function updateTagRelationships(storage2, storageKey, tags) {
+  for (const tag of tags) {
+    const tagStoreKey = `${TAG_PREFIX}${tag}`;
+    const keyList = await storage2.get(tagStoreKey);
+    const keyArray = keyList || [];
+    if (!keyArray.includes(storageKey)) {
+      keyArray.push(storageKey);
+    }
+    await storage2.set(tagStoreKey, keyArray);
+  }
+}
+async function removeKeyFromTags(storage2, storageKey, tags) {
+  for (const tag of tags) {
+    const tagStoreKey = `${TAG_PREFIX}${tag}`;
+    const keyList = await storage2.get(tagStoreKey);
+    if (keyList) {
+      try {
+        const keyArray = Array.isArray(keyList) ? keyList : [];
+        const updatedKeyList = keyArray.filter((key) => key !== storageKey);
+        if (updatedKeyList.length > 0) {
+          await storage2.set(tagStoreKey, updatedKeyList);
+        } else {
+          await storage2.delete(tagStoreKey);
+        }
+      } catch (error) {
+        console.warn(`Failed to process tag key list for tag ${tag}:`, error);
+      }
+    }
+  }
+}
 function withRequestCache(handler) {
   if (!isServer) {
     return handler;
   }
   return async (req, ...args) => {
-    const storage = getAsyncLocalStorage();
-    return storage.run({
+    const storage2 = getAsyncLocalStorage();
+    return storage2.run({
       request: req
     }, () => handler(req, ...args));
   };
 }
-function revalidateTag(tag) {
-  const keys = tagKeyMap.get(tag);
-  if (keys) {
-    keys.forEach((key) => {
-      lruCache === null || lruCache === void 0 ? void 0 : lruCache.delete(key);
-    });
+async function revalidateTag(tag) {
+  const currentStorage = getStorage();
+  const tagStoreKey = `${TAG_PREFIX}${tag}`;
+  const keyList = await currentStorage.get(tagStoreKey);
+  if (keyList) {
+    try {
+      const keyArray = Array.isArray(keyList) ? keyList : [];
+      for (const cacheKey of keyArray) {
+        const cached = await currentStorage.get(cacheKey);
+        if (cached) {
+          try {
+            const cacheItem = cached;
+            if (cacheItem.tags) {
+              const otherTags = cacheItem.tags.filter((t) => t !== tag);
+              await removeKeyFromTags(currentStorage, cacheKey, otherTags);
+            }
+          } catch (error) {
+            console.warn("Failed to parse cached data while revalidating:", error);
+          }
+        }
+        await currentStorage.delete(cacheKey);
+      }
+      await currentStorage.delete(tagStoreKey);
+    } catch (error) {
+      console.warn("Failed to process tag key list:", error);
+    }
   }
 }
-function clearStore() {
-  lruCache === null || lruCache === void 0 ? void 0 : lruCache.clear();
-  lruCache = void 0;
-  tagKeyMap.clear();
+async function clearStore() {
+  const currentStorage = getStorage();
+  await currentStorage.clear();
+  storage = void 0;
+  ongoingRevalidations.clear();
 }
 export {
   CacheSize,

package/dist/types/universal/cache.d.ts

@@ -14,32 +14,55 @@ export declare const CacheTime: {
 export type CacheStatus = 'hit' | 'stale' | 'miss';
 export interface CacheStatsInfo {
     status: CacheStatus;
-    key: string | symbol;
+    key: string;
     params: any[];
     result: any;
+    /**
+     * Cache miss reason:
+     * 1: Caching is disabled for the current request
+     * 2: Item not found in cache
+     * 3: Item found in cache but has expired
+     * 4: Failed to parse data from cache
+     * 5: Execution error
+     */
+    reason?: number;
 }
-interface CacheOptions {
+export interface Container {
+    get: (key: string) => Promise<any | undefined | null>;
+    set: (key: string, value: any, options?: {
+        ttl?: number;
+    }) => Promise<any>;
+    has: (key: string) => Promise<boolean>;
+    delete: (key: string) => Promise<boolean>;
+    clear: () => Promise<void>;
+}
+interface CacheOptions<T extends (...args: any[]) => any> {
     tag?: string | string[];
     maxAge?: number;
     revalidate?: number;
-    getKey?: <Args extends any[]>(...args: Args) => string;
-    customKey?: <Args extends any[]>(options: {
-        params: Args;
-        fn: (...args: Args) => any;
+    getKey?: (...args: Parameters<T>) => string;
+    customKey?: (options: {
+        params: Parameters<T>;
+        fn: T;
         generatedKey: string;
-    }) => string | symbol;
+    }) => string;
     onCache?: (info: CacheStatsInfo) => void;
+    unstable_shouldCache?: (info: {
+        params: Parameters<T>;
+        result: Awaited<ReturnType<T>>;
+    }) => boolean | Promise<boolean>;
 }
 interface CacheConfig {
     maxSize?: number;
+    container?: Container;
     unstable_shouldDisable?: ({ request, }: {
         request: Request;
     }) => boolean | Promise<boolean>;
 }
 export declare function configureCache(config: CacheConfig): void;
 export declare function generateKey(args: unknown[]): string;
-export declare function cache<T extends (...args: any[]) => Promise<any>>(fn: T, options?: CacheOptions): T;
+export declare function cache<T extends (...args: any[]) => Promise<any>>(fn: T, options?: CacheOptions<T>): T;
 export declare function withRequestCache<T extends (req: Request, ...args: any[]) => Promise<any>>(handler: T): T;
-export declare function revalidateTag(tag: string): void;
-export declare function clearStore(): void;
+export declare function revalidateTag(tag: string): Promise<void>;
+export declare function clearStore(): Promise<void>;
 export {};

package/package.json

@@ -15,7 +15,7 @@
     "modern",
     "modern.js"
   ],
-  "version": "2.68.1",
+  "version": "2.68.2",
   "_comment": "Provide ESM and CJS exports, ESM is used by runtime package, for treeshaking",
   "exports": {
     "./router": {
@@ -145,8 +145,8 @@
     "lru-cache": "^10.4.3",
     "react-router-dom": "6.27.0",
     "serialize-javascript": "^6.0.0",
-    "@modern-js/types": "2.68.1",
-    "@modern-js/utils": "2.68.1"
+    "@modern-js/types": "2.68.2",
+    "@modern-js/utils": "2.68.2"
   },
   "peerDependencies": {
     "react": ">=17.0.0",
@@ -161,9 +161,11 @@
     }
   },
   "devDependencies": {
+    "@types/ioredis-mock": "^8.2.6",
     "@types/jest": "^29",
     "@types/node": "^14",
     "@types/serialize-javascript": "^5.0.1",
+    "ioredis-mock": "^8.9.0",
     "jest": "^29",
     "react": "^18.3.1",
     "react-dom": "^18.3.1",