koatty_store 1.7.0 → 1.9.0

package/dist/index.mjs

@@ -1,6 +1,6 @@
 /*!
 * @Author: richen
-* @Date: 2024-11-07 14:38:56
+* @Date: 2025-11-02 08:37:33
 * @License: BSD (3-Clause)
 * @Copyright (c) - <richenlin(at)gmail.com>
 * @HomePage: https://koatty.org/
@@ -8,6 +8,8 @@
 import { flatten, isNil, union, isUndefined } from 'lodash';
 import * as helper from 'koatty_lib';
 import { EventEmitter } from 'events';
+import { LRUCache } from 'lru-cache';
+import AsyncLock from 'async-lock';
 import { DefaultLogger } from 'koatty_logger';
 import { Cluster, Redis } from 'ioredis';
 import genericPool from 'generic-pool';
@@ -49,26 +51,100 @@ var messages;
     messages["mutuallyExclusiveNXXX"] = "ERR XX and NX options at the same time are not compatible";
 })(messages || (messages = {}));
 class MemoryCache extends EventEmitter {
-    databases = Object.create({});
-    options;
-    currentDBIndex;
-    connected;
-    lastSave;
-    multiMode;
-    cache;
-    responseMessages;
     /**
      * Creates an instance of MemoryCache.
-     * @param {*} options
+     * @param {MemoryCacheOptions} options
      * @memberof MemoryCache
      */
     constructor(options) {
         super();
-        this.options = { ...{ database: "0" }, ...options };
-        this.currentDBIndex = 0;
+        this.databases = new Map();
+        this.ttlCheckTimer = null;
+        this.options = {
+            database: 0,
+            maxKeys: 1000,
+            evictionPolicy: 'lru',
+            ttlCheckInterval: 60000, // 1分钟检查一次过期键
+            maxAge: 1000 * 60 * 60, // 默认1小时过期
+            ...options
+        };
+        this.currentDBIndex = options.database || 0;
         this.connected = false;
         this.lastSave = Date.now();
         this.multiMode = false;
+        this.responseMessages = [];
+        this.lock = new AsyncLock();
+        // 初始化数据库和缓存
+        if (!this.databases.has(this.currentDBIndex)) {
+            this.databases.set(this.currentDBIndex, this.createLRUCache());
+        }
+        this.cache = this.databases.get(this.currentDBIndex);
+        // 启动TTL检查定时器
+        this.startTTLCheck();
+    }
+    /**
+     * 创建LRU缓存实例
+     */
+    createLRUCache() {
+        return new LRUCache({
+            max: this.options.maxKeys || 1000,
+            ttl: this.options.maxAge || 1000 * 60 * 60, // 1小时默认
+            updateAgeOnGet: true, // 访问时更新age
+            dispose: (value, key, reason) => {
+                // 键被淘汰时的回调 - 直接使用lru-cache的事件机制
+                this.emit('evict', key, value, reason);
+            },
+            onInsert: (value, key) => {
+                // 键被插入时的回调
+                this.emit('insert', key, value);
+            }
+        });
+    }
+    /**
+     * 启动TTL检查定时器
+     */
+    startTTLCheck() {
+        if (this.ttlCheckTimer) {
+            clearInterval(this.ttlCheckTimer);
+        }
+        this.ttlCheckTimer = setInterval(() => {
+            this.cleanExpiredKeys();
+        }, this.options.ttlCheckInterval || 60000);
+    }
+    /**
+     * 清理过期键
+     */
+    cleanExpiredKeys() {
+        for (const [_dbIndex, cache] of this.databases) {
+            const keysToDelete = [];
+            cache.forEach((item, key) => {
+                if (item.timeout && item.timeout <= Date.now()) {
+                    keysToDelete.push(key);
+                }
+            });
+            keysToDelete.forEach(key => {
+                cache.delete(key);
+                this.emit('expire', key);
+            });
+        }
+    }
+    /**
+     * 停止TTL检查
+     */
+    stopTTLCheck() {
+        if (this.ttlCheckTimer) {
+            clearInterval(this.ttlCheckTimer);
+            this.ttlCheckTimer = null;
+        }
+    }
+    /**
+     * 清理所有资源
+     * @private
+     */
+    cleanup() {
+        this.stopTTLCheck();
+        this.databases.clear();
+        this.removeAllListeners();
     }
     /**
      *
@@ -77,8 +153,10 @@ class MemoryCache extends EventEmitter {
      * @memberof MemoryCache
      */
     createClient() {
-        this.databases[this.options.database] = Object.create({});
-        this.cache = this.databases[this.options.database];
+        if (!this.databases.has(this.options.database)) {
+            this.databases.set(this.options.database, this.createLRUCache());
+        }
+        this.cache = this.databases.get(this.options.database);
         this.connected = true;
         // exit multi mode if we are in it
         this.discard(null, true);
@@ -93,6 +171,7 @@ class MemoryCache extends EventEmitter {
      * @memberof MemoryCache
      */
     quit() {
+        this.cleanup(); // 调用清理方法
         this.connected = false;
         // exit multi mode if we are in it
         this.discard(null, true);
@@ -108,6 +187,40 @@ class MemoryCache extends EventEmitter {
     end() {
         return this.quit();
     }
+    /**
+     * 获取缓存统计信息
+     */
+    info() {
+        const stats = {
+            databases: this.databases.size,
+            currentDB: this.currentDBIndex,
+            keys: this.cache ? this.cache.length : 0,
+            maxKeys: this.options.maxKeys,
+            hits: 0,
+            misses: 0,
+            memory: this.getMemoryUsage()
+        };
+        // 如果缓存支持统计信息
+        if (this.cache && typeof this.cache.dump === 'function') {
+            const dump = this.cache.dump();
+            stats.keys = dump.length;
+        }
+        return stats;
+    }
+    /**
+     * 估算内存使用量
+     */
+    getMemoryUsage() {
+        let totalSize = 0;
+        for (const [, cache] of this.databases) {
+            cache.forEach((item, key) => {
+                // 粗略估算：key长度 + JSON序列化后的大小
+                totalSize += key.length * 2; // Unicode字符占2字节
+                totalSize += JSON.stringify(item).length * 2;
+            });
+        }
+        return totalSize;
+    }
     /**
      *
      *
@@ -154,12 +267,12 @@ class MemoryCache extends EventEmitter {
         if (!helper.isNumber(dbIndex)) {
             return this._handleCallback(callback, null, messages.invalidDBIndex);
         }
-        if (!this.databases.hasOwnProperty(dbIndex)) {
-            this.databases[dbIndex] = Object.create({});
+        if (!this.databases.has(dbIndex)) {
+            this.databases.set(dbIndex, this.createLRUCache());
         }
         this.multiMode = false;
         this.currentDBIndex = dbIndex;
-        this.cache = this.databases[dbIndex];
+        this.cache = this.databases.get(dbIndex);
         return this._handleCallback(callback, messages.ok);
     }
     // ---------------------------------------
@@ -238,7 +351,7 @@ class MemoryCache extends EventEmitter {
         else if (onlyexist) {
             return this._handleCallback(callback, retVal);
         }
-        this.cache[key] = this._makeKey(value.toString(), 'string', pttl);
+        this.cache.set(key, this._makeKey(value.toString(), 'string', pttl));
         return this._handleCallback(callback, messages.ok);
     }
     /**
@@ -268,7 +381,8 @@ class MemoryCache extends EventEmitter {
     expire(key, seconds, callback) {
         let retVal = 0;
         if (this._hasKey(key)) {
-            this.cache[key].timeout = Date.now() + seconds * 1000;
+            const pttl = seconds * 1000;
+            this.cache.set(key, { ...this.cache.get(key), timeout: Date.now() + pttl });
             retVal = 1;
         }
         return this._handleCallback(callback, retVal);
@@ -288,7 +402,7 @@ class MemoryCache extends EventEmitter {
         for (let itr = 0; itr < keys.length; itr++) {
             const key = keys[itr];
             if (this._hasKey(key)) {
-                delete this.cache[key];
+                this.cache.delete(key);
                 retVal++;
             }
         }
@@ -321,14 +435,18 @@ class MemoryCache extends EventEmitter {
      * @memberof MemoryCache
      */
     incr(key, callback) {
-        let retVal = null;
-        try {
-            retVal = this._addToKey(key, 1);
-        }
-        catch (err) {
-            return this._handleCallback(callback, null, err);
-        }
-        return this._handleCallback(callback, retVal);
+        // 使用锁保护原子操作
+        const lockKey = `incr:${key}`;
+        return this.lock.acquire(lockKey, () => {
+            let retVal = null;
+            try {
+                retVal = this._addToKey(key, 1);
+            }
+            catch (err) {
+                return this._handleCallback(callback, null, err);
+            }
+            return this._handleCallback(callback, retVal);
+        });
     }
     /**
      *
@@ -340,14 +458,18 @@ class MemoryCache extends EventEmitter {
      * @memberof MemoryCache
      */
     incrby(key, amount, callback) {
-        let retVal = null;
-        try {
-            retVal = this._addToKey(key, amount);
-        }
-        catch (err) {
-            return this._handleCallback(callback, null, err);
-        }
-        return this._handleCallback(callback, retVal);
+        // 使用锁保护原子操作
+        const lockKey = `incrby:${key}`;
+        return this.lock.acquire(lockKey, () => {
+            let retVal = null;
+            try {
+                retVal = this._addToKey(key, amount);
+            }
+            catch (err) {
+                return this._handleCallback(callback, null, err);
+            }
+            return this._handleCallback(callback, retVal);
+        });
     }
     /**
      *
@@ -358,14 +480,18 @@ class MemoryCache extends EventEmitter {
      * @memberof MemoryCache
      */
     decr(key, callback) {
-        let retVal = null;
-        try {
-            retVal = this._addToKey(key, -1);
-        }
-        catch (err) {
-            return this._handleCallback(callback, null, err);
-        }
-        return this._handleCallback(callback, retVal);
+        // 使用锁保护原子操作
+        const lockKey = `decr:${key}`;
+        return this.lock.acquire(lockKey, () => {
+            let retVal = null;
+            try {
+                retVal = this._addToKey(key, -1);
+            }
+            catch (err) {
+                return this._handleCallback(callback, null, err);
+            }
+            return this._handleCallback(callback, retVal);
+        });
     }
     /**
      *
@@ -377,30 +503,42 @@ class MemoryCache extends EventEmitter {
      * @memberof MemoryCache
      */
     decrby(key, amount, callback) {
-        let retVal = null;
-        try {
-            retVal = this._addToKey(key, -amount);
-        }
-        catch (err) {
-            return this._handleCallback(callback, null, err);
-        }
-        return this._handleCallback(callback, retVal);
+        // 使用锁保护原子操作
+        const lockKey = `decrby:${key}`;
+        return this.lock.acquire(lockKey, () => {
+            let retVal = null;
+            try {
+                retVal = this._addToKey(key, 0 - amount);
+            }
+            catch (err) {
+                return this._handleCallback(callback, null, err);
+            }
+            return this._handleCallback(callback, retVal);
+        });
     }
     // ---------------------------------------
     // ## Hash ##
     // ---------------------------------------
-    hset(key, field, value, callback) {
+    hset(key, field, value, timeout, callback) {
         let retVal = 0;
         if (this._hasKey(key)) {
             this._testType(key, 'hash', true, callback);
         }
         else {
-            this.cache[key] = this._makeKey({}, 'hash');
+            this.cache.set(key, this._makeKey({}, 'hash'));
         }
         if (!this._hasField(key, field)) {
             retVal = 1;
         }
         this._setField(key, field, value.toString());
+        // 如果指定了 timeout，存储字段级别的过期时间
+        if (typeof timeout === 'number') {
+            const hashObj = this.cache.get(key).value;
+            if (!hashObj._fieldTTL) {
+                hashObj._fieldTTL = {};
+            }
+            hashObj._fieldTTL[field] = Date.now() + (timeout * 1000);
+        }
         this.persist(key);
         return this._handleCallback(callback, retVal);
     }
@@ -417,8 +555,17 @@ class MemoryCache extends EventEmitter {
         let retVal = null;
         if (this._hasKey(key)) {
             this._testType(key, 'hash', true, callback);
+            // 检查字段级别的过期时间
+            const hashObj = this._getKey(key);
+            if (hashObj && hashObj._fieldTTL && hashObj._fieldTTL[field]) {
+                if (hashObj._fieldTTL[field] <= Date.now()) {
+                    // 过期，删除字段
+                    this.hdel(key, field);
+                    return this._handleCallback(callback, null);
+                }
+            }
             if (this._hasField(key, field)) {
-                retVal = this._getKey(key)[field];
+                retVal = hashObj[field];
             }
         }
         return this._handleCallback(callback, retVal);
@@ -436,6 +583,15 @@ class MemoryCache extends EventEmitter {
         let retVal = 0;
         if (this._hasKey(key)) {
             this._testType(key, 'hash', true, callback);
+            // 检查字段级别的过期时间
+            const hashObj = this._getKey(key);
+            if (hashObj && hashObj._fieldTTL && hashObj._fieldTTL[field]) {
+                if (hashObj._fieldTTL[field] <= Date.now()) {
+                    // 过期，删除字段
+                    this.hdel(key, field);
+                    return this._handleCallback(callback, 0);
+                }
+            }
             if (this._hasField(key, field)) {
                 retVal = 1;
             }
@@ -455,10 +611,15 @@ class MemoryCache extends EventEmitter {
         const callback = this._retrieveCallback(fields);
         if (this._hasKey(key)) {
             this._testType(key, 'hash', true, callback);
+            const hashObj = this.cache.get(key).value;
             for (let itr = 0; itr < fields.length; itr++) {
                 const field = fields[itr];
                 if (this._hasField(key, field)) {
-                    delete this.cache[key].value[field];
+                    delete hashObj[field];
+                    // 清理过期时间记录
+                    if (hashObj._fieldTTL && hashObj._fieldTTL[field]) {
+                        delete hashObj._fieldTTL[field];
+                    }
                     retVal++;
                 }
             }
@@ -488,14 +649,18 @@ class MemoryCache extends EventEmitter {
      * @memberof MemoryCache
      */
     hincrby(key, field, value, callback) {
-        let retVal;
-        try {
-            retVal = this._addToField(key, field, value, false);
-        }
-        catch (err) {
-            return this._handleCallback(callback, null, err);
-        }
-        return this._handleCallback(callback, retVal);
+        // 使用锁保护原子操作，使用组合 key
+        const lockKey = `hincrby:${key}:${field}`;
+        return this.lock.acquire(lockKey, () => {
+            let retVal;
+            try {
+                retVal = this._addToField(key, field, value, false);
+            }
+            catch (err) {
+                return this._handleCallback(callback, null, err);
+            }
+            return this._handleCallback(callback, retVal);
+        });
     }
     /**
      *
@@ -509,7 +674,11 @@ class MemoryCache extends EventEmitter {
         let retVals = {};
         if (this._hasKey(key)) {
             this._testType(key, 'hash', true, callback);
-            retVals = this._getKey(key);
+            const hashObj = this._getKey(key);
+            // 排除内部属性 _fieldTTL
+            retVals = Object.entries(hashObj)
+                .filter(([k]) => k !== '_fieldTTL')
+                .reduce((acc, [k, v]) => ({ ...acc, [k]: v }), {});
         }
         return this._handleCallback(callback, retVals);
     }
@@ -525,7 +694,9 @@ class MemoryCache extends EventEmitter {
         let retVals = [];
         if (this._hasKey(key)) {
             this._testType(key, 'hash', true, callback);
-            retVals = Object.keys(this._getKey(key));
+            const hashObj = this._getKey(key);
+            // 排除内部属性 _fieldTTL
+            retVals = Object.keys(hashObj).filter(k => k !== '_fieldTTL');
         }
         return this._handleCallback(callback, retVals);
     }
@@ -541,7 +712,11 @@ class MemoryCache extends EventEmitter {
         let retVals = [];
         if (this._hasKey(key)) {
             this._testType(key, 'hash', true, callback);
-            retVals = Object.values(this._getKey(key));
+            const hashObj = this._getKey(key);
+            // 排除内部属性 _fieldTTL 的值
+            retVals = Object.entries(hashObj)
+                .filter(([k]) => k !== '_fieldTTL')
+                .map(([, v]) => v);
         }
         return this._handleCallback(callback, retVals);
     }
@@ -579,22 +754,18 @@ class MemoryCache extends EventEmitter {
             this._testType(key, 'list', true, callback);
         }
         else {
-            this.cache[key] = this._makeKey([], 'list');
+            this.cache.set(key, this._makeKey([], 'list'));
         }
-        const val = this._getKey(key);
-        val.push(value);
-        this._setKey(key, val);
-        retVal = val.length;
+        this._getKey(key).push(value.toString());
+        retVal = this._getKey(key).length;
+        this.persist(key);
         return this._handleCallback(callback, retVal);
     }
     /**
-     *
-     *
-     * @param {string} key
-     * @param {(string | number)} value
-     * @param {Function} [callback]
-     * @returns {*}
-     * @memberof MemoryCache
+     * List：从左侧推入
+     * @param key
+     * @param value
+     * @param callback
      */
     lpush(key, value, callback) {
         let retVal = 0;
@@ -602,14 +773,31 @@ class MemoryCache extends EventEmitter {
             this._testType(key, 'list', true, callback);
         }
         else {
-            this.cache[key] = this._makeKey([], 'list');
+            this.cache.set(key, this._makeKey([], 'list'));
         }
-        const val = this._getKey(key);
-        val.splice(0, 0, value);
-        this._setKey(key, val);
-        retVal = val.length;
+        const list = this._getKey(key);
+        retVal = list.unshift(value);
+        this._setKey(key, list);
         return this._handleCallback(callback, retVal);
     }
+    /**
+     * List：获取指定索引的元素
+     * @param key
+     * @param index
+     * @param callback
+     */
+    lindex(key, index, callback) {
+        if (!this._hasKey(key)) {
+            return this._handleCallback(callback, null);
+        }
+        this._testType(key, 'list', true, callback);
+        const list = this._getKey(key);
+        if (index < 0) {
+            index = list.length + index;
+        }
+        const value = index >= 0 && index < list.length ? list[index] : null;
+        return this._handleCallback(callback, value);
+    }
     /**
      *
      *
@@ -622,9 +810,11 @@ class MemoryCache extends EventEmitter {
         let retVal = null;
         if (this._hasKey(key)) {
             this._testType(key, 'list', true, callback);
-            const val = this._getKey(key);
-            retVal = val.shift();
-            this._setKey(key, val);
+            const list = this._getKey(key);
+            if (list.length > 0) {
+                retVal = list.shift();
+                this.persist(key);
+            }
         }
         return this._handleCallback(callback, retVal);
     }
@@ -640,9 +830,11 @@ class MemoryCache extends EventEmitter {
         let retVal = null;
         if (this._hasKey(key)) {
             this._testType(key, 'list', true, callback);
-            const val = this._getKey(key);
-            retVal = val.pop();
-            this._setKey(key, val);
+            const list = this._getKey(key);
+            if (list.length > 0) {
+                retVal = list.pop();
+                this.persist(key);
+            }
         }
         return this._handleCallback(callback, retVal);
     }
@@ -660,8 +852,8 @@ class MemoryCache extends EventEmitter {
         const retVal = [];
         if (this._hasKey(key)) {
             this._testType(key, 'list', true, callback);
-            const val = this._getKey(key);
-            const length = val.length;
+            const list = this._getKey(key);
+            const length = list.length;
             if (stop < 0) {
                 stop = length + stop;
             }
@@ -675,9 +867,8 @@ class MemoryCache extends EventEmitter {
                 stop = length - 1;
             }
             if (stop >= 0 && stop >= start) {
-                const size = stop - start + 1;
-                for (let itr = start; itr < size; itr++) {
-                    retVal.push(val[itr]);
+                for (let itr = start; itr <= stop; itr++) {
+                    retVal.push(list[itr]);
                 }
             }
         }
@@ -701,7 +892,7 @@ class MemoryCache extends EventEmitter {
             this._testType(key, 'set', true, callback);
         }
         else {
-            this.cache[key] = this._makeKey([], 'set');
+            this.cache.set(key, this._makeKey([], 'set'));
         }
         const val = this._getKey(key);
         const length = val.length;
@@ -773,19 +964,29 @@ class MemoryCache extends EventEmitter {
      * @memberof MemoryCache
      */
     spop(key, count, callback) {
-        let retVal = null;
+        let retVal = [];
         count = count || 1;
-        if (isNaN(count)) {
-            return this._handleCallback(callback, null, messages.noint);
+        if (typeof count === 'function') {
+            callback = count;
+            count = 1;
         }
         if (this._hasKey(key)) {
-            retVal = [];
             this._testType(key, 'set', true, callback);
             const val = this._getKey(key);
-            const length = val.length;
-            count = count > length ? length : count;
-            for (let itr = 0; itr < count; itr++) {
-                retVal.push(val.pop());
+            const keys = Object.keys(val);
+            const keysLength = keys.length;
+            if (keysLength) {
+                if (count >= keysLength) {
+                    retVal = keys;
+                    this.del(key);
+                }
+                else {
+                    for (let itr = 0; itr < count; itr++) {
+                        const randomNum = Math.floor(Math.random() * keys.length);
+                        retVal.push(keys[randomNum]);
+                        this.srem(key, keys[randomNum]);
+                    }
+                }
             }
         }
         return this._handleCallback(callback, retVal);
@@ -852,14 +1053,14 @@ class MemoryCache extends EventEmitter {
     discard(callback, silent) {
         // Clear the queue mode, drain the queue, empty the watch list
         if (this.multiMode) {
-            this.cache = this.databases[this.currentDBIndex];
+            this.cache = this.databases.get(this.currentDBIndex);
             this.multiMode = false;
             this.responseMessages = [];
         }
-        else if (!silent) {
-            return this._handleCallback(callback, null, messages.nomultidiscard);
+        if (!silent) {
+            return this._handleCallback(callback, messages.ok);
         }
-        return this._handleCallback(callback, messages.ok);
+        return null;
     }
     // ---------------------------------------
     // ## Internal - Key ##
@@ -872,11 +1073,12 @@ class MemoryCache extends EventEmitter {
      * @returns {*}
      * @memberof MemoryCache
      */
-    pttl(key, callback) {
+    pttl(key, _callback) {
+        var _a;
         let retVal = -2;
         if (this._hasKey(key)) {
-            if (!isNil(this.cache[key].timeout)) {
-                retVal = this.cache[key].timeout - Date.now();
+            if (!isNil((_a = this.cache.get(key)) === null || _a === void 0 ? void 0 : _a.timeout)) {
+                retVal = this.cache.get(key).timeout - Date.now();
                 // Prevent unexpected errors if the actual ttl just happens to be -2 or -1
                 if (retVal < 0 && retVal > -3) {
                     retVal = -3;
@@ -886,7 +1088,7 @@ class MemoryCache extends EventEmitter {
                 retVal = -1;
             }
         }
-        return this._handleCallback(callback, retVal);
+        return retVal;
     }
     /**
      *
@@ -901,7 +1103,7 @@ class MemoryCache extends EventEmitter {
         let retVal = 0;
         if (this._hasKey(key)) {
             if (!isNil(this._key(key).timeout)) {
-                this._key(key).timeout = null;
+                this.cache.set(key, { ...this.cache.get(key), timeout: null });
                 retVal = 1;
             }
         }
@@ -916,7 +1118,7 @@ class MemoryCache extends EventEmitter {
      * @memberof MemoryCache
      */
     _hasKey(key) {
-        return this.cache.hasOwnProperty(key);
+        return this.cache.has(key);
     }
     /**
      *
@@ -940,8 +1142,8 @@ class MemoryCache extends EventEmitter {
      * @memberof MemoryCache
      */
     _key(key) {
-        this.cache[key].lastAccess = Date.now();
-        return this.cache[key];
+        this.cache.get(key).lastAccess = Date.now();
+        return this.cache.get(key);
     }
     /**
      *
@@ -966,7 +1168,7 @@ class MemoryCache extends EventEmitter {
             }
         }
         else {
-            this.cache[key] = this._makeKey('0', 'string');
+            this.cache.set(key, this._makeKey('0', 'string'));
         }
         const val = keyValue + amount;
         this._setKey(key, val.toString());
@@ -1019,8 +1221,7 @@ class MemoryCache extends EventEmitter {
      * @memberof MemoryCache
      */
     _setKey(key, value) {
-        this.cache[key].value = value;
-        this.cache[key].lastAccess = Date.now();
+        this.cache.set(key, { ...this.cache.get(key), value: value, lastAccess: Date.now() });
     }
     /**
      *
@@ -1048,7 +1249,7 @@ class MemoryCache extends EventEmitter {
             }
         }
         else {
-            this.cache[key] = this._makeKey({}, 'hash');
+            this.cache.set(key, this._makeKey({}, 'hash'));
         }
         fieldValue = useFloat ? parseFloat(`${value}`) : parseInt(`${value}`);
         amount = useFloat ? parseFloat(`${amount}`) : parseInt(`${amount}`);
@@ -1085,7 +1286,8 @@ class MemoryCache extends EventEmitter {
         if (key && field) {
             const ky = this._getKey(key);
             if (ky) {
-                retVal = ky.hasOwnProperty(field);
+                // 排除内部属性 _fieldTTL
+                retVal = field !== '_fieldTTL' && ky.hasOwnProperty(field);
             }
         }
         return retVal;
@@ -1157,6 +1359,333 @@ class MemoryCache extends EventEmitter {
         }
         return;
     }
+    /**
+     * 字符串追加操作
+     * @param key
+     * @param value
+     * @param callback
+     */
+    append(key, value, callback) {
+        let retVal = 0;
+        if (this._hasKey(key)) {
+            this._testType(key, 'string', true, callback);
+            const existingValue = this._getKey(key);
+            const newValue = existingValue + value;
+            this._setKey(key, newValue);
+            retVal = newValue.length;
+        }
+        else {
+            this.cache.set(key, this._makeKey(value, 'string'));
+            retVal = value.length;
+        }
+        return this._handleCallback(callback, retVal);
+    }
+    /**
+     * 获取字符串长度
+     * @param key
+     * @param callback
+     */
+    strlen(key, callback) {
+        let retVal = 0;
+        if (this._hasKey(key)) {
+            this._testType(key, 'string', true, callback);
+            retVal = this._getKey(key).length;
+        }
+        return this._handleCallback(callback, retVal);
+    }
+    /**
+     * 获取子字符串
+     * @param key
+     * @param start
+     * @param end
+     * @param callback
+     */
+    getrange(key, start, end, callback) {
+        let retVal = '';
+        if (this._hasKey(key)) {
+            this._testType(key, 'string', true, callback);
+            const value = this._getKey(key);
+            retVal = value.substring(start, end + 1);
+        }
+        return this._handleCallback(callback, retVal);
+    }
+    /**
+     * 设置子字符串
+     * @param key
+     * @param offset
+     * @param value
+     * @param callback
+     */
+    setrange(key, offset, value, callback) {
+        let retVal = 0;
+        if (this._hasKey(key)) {
+            this._testType(key, 'string', true, callback);
+            const existingValue = this._getKey(key);
+            const newValue = existingValue.substring(0, offset) + value + existingValue.substring(offset + value.length);
+            this._setKey(key, newValue);
+            retVal = newValue.length;
+        }
+        else {
+            // 如果键不存在，创建一个足够长的字符串
+            const newValue = ''.padEnd(offset, '\0') + value;
+            this.cache.set(key, this._makeKey(newValue, 'string'));
+            retVal = newValue.length;
+        }
+        return this._handleCallback(callback, retVal);
+    }
+    /**
+     * 批量获取
+     * @param keys
+     * @param callback
+     */
+    mget(...keys) {
+        const callback = this._retrieveCallback(keys);
+        const retVal = [];
+        for (const key of keys) {
+            if (this._hasKey(key)) {
+                this._testType(key, 'string', false, callback);
+                retVal.push(this._getKey(key));
+            }
+            else {
+                retVal.push(null);
+            }
+        }
+        return this._handleCallback(callback, retVal);
+    }
+    /**
+     * 批量设置
+     * @param keyValuePairs
+     * @param callback
+     */
+    mset(...keyValuePairs) {
+        const callback = this._retrieveCallback(keyValuePairs);
+        // 确保参数是偶数个
+        if (keyValuePairs.length % 2 !== 0) {
+            return this._handleCallback(callback, null, messages.wrongArgCount.replace('%0', 'mset'));
+        }
+        for (let i = 0; i < keyValuePairs.length; i += 2) {
+            const key = keyValuePairs[i];
+            const value = keyValuePairs[i + 1];
+            this.cache.set(key, this._makeKey(value.toString(), 'string'));
+        }
+        return this._handleCallback(callback, messages.ok);
+    }
+    /**
+     * 获取所有键
+     * @param pattern
+     * @param callback
+     */
+    keys(pattern = '*', callback) {
+        const retVal = [];
+        this.cache.forEach((_item, key) => {
+            if (pattern === '*' || this.matchPattern(key, pattern)) {
+                retVal.push(key);
+            }
+        });
+        return this._handleCallback(callback, retVal);
+    }
+    /**
+     * 简单的模式匹配
+     * @param key
+     * @param pattern
+     */
+    matchPattern(key, pattern) {
+        if (pattern === '*')
+            return true;
+        // 转换glob模式为正则表达式
+        const regexPattern = pattern
+            .replace(/\*/g, '.*')
+            .replace(/\?/g, '.')
+            .replace(/\[([^\]]*)\]/g, '[$1]');
+        const regex = new RegExp(`^${regexPattern}$`);
+        return regex.test(key);
+    }
+    /**
+     * 获取随机键
+     * @param callback
+     */
+    randomkey(callback) {
+        const keys = [];
+        this.cache.forEach((_item, key) => {
+            keys.push(key);
+        });
+        if (keys.length === 0) {
+            return this._handleCallback(callback, null);
+        }
+        const randomIndex = Math.floor(Math.random() * keys.length);
+        return this._handleCallback(callback, keys[randomIndex]);
+    }
+    /**
+     * 重命名键
+     * @param oldKey
+     * @param newKey
+     * @param callback
+     */
+    rename(oldKey, newKey, callback) {
+        if (!this._hasKey(oldKey)) {
+            return this._handleCallback(callback, null, messages.nokey);
+        }
+        const value = this.cache.get(oldKey);
+        this.cache.set(newKey, value);
+        this.cache.delete(oldKey);
+        return this._handleCallback(callback, messages.ok);
+    }
+    /**
+     * 安全重命名键（目标键不存在时才重命名）
+     * @param oldKey
+     * @param newKey
+     * @param callback
+     */
+    renamenx(oldKey, newKey, callback) {
+        if (!this._hasKey(oldKey)) {
+            return this._handleCallback(callback, null, messages.nokey);
+        }
+        if (this._hasKey(newKey)) {
+            return this._handleCallback(callback, 0);
+        }
+        const value = this.cache.get(oldKey);
+        this.cache.set(newKey, value);
+        this.cache.delete(oldKey);
+        return this._handleCallback(callback, 1);
+    }
+    /**
+     * 获取键的类型
+     * @param key
+     * @param callback
+     */
+    type(key, callback) {
+        if (!this._hasKey(key)) {
+            return this._handleCallback(callback, 'none');
+        }
+        const item = this.cache.get(key);
+        return this._handleCallback(callback, item.type);
+    }
+    /**
+     * 清空当前数据库
+     * @param callback
+     */
+    flushdb(callback) {
+        this.cache.clear();
+        return this._handleCallback(callback, messages.ok);
+    }
+    /**
+     * 清空所有数据库
+     * @param callback
+     */
+    flushall(callback) {
+        this.databases.clear();
+        this.cache = this.createLRUCache();
+        this.databases.set(this.currentDBIndex, this.cache);
+        return this._handleCallback(callback, messages.ok);
+    }
+    /**
+     * 获取数据库大小
+     * @param callback
+     */
+    dbsize(callback) {
+        const size = this.cache.size || 0;
+        return this._handleCallback(callback, size);
+    }
+    /**
+     * Sorted Set基础实现 - 添加成员
+     * @param key
+     * @param score
+     * @param member
+     * @param callback
+     */
+    zadd(key, score, member, callback) {
+        let retVal = 0;
+        if (this._hasKey(key)) {
+            this._testType(key, 'zset', true, callback);
+        }
+        else {
+            this.cache.set(key, this._makeKey([], 'zset'));
+        }
+        const zset = this._getKey(key);
+        const existing = zset.find((item) => item.member === member);
+        if (existing) {
+            existing.score = score;
+        }
+        else {
+            zset.push({ score, member });
+            retVal = 1;
+        }
+        // 按分数排序
+        zset.sort((a, b) => a.score - b.score);
+        this._setKey(key, zset);
+        return this._handleCallback(callback, retVal);
+    }
+    /**
+     * Sorted Set - 获取成员分数
+     * @param key
+     * @param member
+     * @param callback
+     */
+    zscore(key, member, callback) {
+        if (!this._hasKey(key)) {
+            return this._handleCallback(callback, null);
+        }
+        this._testType(key, 'zset', true, callback);
+        const zset = this._getKey(key);
+        const item = zset.find((item) => item.member === member);
+        return this._handleCallback(callback, item ? item.score : null);
+    }
+    /**
+     * Sorted Set - 获取范围内的成员
+     * @param key
+     * @param start
+     * @param stop
+     * @param callback
+     */
+    zrange(key, start, stop, callback) {
+        if (!this._hasKey(key)) {
+            return this._handleCallback(callback, []);
+        }
+        this._testType(key, 'zset', true, callback);
+        const zset = this._getKey(key);
+        const length = zset.length;
+        if (stop < 0) {
+            stop = length + stop;
+        }
+        if (start < 0) {
+            start = length + start;
+        }
+        const retVal = zset.slice(start, stop + 1).map((item) => item.member);
+        return this._handleCallback(callback, retVal);
+    }
+    /**
+     * Sorted Set - 获取成员数量
+     * @param key
+     * @param callback
+     */
+    zcard(key, callback) {
+        if (!this._hasKey(key)) {
+            return this._handleCallback(callback, 0);
+        }
+        this._testType(key, 'zset', true, callback);
+        const zset = this._getKey(key);
+        return this._handleCallback(callback, zset.length);
+    }
+    /**
+     * Sorted Set - 删除成员
+     * @param key
+     * @param member
+     * @param callback
+     */
+    zrem(key, member, callback) {
+        let retVal = 0;
+        if (this._hasKey(key)) {
+            this._testType(key, 'zset', true, callback);
+            const zset = this._getKey(key);
+            const index = zset.findIndex((item) => item.member === member);
+            if (index !== -1) {
+                zset.splice(index, 1);
+                retVal = 1;
+                this._setKey(key, zset);
+            }
+        }
+        return this._handleCallback(callback, retVal);
+    }
 }
 
 /*
@@ -1167,17 +1696,27 @@ class MemoryCache extends EventEmitter {
  * @LastEditTime: 2023-02-18 23:52:47
  */
 class MemoryStore {
-    client;
-    pool;
-    options;
     /**
      * Creates an instance of MemoryStore.
      * @param {MemoryStoreOpt} options
      * @memberof MemoryStore
      */
     constructor(options) {
-        this.options = options;
-        this.client = null;
+        this.options = {
+            maxKeys: 1000,
+            evictionPolicy: 'lru',
+            ttlCheckInterval: 60000, // 1分钟
+            ...options
+        };
+        // 直接创建 MemoryCache 实例
+        this.client = new MemoryCache({
+            database: this.options.db || 0,
+            maxKeys: this.options.maxKeys,
+            maxMemory: this.options.maxMemory,
+            evictionPolicy: this.options.evictionPolicy,
+            ttlCheckInterval: this.options.ttlCheckInterval
+        });
+        this.client.createClient();
     }
     /**
      * getConnection
@@ -1186,15 +1725,7 @@ class MemoryStore {
      * @memberof MemoryStore
      */
     getConnection() {
-        if (!this.pool) {
-            this.pool = new MemoryCache({
-                database: this.options.db
-            });
-        }
-        if (!this.client) {
-            this.client = this.pool.createClient();
-            this.client.status = "ready";
-        }
+        // 直接返回 MemoryCache 实例
         return this.client;
     }
     /**
@@ -1204,8 +1735,10 @@ class MemoryStore {
      * @memberof MemoryStore
      */
     async close() {
-        this.client.end();
-        this.client = null;
+        if (this.client) {
+            this.client.end();
+            this.client = null;
+        }
     }
     /**
      * release
@@ -1215,7 +1748,8 @@ class MemoryStore {
      * @memberof MemoryStore
      */
     async release(_conn) {
-        return;
+        // 对于内存存储，不需要释放连接
+        return Promise.resolve();
     }
     /**
      * defineCommand
@@ -1248,6 +1782,20 @@ class MemoryStore {
             return -1;
         }
     }
+    /**
+     * 获取缓存统计信息
+     */
+    getStats() {
+        if (this.client) {
+            return this.client.info();
+        }
+        return {
+            keys: 0,
+            memory: 0,
+            hits: 0,
+            misses: 0
+        };
+    }
 }
 
 /*
@@ -1265,15 +1813,15 @@ class MemoryStore {
  * @class RedisStore
  */
 class RedisStore {
-    options;
-    pool;
-    client;
     /**
      * Creates an instance of RedisStore.
      * @param {RedisStoreOpt} options
      * @memberof RedisStore
      */
     constructor(options) {
+        this.reconnectAttempts = 0;
+        this.maxReconnectAttempts = 5;
+        this.reconnectDelay = 1000; // 初始重连延迟1秒
         this.options = this.parseOpt(options);
         this.pool = null;
     }
@@ -1327,7 +1875,7 @@ class RedisStore {
         return opt;
     }
     /**
-     * create connection by native
+     * create connection by native with improved error handling
      *
      * @param {number} [connNum=0]
      * @returns {*}  {Promise<Redis | Cluster>}
@@ -1339,32 +1887,77 @@ class RedisStore {
         }
         const defer = helper.getDefer();
         let connection;
-        if (!helper.isEmpty(this.options.clusters)) {
-            connection = new Cluster([...this.options.clusters], { redisOptions: this.options });
-        }
-        else {
-            connection = new Redis(this.options);
-        }
-        // 去除prefix, 防止重复
-        this.options.keyPrefix = "";
-        connection.on('end', () => {
-            if (connNum < 3) {
-                connNum++;
-                defer.resolve(this.connect(connNum));
+        try {
+            if (!helper.isEmpty(this.options.clusters)) {
+                connection = new Cluster([...this.options.clusters], {
+                    redisOptions: this.options,
+                    enableOfflineQueue: false,
+                    retryDelayOnFailover: 100
+                });
             }
             else {
-                this.close();
-                defer.reject('redis connection end');
+                connection = new Redis({
+                    ...this.options,
+                    enableOfflineQueue: false,
+                    retryDelayOnFailover: 100,
+                    lazyConnect: true
+                });
             }
-        });
-        connection.on('ready', () => {
-            this.client = connection;
-            defer.resolve(connection);
-        });
+            // 去除prefix, 防止重复
+            this.options.keyPrefix = "";
+            connection.on('error', (err) => {
+                DefaultLogger.Error(`Redis connection error: ${err.message}`);
+                if (this.reconnectAttempts < this.maxReconnectAttempts) {
+                    this.scheduleReconnect(connNum);
+                }
+                else {
+                    defer.reject(new Error(`Redis connection failed after ${this.maxReconnectAttempts} attempts`));
+                }
+            });
+            connection.on('end', () => {
+                DefaultLogger.Warn('Redis connection ended');
+                if (connNum < 3) {
+                    this.scheduleReconnect(connNum + 1);
+                }
+                else {
+                    this.close();
+                    defer.reject(new Error('Redis connection end after 3 attempts'));
+                }
+            });
+            connection.on('ready', () => {
+                DefaultLogger.Info('Redis connection ready');
+                this.client = connection;
+                this.reconnectAttempts = 0; // 重置重连计数
+                defer.resolve(connection);
+            });
+            // 主动连接
+            if (connection instanceof Redis) {
+                await connection.connect();
+            }
+        }
+        catch (error) {
+            DefaultLogger.Error(`Failed to create Redis connection: ${error.message}`);
+            defer.reject(error);
+        }
         return defer.promise;
     }
     /**
-     * get connection from pool
+     * 计划重连，使用指数退避策略
+     * @private
+     * @param {number} connNum
+     */
+    scheduleReconnect(connNum) {
+        this.reconnectAttempts++;
+        const delay = this.reconnectDelay * Math.pow(2, this.reconnectAttempts - 1);
+        DefaultLogger.Info(`Scheduling Redis reconnect attempt ${this.reconnectAttempts} in ${delay}ms`);
+        setTimeout(() => {
+            this.connect(connNum).catch(err => {
+                DefaultLogger.Error(`Reconnect attempt ${this.reconnectAttempts} failed: ${err.message}`);
+            });
+        }, delay);
+    }
+    /**
+     * get connection from pool with improved configuration
      *
      * @returns {*}
      * @memberof RedisStore
@@ -1375,38 +1968,57 @@ class RedisStore {
                 create: () => {
                     return this.connect();
                 },
-                destroy: () => {
-                    return this.close();
+                destroy: (resource) => {
+                    if (resource && typeof resource.disconnect === 'function') {
+                        resource.disconnect();
+                    }
+                    return Promise.resolve();
                 },
                 validate: (resource) => {
-                    return Promise.resolve(resource.status === 'ready');
+                    return Promise.resolve(resource && resource.status === 'ready');
                 }
             };
             this.pool = genericPool.createPool(factory, {
                 max: this.options.poolSize || 10, // maximum size of the pool
-                min: 2 // minimum size of the pool
+                min: Math.min(2, this.options.poolSize || 2), // minimum size of the pool
+                acquireTimeoutMillis: 30000, // 30秒获取连接超时
+                testOnBorrow: true, // 借用时测试连接
+                evictionRunIntervalMillis: 30000, // 30秒检查一次空闲连接
+                idleTimeoutMillis: 300000, // 5分钟空闲超时
+                softIdleTimeoutMillis: 180000 // 3分钟软空闲超时
             });
             this.pool.on('factoryCreateError', function (err) {
-                DefaultLogger.Error(err);
+                DefaultLogger.Error(`Redis pool create error: ${err.message}`);
             });
             this.pool.on('factoryDestroyError', function (err) {
-                DefaultLogger.Error(err);
+                DefaultLogger.Error(`Redis pool destroy error: ${err.message}`);
             });
         }
         return this.pool.acquire();
     }
     /**
-     * close connection
+     * close connection with proper cleanup
      *
      * @returns {*}
      * @memberof RedisStore
      */
     async close() {
-        this.client.disconnect();
-        this.client = null;
-        this.pool.destroy(this.client);
-        this.pool = null;
-        return;
+        try {
+            if (this.pool) {
+                await this.pool.drain();
+                await this.pool.clear();
+                this.pool = null;
+            }
+            if (this.client) {
+                if (typeof this.client.disconnect === 'function') {
+                    this.client.disconnect();
+                }
+                this.client = null;
+            }
+        }
+        catch (error) {
+            DefaultLogger.Error(`Error closing Redis connection: ${error.message}`);
+        }
     }
     /**
      *
@@ -1449,16 +2061,16 @@ class RedisStore {
         try {
             conn = await this.defineCommand("getCompare", {
                 numberOfKeys: 1,
-                lua: `
-                    local remote_value = redis.call("get",KEYS[1])
-                    
-                    if (not remote_value) then
-                        return 0
-                    elseif (remote_value == ARGV[1]) then
-                        return redis.call("del",KEYS[1])
-                    else
-                        return -1
-                    end
+                lua: `
+                    local remote_value = redis.call("get",KEYS[1])
+                    
+                    if (not remote_value) then
+                        return 0
+                    elseif (remote_value == ARGV[1]) then
+                        return redis.call("del",KEYS[1])
+                    else
+                        return -1
+                    end
             `
             });
             return conn.getCompare(name, value);
@@ -1496,9 +2108,6 @@ const defaultOptions = {
  * @class Store
  */
 class CacheStore {
-    client;
-    options;
-    static instance;
     /**
      * Creates an instance of CacheStore.
      * @param {StoreOptions} options
@@ -1518,17 +2127,70 @@ class CacheStore {
         }
     }
     /**
-     *
-     *
+     * 获取单例实例，支持多配置实例管理
      * @static
-     * @returns
+     * @param {StoreOptions} [options]
+     * @param {string} [instanceKey='default'] 实例键名，用于区分不同配置的实例
+     * @returns {CacheStore}
      */
-    static getInstance(options) {
-        if (this.instance) {
-            return this.instance;
+    static getInstance(options, instanceKey = 'default') {
+        // 生成配置哈希作为实例键的一部分
+        const configHash = options ? this.generateConfigHash(options) : 'default';
+        const fullKey = `${instanceKey}_${configHash}`;
+        if (this.instances.has(fullKey)) {
+            return this.instances.get(fullKey);
+        }
+        const instance = new CacheStore(options);
+        this.instances.set(fullKey, instance);
+        return instance;
+    }
+    /**
+     * 生成配置哈希
+     * @private
+     * @static
+     * @param {StoreOptions} options
+     * @returns {string}
+     */
+    static generateConfigHash(options) {
+        const configStr = JSON.stringify({
+            type: options.type,
+            host: options.host,
+            port: options.port,
+            db: options.db,
+            keyPrefix: options.keyPrefix
+        });
+        // 简单哈希函数
+        let hash = 0;
+        for (let i = 0; i < configStr.length; i++) {
+            const char = configStr.charCodeAt(i);
+            hash = ((hash << 5) - hash) + char;
+            hash = hash & hash; // 转换为32位整数
+        }
+        return Math.abs(hash).toString(36);
+    }
+    /**
+     * 清理指定实例
+     * @static
+     * @param {string} [instanceKey='default']
+     */
+    static async clearInstance(instanceKey = 'default') {
+        const keysToRemove = Array.from(this.instances.keys()).filter(key => key.startsWith(`${instanceKey}_`));
+        for (const key of keysToRemove) {
+            const instance = this.instances.get(key);
+            if (instance) {
+                await instance.close();
+                this.instances.delete(key);
+            }
         }
-        this.instance = new CacheStore(options);
-        return this.instance;
+    }
+    /**
+     * 清理所有实例
+     * @static
+     */
+    static async clearAllInstances() {
+        const promises = Array.from(this.instances.values()).map(instance => instance.close());
+        await Promise.all(promises);
+        this.instances.clear();
     }
     getConnection() {
         return this.client.getConnection();
@@ -1539,11 +2201,13 @@ class CacheStore {
     release(conn) {
         return this.client.release(conn);
     }
-    defineCommand(name, scripts) {
-        return this.client.defineCommand(name, scripts);
-    }
-    getCompare(name, value) {
-        return this.client.getCompare(name, value);
+    /**
+     * 获取底层实现客户端，用于访问特定实现的功能
+     * 例如：Redis的defineCommand, getCompare等
+     * @returns {MemoryStore | RedisStore}
+     */
+    getRawClient() {
+        return this.client;
     }
     /**
      * handler for native client
@@ -1561,10 +2225,22 @@ class CacheStore {
             return res;
         }
         catch (err) {
-            throw err;
+            // 添加详细的错误信息
+            const error = new Error(`Cache operation failed: ${name}(${data.slice(0, 2).join(', ')}${data.length > 2 ? '...' : ''}) - ${err.message}`);
+            error.stack = err.stack;
+            throw error;
         }
         finally {
-            this.release(conn);
+            // 安全地释放连接
+            if (conn) {
+                try {
+                    await this.release(conn);
+                }
+                catch (releaseErr) {
+                    // 记录但不抛出，避免掩盖原始错误
+                    DefaultLogger.Error(`Failed to release connection: ${releaseErr.message}`);
+                }
+            }
         }
     }
     /**
@@ -1603,13 +2279,6 @@ class CacheStore {
     expire(name, timeout) {
         return this.wrap('expire', [`${this.options.keyPrefix || ""}${name}`, timeout]);
     }
-    /**
-     * 删除key
-     * @param name
-     */
-    rm(name) {
-        return this.wrap('del', [`${this.options.keyPrefix || ""}${name}`]);
-    }
     /**
      *
      *
@@ -1647,8 +2316,8 @@ class CacheStore {
      * @param incr
      * @returns {*}
      */
-    incrby(name, incr = 1) {
-        return this.wrap('incrby', [`${this.options.keyPrefix || ""}${name}`, incr]);
+    incrby(name, increment) {
+        return this.wrap('incrby', [`${this.options.keyPrefix || ""}${name}`, increment]);
     }
     /**
      * 将 key 所储存的值减去减量
@@ -1656,8 +2325,8 @@ class CacheStore {
      * @param {any} name
      * @param {any} decr
      */
-    decrby(name, decr = 1) {
-        return this.wrap('decrby', [`${this.options.keyPrefix || ""}${name}`, decr]);
+    decrby(name, decrement) {
+        return this.wrap('decrby', [`${this.options.keyPrefix || ""}${name}`, decrement]);
     }
     /**
      * 哈希写入
@@ -1666,13 +2335,9 @@ class CacheStore {
      * @param value
      * @param timeout
      */
-    hset(name, key, value, timeout) {
-        const setP = [this.wrap('hset', [`${this.options.keyPrefix || ""}${name}`, key, value])];
-        if (typeof timeout !== 'number') {
-            timeout = this.options.timeout;
-        }
-        setP.push(this.set(`${name}:${key}_ex`, 1, timeout));
-        return Promise.all(setP);
+    async hset(name, key, value, timeout) {
+        // MemoryStore 直接支持字段级 TTL，传递 timeout 参数
+        return this.wrap('hset', [`${this.options.keyPrefix || ""}${name}`, key, value, timeout]);
     }
     /**
      * 哈希获取
@@ -1681,15 +2346,8 @@ class CacheStore {
      * @returns {*}
      */
     hget(name, key) {
-        const setP = [this.get(`${name}:${key}_ex`)];
-        setP.push(this.wrap('hget', [`${this.options.keyPrefix || ""}${name}`, key]));
-        return Promise.all(setP).then(dataArr => {
-            if (dataArr[0] === null) {
-                this.hdel(name, key);
-                return null;
-            }
-            return dataArr[1] || null;
-        });
+        // 直接调用底层实现，TTL 检查在 MemoryCache 中处理
+        return this.wrap('hget', [`${this.options.keyPrefix || ""}${name}`, key]);
     }
     /**
      * 查看哈希表 hashKey 中，给定域 key 是否存在
@@ -1698,15 +2356,8 @@ class CacheStore {
      * @returns {*}
      */
     hexists(name, key) {
-        const setP = [this.get(`${name}:${key}_ex`)];
-        setP.push(this.wrap('hexists', [`${this.options.keyPrefix || ""}${name}`, key]));
-        return Promise.all(setP).then(dataArr => {
-            if (dataArr[0] === null) {
-                this.hdel(name, key);
-                return 0;
-            }
-            return dataArr[1] || 0;
-        });
+        // 直接调用底层实现，TTL 检查在 MemoryCache 中处理
+        return this.wrap('hexists', [`${this.options.keyPrefix || ""}${name}`, key]);
     }
     /**
      * 哈希删除
@@ -1714,10 +2365,9 @@ class CacheStore {
      * @param key
      * @returns {*}
      */
-    hdel(name, key) {
-        const setP = [this.del(`${name}:${key}_ex`)];
-        setP.push(this.wrap('hdel', [`${this.options.keyPrefix || ""}${name}`, key]));
-        return Promise.all(setP);
+    async hdel(name, key) {
+        // 直接调用底层实现，TTL 清理在 MemoryCache 中处理
+        return this.wrap('hdel', [`${this.options.keyPrefix || ""}${name}`, key]);
     }
     /**
      * 返回哈希表 key 中域的数量
@@ -1731,11 +2381,11 @@ class CacheStore {
      * 给哈希表指定key，增加increment
      * @param name
      * @param key
-     * @param incr
+     * @param increment
      * @returns {*}
      */
-    hincrby(name, key, incr = 1) {
-        return this.wrap('hincrby', [`${this.options.keyPrefix || ""}${name}`, key, incr]);
+    hincrby(name, key, increment) {
+        return this.wrap('hincrby', [`${this.options.keyPrefix || ""}${name}`, key, increment]);
     }
     /**
      * 返回哈希表所有key-value
@@ -1824,12 +2474,12 @@ class CacheStore {
      * @param timeout
      * @returns {*}
      */
-    sadd(name, value, timeout) {
-        const setP = [this.wrap('sadd', [`${this.options.keyPrefix || ""}${name}`, value])];
-        if (typeof timeout !== 'number') {
-            setP.push(this.wrap('expire', [`${this.options.keyPrefix || ""}${name}`, timeout]));
+    async sadd(name, value, timeout) {
+        const result = await this.wrap('sadd', [`${this.options.keyPrefix || ""}${name}`, value]);
+        if (typeof timeout === 'number') {
+            await this.wrap('expire', [`${this.options.keyPrefix || ""}${name}`, timeout]);
         }
-        return Promise.all(setP);
+        return result;
     }
     /**
      * 返回集合的基数(集合中元素的数量)
@@ -1881,8 +2531,9 @@ class CacheStore {
      * @returns {*}
      */
     smove(source, destination, member) {
-        return this.wrap('smove', [`${this.options.keyPrefix || ""}${source}`, `${this.options.keyPrefix}${destination}`, member]);
+        return this.wrap('smove', [`${this.options.keyPrefix || ""}${source}`, `${this.options.keyPrefix || ""}${destination}`, member]);
     }
 }
+CacheStore.instances = new Map();
 
 export { CacheStore };