@zenweb/cache 4.5.0 → 4.6.0

package/dist/cache.d.ts

@@ -17,9 +17,13 @@ export declare class CacheResult {
  * 对象缓存系统
  */
 export declare class Cache {
-    private redis;
+    redis: Redis;
     private option;
     constructor(redis: Redis, option: Required<SetupOption>);
+    /**
+     * 取得缓存剩余有效期
+     */
+    ttl(key: string): Promise<number>;
     /**
      * 删除缓存
      */
@@ -59,10 +63,17 @@ export declare class Cache {
      * @param key 缓存KEY
      * @param fetch 缓存设置方法回调
      */
-    lockGet<T = unknown>(key: string, fetch: () => Promise<T> | T, _opt: {
+    lockGet<T = unknown>(key: string, fetch: () => Promise<T> | T, opt: {
+        parse: false;
+        noWait: true;
+    } & LockGetOption): Promise<CacheResult | undefined>;
+    lockGet<T = unknown>(key: string, fetch: () => Promise<T> | T, opt: {
+        noWait: true;
+    } & LockGetOption): Promise<T | undefined>;
+    lockGet<T = unknown>(key: string, fetch: () => Promise<T> | T, opt: {
         parse: false;
     } & LockGetOption): Promise<CacheResult>;
-    lockGet<T = unknown>(key: string, fetch: () => Promise<T> | T, _opt?: {
+    lockGet<T = unknown>(key: string, fetch: () => Promise<T> | T, opt?: {
         parse?: true;
     } & LockGetOption): Promise<T>;
     /**

package/dist/cache.js

@@ -33,6 +33,12 @@ class Cache {
         this.redis = redis;
         this.option = option;
     }
+    /**
+     * 取得缓存剩余有效期
+     */
+    ttl(key) {
+        return this.redis.ttl(key);
+    }
     /**
      * 删除缓存
      */
@@ -106,110 +112,154 @@ class Cache {
             return new CacheResult(compressed, data);
         }
     }
-    async lockGet(key, fetch, _opt) {
-        const opt = Object.assign({}, this.option.set, this.option.lockGet, _opt);
+    lockGet(key, fetch, opt) {
+        const _opt = Object.assign({}, this.option.set, this.option.lockGet, opt);
+        return new LockGet(this, key, fetch, _opt).get();
+    }
+    /**
+     * 单例执行，在并发情况下保证同一个 key 只会单独执行，防止同时处理
+     * @param key 锁key
+     * @param run 获得锁时调用
+     */
+    async singleRunner(key, run, _opt) {
+        const opt = Object.assign({}, this.option.lockGet, _opt);
+        const locker = new locker_1.Locker(this.redis, key, opt.lockTimeout);
+        const retryTimeout = typeof opt.retryTimeout === 'number' ? opt.retryTimeout : 0;
+        const retryDelay = (opt.retryDelay === undefined || opt.retryDelay < 0) ? 500 : opt.retryDelay;
+        let retryTime = 0;
+        while (true) {
+            // 取得锁并执行
+            if (await locker.acquire()) {
+                try {
+                    return await run();
+                }
+                finally {
+                    await locker.release();
+                }
+            }
+            // 无法取得锁是否重复尝试
+            if (retryTime >= retryTimeout) {
+                throw new Error('Unable to acquire lock');
+            }
+            else {
+                retryTime += retryDelay;
+                await (0, utils_1.sleep)(retryDelay);
+            }
+        }
+    }
+}
+exports.Cache = Cache;
+class LockGet {
+    constructor(cache, key, fetch, opt) {
+        this.cache = cache;
+        this.key = key;
+        this.fetch = fetch;
+        this.opt = opt;
+    }
+    /**
+     * 获取数据并设置到缓存中
+     */
+    async fetchAndSet() {
+        const obj = await this.fetch();
         // 本地存储
-        if (opt.localStore && key in opt.localStore) {
-            return opt.localStore[key];
+        if (this.opt.localStore) {
+            this.opt.localStore[this.key] = obj;
         }
-        // 获取数据并设置到缓存中
-        const fetchAndSet = async () => {
-            const obj = await fetch();
-            // 本地存储
-            if (opt.localStore) {
-                opt.localStore[key] = obj;
-            }
-            const result = await this.set(key, obj, opt);
-            if ((_opt === null || _opt === void 0 ? void 0 : _opt.parse) !== false) {
-                return obj;
+        const result = await this.cache.set(this.key, obj, this.opt);
+        if (this.opt.parse !== false) {
+            return obj;
+        }
+        return new CacheResult(!this.opt.decompress && Boolean(result.compressed), !this.opt.decompress && result.compressed || Buffer.from(result.data));
+    }
+    /**
+     * 预刷新处理
+     */
+    async preRefresh(preRefresh) {
+        const ttl = await this.cache.ttl(this.key);
+        _lockDebug('[%s] preRefresh remain: %d', this.key, ttl);
+        if (ttl < preRefresh) {
+            _lockDebug('[%s] preRefresh -> fetchAndSet', this.key);
+            await this.fetchAndSet();
+        }
+    }
+    /**
+     * 从缓存中取得数据
+     */
+    async getCache() {
+        // 本地存储
+        if (this.opt.localStore && this.key in this.opt.localStore) {
+            return this.opt.localStore[this.key];
+        }
+        // 尝试从 redis 中获取
+        const data = await this.cache.get(this.key, this.opt);
+        if (data !== undefined) {
+            if (!this.locker && this.opt.preRefresh && this.opt.preRefresh > 0) {
+                this.preRefresh(this.opt.preRefresh);
             }
-            return new CacheResult(!opt.decompress && Boolean(result.compressed), !opt.decompress && result.compressed || Buffer.from(result.data));
-        };
-        // 预刷新处理
-        const preRefresh = async () => {
-            if (opt.preRefresh && opt.preRefresh > 0) {
-                const ttl = await this.redis.ttl(key);
-                _lockDebug('[%s] preRefresh remain: %d', key, ttl);
-                if (ttl < opt.preRefresh) {
-                    _lockDebug('[%s] preRefresh -> fetchAndSet', key);
-                    await fetchAndSet();
-                }
+            // 本地存储
+            if (this.opt.localStore && typeof this.opt.localStore === 'object') {
+                this.opt.localStore[this.key] = data;
             }
-        };
-        // 使用锁设置缓存
-        let locker;
-        let refresh = opt.refresh || false; // 强制刷新
-        let retryCount = typeof opt.retryCount === 'number' ? opt.retryCount : 10;
+            return data;
+        }
+    }
+    async tryFetch() {
+        const retryTimeout = typeof this.opt.retryTimeout === 'number' ? this.opt.retryTimeout : 5000;
+        const retryDelay = (this.opt.retryDelay === undefined || this.opt.retryDelay < 0) ? 500 : this.opt.retryDelay;
+        let retryTime = 0;
         while (true) {
-            if (!refresh) {
+            if (!this.locker) {
+                this.locker = new locker_1.Locker(this.cache.redis, `${this.key}.LOCK`, this.opt.lockTimeout);
+            }
+            else {
                 // 尝试从 redis 中获取
-                const data = await this.get(key, opt);
+                const data = await this.getCache();
                 if (data !== undefined) {
-                    if (!locker) {
-                        preRefresh();
-                    }
-                    // 本地存储
-                    if (opt.localStore) {
-                        opt.localStore[key] = data;
-                    }
                     return data;
                 }
             }
-            // 已经跳过 redis 获取可以结束强制刷新，进入锁获取，锁获取不成功则代表其他刷新任务已经进行，只要等待获取即可
-            refresh = false;
             // 获取锁
-            if (!locker) {
-                locker = new locker_1.Locker(this.redis, `${key}.LOCK`, opt.lockTimeout);
-            }
-            if (await locker.acquire()) {
-                _lockDebug('[%s] acquire success', key);
+            if (await this.locker.acquire()) {
+                _lockDebug('[%s] acquire success', this.key);
                 try {
-                    return await fetchAndSet();
+                    return await this.fetchAndSet();
                 }
                 finally {
-                    await locker.release();
+                    await this.locker.release();
                 }
             }
             else {
+                // 不等待为 true 不需要重试，说明有其他请求更新数据
+                if (this.opt.noWait === true) {
+                    _lockDebug('[%s] no wait', this.key);
+                    return;
+                }
                 // 获取锁失败，有其他请求更新数据，等待后重新获取获取数据
-                if (retryCount <= 0) {
-                    throw new Error('Unable to acquire lock: ' + key);
+                if (retryTime >= retryTimeout) {
+                    throw new Error('Unable to acquire lock: ' + this.key);
                 }
                 else {
-                    retryCount--;
-                    await (0, utils_1.sleep)(opt.retryDelay || 300);
+                    retryTime += retryDelay;
+                    await (0, utils_1.sleep)(retryDelay);
                 }
             }
         }
     }
-    /**
-     * 单例执行，在并发情况下保证同一个 key 只会单独执行，防止同时处理
-     * @param key 锁key
-     * @param run 获得锁时调用
-     */
-    async singleRunner(key, run, _opt) {
-        const opt = Object.assign({}, _opt);
-        const locker = new locker_1.Locker(this.redis, key, opt.lockTimeout);
-        let retryCount = opt.retryCount || 0;
-        while (true) {
-            // 取得锁并执行
-            if (await locker.acquire()) {
-                try {
-                    return await run();
-                }
-                finally {
-                    await locker.release();
-                }
-            }
-            // 无法取得锁是否重复尝试
-            if (retryCount <= 0) {
-                throw new Error('Unable to acquire lock');
-            }
-            else {
-                retryCount--;
-                await (0, utils_1.sleep)(opt.retryDelay || 300);
+    async get() {
+        // 如果强制刷新则不需要尝试从缓存获取，直接进入锁获取并取得数据
+        const refresh = this.opt.refresh || false;
+        if (!refresh) {
+            // 先尝试从缓存获取
+            const data = await this.getCache();
+            if (data !== undefined) {
+                return data;
             }
         }
+        // 不等待为 true 直接返回 undefined
+        if (this.opt.noWait === true) {
+            this.tryFetch();
+            return;
+        }
+        return this.tryFetch();
     }
 }
-exports.Cache = Cache;

package/dist/options.js

@@ -14,6 +14,8 @@ exports.defaultSetOption = {
     compressLevel: 1,
 };
 exports.defaultLockGetOption = {
+    retryTimeout: 5000,
+    retryDelay: 500,
     preRefresh: 0,
     refresh: false,
     localStore: undefined,

package/dist/types.d.ts

@@ -45,7 +45,7 @@ export interface SetupOption {
     /**
      * Redis 实例或 Redis 选项
      */
-    redis: Redis | RedisOptions;
+    redis?: Redis | RedisOptions;
     /**
      * 默认缓存设置选项
      */
@@ -100,15 +100,15 @@ export interface LockOption {
      */
     lockTimeout?: number;
     /**
-     * 锁获取失败重试次数
+     * 数据获取重试超时 (毫秒)
      * - 0 不进行重试
-     * - lockGet 默认为 10
+     * - lockGet 默认为 5000
      * - singleRunner 默认为 0
      */
-    retryCount?: number;
+    retryTimeout?: number;
     /**
-     * 锁获取失败重试间隔时间 (毫秒)
-     * @default 300
+     * 数据获取重试间隔 (毫秒)
+     * @default 500
      */
     retryDelay?: number;
 }
@@ -138,4 +138,11 @@ export interface LockGetOption extends GetOption, SetOption, LockOption {
     localStore?: {
         [key: string]: any;
     };
+    /**
+     * 不等待
+     * - 当缓存不存在时直接返回 `undefined`，之后使用 `fetch` 取得数据并设置缓存
+     * - 应用场景: 某些数据并不参与业务逻辑又比较耗时，当 `fetch` 处理时间过长的情况下可能会造成请求超时，使用 `wait: false` 可以跳过等待
+     * @default false
+     */
+    noWait?: boolean;
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@zenweb/cache",
   "packageManager": "yarn@4.0.2",
-  "version": "4.5.0",
+  "version": "4.6.0",
   "description": "Zenweb Cache module",
   "exports": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -36,6 +36,7 @@
     "@types/node": "^20.10.6",
     "cross-env": "^7.0.3",
     "mocha": "^10.2.0",
+    "msgpackr": "^1.11.0",
     "rimraf": "^4.3.1",
     "ts-mocha": "^10.0.0",
     "ts-node": "^10.9.1",