@zenweb/cache 4.4.0 → 4.6.0

package/dist/cache.d.ts

@@ -17,15 +17,19 @@ export declare class CacheResult {
  * 对象缓存系统
  */
 export declare class Cache {
-    private redis;
-    private option?;
-    constructor(redis: Redis, option?: SetupOption | undefined);
+    redis: Redis;
+    private option;
+    constructor(redis: Redis, option: Required<SetupOption>);
+    /**
+     * 取得缓存剩余有效期
+     */
+    ttl(key: string): Promise<number>;
     /**
      * 删除缓存
      */
     del(key: string): Promise<number>;
     /**
-     * 直接设置缓存 - 不经过 JSON 序列化的数据
+     * 直接设置缓存 - 不经过序列化的数据
      * @param key
      * @param value
      * @param ttl  缓存有效时长 (秒)，不设置取默认设置
@@ -34,7 +38,7 @@ export declare class Cache {
     /**
      * 缓存对象
      * @param key 缓存key
-     * @param value 缓存值，除了 `Buffer` 以外的值会经过 JSON 序列化
+     * @param value 缓存值，除了 `Buffer` 以外的值会经过序列化
      * @param ttlopt 缓存有效时长 (秒)，不设置取默认设置 | 缓存选项
      */
     set(key: string, value: any, ttlopt?: number | SetOption): Promise<SetResult>;
@@ -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);
+    }
     /**
      * 删除缓存
      */
@@ -40,7 +46,7 @@ class Cache {
         return this.redis.del(key);
     }
     /**
-     * 直接设置缓存 - 不经过 JSON 序列化的数据
+     * 直接设置缓存 - 不经过序列化的数据
      * @param key
      * @param value
      * @param ttl  缓存有效时长 (秒)，不设置取默认设置
@@ -54,19 +60,13 @@ class Cache {
     /**
      * 缓存对象
      * @param key 缓存key
-     * @param value 缓存值，除了 `Buffer` 以外的值会经过 JSON 序列化
+     * @param value 缓存值，除了 `Buffer` 以外的值会经过序列化
      * @param ttlopt 缓存有效时长 (秒)，不设置取默认设置 | 缓存选项
      */
     async set(key, value, ttlopt) {
-        var _a;
         let compressed;
-        let data = Buffer.isBuffer(value) ? value : JSON.stringify(value);
-        const opt = Object.assign({
-            ttl: 60,
-            compressMinLength: 1024,
-            compressStoreRatio: 0.95,
-            compressLevel: 1,
-        }, (_a = this.option) === null || _a === void 0 ? void 0 : _a.set, typeof ttlopt === 'object' ? ttlopt : undefined);
+        let data = Buffer.isBuffer(value) ? value : this.option.serializer.serialize(value);
+        const opt = Object.assign({}, this.option.set, typeof ttlopt === 'object' ? ttlopt : undefined);
         if (typeof ttlopt === 'number') {
             opt.ttl = ttlopt;
         }
@@ -107,116 +107,159 @@ class Cache {
             // 解析处理
             if (_opt.parse) {
                 _getDebug('[%s] parse', key);
-                return JSON.parse(data.toString());
+                return this.option.serializer.deserialize(data);
             }
             return new CacheResult(compressed, data);
         }
     }
-    async lockGet(key, fetch, _opt) {
-        var _a, _b;
-        const opt = Object.assign({}, (_a = this.option) === null || _a === void 0 ? void 0 : _a.set, (_b = this.option) === null || _b === void 0 ? void 0 : _b.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/index.js

@@ -18,6 +18,7 @@ exports.Cache = exports.cached = exports.Locker = exports.$cache = exports.getCa
 const cache_1 = require("./cache");
 Object.defineProperty(exports, "Cache", { enumerable: true, get: function () { return cache_1.Cache; } });
 const ioredis_1 = require("ioredis");
+const options_1 = require("./options");
 var global_1 = require("./global");
 Object.defineProperty(exports, "getCache", { enumerable: true, get: function () { return global_1.getCache; } });
 Object.defineProperty(exports, "$cache", { enumerable: true, get: function () { return global_1.$cache; } });
@@ -27,24 +28,13 @@ var locker_1 = require("./locker");
 Object.defineProperty(exports, "Locker", { enumerable: true, get: function () { return locker_1.Locker; } });
 var middleware_1 = require("./middleware");
 Object.defineProperty(exports, "cached", { enumerable: true, get: function () { return middleware_1.cached; } });
-/**
- * 默认选项
- */
-const defaultOption = {
-    redis: {
-        host: process.env.REDIS_HOST || '127.0.0.1',
-        port: parseInt(process.env.REDIS_PORT || '') || 6379,
-        password: process.env.REDIS_PASSWORD || '',
-        db: parseInt(process.env.REDIS_DB || '') || 0,
-    },
-};
 /**
  * 安装模块
  * @param option 配置
  */
 function setup(option) {
     return async function cache(setup) {
-        const opt = Object.assign({}, defaultOption, option);
+        const opt = Object.assign({}, options_1.defaultSetupOption, option);
         setup.debug('option: %o', opt);
         const redis = opt.redis instanceof ioredis_1.Redis ? opt.redis : new ioredis_1.Redis(opt.redis);
         await redis.ping('check');

package/dist/options.d.ts

@@ -0,0 +1,7 @@
+import type { RedisOptions } from "ioredis";
+import type { LockGetOption, ObjectSerializer, SetOption, SetupOption } from "./types";
+export declare const defaultRedisOption: RedisOptions;
+export declare const defaultSetOption: SetOption;
+export declare const defaultLockGetOption: LockGetOption;
+export declare const defaultSerializer: ObjectSerializer;
+export declare const defaultSetupOption: Required<SetupOption>;

package/dist/options.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultSetupOption = exports.defaultSerializer = exports.defaultLockGetOption = exports.defaultSetOption = exports.defaultRedisOption = void 0;
+exports.defaultRedisOption = {
+    host: process.env.REDIS_HOST || '127.0.0.1',
+    port: parseInt(process.env.REDIS_PORT || '') || 6379,
+    password: process.env.REDIS_PASSWORD || '',
+    db: parseInt(process.env.REDIS_DB || '') || 0,
+};
+exports.defaultSetOption = {
+    ttl: 60,
+    compressMinLength: 1024,
+    compressStoreRatio: 0.95,
+    compressLevel: 1,
+};
+exports.defaultLockGetOption = {
+    retryTimeout: 5000,
+    retryDelay: 500,
+    preRefresh: 0,
+    refresh: false,
+    localStore: undefined,
+};
+exports.defaultSerializer = {
+    serialize: (data) => {
+        return Buffer.from(JSON.stringify(data));
+    },
+    deserialize: (data) => {
+        return JSON.parse(data.toString());
+    },
+};
+exports.defaultSetupOption = {
+    redis: exports.defaultRedisOption,
+    set: exports.defaultSetOption,
+    lockGet: exports.defaultLockGetOption,
+    serializer: exports.defaultSerializer,
+};

package/dist/types.d.ts

@@ -34,11 +34,18 @@ export interface SetOption {
      */
     compressLevel?: number;
 }
+/**
+ * 对象序列化
+ */
+export interface ObjectSerializer {
+    serialize(data: object): Buffer;
+    deserialize(data: Buffer): object;
+}
 export interface SetupOption {
     /**
      * Redis 实例或 Redis 选项
      */
-    redis: Redis | RedisOptions;
+    redis?: Redis | RedisOptions;
     /**
      * 默认缓存设置选项
      */
@@ -47,13 +54,18 @@ export interface SetupOption {
      * 默认锁缓存选项
      */
     lockGet?: LockGetOption;
+    /**
+     * 自定义序列化器
+     * - 默认为 JSON 序列化
+     */
+    serializer?: ObjectSerializer;
 }
 /**
  * 取得缓存选项
  */
 export interface GetOption {
     /**
-     * 是否解析 JSON 数据
+     * 是否反序列化数据为对象
      * @default true
      */
     parse?: boolean;
@@ -88,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;
 }
@@ -126,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.4.0",
+  "version": "4.6.0",
   "description": "Zenweb Cache module",
   "exports": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -11,7 +11,7 @@
   "scripts": {
     "vscode": "yarn dlx @yarnpkg/sdks vscode",
     "build": "rimraf dist && tsc",
-    "prepublishOnly": "yarn run build",
+    "prepack": "yarn run build",
     "test": "ts-mocha -p tsconfig.json test/**/*.test.ts",
     "dev": "cd example && cross-env DEBUG=\\* NODE_ENV=development ts-node app"
   },
@@ -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",