@zenweb/cache 4.0.0

package/CHANGELOG.md

@@ -0,0 +1,4 @@
+# Changelog
+
+## [4.0.0] - 2023-8-8
+发布

package/README.md

@@ -0,0 +1,85 @@
+# ZenWeb Cache Module
+
+基于 Redis 的对象缓存工具
+
+功能如下:
+- 对象缓存
+- 大对象自动压缩
+- JSON 序列直接输出
+- 防止缓存击穿
+- 单例执行
+
+## 安装
+
+```bash
+yarn add @zenweb/cache
+```
+
+```ts title="src/index.ts"
+import { create } from 'zenweb';
+import modCache from '@zenweb/cache';
+
+const app = create();
+
+app.setup(modCache());
+
+app.start();
+```
+
+## 使用
+```ts
+import { Context, mapping } from "zenweb";
+import { $cache, cached } from "@zenweb/cache";
+
+export class CacheController {
+  /**
+   * 一般使用
+   */
+  @mapping()
+  async index() {
+    const result = await $cache.lockGet('TEST', function() {
+      return {
+        cacheAt: new Date(),
+      };
+    });
+    return result;
+  }
+
+  /**
+   * 大对象压缩存储
+   */
+  @mapping()
+  async big() {
+    const result = await $cache.lockGet('TEST-GZ', function() {
+      return longData;
+    });
+    return result;
+  }
+
+  /**
+   * 大对象直接输出 - 1
+   */
+  @mapping()
+  async big_direct_out(ctx: Context) {
+    const result = await $cache.lockGet('TEST-GZ', function() {
+      return longData;
+    }, { parse: false, decompress: false });
+    if (result.compressed) {
+      ctx.set('Content-Encoding', 'gzip');
+    }
+    ctx.type = 'json';
+    ctx.body = result.data;
+  }
+
+  /**
+   * 使用缓存中间件
+   * - 自动处理是否需要解压缩对象
+   */
+  @mapping({
+    middleware: cached('TEST-middleware'),
+  })
+  async cached_middleware() {
+    return longData;
+  }
+}
+```

package/dist/cache.d.ts

@@ -0,0 +1,74 @@
+/// <reference types="node" />
+import { Redis, RedisValue } from 'ioredis';
+import { SetupOption, SetOption, GetOption, LockGetOption, SetResult, LockOption } from './types';
+/**
+ * 缓存结果
+ */
+export declare class CacheResult {
+    compressed: boolean;
+    data: Buffer;
+    /**
+     * @param compressed 是否为压缩数据
+     * @param data 数据
+     */
+    constructor(compressed: boolean, data: Buffer);
+}
+/**
+ * 对象缓存系统
+ */
+export declare class Cache {
+    private redis;
+    private option?;
+    constructor(redis: Redis, option?: SetupOption | undefined);
+    /**
+     * 删除缓存
+     */
+    del(key: string): Promise<number>;
+    /**
+     * 直接设置缓存 - 不经过 JSON 序列化的数据
+     * @param key
+     * @param value
+     * @param ttl  缓存有效时长 (秒)，不设置取默认设置
+     */
+    setRaw(key: string, value: RedisValue, ttl?: number): Promise<"OK">;
+    /**
+     * 缓存对象
+     * @param key 缓存key
+     * @param value 缓存值，对象会经过 JSON 序列化
+     * @param ttlopt 缓存有效时长 (秒)，不设置取默认设置 | 缓存选项
+     */
+    set(key: string, value: object | number | string | Buffer, ttlopt?: number | SetOption): Promise<SetResult>;
+    /**
+     * 直接取得缓存
+     */
+    getRaw(key: string): Promise<Buffer | null>;
+    /**
+     * 取得缓存对象
+     * @param key 缓存key
+     */
+    get<T>(key: string, opt: {
+        parse: false;
+    } & GetOption): Promise<CacheResult | undefined>;
+    get<T = unknown>(key: string, opt?: {
+        parse?: true;
+    } & GetOption): Promise<T | undefined>;
+    /**
+     * 取得缓存值，如果缓存不存在则取得锁并调用 fetch 设置缓存值
+     * - 防止缓存击穿
+     * - 保障只有一个业务会设置缓存，其他业务会等待设置完成并返回设置结果
+     * @param key 缓存KEY
+     * @param fetch 缓存设置方法回调
+     */
+    lockGet<T extends {} | string>(key: string, fetch: () => Promise<T> | T, _opt: {
+        parse: false;
+    } & LockGetOption): Promise<CacheResult>;
+    lockGet<T extends {} | string>(key: string, fetch: () => Promise<T> | T, _opt?: {
+        parse?: true;
+    } & LockGetOption): Promise<T>;
+    /**
+     * 单例执行，在并发情况下保证同一个 key 只会单独执行，防止同时处理
+     * @param key 锁key
+     * @param run 获得锁时调用
+     */
+    singleRunner<T>(key: string, run: () => Promise<T> | T, _opt?: LockOption): Promise<T>;
+}

package/dist/cache.js

@@ -0,0 +1,209 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Cache = exports.CacheResult = void 0;
+const zlib_1 = require("zlib");
+const util_1 = require("util");
+const locker_1 = require("./locker");
+const utils_1 = require("./utils");
+const compress = (0, util_1.promisify)(zlib_1.gzip);
+const decompress = (0, util_1.promisify)(zlib_1.unzip);
+const GZ_HEADER = Buffer.from([0x1F, 0x8B, 0x08]);
+const _getDebug = utils_1.debug.extend('get');
+const _setDebug = utils_1.debug.extend('set');
+const _lockDebug = utils_1.debug.extend('lock');
+/**
+ * 缓存结果
+ */
+class CacheResult {
+    /**
+     * @param compressed 是否为压缩数据
+     * @param data 数据
+     */
+    constructor(compressed, data) {
+        this.compressed = compressed;
+        this.data = data;
+    }
+}
+exports.CacheResult = CacheResult;
+/**
+ * 对象缓存系统
+ */
+class Cache {
+    constructor(redis, option) {
+        this.redis = redis;
+        this.option = option;
+    }
+    /**
+     * 删除缓存
+     */
+    del(key) {
+        return this.redis.del(key);
+    }
+    /**
+     * 直接设置缓存 - 不经过 JSON 序列化的数据
+     * @param key
+     * @param value
+     * @param ttl  缓存有效时长 (秒)，不设置取默认设置
+     */
+    setRaw(key, value, ttl) {
+        if (ttl && ttl > 0) {
+            return this.redis.set(key, value, 'EX', ttl);
+        }
+        return this.redis.set(key, value);
+    }
+    /**
+     * 缓存对象
+     * @param key 缓存key
+     * @param value 缓存值，对象会经过 JSON 序列化
+     * @param ttlopt 缓存有效时长 (秒)，不设置取默认设置 | 缓存选项
+     */
+    async set(key, value, ttlopt) {
+        var _a;
+        let compressed;
+        let data = Buffer.isBuffer(value) ? value : typeof value === 'object' ? JSON.stringify(value) : String(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);
+        if (typeof ttlopt === 'number') {
+            opt.ttl = ttlopt;
+        }
+        _setDebug('[%s] data length:', key, data.length);
+        if (opt.compressMinLength && data.length >= opt.compressMinLength) {
+            let _compressed = await compress(data, { level: opt.compressLevel });
+            _setDebug('[%s] compressed length: %d', key, _compressed.length);
+            if (_compressed.length < (data.length * (opt.compressStoreRatio || 0.95))) {
+                compressed = _compressed;
+            }
+        }
+        await this.setRaw(key, compressed || data, opt.ttl);
+        return {
+            data,
+            compressed,
+        };
+    }
+    /**
+     * 直接取得缓存
+     */
+    getRaw(key) {
+        return this.redis.getBuffer(key);
+    }
+    async get(key, opt) {
+        let data = await this.getRaw(key);
+        let _opt = Object.assign({ parse: true, decompress: true }, opt);
+        if (data) {
+            // 解压处理
+            const compressed = GZ_HEADER.equals(data.subarray(0, GZ_HEADER.length));
+            if (compressed) {
+                _getDebug('[%s] is compressed', key);
+                if (_opt.parse || _opt.decompress) {
+                    _getDebug('[%s] decompress', key);
+                    data = await decompress(data);
+                }
+            }
+            // 解析处理
+            if (_opt.parse) {
+                _getDebug('[%s] parse', key);
+                return JSON.parse(data.toString());
+            }
+            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);
+        // 获取数据并设置到缓存中
+        const fetchAndSet = async () => {
+            const obj = await fetch();
+            const result = await this.set(key, obj, opt);
+            if ((_opt === null || _opt === void 0 ? void 0 : _opt.parse) !== false) {
+                return obj;
+            }
+            return new CacheResult(!!result.compressed, 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();
+                }
+            }
+        };
+        // 使用锁设置缓存
+        let locker;
+        let refresh = opt.refresh || false; // 强制刷新
+        let retryCount = typeof opt.retryCount === 'number' ? opt.retryCount : 100;
+        while (true) {
+            if (!refresh) {
+                // 尝试从 redis 中获取
+                const data = await this.get(key, opt);
+                if (data !== undefined) {
+                    if (!locker) {
+                        preRefresh();
+                    }
+                    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);
+                try {
+                    return await fetchAndSet();
+                }
+                finally {
+                    await locker.release();
+                }
+            }
+            else {
+                // 获取锁失败，有其他请求更新数据，等待后重新获取获取数据
+                if (retryCount <= 0) {
+                    throw new Error('Unable to acquire lock: ' + key);
+                }
+                else {
+                    retryCount--;
+                    await (0, utils_1.sleep)(opt.retryDelay || 300);
+                }
+            }
+        }
+    }
+    /**
+     * 单例执行，在并发情况下保证同一个 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);
+            }
+        }
+    }
+}
+exports.Cache = Cache;

package/dist/global.d.ts

@@ -0,0 +1,8 @@
+/**
+ * 取得缓存实例
+ */
+export declare function getCache(): import("./cache").Cache;
+/**
+ * 快捷方法 - 缓存实例
+ */
+export declare const $cache: import("./cache").Cache;

package/dist/global.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.$cache = exports.getCache = void 0;
+const core_1 = require("@zenweb/core");
+/**
+ * 取得缓存实例
+ */
+function getCache() {
+    const ins = (0, core_1.getCore)();
+    return ins.cache;
+}
+exports.getCache = getCache;
+/**
+ * 快捷方法 - 缓存实例
+ */
+exports.$cache = (0, core_1.callProxy)(getCache);

package/dist/index.d.ts

@@ -0,0 +1,27 @@
+import { SetupFunction } from '@zenweb/core';
+import { SetupOption } from './types';
+import { Cache } from './cache';
+import { Redis } from 'ioredis';
+export { getCache, $cache } from './global';
+export * from './types';
+export * from './utils';
+export { Locker } from './locker';
+export { cached } from './middleware';
+export { Cache };
+/**
+ * 安装模块
+ * @param option 配置
+ */
+export default function setup(option?: SetupOption): SetupFunction;
+declare module '@zenweb/core' {
+    interface Core {
+        /**
+         * Redis 实例
+         */
+        redis: Redis;
+        /**
+         * 缓存实例
+         */
+        cache: Cache;
+    }
+}

package/dist/index.js

@@ -0,0 +1,59 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Cache = exports.cached = exports.Locker = exports.$cache = exports.getCache = void 0;
+const cache_1 = require("./cache");
+Object.defineProperty(exports, "Cache", { enumerable: true, get: function () { return cache_1.Cache; } });
+const ioredis_1 = require("ioredis");
+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; } });
+__exportStar(require("./types"), exports);
+__exportStar(require("./utils"), exports);
+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);
+        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');
+        setup.defineCoreProperty('redis', { value: redis });
+        setup.defineCoreProperty('cache', { value: new cache_1.Cache(redis, opt) });
+        setup.destroy(async () => {
+            setup.debug('quit redis...');
+            await redis.quit();
+        });
+    };
+}
+exports.default = setup;

package/dist/locker.d.ts

@@ -0,0 +1,30 @@
+import { Redis, RedisKey } from 'ioredis';
+/**
+ * 基于 Redis 的分布式锁
+ */
+export declare class Locker {
+    private redis;
+    private key;
+    private timeout;
+    private value;
+    /**
+     * @param redis Redis 实例
+     * @param key 锁KEY
+     * @param timeout 锁超时(毫秒) 默认 10秒
+     */
+    constructor(redis: Redis, key: RedisKey, timeout?: number);
+    /**
+     * 取得锁
+     * @returns true 取得成功, 否则失败
+     */
+    acquire(): Promise<boolean>;
+    /**
+     * 释放锁
+     */
+    release(): Promise<boolean>;
+    /**
+     * 使用锁回调
+     * @param callback 获取结果回调 true: 成功 false: 失败
+     */
+    using(callback: (ok: boolean) => any): Promise<void>;
+}

package/dist/locker.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Locker = void 0;
+const crypto_1 = require("crypto");
+const utils_1 = require("./utils");
+const RELEASE_SCRIPT = `
+if redis.call("get", KEYS[1]) == ARGV[1] then
+    return redis.call("del", KEYS[1])
+else
+    return 0
+end
+`;
+const RELEASE_SCRIPT_HASH = (0, crypto_1.createHash)('sha1').update(RELEASE_SCRIPT).digest('hex');
+/**
+ * 基于 Redis 的分布式锁
+ */
+class Locker {
+    /**
+     * @param redis Redis 实例
+     * @param key 锁KEY
+     * @param timeout 锁超时(毫秒) 默认 10秒
+     */
+    constructor(redis, key, timeout = 10000) {
+        this.redis = redis;
+        this.key = key;
+        this.timeout = timeout;
+        this.value = (0, crypto_1.randomBytes)(16).toString('hex');
+    }
+    /**
+     * 取得锁
+     * @returns true 取得成功, 否则失败
+     */
+    async acquire() {
+        // NX 不存在key 才创建
+        // PX 过期时间
+        const result = await this.redis.call('SET', this.key, this.value, 'NX', 'PX', this.timeout);
+        return result === 'OK';
+    }
+    /**
+     * 释放锁
+     */
+    async release() {
+        return (await (0, utils_1.runRedisScript)(this.redis, RELEASE_SCRIPT_HASH, RELEASE_SCRIPT, [this.key], [this.value])) === 1;
+    }
+    /**
+     * 使用锁回调
+     * @param callback 获取结果回调 true: 成功 false: 失败
+     */
+    async using(callback) {
+        if (await this.acquire()) {
+            try {
+                await callback(true);
+                return;
+            }
+            finally {
+                await this.release();
+            }
+        }
+        callback(false);
+    }
+}
+exports.Locker = Locker;

package/dist/middleware.d.ts

@@ -0,0 +1,8 @@
+import { Context, Middleware } from "@zenweb/core";
+import { LockGetOption } from "./types";
+/**
+ * 缓存中间件
+ * - 会根据客户端请求头判断是否需要解压
+ * @param key 缓存 key 如果不指定则默认使用 ctx.path
+ */
+export declare function cached(key?: string | ((ctx: Context) => string | Promise<string>), opt?: Omit<LockGetOption, 'parse' | 'decompress'>): Middleware;

package/dist/middleware.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cached = void 0;
+/**
+ * 缓存中间件
+ * - 会根据客户端请求头判断是否需要解压
+ * @param key 缓存 key 如果不指定则默认使用 ctx.path
+ */
+function cached(key, opt) {
+    return async function cachedMiddleware(ctx, next) {
+        const _key = key ? typeof key === 'string' ? key : await key(ctx) : `CACHED-PATH:${ctx.path}`;
+        const decompress = ctx.acceptsEncodings('gzip') === false;
+        const _opt = Object.assign({}, opt, {
+            parse: false,
+            decompress,
+        });
+        const result = await ctx.core.cache.lockGet(_key, async function () {
+            await next();
+            return ctx.body;
+        }, _opt);
+        if (!decompress && result.compressed) {
+            ctx.set('Content-Encoding', 'gzip');
+        }
+        ctx.body = result.data;
+    };
+}
+exports.cached = cached;

package/dist/types.d.ts

@@ -0,0 +1,118 @@
+/// <reference types="node" />
+import { Redis, RedisOptions } from "ioredis";
+/**
+ * 缓存选项
+ */
+export interface SetOption {
+    /**
+     * 缓存有效时长 (秒)
+     * - `0` 永久有效
+     * @default 60
+     */
+    ttl?: number;
+    /**
+     * 压缩内容最少长度(字节)
+     * - `0` 不压缩
+     * - 是否压缩判断:
+     *   - 原始内容长度大于配置值
+     *   - 压缩完成后的长度小于配置值
+     * @default 1024
+     */
+    compressMinLength?: number;
+    /**
+     * 压缩存储比率
+     * - 压缩完成后的长度对比压缩之前的长度所缩减的比率
+     * - 压缩率不满足要求则不存储压缩数据
+     * - 相对于低比率的压缩数据再解压节省的空间十分有限又浪费计算资源
+     * - 默认 0.95, 至少压缩率达到 95% 才有价值
+     * @default 0.95
+     */
+    compressStoreRatio?: number;
+    /**
+     * 压缩级别
+     * @default 1
+     */
+    compressLevel?: number;
+}
+export interface SetupOption {
+    /**
+     * Redis 实例或 Redis 选项
+     */
+    redis: Redis | RedisOptions;
+    /**
+     * 默认缓存设置选项
+     */
+    set?: SetOption;
+    /**
+     * 默认锁缓存选项
+     */
+    lockGet?: LockGetOption;
+}
+/**
+ * 取得缓存选项
+ */
+export interface GetOption {
+    /**
+     * 是否解析 JSON 数据
+     * @default true
+     */
+    parse?: boolean;
+    /**
+     * 如果数据被压缩，是否需要解压
+     * - `parse: false` 时有效
+     * @default true
+     */
+    decompress?: boolean;
+}
+/**
+ * 设置缓存结果
+ */
+export interface SetResult {
+    /**
+     * 未经过压缩的数据
+     */
+    data: string | Buffer;
+    /**
+     * 经过压缩的数据
+     */
+    compressed?: Buffer;
+}
+/**
+ * 锁选项
+ */
+export interface LockOption {
+    /**
+     * 锁超时 (毫秒)
+     * - 取得锁后多久没有释放则自动释放
+     * @default 10000
+     */
+    lockTimeout?: number;
+    /**
+     * 锁获取失败重试次数
+     * @default 100
+     */
+    retryCount?: number;
+    /**
+     * 锁获取失败重试间隔时间 (毫秒)
+     * @default 300
+     */
+    retryDelay?: number;
+}
+/**
+ * 取得或使用锁设置新缓存
+ */
+export interface LockGetOption extends GetOption, SetOption, LockOption {
+    /**
+     * 预刷新（秒）
+     * - `0` 无效
+     * - 缓存剩余时间小于值时主动刷新，不影响当前数据获取
+     * @default 0
+     */
+    preRefresh?: number;
+    /**
+     * 刷新数据
+     * - 不从 Redis 获取数据，直接调用 fetch 设置新的数据
+     * @default false
+     */
+    refresh?: boolean;
+}

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils.d.ts

@@ -0,0 +1,19 @@
+/// <reference types="debug" />
+import { Redis, RedisKey, RedisValue } from 'ioredis';
+export declare const debug: import("debug").Debugger;
+/**
+ * Promise 等待
+ * @param ms 毫秒
+ * @returns
+ */
+export declare function sleep(ms: number): Promise<void>;
+/**
+ * 执行 Redis Lua 脚本
+ * @param redis Redis 实例
+ * @param hash 脚本 sha1 hash
+ * @param script 脚本代码
+ * @param keys 输入键
+ * @param values 输入值
+ * @returns 执行结果
+ */
+export declare function runRedisScript(redis: Redis, hash: string, script: string, keys: RedisKey[], values?: RedisValue[]): Promise<unknown>;

package/dist/utils.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runRedisScript = exports.sleep = exports.debug = void 0;
+const debug_1 = require("debug");
+exports.debug = (0, debug_1.default)('zenweb:cache');
+/**
+ * Promise 等待
+ * @param ms 毫秒
+ * @returns
+ */
+function sleep(ms) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+}
+exports.sleep = sleep;
+/**
+ * 执行 Redis Lua 脚本
+ * @param redis Redis 实例
+ * @param hash 脚本 sha1 hash
+ * @param script 脚本代码
+ * @param keys 输入键
+ * @param values 输入值
+ * @returns 执行结果
+ */
+async function runRedisScript(redis, hash, script, keys, values = []) {
+    try {
+        const result = await redis.evalsha(hash, keys.length, ...keys, ...values);
+        return result;
+    }
+    catch (err) {
+        if (err instanceof Error && err.message.includes('NOSCRIPT')) {
+            (0, exports.debug)('runRedisScript: NOSCRIPT');
+            // 缺少预设脚本，设置
+            const result = await redis.eval(script, keys.length, ...keys, ...values);
+            return result;
+        }
+        throw err;
+    }
+}
+exports.runRedisScript = runRedisScript;

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@zenweb/cache",
+  "version": "4.0.0",
+  "description": "Zenweb Cache module",
+  "exports": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "rimraf dist && tsc",
+    "prepublishOnly": "npm run build",
+    "test": "ts-mocha -p tsconfig.json test/**/*.test.ts",
+    "dev": "cd example && cross-env DEBUG=* NODE_ENV=development ts-node app"
+  },
+  "author": {
+    "name": "YeFei",
+    "email": "316606233@qq.com"
+  },
+  "keywords": [
+    "web",
+    "app",
+    "http",
+    "framework",
+    "koa",
+    "cache",
+    "redis",
+    "locker"
+  ],
+  "license": "MIT",
+  "homepage": "https://zenweb.node.ltd/docs/modules/cache",
+  "devDependencies": {
+    "@types/mocha": "^10.0.1",
+    "cross-env": "^7.0.3",
+    "mocha": "^10.2.0",
+    "rimraf": "^4.3.1",
+    "ts-mocha": "^10.0.0",
+    "ts-node": "^10.9.1",
+    "typescript": "^5.1.6",
+    "zenweb": "^4.0.1"
+  },
+  "dependencies": {
+    "debug": "^4.3.4",
+    "ioredis": "^5.3.2"
+  }
+}