@zenweb/cache 5.1.1 → 5.2.0

package/dist/global.d.ts

@@ -1,4 +1,4 @@
-import { CacheHelperOption } from "./types.js";
+import { CacheHelperKey, CacheHelperOption, CacheKeyType } from "./types.js";
 import { CacheHelper } from "./helper.js";
 /**
  * 取得缓存实例
@@ -11,4 +11,4 @@ export declare const $cache: import("./cache.js").Cache;
 /**
  * 快捷方法 - 缓存助手
  */
-export declare function $cacheHelper<T = unknown>(key: string | (() => string), fetch?: () => Promise<T> | T, opt?: CacheHelperOption): CacheHelper<T>;
+export declare function $cacheHelper<P extends CacheKeyType[], T = unknown>(key: CacheHelperKey<P>, fetch?: (...param: P) => Promise<T> | T, opt?: CacheHelperOption): CacheHelper<P, T>;

package/dist/helper.d.ts

@@ -1,27 +1,29 @@
 import { Cache } from "./cache.js";
-import { CacheHelperOption } from "./types.js";
+import { CacheHelperKey, CacheHelperOption, CacheKeyType } from "./types.js";
 export declare class CacheNotExists extends Error {
 }
-export declare class CacheHelper<T = unknown> {
+export declare class CacheHelper<P extends CacheKeyType[], T = unknown> {
     private _cache;
     private _key;
     private _fetch?;
     private _opt?;
-    private __key?;
-    constructor(_cache: Cache, _key: string | (() => string), _fetch?: (() => Promise<T> | T) | undefined, _opt?: CacheHelperOption | undefined);
-    private get _cacheKey();
+    constructor(_cache: Cache, _key: CacheHelperKey<P>, _fetch?: ((...param: P) => Promise<T> | T) | undefined, _opt?: CacheHelperOption | undefined);
+    /**
+     * 取得缓存 key
+     */
+    key(...param: P): string | Promise<string>;
     /**
      * 取得缓存
      *
      * 如果已定义 `fetch` 参数当缓存不存在时使用 `fetch` 获取并设置缓存，否则抛出异常
      */
-    get(): Promise<T>;
+    get(...param: P): Promise<T>;
     /**
      * 设置缓存
      */
-    set(value: T): Promise<import("./types.js").SetResult>;
+    set(value: T, ...param: P): Promise<import("./types.js").SetResult>;
     /**
      * 删除缓存
      */
-    del(): Promise<number>;
+    del(...param: P): Promise<number>;
 }

package/dist/helper.js

@@ -1,3 +1,4 @@
+import { cacheKey } from "./utils.js";
 export class CacheNotExists extends Error {
 }
 export class CacheHelper {
@@ -5,49 +6,52 @@ export class CacheHelper {
     _key;
     _fetch;
     _opt;
-    __key;
     constructor(_cache, _key, _fetch, _opt) {
         this._cache = _cache;
         this._key = _key;
         this._fetch = _fetch;
         this._opt = _opt;
     }
-    get _cacheKey() {
-        if (!this.__key) {
-            if (typeof this._key === 'function') {
-                this.__key = this._key();
-            }
-            else {
-                this.__key = this._key;
-            }
+    /**
+     * 取得缓存 key
+     */
+    key(...param) {
+        if (typeof this._key === 'function') {
+            return this._key(...param);
+        }
+        else {
+            return cacheKey(this._key, ...param);
         }
-        return this.__key;
     }
     /**
      * 取得缓存
      *
      * 如果已定义 `fetch` 参数当缓存不存在时使用 `fetch` 获取并设置缓存，否则抛出异常
      */
-    async get() {
-        if (typeof this._fetch === 'function') {
-            return this._cache.lockGet(this._cacheKey, this._fetch, { parse: true, noWait: false, ...this._opt });
+    async get(...param) {
+        const _key = await this.key(...param);
+        const _fetch = this._fetch;
+        if (_fetch) {
+            return this._cache.lockGet(_key, () => _fetch(...param), { parse: true, noWait: false, ...this._opt });
         }
-        const data = await this._cache.get(this._cacheKey, { parse: true, ...this._opt });
+        const data = await this._cache.get(_key, { parse: true, ...this._opt });
         if (data === undefined) {
-            throw new CacheNotExists(`cache not exists: ${this._cacheKey}`);
+            throw new CacheNotExists(`cache not exists: ${_key}`);
         }
         return data;
     }
     /**
      * 设置缓存
      */
-    set(value) {
-        return this._cache.set(this._cacheKey, value, this._opt);
+    async set(value, ...param) {
+        const _key = await this.key(...param);
+        return this._cache.set(_key, value, this._opt);
     }
     /**
      * 删除缓存
      */
-    del() {
-        return this._cache.del(this._cacheKey);
+    async del(...param) {
+        const _key = await this.key(...param);
+        return this._cache.del(_key);
     }
 }

package/dist/types.d.ts

@@ -145,4 +145,6 @@ export interface LockGetOption extends GetOption, SetOption, LockOption {
      */
     noWait?: boolean;
 }
+export type CacheKeyType = string | number | object;
 export type CacheHelperOption = Omit<LockGetOption, 'parse' | 'noWait'>;
+export type CacheHelperKey<P extends CacheKeyType[]> = string | ((...param: P) => string | Promise<string>);

package/dist/utils.d.ts

@@ -1,4 +1,5 @@
 import { Redis, RedisKey, RedisValue } from 'ioredis';
+import { CacheKeyType } from './types.js';
 export declare const debug: import("@zenweb/core").Debugger;
 /**
  * Promise 等待
@@ -20,4 +21,4 @@ export declare function runRedisScript(redis: Redis, hash: string, script: strin
  * 生成一个参数缓存key
  * - 多个元素用 : 连接
  */
-export declare function cacheKey(...key: (string | number | object)[]): string;
+export declare function cacheKey(...key: CacheKeyType[]): string;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@zenweb/cache",
   "type": "module",
-  "version": "5.1.1",
+  "version": "5.2.0",
   "description": "Zenweb Cache module",
   "exports": "./dist/index.js",
   "types": "./dist/index.d.ts",